def _load_data(self, station: str, year: Optional[int] = None) -> None:
        """
        Load file for a single station from Meteostat
        """
        # File name
        file = generate_endpoint_path(self.granularity, station, year)

        # Get local file path
        path = get_local_file_path(self.cache_dir, self.cache_subdir, file)

        # Check if file in cache
        if self.max_age > 0 and file_in_cache(path, self.max_age):
            # Read cached data
            df = pd.read_pickle(path)

        else:
            # Get data from Meteostat
            df = load_handler(
                self.endpoint,
                file,
                self.proxy,
                default_df=pd.DataFrame(
                    columns=self._raw_columns
                    + with_suffix(self._raw_columns, "_source")
                ),
            )

            # Add time column and drop original columns
            if len(self._parse_dates) < 3:
                df["day"] = 1

            df["time"] = pd.to_datetime(
                df[
                    (
                        self._parse_dates
                        if len(self._parse_dates) > 2
                        else self._parse_dates + ["day"]
                    )
                ]
            )
            df = df.drop(self._parse_dates, axis=1)

            # Validate and prepare data for further processing
            df = validate_series(df, station)

            # Rename columns
            df = df.rename(columns=self._renamed_columns, errors="ignore")

            # Convert sources to flags
            for col in df.columns:
                basecol = col[:-7] if col.endswith("_source") else col

                if basecol not in self._processed_columns:
                    df.drop(col, axis=1, inplace=True)
                    continue

                if basecol == col:
                    df[col] = df[col].astype("Float64")

                if col.endswith("_source"):
                    flagcol = f"{basecol}_flag"
                    df[flagcol] = pd.NA
                    df[flagcol] = df[flagcol].astype("string")
                    mask = df[col].notna()
                    df.loc[mask, flagcol] = df.loc[mask, col].apply(
                        get_flag_from_source_factory(
                            self._source_mappings, self._model_flag
                        )
                    )
                    df.drop(col, axis=1, inplace=True)

            # Process virtual columns
            for key, value in self._virtual_columns.items():
                df = value(df, key)

            # Save as Pickle
            if self.max_age > 0:
                df.to_pickle(path)

        # Localize time column
        if (
            self.granularity == Granularity.HOURLY
            and self._timezone is not None
            and len(df.index) > 0
        ):
            df = localize(df, self._timezone)

        # Filter time period and append to DataFrame
        df = filter_time(df, self._start, self._end)

        # Return
        return df

        Load file for a single station from Meteostat
        
meteostat/interface/timeseries.py