internlm/SWE-Fixer-Train-110K huggingface dataset:
Repository: pandas-dev/pandas

Issue:
BUG: datetime ops with non-unique indexes is buggy
from [SO](http://stackoverflow.com/questions/25963622/column-operations-with-pandas-dataframe-objects-with-non-unique-indices/25964177?noredirect=1#comment40684868_25964177)

```
In [3]:       df = DataFrame({'A' : np.arange(5), 'B' : np.arange(1,6)},index=[2,2,3,3,4])

In [4]:   df.B-df.A
Out[4]: 
2    1
2    1
3    1
3    1
4    1
dtype: int64

In [5]:        df = DataFrame({'A' : date_range('20130101',periods=5), 'B' : date_range('20130101 09:00:00', periods=5)},index=[2,2,3,3,4])

In [6]:   df.B-df.A
Out[6]: 
2     0 days 09:00:00
2   -1 days +09:00:00
2     1 days 09:00:00
2     0 days 09:00:00
3     0 days 09:00:00
3   -1 days +09:00:00
3     1 days 09:00:00
3     0 days 09:00:00
4     0 days 09:00:00
dtype: timedelta64[ns]
```



Discussion:

Resolving patch:
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -3112,9 +3112,13 @@ def _align_series(self, other, join='outer', axis=None, level=None,
                 raise ValueError('cannot align series to a series other than '
                                  'axis 0')
 
-            join_index, lidx, ridx = self.index.join(other.index, how=join,
-                                                     level=level,
-                                                     return_indexers=True)
+            # equal
+            if  self.index.equals(other.index):
+                join_index, lidx, ridx = None, None, None
+            else:
+                join_index, lidx, ridx = self.index.join(other.index, how=join,
+                                                         level=level,
+                                                         return_indexers=True)
 
             left_result = self._reindex_indexer(join_index, lidx, copy)
             right_result = other._reindex_indexer(join_index, ridx, copy)


Test patch:
diff --git a/pandas/tests/test_frame.py b/pandas/tests/test_frame.py
--- a/pandas/tests/test_frame.py
+++ b/pandas/tests/test_frame.py
@@ -3523,6 +3523,21 @@ def check(result, expected=None):
         result = z.ix[['a', 'c', 'a']]
         check(result,expected)
 
+
+    def test_column_dups_indexing2(self):
+
+        # GH 8363
+        # datetime ops with a non-unique index
+        df = DataFrame({'A' : np.arange(5), 'B' : np.arange(1,6)},index=[2,2,3,3,4])
+        result = df.B-df.A
+        expected = Series(1,index=[2,2,3,3,4])
+        assert_series_equal(result,expected)
+
+        df = DataFrame({'A' : date_range('20130101',periods=5), 'B' : date_range('20130101 09:00:00', periods=5)},index=[2,2,3,3,4])
+        result = df.B-df.A
+        expected = Series(Timedelta('9 hours'),index=[2,2,3,3,4])
+        assert_series_equal(result,expected)
+
     def test_insert_benchmark(self):
         # from the vb_suite/frame_methods/frame_insert_columns
         N = 10
Repository: pandas-dev/pandas

Issue:
Suggestion/Discussion: read_hdf
At the moment `read_hdf` is implemented such way that it opens HDFStore connection immediately when it is called. If the file does not exist, then it creates an HDF file and then throws `KeyError`. There are two side effects:
- You can not distinguish situation when the file does not exist from situation when the key does not exist in the file
- If you have a typo in the filename, empty file is created -> polluting directory 

I suggest to check if the file exist before and throw `IOError` if it does not.



Discussion:
sounds reasonable. The reason this behavior is that the default mode is `a` (append), to avoid certain issues with concurrency with some older pytables. iow. you can open a file multiple times (even across processes) no problem, but (even though this seems backward), opening in append mode with always work, but opening in read-only mode _can_ raise if the file is opened in append mode elsewhere.

so you can open with `mode='r'` and this should raise`IOError`` if it doesn't exist.

the api change is to do the same even if the mode is append AND its called from `read_hdf` AND the file doesn't exist.

pull-requests are welcome!

I was looking around the issues and this one popped out a relatively simple to fix. I'm new in pandas dev, so forgive me if I'm misunderstanding. Is the fix/change proposal for this simply some of kind file existence check in https://github.com/pydata/pandas/blob/master/pandas/io/pytables.py#L299 before we create an entire HDFStore object? Or is there still a need to create an HDFStore object, but to pop an IOError instead of a KeyError? When would we want to still create a HDFStore object, even if read_hdf fails?

your first suggestion is right. if the file doesn't exist (and you are in read_hdf), then don't create it, but raise an IOError


Resolving patch:
diff --git a/pandas/io/pytables.py b/pandas/io/pytables.py
--- a/pandas/io/pytables.py
+++ b/pandas/io/pytables.py
@@ -332,6 +332,16 @@ def read_hdf(path_or_buf, key, **kwargs):
         key, auto_close=auto_close, **kwargs)
 
     if isinstance(path_or_buf, string_types):
+        
+        try:
+            exists = os.path.exists(path_or_buf)
+
+        #if filepath is too long
+        except (TypeError,ValueError):
+            exists = False
+
+        if not exists:
+            raise IOError('File %s does not exist' % path_or_buf)
 
         # can't auto open/close if we are using an iterator
         # so delegate to the iterator


Test patch:
diff --git a/pandas/io/tests/test_pytables.py b/pandas/io/tests/test_pytables.py
--- a/pandas/io/tests/test_pytables.py
+++ b/pandas/io/tests/test_pytables.py
@@ -288,6 +288,10 @@ def test_api(self):
             self.assertRaises(TypeError, df.to_hdf, path,'df',append=True,format='foo')
             self.assertRaises(TypeError, df.to_hdf, path,'df',append=False,format='bar')
 
+        #File path doesn't exist
+        path = ""
+        self.assertRaises(IOError, read_hdf, path, 'df') 
+
     def test_api_default_format(self):
 
         # default_format option
Repository: pandas-dev/pandas

Issue:
PERF: add vbenchs for groupby functions with different group sizes
http://stackoverflow.com/questions/22845856/performance-issues-with-groupbys-last-in-pandas/22846215#22846215

want to run all built-in functions (e.g. `first,last,nth,sum,min`...etc with
large number of groups, say 10000 to verify perf.



Discussion:

Resolving patch:
diff --git a/vb_suite/groupby.py b/vb_suite/groupby.py
--- a/vb_suite/groupby.py
+++ b/vb_suite/groupby.py
@@ -484,3 +484,78 @@ def f(g):
 
 groupby_agg_builtins1 = Benchmark("df.groupby('jim').agg([sum, min, max])", setup)
 groupby_agg_builtins2 = Benchmark("df.groupby(['jim', 'joe']).agg([sum, min, max])", setup)
+
+#----------------------------------------------------------------------
+# groupby with a variable value for ngroups
+
+
+ngroups_list = [100, 10000]
+no_arg_func_list = [
+    'all',
+    'any',
+    'count',
+    'cumcount',
+    'cummax',
+    'cummin',
+    'cumprod',
+    'cumsum',
+    'describe',
+    'diff',
+    'first',
+    'head',
+    'last',
+    'mad',
+    'max',
+    'mean',
+    'median',
+    'min',
+    'nunique',
+    'pct_change',
+    'prod',
+    'rank',
+    'sem',
+    'size',
+    'skew',
+    'std',
+    'sum',
+    'tail',
+    'unique',
+    'var',
+    'value_counts',
+]
+
+
+_stmt_template = "df.groupby('value')['timestamp'].%s"
+_setup_template = common_setup + """
+np.random.seed(1234)
+ngroups = %s
+size = ngroups * 10
+rng = np.arange(ngroups)
+df = DataFrame(dict(
+    timestamp=rng.take(np.random.randint(0, ngroups, size=size)),
+    value=np.random.randint(0, size, size=size)
+))
+"""
+START_DATE = datetime(2011, 7, 1)
+
+
+def make_large_ngroups_bmark(ngroups, func_name, func_args=''):
+    bmark_name = 'groupby_ngroups_%s_%s' % (ngroups, func_name)
+    stmt = _stmt_template % ('%s(%s)' % (func_name, func_args))
+    setup = _setup_template % ngroups
+    bmark = Benchmark(stmt, setup, start_date=START_DATE)
+    # MUST set name
+    bmark.name = bmark_name
+    return bmark
+
+
+def inject_bmark_into_globals(bmark):
+    if not bmark.name:
+        raise AssertionError('benchmark must have a name')
+    globals()[bmark.name] = bmark
+
+
+for ngroups in ngroups_list:
+    for func_name in no_arg_func_list:
+        bmark = make_large_ngroups_bmark(ngroups, func_name)
+        inject_bmark_into_globals(bmark)


Test patch:
Repository: pandas-dev/pandas

Issue:
REGR: grouping with a multi-index with first, a regression from 0.14.1
reported in #7965

```
df = pd.DataFrame([[1,2,3],[4,5,6],[7,8,9]])
df.columns = pd.MultiIndex.from_tuples([(0,1),(1,1),(2,1)])
df.groupby(axis=1, level=[0,1]).first()
TypeError: can only sort by level with a hierarchical index
```



Discussion:

Resolving patch:
diff --git a/pandas/core/groupby.py b/pandas/core/groupby.py
--- a/pandas/core/groupby.py
+++ b/pandas/core/groupby.py
@@ -3233,7 +3233,8 @@ def _reindex_output(self, result):
 
         levels_list = [ ping._group_index for ping in groupings ]
         index = MultiIndex.from_product(levels_list, names=self.grouper.names)
-        return result.reindex(**{ self.obj._get_axis_name(self.axis) : index, 'copy' : False }).sortlevel()
+        d = { self.obj._get_axis_name(self.axis) : index, 'copy' : False }
+        return result.reindex(**d).sortlevel(axis=self.axis)
 
     def _iterate_column_groupbys(self):
         for i, colname in enumerate(self._selected_obj.columns):


Test patch:
diff --git a/pandas/tests/test_groupby.py b/pandas/tests/test_groupby.py
--- a/pandas/tests/test_groupby.py
+++ b/pandas/tests/test_groupby.py
@@ -1495,6 +1495,16 @@ def test_groupby_as_index_agg(self):
         result3 = grouped['C'].agg({'Q': np.sum})
         assert_frame_equal(result3, expected3)
 
+    def test_mulitindex_passthru(self):
+
+        # GH 7997
+        # regression from 0.14.1
+        df = pd.DataFrame([[1,2,3],[4,5,6],[7,8,9]])
+        df.columns = pd.MultiIndex.from_tuples([(0,1),(1,1),(2,1)])
+
+        result = df.groupby(axis=1, level=[0,1]).first()
+        assert_frame_equal(result, df)
+
     def test_multifunc_select_col_integer_cols(self):
         df = self.df
         df.columns = np.arange(len(df.columns))
Repository: pandas-dev/pandas

Issue:
BinGrouper breaks on DataFrame.transform
``` python
import pandas as pd
import numpy as np
from pandas.tseries.resample import TimeGrouper
import pandas.util.testing as tm

df = tm.makeTimeDataFrame()
tg = TimeGrouper('M')

func = lambda x: (x - 1)
df.groupby(tg).transform(func)

```

```
/externals/pandas/pandas/core/groupby.py in _get_compressed_labels(self)
   1360     def _get_compressed_labels(self):
-> 1361         all_labels = [ping.labels for ping in self.groupings]
   1362         if self._overflow_possible:

TypeError: 'NoneType' object is not iterable
```

Seems related to #8049 as that check group_info which errors on BinGrouper since there are no `groupings`



Discussion:
hmm breaking on the heuristic to figure out if we have the right label set

I can take a stab if u would like
I prob will look later


Resolving patch:
diff --git a/pandas/core/groupby.py b/pandas/core/groupby.py
--- a/pandas/core/groupby.py
+++ b/pandas/core/groupby.py
@@ -484,8 +484,7 @@ def _set_result_index_ordered(self, result):
         indices = self.indices
 
         # shortcut of we have an already ordered grouper
-
-        if not Index(self.grouper.group_info[0]).is_monotonic:
+        if not self.grouper.is_monotonic:
             index = Index(np.concatenate([ indices[v] for v in self.grouper.result_index ]))
             result.index = index
             result = result.sort_index()
@@ -1348,6 +1347,11 @@ def groups(self):
             to_groupby = Index(to_groupby)
             return self.axis.groupby(to_groupby.values)
 
+    @cache_readonly
+    def is_monotonic(self):
+        # return if my group orderings are monotonic
+        return Index(self.group_info[0]).is_monotonic
+
     @cache_readonly
     def group_info(self):
         comp_ids, obs_group_ids = self._get_compressed_labels()
@@ -1739,6 +1743,11 @@ def indices(self):
                 i = bin
         return indices
 
+    @cache_readonly
+    def group_info(self):
+        # for compat
+        return self.bins, self.binlabels, self.ngroups
+
     @cache_readonly
     def ngroups(self):
         return len(self.binlabels)


Test patch:
diff --git a/pandas/tests/test_groupby.py b/pandas/tests/test_groupby.py
--- a/pandas/tests/test_groupby.py
+++ b/pandas/tests/test_groupby.py
@@ -897,6 +897,11 @@ def demean(arr):
         expected = people.groupby(key).apply(demean).groupby(key).mean()
         assert_frame_equal(result, expected)
 
+        # GH 8430
+        df = tm.makeTimeDataFrame()
+        g = df.groupby(pd.TimeGrouper('M'))
+        g.transform(lambda x: x-1)
+
     def test_transform_fast(self):
 
         df = DataFrame( { 'id' : np.arange( 100000 ) / 3,
Repository: pandas-dev/pandas

Issue:
Indexing Series with DataFrame should throw an exception
I came across this today when being a little bit careless when using a boolean array to index into a Series.  The result was not what I expected which turned out to be because I was using a boolean index in a DataFrame to index a Series.  Either we should make this work or throw an error that you cannot index a Series with a DataFrame.

```
import pandas as pd
series = pd.Series(10, index=range(10))
df = pd.DataFrame(range(10), index=range(10))
series[df > 5]
Out[9]: 
0    10
dtype: int64
# What is really meant is this:
series[df[0] > 5]
Out[11]: 
6    10
7    10
8    10
9    10
dtype: int64
```

This is on 0.14.1



Discussion:
this is checked for in `.loc` but not getitem (`[]`). yes I would agree. would you like to submit a PR?

Sure, seems straightforward.


Resolving patch:
diff --git a/pandas/core/series.py b/pandas/core/series.py
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -21,7 +21,7 @@
                                 _possibly_convert_platform, _try_sort,
                                 ABCSparseArray, _maybe_match_name, _coerce_to_dtype,
                                 _ensure_object, SettingWithCopyError,
-                                _maybe_box_datetimelike)
+                                _maybe_box_datetimelike, ABCDataFrame)
 from pandas.core.index import (Index, MultiIndex, InvalidIndexError,
                                _ensure_index)
 from pandas.core.indexing import _check_bool_indexer, _maybe_convert_indices
@@ -545,6 +545,9 @@ def _get_with(self, key):
         if isinstance(key, slice):
             indexer = self.index._convert_slice_indexer(key, typ='getitem')
             return self._get_values(indexer)
+        elif isinstance(key, ABCDataFrame):
+            raise TypeError('Indexing a Series with DataFrame is not supported, '\
+                            'use the appropriate DataFrame column')
         else:
             if isinstance(key, tuple):
                 try:


Test patch:
diff --git a/pandas/tests/test_series.py b/pandas/tests/test_series.py
--- a/pandas/tests/test_series.py
+++ b/pandas/tests/test_series.py
@@ -1222,6 +1222,12 @@ def test_getitem_dups(self):
         expected = Series([3,4],index=['C','C'],dtype=np.int64)
         result = s['C']
         assert_series_equal(result, expected)
+        
+    def test_getitem_dataframe(self):
+        rng = list(range(10))
+        s   = pd.Series(10, index=rng)
+        df  = pd.DataFrame(rng, index=rng)
+        self.assertRaises(TypeError, s.__getitem__, df>5)
 
     def test_setitem_ambiguous_keyerror(self):
         s = Series(lrange(10), index=lrange(0, 20, 2))
Repository: pandas-dev/pandas

Issue:
DEPR: deprecate/remove pandas.tools.describe
This is really superfluous as `.describe` is much more comprehensive.

It is only a very brief mention in the docs, only a single test (for a single dtype), and not implemented generically.

https://github.com/pydata/pandas/blob/master/pandas/tools/describe.py



Discussion:

Resolving patch:
diff --git a/pandas/__init__.py b/pandas/__init__.py
--- a/pandas/__init__.py
+++ b/pandas/__init__.py
@@ -53,11 +53,13 @@
 from pandas.io.api import *
 from pandas.computation.api import *
 
-from pandas.tools.describe import value_range
 from pandas.tools.merge import merge, concat, ordered_merge
 from pandas.tools.pivot import pivot_table, crosstab
 from pandas.tools.plotting import scatter_matrix, plot_params
 from pandas.tools.tile import cut, qcut
+from pandas.tools.util import value_range
 from pandas.core.reshape import melt
 from pandas.util.print_versions import show_versions
 import pandas.util.testing
+
+
diff --git a/pandas/tools/describe.py b/pandas/tools/describe.py
deleted file mode 100644
--- a/pandas/tools/describe.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from pandas.core.series import Series
-
-
-def value_range(df):
-    """
-    Return the minimum and maximum of a dataframe in a series object
-
-    Parameters
-    ----------
-    df : DataFrame
-
-    Returns
-    -------
-    (maximum, minimum) : Series
-
-    """
-    return Series((min(df.min()), max(df.max())), ('Minimum', 'Maximum'))
diff --git a/pandas/tools/util.py b/pandas/tools/util.py
--- a/pandas/tools/util.py
+++ b/pandas/tools/util.py
@@ -1,4 +1,5 @@
 import operator
+import warnings
 from pandas.compat import reduce
 from pandas.core.index import Index
 import numpy as np
@@ -47,3 +48,22 @@ def compose(*funcs):
     """Compose 2 or more callables"""
     assert len(funcs) > 1, 'At least 2 callables must be passed to compose'
     return reduce(_compose2, funcs)
+
+### FIXME: remove in 0.16
+def value_range(df):
+    """
+    Return the minimum and maximum of a dataframe in a series object
+
+    Parameters
+    ----------
+    df : DataFrame
+
+    Returns
+    -------
+    (maximum, minimum) : Series
+
+    """
+    from pandas import Series
+    warnings.warn("value_range is deprecated. Use .describe() instead", FutureWarning)
+
+    return Series((min(df.min()), max(df.max())), ('Minimum', 'Maximum'))


Test patch:
diff --git a/pandas/tools/tests/test_tools.py b/pandas/tools/tests/test_tools.py
deleted file mode 100644
--- a/pandas/tools/tests/test_tools.py
+++ /dev/null
@@ -1,23 +0,0 @@
-from pandas import DataFrame
-from pandas.tools.describe import value_range
-
-import numpy as np
-import pandas.util.testing as tm
-
-
-class TestTools(tm.TestCase):
-
-    def test_value_range(self):
-        df = DataFrame(np.random.randn(5, 5))
-        df.ix[0, 2] = -5
-        df.ix[2, 0] = 5
-
-        res = value_range(df)
-
-        self.assertEqual(res['Minimum'], -5)
-        self.assertEqual(res['Maximum'], 5)
-
-        df.ix[0, 1] = np.NaN
-
-        self.assertEqual(res['Minimum'], -5)
-        self.assertEqual(res['Maximum'], 5)
Repository: pandas-dev/pandas

Issue:
DEPR: seems numpy is deprecating object array bool comparison w/nan in 1.9
related: 
#8509

https://github.com/pydata/pandas/pull/5283
https://github.com/numpy/numpy/issues/4685



Discussion:
cc @unutbu

If catch_warnings were to be used to suppress the warning, I wish there was a mechanism to remind us to remove the catch_warnings when it is no longer needed...

@unutbu 

I think we need to write an elementwise comparer for the this part
positive is you can do the expression all at once (and maybe the nan checking in-line)

@jreback: Sorry, I don't understand what that entails. Are you thinking of using Cython? (that's not something I know much about.)

I wrote that before seeing your comment in the other issue

filtering warning is ok here I think 


Resolving patch:
diff --git a/pandas/core/common.py b/pandas/core/common.py
--- a/pandas/core/common.py
+++ b/pandas/core/common.py
@@ -406,6 +406,7 @@ def array_equivalent(left, right, strict_nan=False):
     >>> array_equivalent(np.array([1, nan, 2]), np.array([1, 2, nan]))
     False
     """
+
     left, right = np.asarray(left), np.asarray(right)
     if left.shape != right.shape: return False
 
@@ -414,8 +415,8 @@ def array_equivalent(left, right, strict_nan=False):
 
         if not strict_nan:
             # pd.isnull considers NaN and None to be equivalent.
-            return ((left == right) | (pd.isnull(left) & pd.isnull(right))).all()
-
+            return lib.array_equivalent_object(left.ravel(), right.ravel())
+        
         for left_value, right_value in zip(left, right):
             if left_value is tslib.NaT and right_value is not tslib.NaT:
                 return False
@@ -426,7 +427,6 @@ def array_equivalent(left, right, strict_nan=False):
             else:
                 if left_value != right_value:
                     return False
-
         return True
 
     # NaNs can occur in float and complex arrays.
diff --git a/pandas/core/index.py b/pandas/core/index.py
--- a/pandas/core/index.py
+++ b/pandas/core/index.py
@@ -1047,7 +1047,7 @@ def equals(self, other):
         if type(other) != Index:
             return other.equals(self)
 
-        return array_equivalent(self, other)
+        return array_equivalent(_values_from_object(self), _values_from_object(other))
 
     def identical(self, other):
         """Similar to equals, but check that other comparable attributes are
@@ -2260,7 +2260,7 @@ def equals(self, other):
         #     return False
 
         try:
-            return array_equivalent(self, other)
+            return array_equivalent(_values_from_object(self), _values_from_object(other))
         except TypeError:
             # e.g. fails in numpy 1.6 with DatetimeIndex #1681
             return False
@@ -4175,7 +4175,8 @@ def equals(self, other):
             return True
 
         if not isinstance(other, MultiIndex):
-            return array_equivalent(self.values, _ensure_index(other))
+            return array_equivalent(self.values,
+                                    _values_from_object(_ensure_index(other)))
 
         if self.nlevels != other.nlevels:
             return False


Test patch:
Repository: pandas-dev/pandas

Issue:
DatetimeIndex very slow repr performance
Hi folks, it's been a while. I would like to draw your attention to:

```
dr = pd.date_range('20000101', freq='D', periods=100000)
%time dr._is_dates_only
```

This takes about 500ms on my machine. Scales linearly with the size of the index (I interrupted a repr on a 5mm-length index and discovered this). Probably a good idea to fix this for 0.15.0 (this is on master)



Discussion:

Resolving patch:
diff --git a/pandas/core/format.py b/pandas/core/format.py
--- a/pandas/core/format.py
+++ b/pandas/core/format.py
@@ -2027,14 +2027,19 @@ def _format_datetime64_dateonly(x, nat_rep='NaT', date_format=None):
 
 
 def _is_dates_only(values):
-    for d in values:
-        if isinstance(d, np.datetime64):
-            d = Timestamp(d)
-
-        if d is not None and not lib.checknull(d) and d._has_time_component():
-            return False
-    return True
+    # return a boolean if we are only dates (and don't have a timezone)
+    from pandas import DatetimeIndex
+    values = DatetimeIndex(values)
+    if values.tz is not None:
+        return False
 
+    values_int = values.asi8
+    consider_values = values_int != iNaT
+    one_day_nanos = (86400 * 1e9)
+    even_days = np.logical_and(consider_values, values_int % one_day_nanos != 0).sum() == 0
+    if even_days:
+        return True
+    return False
 
 def _get_format_datetime64(is_dates_only, nat_rep='NaT', date_format=None):
 
diff --git a/vb_suite/index_object.py b/vb_suite/index_object.py
--- a/vb_suite/index_object.py
+++ b/vb_suite/index_object.py
@@ -108,7 +108,7 @@
 
 
 # Constructing MultiIndex from cartesian product of iterables
-# 
+#
 
 setup = common_setup + """
 iterables = [tm.makeStringIndex(10000), xrange(20)]
@@ -130,3 +130,14 @@
     Benchmark("MultiIndex.from_product([level1, level2]).values", setup,
               name='multiindex_with_datetime_level',
               start_date=datetime(2014, 10, 11))
+
+#----------------------------------------------------------------------
+# repr
+
+setup = common_setup + """
+dr = pd.date_range('20000101', freq='D', periods=100000)
+"""
+
+datetime_index_repr = \
+    Benchmark("dr._is_dates_only", setup,
+              start_date=datetime(2012, 1, 11))


Test patch: