code: # -*- coding: utf-8 -*-
  
  """
  Tests date parsing functionality for all of the
  parsers defined in parsers.py
  """
  
  from datetime import date, datetime
  from io import StringIO
  
  import numpy as np
  import pytest
  import pytz
  
  from pandas._libs.tslib import Timestamp
  from pandas._libs.tslibs import parsing
  from pandas.compat import lrange, parse_date
  from pandas.compat.numpy import np_array_datetime64_compat
  
  import pandas as pd
  from pandas import DataFrame, DatetimeIndex, Index, MultiIndex
  from pandas.core.indexes.datetimes import date_range
  import pandas.util.testing as tm
  
  import pandas.io.date_converters as conv
  import pandas.io.parsers as parsers
  
  
  def test_separator_date_conflict(all_parsers):
      # Regression test for gh-4678
      #
      # Make sure thousands separator and
      # date parsing do not conflict.
      parser = all_parsers
      data = "06-02-2013;13:00;1-000.215"
      expected = DataFrame([[datetime(2013, 6, 2, 13, 0, 0), 1000.215]],
                           columns=["Date", 2])
  
      df = parser.read_csv(StringIO(data), sep=";", thousands="-",
                           parse_dates={"Date": [0, 1]}, header=None)
      tm.assert_frame_equal(df, expected)
  
  
  @pytest.mark.parametrize("keep_date_col", [True, False])
  def test_multiple_date_col_custom(all_parsers, keep_date_col):
      data = """\
  KORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000
  KORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000
  KORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000
  KORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000
  KORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000
  KORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000
  """
      parser = all_parsers
  
      def date_parser(*date_cols):
          """
          Test date parser.
  
          Parameters
          ----------
          date_cols : args
              The list of data columns to parse.
  
          Returns
          -------
          parsed : Series
          """
          return parsing.try_parse_dates(parsers._concat_date_cols(date_cols))
  
      result = parser.read_csv(StringIO(data), header=None,
                               date_parser=date_parser, prefix="X",
                               parse_dates={"actual": [1, 2],
                                            "nominal": [1, 3]},
                               keep_date_col=keep_date_col)
      expected = DataFrame([
          [datetime(1999, 1, 27, 19, 0), datetime(1999, 1, 27, 18, 56),
           "KORD", "19990127", " 19:00:00", " 18:56:00",
           0.81, 2.81, 7.2, 0.0, 280.0],
          [datetime(1999, 1, 27, 20, 0), datetime(1999, 1, 27, 19, 56),
           "KORD", "19990127", " 20:00:00", " 19:56:00",
           0.01, 2.21, 7.2, 0.0, 260.0],
          [datetime(1999, 1, 27, 21, 0), datetime(1999, 1, 27, 20, 56),
           "KORD", "19990127", " 21:00:00", " 20:56:00",
           -0.59, 2.21, 5.7, 0.0, 280.0],
          [datetime(1999, 1, 27, 21, 0), datetime(1999, 1, 27, 21, 18),
           "KORD", "19990127", " 21:00:00", " 21:18:00",
           -0.99, 2.01, 3.6, 0.0, 270.0],
          [datetime(1999, 1, 27, 22, 0), datetime(1999, 1, 27, 21, 56),
           "KORD", "19990127", " 22:00:00", " 21:56:00",
           -0.59, 1.71, 5.1, 0.0, 290.0],
          [datetime(1999, 1, 27, 23, 0), datetime(1999, 1, 27, 22, 56),
           "KORD", "19990127", " 23:00:00", " 22:56:00",
           -0.59, 1.71, 4.6, 0.0, 280.0],
      ], columns=["actual", "nominal", "X0", "X1", "X2",
                  "X3", "X4", "X5", "X6", "X7", "X8"])
  
      if not keep_date_col:
          expected = expected.drop(["X1", "X2", "X3"], axis=1)
      elif parser.engine == "python":
          expected["X1"] = expected["X1"].astype(np.int64)
  
      # Python can sometimes be flaky about how
      # the aggregated columns are entered, so
      # this standardizes the order.
      result = result[expected.columns]
      tm.assert_frame_equal(result, expected)
  
  
  @pytest.mark.parametrize("keep_date_col", [True, False])
  def test_multiple_date_col(all_parsers, keep_date_col):
      data = """\
  KORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000
  KORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000
  KORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000
  KORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000
  KORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000
  KORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000
  """
      parser = all_parsers
      result = parser.read_csv(StringIO(data), header=None,
                               prefix="X", parse_dates=[[1, 2], [1, 3]],
                               keep_date_col=keep_date_col)
      expected = DataFrame([
          [datetime(1999, 1, 27, 19, 0), datetime(1999, 1, 27, 18, 56),
           "KORD", "19990127", " 19:00:00", " 18:56:00",
           0.81, 2.81, 7.2, 0.0, 280.0],
          [datetime(1999, 1, 27, 20, 0), datetime(1999, 1, 27, 19, 56),
           "KORD", "19990127", " 20:00:00", " 19:56:00",
           0.01, 2.21, 7.2, 0.0, 260.0],
          [datetime(1999, 1, 27, 21, 0), datetime(1999, 1, 27, 20, 56),
           "KORD", "19990127", " 21:00:00", " 20:56:00",
           -0.59, 2.21, 5.7, 0.0, 280.0],
          [datetime(1999, 1, 27, 21, 0), datetime(1999, 1, 27, 21, 18),
           "KORD", "19990127", " 21:00:00", " 21:18:00",
           -0.99, 2.01, 3.6, 0.0, 270.0],
          [datetime(1999, 1, 27, 22, 0), datetime(1999, 1, 27, 21, 56),
           "KORD", "19990127", " 22:00:00", " 21:56:00",
           -0.59, 1.71, 5.1, 0.0, 290.0],
          [datetime(1999, 1, 27, 23, 0), datetime(1999, 1, 27, 22, 56),
           "KORD", "19990127", " 23:00:00", " 22:56:00",
           -0.59, 1.71, 4.6, 0.0, 280.0],
      ], columns=["X1_X2", "X1_X3", "X0", "X1", "X2",
                  "X3", "X4", "X5", "X6", "X7", "X8"])
  
      if not keep_date_col:
          expected = expected.drop(["X1", "X2", "X3"], axis=1)
      elif parser.engine == "python":
          expected["X1"] = expected["X1"].astype(np.int64)
  
      tm.assert_frame_equal(result, expected)
  
  
  def test_date_col_as_index_col(all_parsers):
      data = """\
  KORD,19990127 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000
  KORD,19990127 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000
  KORD,19990127 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000
  KORD,19990127 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000
  KORD,19990127 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000
  """
      parser = all_parsers
      result = parser.read_csv(StringIO(data), header=None, prefix="X",
                               parse_dates=[1], index_col=1)
  
      index = Index([datetime(1999, 1, 27, 19, 0), datetime(1999, 1, 27, 20, 0),
                     datetime(1999, 1, 27, 21, 0), datetime(1999, 1, 27, 21, 0),
                     datetime(1999, 1, 27, 22, 0)], name="X1")
      expected = DataFrame([
          ["KORD", " 18:56:00", 0.81, 2.81, 7.2, 0.0, 280.0],
          ["KORD", " 19:56:00", 0.01, 2.21, 7.2, 0.0, 260.0],
          ["KORD", " 20:56:00", -0.59, 2.21, 5.7, 0.0, 280.0],
          ["KORD", " 21:18:00", -0.99, 2.01, 3.6, 0.0, 270.0],
          ["KORD", " 21:56:00", -0.59, 1.71, 5.1, 0.0, 290.0],
      ], columns=["X0", "X2", "X3", "X4", "X5", "X6", "X7"], index=index)
      tm.assert_frame_equal(result, expected)
  
  
  def test_multiple_date_cols_int_cast(all_parsers):
      data = ("KORD,19990127, 19:00:00, 18:56:00, 0.8100\n"
              "KORD,19990127, 20:00:00, 19:56:00, 0.0100\n"
              "KORD,19990127, 21:00:00, 20:56:00, -0.5900\n"
              "KORD,19990127, 21:00:00, 21:18:00, -0.9900\n"
              "KORD,19990127, 22:00:00, 21:56:00, -0.5900\n"
              "KORD,19990127, 23:00:00, 22:56:00, -0.5900")
      parse_dates = {"actual": [1, 2], "nominal": [1, 3]}
      parser = all_parsers
  
      result = parser.read_csv(StringIO(data), header=None,
                               date_parser=conv.parse_date_time,
                               parse_dates=parse_dates, prefix="X")
      expected = DataFrame([
          [datetime(1999, 1, 27, 19, 0), datetime(1999, 1, 27, 18, 56),
           "KORD", 0.81],
          [datetime(1999, 1, 27, 20, 0), datetime(1999, 1, 27, 19, 56),
           "KORD", 0.01],
          [datetime(1999, 1, 27, 21, 0), datetime(1999, 1, 27, 20, 56),
           "KORD", -0.59],
          [datetime(1999, 1, 27, 21, 0), datetime(1999, 1, 27, 21, 18),
           "KORD", -0.99],
          [datetime(1999, 1, 27, 22, 0), datetime(1999, 1, 27, 21, 56),
           "KORD", -0.59],
          [datetime(1999, 1, 27, 23, 0), datetime(1999, 1, 27, 22, 56),
           "KORD", -0.59],
      ], columns=["actual", "nominal", "X0", "X4"])
  
      # Python can sometimes be flaky about how
      # the aggregated columns are entered, so
      # this standardizes the order.
      result = result[expected.columns]
      tm.assert_frame_equal(result, expected)
  
  
  def test_multiple_date_col_timestamp_parse(all_parsers):
      parser = all_parsers
      data = """05/31/2012,15:30:00.029,1306.25,1,E,0,,1306.25
  05/31/2012,15:30:00.029,1306.25,8,E,0,,1306.25"""
  
      result = parser.read_csv(StringIO(data), parse_dates=[[0, 1]],
                               header=None, date_parser=Timestamp)
      expected = DataFrame([
          [Timestamp("05/31/2012, 15:30:00.029"),
           1306.25, 1, "E", 0, np.nan, 1306.25],
          [Timestamp("05/31/2012, 15:30:00.029"),
           1306.25, 8, "E", 0, np.nan, 1306.25]
      ], columns=["0_1", 2, 3, 4, 5, 6, 7])
      tm.assert_frame_equal(result, expected)
  
  
  def test_multiple_date_cols_with_header(all_parsers):
      parser = all_parsers
      data = """\
  ID,date,NominalTime,ActualTime,TDew,TAir,Windspeed,Precip,WindDir
  KORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000
  KORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000
  KORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000
  KORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000
  KORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000
  KORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000"""
  
      result = parser.read_csv(StringIO(data), parse_dates={"nominal": [1, 2]})
      expected = DataFrame([
          [datetime(1999, 1, 27, 19, 0), "KORD", " 18:56:00",
           0.81, 2.81, 7.2, 0.0, 280.0],
          [datetime(1999, 1, 27, 20, 0), "KORD", " 19:56:00",
           0.01, 2.21, 7.2, 0.0, 260.0],
          [datetime(1999, 1, 27, 21, 0), "KORD", " 20:56:00",
           -0.59, 2.21, 5.7, 0.0, 280.0],
          [datetime(1999, 1, 27, 21, 0), "KORD", " 21:18:00",
           -0.99, 2.01, 3.6, 0.0, 270.0],
          [datetime(1999, 1, 27, 22, 0), "KORD", " 21:56:00",
           -0.59, 1.71, 5.1, 0.0, 290.0],
          [datetime(1999, 1, 27, 23, 0), "KORD", " 22:56:00",
           -0.59, 1.71, 4.6, 0.0, 280.0],
      ], columns=["nominal", "ID", "ActualTime", "TDew",
                  "TAir", "Windspeed", "Precip", "WindDir"])
      tm.assert_frame_equal(result, expected)
  
  
  @pytest.mark.parametrize("data,parse_dates,msg", [
      ("""\
  date_NominalTime,date,NominalTime
  KORD1,19990127, 19:00:00
  KORD2,19990127, 20:00:00""", [[1, 2]], ("New date column already "
                                          "in dict date_NominalTime")),
      ("""\
  ID,date,nominalTime
  KORD,19990127, 19:00:00
  KORD,19990127, 20:00:00""", dict(ID=[1, 2]), "Date column ID already in dict")
  ])
  def test_multiple_date_col_name_collision(all_parsers, data, parse_dates, msg):
      parser = all_parsers
  
      with pytest.raises(ValueError, match=msg):
          parser.read_csv(StringIO(data), parse_dates=parse_dates)
  
  
  def test_date_parser_int_bug(all_parsers):
      # see gh-3071
      parser = all_parsers
      data = ("posix_timestamp,elapsed,sys,user,queries,query_time,rows,"
              "accountid,userid,contactid,level,silo,method\n"
              "1343103150,0.062353,0,4,6,0.01690,3,"
              "12345,1,-1,3,invoice_InvoiceResource,search\n")
  
      result = parser.read_csv(
          StringIO(data), index_col=0, parse_dates=[0],
          date_parser=lambda x: datetime.utcfromtimestamp(int(x)))
      expected = DataFrame([[0.062353, 0, 4, 6, 0.01690, 3, 12345, 1, -1,
                             3, "invoice_InvoiceResource", "search"]],
                           columns=["elapsed", "sys", "user", "queries",
                                    "query_time", "rows", "accountid",
                                    "userid", "contactid", "level",
                                    "silo", "method"],
                           index=Index([Timestamp("2012-07-24 04:12:30")],
                                       name="posix_timestamp"))
      tm.assert_frame_equal(result, expected)
  
  
  def test_nat_parse(all_parsers):
      # see gh-3062
      parser = all_parsers
      df = DataFrame(dict({"A": np.asarray(lrange(10), dtype="float64"),
                           "B": pd.Timestamp("20010101")}))
      df.iloc[3:6, :] = np.nan
  
      with tm.ensure_clean("__nat_parse_.csv") as path:
          df.to_csv(path)
  
          result = parser.read_csv(path, index_col=0, parse_dates=["B"])
          tm.assert_frame_equal(result, df)
  
  
  def test_csv_custom_parser(all_parsers):
      data = """A,B,C
  20090101,a,1,2
  20090102,b,3,4
  20090103,c,4,5
  """
      parser = all_parsers
      result = parser.read_csv(
          StringIO(data),
          date_parser=lambda x: datetime.strptime(x, "%Y%m%d"))
      expected = parser.read_csv(StringIO(data), parse_dates=True)
      tm.assert_frame_equal(result, expected)
  
  
  def test_parse_dates_implicit_first_col(all_parsers):
      data = """A,B,C
  20090101,a,1,2
  20090102,b,3,4
  20090103,c,4,5
  """
      parser = all_parsers
      result = parser.read_csv(StringIO(data), parse_dates=True)
  
      expected = parser.read_csv(StringIO(data), index_col=0,
                                 parse_dates=True)
      tm.assert_frame_equal(result, expected)
  
  
  def test_parse_dates_string(all_parsers):
      data = """date,A,B,C
  20090101,a,1,2
  20090102,b,3,4
  20090103,c,4,5
  """
      parser = all_parsers
      result = parser.read_csv(StringIO(data), index_col="date",
                               parse_dates=["date"])
      index = date_range("1/1/2009", periods=3)
      index.name = "date"
  
      expected = DataFrame({"A": ["a", "b", "c"], "B": [1, 3, 4],
                            "C": [2, 4, 5]}, index=index)
      tm.assert_frame_equal(result, expected)
  
  
  # Bug in https://github.com/dateutil/dateutil/issues/217
  # has been addressed, but we just don't pass in the `yearfirst`
  @pytest.mark.xfail(reason="yearfirst is not surfaced in read_*")
  @pytest.mark.parametrize("parse_dates", [
      [["date", "time"]],
      [[0, 1]]
  ])
  def test_yy_format_with_year_first(all_parsers, parse_dates):
      data = """date,time,B,C
  090131,0010,1,2
  090228,1020,3,4
  090331,0830,5,6
  """
      parser = all_parsers
      result = parser.read_csv(StringIO(data), index_col=0,
                               parse_dates=parse_dates)
      index = DatetimeIndex([datetime(2009, 1, 31, 0, 10, 0),
                             datetime(2009, 2, 28, 10, 20, 0),
                             datetime(2009, 3, 31, 8, 30, 0)],
                            dtype=object, name="date_time")
      expected = DataFrame({"B": [1, 3, 5], "C": [2, 4, 6]}, index=index)
      tm.assert_frame_equal(result, expected)
  
  
  @pytest.mark.parametrize("parse_dates", [[0, 2], ["a", "c"]])
  def test_parse_dates_column_list(all_parsers, parse_dates):
      data = "a,b,c\n01/01/2010,1,15/02/2010"
      parser = all_parsers
  
      expected = DataFrame({"a": [datetime(2010, 1, 1)], "b": [1],
                            "c": [datetime(2010, 2, 15)]})
      expected = expected.set_index(["a", "b"])
  
      result = parser.read_csv(StringIO(data), index_col=[0, 1],
                               parse_dates=parse_dates, dayfirst=True)
      tm.assert_frame_equal(result, expected)
  
  
  @pytest.mark.parametrize("index_col", [[0, 1], [1, 0]])
  def test_multi_index_parse_dates(all_parsers, index_col):
      data = """index1,index2,A,B,C
  20090101,one,a,1,2
  20090101,two,b,3,4
  20090101,three,c,4,5
  20090102,one,a,1,2
  20090102,two,b,3,4
  20090102,three,c,4,5
  20090103,one,a,1,2
  20090103,two,b,3,4
  20090103,three,c,4,5
  """
      parser = all_parsers
      index = MultiIndex.from_product([
          (datetime(2009, 1, 1), datetime(2009, 1, 2),
           datetime(2009, 1, 3)), ("one", "two", "three")],
          names=["index1", "index2"])
  
      # Out of order.
      if index_col == [1, 0]:
          index = index.swaplevel(0, 1)
  
      expected = DataFrame([["a", 1, 2], ["b", 3, 4], ["c", 4, 5],
                            ["a", 1, 2], ["b", 3, 4], ["c", 4, 5],
                            ["a", 1, 2], ["b", 3, 4], ["c", 4, 5]],
                           columns=["A", "B", "C"], index=index)
      result = parser.read_csv(StringIO(data), index_col=index_col,
                               parse_dates=True)
      tm.assert_frame_equal(result, expected)
  
  
  @pytest.mark.parametrize("kwargs", [
      dict(dayfirst=True), dict(day_first=True)
  ])
  def test_parse_dates_custom_euro_format(all_parsers, kwargs):
      parser = all_parsers
      data = """foo,bar,baz
  31/01/2010,1,2
  01/02/2010,1,NA
  02/02/2010,1,2
  """
      if "dayfirst" in kwargs:
          df = parser.read_csv(StringIO(data), names=["time", "Q", "NTU"],
                               date_parser=lambda d: parse_date(d, **kwargs),
                               header=0, index_col=0, parse_dates=True,
                               na_values=["NA"])
          exp_index = Index([datetime(2010, 1, 31), datetime(2010, 2, 1),
                             datetime(2010, 2, 2)], name="time")
          expected = DataFrame({"Q": [1, 1, 1], "NTU": [2, np.nan, 2]},
                               index=exp_index, columns=["Q", "NTU"])
          tm.assert_frame_equal(df, expected)
      else:
          msg = "got an unexpected keyword argument 'day_first'"
          with pytest.raises(TypeError, match=msg):
              parser.read_csv(StringIO(data), names=["time", "Q", "NTU"],
                              date_parser=lambda d: parse_date(d, **kwargs),
                              skiprows=[0], index_col=0, parse_dates=True,
                              na_values=["NA"])
  
  
  def test_parse_tz_aware(all_parsers):
      # See gh-1693
      parser = all_parsers
      data = "Date,x\n2012-06-13T01:39:00Z,0.5"
  
      result = parser.read_csv(StringIO(data), index_col=0,
                               parse_dates=True)
      expected = DataFrame({"x": [0.5]}, index=Index([Timestamp(
          "2012-06-13 01:39:00+00:00")], name="Date"))
      tm.assert_frame_equal(result, expected)
      assert result.index.tz is pytz.utc
  
  
  @pytest.mark.parametrize("parse_dates,index_col", [
      ({"nominal": [1, 2]}, "nominal"),
      ({"nominal": [1, 2]}, 0),
      ([[1, 2]], 0),
  ])
  def test_multiple_date_cols_index(all_parsers, parse_dates, index_col):
      parser = all_parsers
      data = """
  ID,date,NominalTime,ActualTime,TDew,TAir,Windspeed,Precip,WindDir
  KORD1,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000
  KORD2,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000
  KORD3,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000
  KORD4,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000
  KORD5,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000
  KORD6,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000
  """
      expected = DataFrame([
          [datetime(1999, 1, 27, 19, 0), "KORD1", " 18:56:00",
           0.81, 2.81, 7.2, 0.0, 280.0],
          [datetime(1999, 1, 27, 20, 0), "KORD2", " 19:56:00",
           0.01, 2.21, 7.2, 0.0, 260.0],
          [datetime(1999, 1, 27, 21, 0), "KORD3", " 20:56:00",
           -0.59, 2.21, 5.7, 0.0, 280.0],
          [datetime(1999, 1, 27, 21, 0), "KORD4", " 21:18:00",
           -0.99, 2.01, 3.6, 0.0, 270.0],
          [datetime(1999, 1, 27, 22, 0), "KORD5", " 21:56:00",
           -0.59, 1.71, 5.1, 0.0, 290.0],
          [datetime(1999, 1, 27, 23, 0), "KORD6", " 22:56:00",
           -0.59, 1.71, 4.6, 0.0, 280.0],
      ], columns=["nominal", "ID", "ActualTime", "TDew",
                  "TAir", "Windspeed", "Precip", "WindDir"])
      expected = expected.set_index("nominal")
  
      if not isinstance(parse_dates, dict):
          expected.index.name = "date_NominalTime"
  
      result = parser.read_csv(StringIO(data), parse_dates=parse_dates,
                               index_col=index_col)
      tm.assert_frame_equal(result, expected)
  
  
  def test_multiple_date_cols_chunked(all_parsers):
      parser = all_parsers
      data = """\
  ID,date,nominalTime,actualTime,A,B,C,D,E
  KORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000
  KORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000
  KORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000
  KORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000
  KORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000
  KORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000
  """
  
      expected = DataFrame([
          [datetime(1999, 1, 27, 19, 0), "KORD", " 18:56:00",
           0.81, 2.81, 7.2, 0.0, 280.0],
          [datetime(1999, 1, 27, 20, 0), "KORD", " 19:56:00",
           0.01, 2.21, 7.2, 0.0, 260.0],
          [datetime(1999, 1, 27, 21, 0), "KORD", " 20:56:00",
           -0.59, 2.21, 5.7, 0.0, 280.0],
          [datetime(1999, 1, 27, 21, 0), "KORD", " 21:18:00",
           -0.99, 2.01, 3.6, 0.0, 270.0],
          [datetime(1999, 1, 27, 22, 0), "KORD", " 21:56:00",
           -0.59, 1.71, 5.1, 0.0, 290.0],
          [datetime(1999, 1, 27, 23, 0), "KORD", " 22:56:00",
           -0.59, 1.71, 4.6, 0.0, 280.0],
      ], columns=["nominal", "ID", "actualTime", "A", "B", "C", "D", "E"])
      expected = expected.set_index("nominal")
  
      reader = parser.read_csv(StringIO(data), parse_dates={"nominal": [1, 2]},
                               index_col="nominal", chunksize=2)
      chunks = list(reader)
  
      tm.assert_frame_equal(chunks[0], expected[:2])
      tm.assert_frame_equal(chunks[1], expected[2:4])
      tm.assert_frame_equal(chunks[2], expected[4:])
  
  
  def test_multiple_date_col_named_index_compat(all_parsers):
      parser = all_parsers
      data = """\
  ID,date,nominalTime,actualTime,A,B,C,D,E
  KORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000
  KORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000
  KORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000
  KORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000
  KORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000
  KORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000
  """
  
      with_indices = parser.read_csv(StringIO(data),
                                     parse_dates={"nominal": [1, 2]},
                                     index_col="nominal")
      with_names = parser.read_csv(StringIO(data), index_col="nominal",
                                   parse_dates={"nominal": [
                                       "date", "nominalTime"]})
      tm.assert_frame_equal(with_indices, with_names)
  
  
  def test_multiple_date_col_multiple_index_compat(all_parsers):
      parser = all_parsers
      data = """\
  ID,date,nominalTime,actualTime,A,B,C,D,E
  KORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000
  KORD,19990127, 20:00:00, 19:56:00, 0.0100, 2.2100, 7.2000, 0.0000, 260.0000
  KORD,19990127, 21:00:00, 20:56:00, -0.5900, 2.2100, 5.7000, 0.0000, 280.0000
  KORD,19990127, 21:00:00, 21:18:00, -0.9900, 2.0100, 3.6000, 0.0000, 270.0000
  KORD,19990127, 22:00:00, 21:56:00, -0.5900, 1.7100, 5.1000, 0.0000, 290.0000
  KORD,19990127, 23:00:00, 22:56:00, -0.5900, 1.7100, 4.6000, 0.0000, 280.0000
  """
      result = parser.read_csv(StringIO(data), index_col=["nominal", "ID"],
                               parse_dates={"nominal": [1, 2]})
      expected = parser.read_csv(StringIO(data),
                                 parse_dates={"nominal": [1, 2]})
  
      expected = expected.set_index(["nominal", "ID"])
      tm.assert_frame_equal(result, expected)
  
  
  @pytest.mark.parametrize("kwargs", [dict(), dict(index_col="C")])
  def test_read_with_parse_dates_scalar_non_bool(all_parsers, kwargs):
      # see gh-5636
      parser = all_parsers
      msg = ("Only booleans, lists, and dictionaries "
             "are accepted for the 'parse_dates' parameter")
      data = """A,B,C
      1,2,2003-11-1"""
  
      with pytest.raises(TypeError, match=msg):
          parser.read_csv(StringIO(data), parse_dates="C", **kwargs)
  
  
  @pytest.mark.parametrize("parse_dates", [
      (1,), np.array([4, 5]), {1, 3, 3}
  ])
  def test_read_with_parse_dates_invalid_type(all_parsers, parse_dates):
      parser = all_parsers
      msg = ("Only booleans, lists, and dictionaries "
             "are accepted for the 'parse_dates' parameter")
      data = """A,B,C
      1,2,2003-11-1"""
  
      with pytest.raises(TypeError, match=msg):
          parser.read_csv(StringIO(data), parse_dates=(1,))
  
  
  def test_parse_dates_empty_string(all_parsers):
      # see gh-2263
      parser = all_parsers
      data = "Date,test\n2012-01-01,1\n,2"
      result = parser.read_csv(StringIO(data), parse_dates=["Date"],
                               na_filter=False)
  
      expected = DataFrame([[datetime(2012, 1, 1), 1], [pd.NaT, 2]],
                           columns=["Date", "test"])
      tm.assert_frame_equal(result, expected)
  
  
  @pytest.mark.parametrize("data,kwargs,expected", [
      ("a\n04.15.2016", dict(parse_dates=["a"]),
       DataFrame([datetime(2016, 4, 15)], columns=["a"])),
      ("a\n04.15.2016", dict(parse_dates=True, index_col=0),
       DataFrame(index=DatetimeIndex(["2016-04-15"], name="a"))),
      ("a,b\n04.15.2016,09.16.2013", dict(parse_dates=["a", "b"]),
       DataFrame([[datetime(2016, 4, 15), datetime(2013, 9, 16)]],
                 columns=["a", "b"])),
      ("a,b\n04.15.2016,09.16.2013", dict(parse_dates=True, index_col=[0, 1]),
       DataFrame(index=MultiIndex.from_tuples(
           [(datetime(2016, 4, 15), datetime(2013, 9, 16))], names=["a", "b"]))),
  ])
  def test_parse_dates_no_convert_thousands(all_parsers, data, kwargs, expected):
      # see gh-14066
      parser = all_parsers
  
      result = parser.read_csv(StringIO(data), thousands=".", **kwargs)
      tm.assert_frame_equal(result, expected)
  
  
  def test_parse_date_time_multi_level_column_name(all_parsers):
      data = """\
  D,T,A,B
  date, time,a,b
  2001-01-05, 09:00:00, 0.0, 10.
  2001-01-06, 00:00:00, 1.0, 11.
  """
      parser = all_parsers
      result = parser.read_csv(StringIO(data), header=[0, 1],
                               parse_dates={"date_time": [0, 1]},
                               date_parser=conv.parse_date_time)
  
      expected_data = [[datetime(2001, 1, 5, 9, 0, 0), 0., 10.],
                       [datetime(2001, 1, 6, 0, 0, 0), 1., 11.]]
      expected = DataFrame(expected_data,
                           columns=["date_time", ("A", "a"), ("B", "b")])
      tm.assert_frame_equal(result, expected)
  
  
  @pytest.mark.parametrize("data,kwargs,expected", [
      ("""\
  date,time,a,b
  2001-01-05, 10:00:00, 0.0, 10.
  2001-01-05, 00:00:00, 1., 11.
  """, dict(header=0, parse_dates={"date_time": [0, 1]}),
       DataFrame([[datetime(2001, 1, 5, 10, 0, 0), 0.0, 10],
                  [datetime(2001, 1, 5, 0, 0, 0), 1.0, 11.0]],
                 columns=["date_time", "a", "b"])),
      (("KORD,19990127, 19:00:00, 18:56:00, 0.8100\n"
        "KORD,19990127, 20:00:00, 19:56:00, 0.0100\n"
        "KORD,19990127, 21:00:00, 20:56:00, -0.5900\n"
        "KORD,19990127, 21:00:00, 21:18:00, -0.9900\n"
        "KORD,19990127, 22:00:00, 21:56:00, -0.5900\n"
        "KORD,19990127, 23:00:00, 22:56:00, -0.5900"),
       dict(header=None, parse_dates={"actual": [1, 2], "nominal": [1, 3]}),
       DataFrame([
           [datetime(1999, 1, 27, 19, 0), datetime(1999, 1, 27, 18, 56),
            "KORD", 0.81],
           [datetime(1999, 1, 27, 20, 0), datetime(1999, 1, 27, 19, 56),
            "KORD", 0.01],
           [datetime(1999, 1, 27, 21, 0), datetime(1999, 1, 27, 20, 56),
            "KORD", -0.59],
           [datetime(1999, 1, 27, 21, 0), datetime(1999, 1, 27, 21, 18),
            "KORD", -0.99],
           [datetime(1999, 1, 27, 22, 0), datetime(1999, 1, 27, 21, 56),
            "KORD", -0.59],
           [datetime(1999, 1, 27, 23, 0), datetime(1999, 1, 27, 22, 56),
            "KORD", -0.59]], columns=["actual", "nominal", 0, 4])),
  ])
  def test_parse_date_time(all_parsers, data, kwargs, expected):
      parser = all_parsers
      result = parser.read_csv(StringIO(data), date_parser=conv.parse_date_time,
                               **kwargs)
  
      # Python can sometimes be flaky about how
      # the aggregated columns are entered, so
      # this standardizes the order.
      result = result[expected.columns]
      tm.assert_frame_equal(result, expected)
  
  
  def test_parse_date_fields(all_parsers):
      parser = all_parsers
      data = ("year,month,day,a\n2001,01,10,10.\n"
              "2001,02,1,11.")
      result = parser.read_csv(StringIO(data), header=0,
                               parse_dates={"ymd": [0, 1, 2]},
                               date_parser=conv.parse_date_fields)
  
      expected = DataFrame([[datetime(2001, 1, 10), 10.],
                            [datetime(2001, 2, 1), 11.]], columns=["ymd", "a"])
      tm.assert_frame_equal(result, expected)
  
  
  def test_parse_date_all_fields(all_parsers):
      parser = all_parsers
      data = """\
  year,month,day,hour,minute,second,a,b
  2001,01,05,10,00,0,0.0,10.
  2001,01,5,10,0,00,1.,11.
  """
      result = parser.read_csv(StringIO(data), header=0,
                               date_parser=conv.parse_all_fields,
                               parse_dates={"ymdHMS": [0, 1, 2, 3, 4, 5]})
      expected = DataFrame([[datetime(2001, 1, 5, 10, 0, 0), 0.0, 10.0],
                            [datetime(2001, 1, 5, 10, 0, 0), 1.0, 11.0]],
                           columns=["ymdHMS", "a", "b"])
      tm.assert_frame_equal(result, expected)
  
  
  def test_datetime_fractional_seconds(all_parsers):
      parser = all_parsers
      data = """\
  year,month,day,hour,minute,second,a,b
  2001,01,05,10,00,0.123456,0.0,10.
  2001,01,5,10,0,0.500000,1.,11.
  """
      result = parser.read_csv(StringIO(data), header=0,
                               date_parser=conv.parse_all_fields,
                               parse_dates={"ymdHMS": [0, 1, 2, 3, 4, 5]})
      expected = DataFrame([[datetime(2001, 1, 5, 10, 0, 0,
                                      microsecond=123456), 0.0, 10.0],
                            [datetime(2001, 1, 5, 10, 0, 0,
                                      microsecond=500000), 1.0, 11.0]],
                           columns=["ymdHMS", "a", "b"])
      tm.assert_frame_equal(result, expected)
  
  
  def test_generic(all_parsers):
      parser = all_parsers
      data = "year,month,day,a\n2001,01,10,10.\n2001,02,1,11."
  
      result = parser.read_csv(StringIO(data), header=0,
                               parse_dates={"ym": [0, 1]},
                               date_parser=lambda y, m: date(year=int(y),
                                                             month=int(m),
                                                             day=1))
      expected = DataFrame([[date(2001, 1, 1), 10, 10.],
                            [date(2001, 2, 1), 1, 11.]],
                           columns=["ym", "day", "a"])
      tm.assert_frame_equal(result, expected)
  
  
  def test_date_parser_resolution_if_not_ns(all_parsers):
      # see gh-10245
      parser = all_parsers
      data = """\
  date,time,prn,rxstatus
  2013-11-03,19:00:00,126,00E80000
  2013-11-03,19:00:00,23,00E80000
  2013-11-03,19:00:00,13,00E80000
  """
  
      def date_parser(dt, time):
          return np_array_datetime64_compat(dt + "T" + time + "Z",
                                            dtype="datetime64[s]")
  
      result = parser.read_csv(StringIO(data), date_parser=date_parser,
                               parse_dates={"datetime": ["date", "time"]},
                               index_col=["datetime", "prn"])
  
      datetimes = np_array_datetime64_compat(["2013-11-03T19:00:00Z"] * 3,
                                             dtype="datetime64[s]")
      expected = DataFrame(data={"rxstatus": ["00E80000"] * 3},
                           index=MultiIndex.from_tuples(
                               [(datetimes[0], 126), (datetimes[1], 23),
                                (datetimes[2], 13)], names=["datetime", "prn"]))
      tm.assert_frame_equal(result, expected)
  
  
  def test_parse_date_column_with_empty_string(all_parsers):
      # see gh-6428
      parser = all_parsers
      data = "case,opdate\n7,10/18/2006\n7,10/18/2008\n621, "
      result = parser.read_csv(StringIO(data), parse_dates=["opdate"])
  
      expected_data = [[7, "10/18/2006"],
                       [7, "10/18/2008"],
                       [621, " "]]
      expected = DataFrame(expected_data, columns=["case", "opdate"])
      tm.assert_frame_equal(result, expected)
  
  
  @pytest.mark.parametrize("data,expected", [
      ("a\n135217135789158401\n1352171357E+5",
       DataFrame({"a": [135217135789158401,
                        135217135700000]}, dtype="float64")),
      ("a\n99999999999\n123456789012345\n1234E+0",
       DataFrame({"a": [99999999999,
                        123456789012345,
                        1234]}, dtype="float64"))
  ])
  @pytest.mark.parametrize("parse_dates", [True, False])
  def test_parse_date_float(all_parsers, data, expected, parse_dates):
      # see gh-2697
      #
      # Date parsing should fail, so we leave the data untouched
      # (i.e. float precision should remain unchanged).
      parser = all_parsers
  
      result = parser.read_csv(StringIO(data), parse_dates=parse_dates)
      tm.assert_frame_equal(result, expected)
  
  
  def test_parse_timezone(all_parsers):
      # see gh-22256
      parser = all_parsers
      data = """dt,val
                2018-01-04 09:01:00+09:00,23350
                2018-01-04 09:02:00+09:00,23400
                2018-01-04 09:03:00+09:00,23400
                2018-01-04 09:04:00+09:00,23400
                2018-01-04 09:05:00+09:00,23400"""
      result = parser.read_csv(StringIO(data), parse_dates=["dt"])
  
      dti = pd.date_range(start="2018-01-04 09:01:00",
                          end="2018-01-04 09:05:00", freq="1min",
                          tz=pytz.FixedOffset(540))
      expected_data = {"dt": dti, "val": [23350, 23400, 23400, 23400, 23400]}
  
      expected = DataFrame(expected_data)
      tm.assert_frame_equal(result, expected)
  
apis: pandas.util.testing.ensure_clean pandas.compat.parse_date pandas.DatetimeIndex pandas.core.indexes.datetimes.date_range pandas.DataFrame pandas._libs.tslib.Timestamp pandas.io.parsers._concat_date_cols pandas.MultiIndex.from_tuples pandas.compat.numpy.np_array_datetime64_compat pandas.compat.lrange numpy.array pandas.util.testing.assert_frame_equal pandas.Timestamp