code: def load_df(self):
      df = self.fetch_data()
  
      if self.pre_func:
          df = self.pre_func(df)
  
      # Batch-convert the user-specifed date column into timestamps.
      df["dt"] = self.parse_date_str_series(
          self.date_format,
          self.timezone,
          df[self.date_column],
          self.data_frequency,
          self.trading_day,
      ).values
  
      # ignore rows whose dates we couldn't parse
      df = df[df["dt"].notnull()]
  
      if self.symbol is not None:
          df["sid"] = self.symbol
      elif self.finder:
          df.sort_values(by=self.symbol_column, inplace=True)
  
          # Pop the 'sid' column off of the DataFrame, just in case the user
          # has assigned it, and throw a warning
          try:
              df.pop("sid")
              warnings.warn(
                  "Assignment of the 'sid' column of a DataFrame is "
                  "not supported by Fetcher. The 'sid' column has been "
                  "overwritten.",
                  category=UserWarning,
                  stacklevel=2,
              )
          except KeyError:
              # There was no 'sid' column, so no warning is necessary
              pass
  
          # Fill entries for any symbols that don't require a date to
          # uniquely identify.  Entries for which multiple securities exist
          # are replaced with zeroes, while entries for which no asset
          # exists are replaced with NaNs.
          unique_symbols = df[self.symbol_column].unique()
          sid_series = pd.Series(
              data=map(
                  self._lookup_unconflicted_symbol, unique_symbols
              ),
              index=unique_symbols,
              name="sid",
          )
          df = df.join(sid_series, on=self.symbol_column)
  
          # Fill any zero entries left in our sid column by doing a lookup
          # using both symbol and the row date.
          conflict_rows = df[df["sid"] == 0]
          for row_idx, row in conflict_rows.iterrows():
              try:
                  asset = (
                      self.finder.lookup_symbol(
                          row[self.symbol_column],
                          # Replacing tzinfo here is necessary because of the
                          # timezone metadata bug described below.
                          row["dt"].replace(tzinfo=pytz.utc),
                          country_code=self.country_code,
                          # It's possible that no asset comes back here if our
                          # lookup date is from before any asset held the
                          # requested symbol.  Mark such cases as NaN so that
                          # they get dropped in the next step.
                      )
                      or numpy.nan
                  )
              except SymbolNotFound:
                  asset = numpy.nan
  
              # Assign the resolved asset to the cell
              df.ix[row_idx, "sid"] = asset
  
          # Filter out rows containing symbols that we failed to find.
          length_before_drop = len(df)
          df = df[df["sid"].notnull()]
          no_sid_count = length_before_drop - len(df)
          if no_sid_count:
              logger.warn(
                  "Dropped {} rows from fetched csv.".format(
                      no_sid_count
                  ),
                  no_sid_count,
                  extra={"syslog": True},
              )
      else:
          df["sid"] = df["symbol"]
  
      # Dates are localized to UTC when they come out of
      # parse_date_str_series, but we need to re-localize them here because
      # of a bug that wasn't fixed until
      # https://github.com/pydata/pandas/pull/7092.
      # We should be able to remove the call to tz_localize once we're on
      # pandas 0.14.0
  
      # We don't set 'dt' as the index until here because the Symbol parsing
      # operations above depend on having a unique index for the dataframe,
      # and the 'dt' column can contain multiple dates for the same entry.
      df.drop_duplicates(["sid", "dt"])
      df.set_index(["dt"], inplace=True)
      df = df.tz_localize("UTC")
      df.sort_index(inplace=True)
  
      cols_to_drop = [self.date_column]
      if self.symbol is None:
          cols_to_drop.append(self.symbol_column)
      df = df[df.columns.drop(cols_to_drop)]
  
      if self.post_func:
          df = self.post_func(df)
  
      return df
  
imports: from abc import ABCMeta, abstractmethod
  from collections import namedtuple
  import hashlib
  from textwrap import dedent
  import warnings
  from logbook import Logger
  import numpy
  import pandas
  from pandas import read_csv
  import pytz
  import requests
  from six import StringIO, iteritems, with_metaclass
  from zipline.errors import MultipleSymbolsFound, SymbolNotFound, ZiplineError
  from zipline.protocol import DATASOURCE_TYPE, Event
  from zipline.assets import Equity
label_desc: Use image node_id 8 for calling the PandasCSV obj's underlying member method code with example usage: obj.load_df() and returns: df