neurodebian
diff --git a/‎.travis.yml
+16 b/‎.travis.yml
+16
diff --git a/‎ci/requirements-3.4_SLOW.txt
+19 b/‎ci/requirements-3.4_SLOW.txt
+19
diff --git a/‎doc/source/categorical.rst
+54-15 b/‎doc/source/categorical.rst
+54-15
diff --git a/‎doc/source/cookbook.rst
+4-4 b/‎doc/source/cookbook.rst
+4-4
diff --git a/‎doc/source/indexing.rst
+8-4 b/‎doc/source/indexing.rst
+8-4
diff --git a/‎doc/source/io.rst
+35-6 b/‎doc/source/io.rst
+35-6
diff --git a/‎doc/source/release.rst
+53-3 b/‎doc/source/release.rst
+53-3
@@ -59,6 +59,14 @@ matrix:
       - CLIPBOARD=xsel
       - BUILD_TYPE=conda
       - JOB_NAME: "34_nslow"
+    - python: 3.4
+      env:
+      - NOSE_ARGS="slow and not network and not disabled"
+      - FULL_DEPS=true
+      - JOB_TAG=_SLOW
+      - CLIPBOARD=xsel
+      - BUILD_TYPE=conda
+      - JOB_NAME: "34_slow"
     - python: 3.2
       env:
       - NOSE_ARGS="not slow and not network and not disabled"
@@ -90,6 +98,14 @@ matrix:
         - JOB_TAG=_SLOW
         - BUILD_TYPE=conda
         - JOB_NAME: "27_slow"
+      - python: 3.4
+        env:
+        - NOSE_ARGS="slow and not network and not disabled"
+        - FULL_DEPS=true
+        - JOB_TAG=_SLOW
+        - CLIPBOARD=xsel
+        - BUILD_TYPE=conda
+        - JOB_NAME: "34_slow"
       - python: 2.7
         env:
         - EXPERIMENTAL=true
 
@@ -0,0 +1,19 @@
+dateutil
+pytz
+openpyxl
+xlsxwriter
+xlrd
+html5lib
+patsy
+beautiful-soup
+numpy
+cython
+scipy
+numexpr
+pytables
+matplotlib=1.3.1
+lxml
+sqlalchemy
+bottleneck
+pymysql
+psycopg2
@@ -51,7 +51,7 @@ The categorical data type is useful in the following cases:
   variable to a categorical variable will save some memory, see :ref:`here <categorical.memory>`.
 * The lexical order of a variable is not the same as the logical order ("one", "two", "three").
   By converting to a categorical and specifying an order on the categories, sorting and
-  min/max will use the logical order instead of the lexical order.
+  min/max will use the logical order instead of the lexical order, see :ref:`here <categorical.sort>`.
 * As a signal to other python libraries that this column should be treated as a categorical
   variable (e.g. to use suitable statistical methods or plot types).
 
@@ -265,9 +265,11 @@ or simply set the categories to a predefined scale, use :func:`Categorical.set_c
     intentionally or because it is misspelled or (under Python3) due to a type difference (e.g.,
     numpys S1 dtype and python strings). This can result in surprising behaviour!
 
-Ordered or not...
+Sorting and Order
 -----------------
 
+.. _categorical.sort:
+
 If categorical data is ordered (``s.cat.ordered == True``), then the order of the categories has a
 meaning and certain operations are possible. If the categorical is unordered, a `TypeError` is
 raised.
@@ -296,9 +298,14 @@ This is even true for strings and numeric data:
     s
     s.min(), s.max()
 
+
+Reordering
+~~~~~~~~~~
+
 Reordering the categories is possible via the :func:`Categorical.reorder_categories` and
 the :func:`Categorical.set_categories` methods. For :func:`Categorical.reorder_categories`, all
-old categories must be included in the new categories and no new categories are allowed.
+old categories must be included in the new categories and no new categories are allowed. This will
+necessarily make the sort order the same as the categories order.
 
 .. ipython:: python
 
@@ -324,17 +331,45 @@ old categories must be included in the new categories and no new categories are
     (e.g.``Series.median()``, which would need to compute the mean between two values if the length
     of an array is even) do not work and raise a `TypeError`.
 
+Multi Column Sorting
+~~~~~~~~~~~~~~~~~~~~
+
+A categorical dtyped column will partcipate in a multi-column sort in a similar manner to other columns.
+The ordering of the categorical is determined by the ``categories`` of that columns.
+
+.. ipython:: python
+
+   dfs = DataFrame({'A' : Categorical(list('bbeebbaa'),categories=['e','a','b']),
+                    'B' : [1,2,1,2,2,1,2,1] })
+   dfs.sort(['A','B'])
+
+Reordering the ``categories``, changes a future sort.
+
+.. ipython:: python
+
+   dfs['A'] = dfs['A'].cat.reorder_categories(['a','b','e'])
+   dfs.sort(['A','B'])
 
 Comparisons
 -----------
 
-Comparing `Categoricals` with other objects is possible in two cases:
+Comparing categorical data with other objects is possible in three cases:
+
+ * comparing equality (``==`` and ``!=``) to a list-like object (list, Series, array,
+   ...) of the same length as the categorical data.
+ * all comparisons (``==``, ``!=``, ``>``, ``>=``, ``<``, and ``<=``) of categorical data to
+   another categorical Series, when ``ordered==True`` and the `categories` are the same.
+ * all comparisons of a categorical data to a scalar.
 
- * comparing a categorical Series to another categorical Series, when `categories` and `ordered` is
-   the same or
- * comparing a categorical Series to a scalar.
+All other comparisons, especially "non-equality" comparisons of two categoricals with different
+categories or a categorical with any list-like object, will raise a TypeError.
 
-All other comparisons will raise a TypeError.
+.. note::
+
+    Any "non-equality" comparisons of categorical data with a `Series`, `np.array`, `list` or
+    categorical data with different categories or ordering will raise an `TypeError` because custom
+    categories ordering could be interpreted in two ways: one with taking in account the
+    ordering and one without.
 
 .. ipython:: python
 
@@ -353,6 +388,14 @@ Comparing to a categorical with the same categories and ordering or to a scalar
     cat > cat_base
     cat > 2
 
+Equality comparisons work with any list-like object of same length and scalars:
+
+.. ipython:: python
+
+    cat == cat_base
+    cat == np.array([1,2,3])
+    cat == 2
+
 This doesn't work because the categories are not the same:
 
 .. ipython:: python
@@ -362,13 +405,9 @@ This doesn't work because the categories are not the same:
     except TypeError as e:
          print("TypeError: " + str(e))
 
-.. note::
-
-    Comparisons with `Series`, `np.array` or a `Categorical` with different categories or ordering
-    will raise an `TypeError` because custom categories ordering could be interpreted in two ways:
-    one with taking in account the ordering and one without. If you want to compare a categorical
-    series with such a type, you need to be explicit and convert the categorical data back to the
-    original values:
+If you want to do a "non-equality" comparison of a categorical series with a list-like object
+which is not categorical data, you need to be explicit and convert the categorical data back to
+the original values:
 
 .. ipython:: python
 
 
@@ -489,10 +489,10 @@ Unlike agg, apply's callable is passed a sub-DataFrame which gives you access to
 .. ipython:: python
 
    def GrowUp(x):
-      avg_weight = sum(x[x.size == 'S'].weight * 1.5) 
-      avg_weight += sum(x[x.size == 'M'].weight * 1.25)
-      avg_weight += sum(x[x.size == 'L'].weight)
-      avg_weight = avg_weight / len(x)
+      avg_weight =  sum(x[x['size'] == 'S'].weight * 1.5) 
+      avg_weight += sum(x[x['size'] == 'M'].weight * 1.25)
+      avg_weight += sum(x[x['size'] == 'L'].weight)
+      avg_weight /= len(x)
       return pd.Series(['L',avg_weight,True], index=['size', 'weight', 'adult'])
 
    expected_df = gb.apply(GrowUp) 
 
@@ -84,14 +84,17 @@ of multi-axis indexing.
 
   See more at :ref:`Selection by Label <indexing.label>`
 
-- ``.iloc`` is strictly integer position based (from ``0`` to ``length-1`` of
-  the axis), will raise ``IndexError`` if an indexer is requested and it
-  is out-of-bounds, except *slice* indexers which allow out-of-bounds indexing.
-  (this conforms with python/numpy *slice* semantics). Allowed inputs are:
+- ``.iloc`` is primarily integer position based (from ``0`` to
+  ``length-1`` of the axis), but may also be used with a boolean
+  array.  ``.iloc`` will raise ``IndexError`` if a requested 
+  indexer is out-of-bounds, except *slice* indexers which allow
+  out-of-bounds indexing.  (this conforms with python/numpy *slice*
+  semantics).  Allowed inputs are:
 
   - An integer e.g. ``5``
   - A list or array of integers ``[4, 3, 0]``
   - A slice object with ints ``1:7``
+  - A boolean array
 
   See more at :ref:`Selection by Position <indexing.integer>`
 
@@ -368,6 +371,7 @@ The ``.iloc`` attribute is the primary access method. The following are valid in
 - An integer e.g. ``5``
 - A list or array of integers ``[4, 3, 0]``
 - A slice object with ints ``1:7``
+- A boolean array
 
 .. ipython:: python
 
 
@@ -2348,7 +2348,7 @@ Closing a Store, Context Manager
 
    # Working with, and automatically closing the store with the context
    # manager
-   with get_store('store.h5') as store:
+   with HDFStore('store.h5') as store:
        store.keys()
 
 .. ipython:: python
@@ -3393,12 +3393,34 @@ the database using :func:`~pandas.DataFrame.to_sql`.
 
     data.to_sql('data', engine)
 
-With some databases, writing large DataFrames can result in errors due to packet size limitations being exceeded. This can be avoided by setting the ``chunksize`` parameter when calling ``to_sql``.  For example, the following writes ``data`` to the database in batches of 1000 rows at a time:
+With some databases, writing large DataFrames can result in errors due to
+packet size limitations being exceeded. This can be avoided by setting the
+``chunksize`` parameter when calling ``to_sql``.  For example, the following
+writes ``data`` to the database in batches of 1000 rows at a time:
 
 .. ipython:: python
 
     data.to_sql('data_chunked', engine, chunksize=1000)
 
+SQL data types
+++++++++++++++
+
+:func:`~pandas.DataFrame.to_sql` will try to map your data to an appropriate
+SQL data type based on the dtype of the data. When you have columns of dtype
+``object``, pandas will try to infer the data type.
+
+You can always override the default type by specifying the desired SQL type of
+any of the columns by using the ``dtype`` argument. This argument needs a
+dictionary mapping column names to SQLAlchemy types (or strings for the sqlite3
+fallback mode).
+For example, specifying to use the sqlalchemy ``String`` type instead of the
+default ``Text`` type for string columns:
+
+.. ipython:: python
+
+    from sqlalchemy.types import String
+    data.to_sql('data_dtype', engine, dtype={'Col_1': String})
+
 .. note::
 
     Due to the limited support for timedelta's in the different database
@@ -3413,7 +3435,6 @@ With some databases, writing large DataFrames can result in errors due to packet
     Because of this, reading the database table back in does **not** generate
     a categorical.
 
-
 Reading Tables
 ~~~~~~~~~~~~~~
 
@@ -3643,6 +3664,14 @@ data quickly, but it is not a direct replacement for a transactional database.
 You can access the management console to determine project id's by:
 <https://code.google.com/apis/console/b/0/?noredirect>
 
+As of 0.15.2, the gbq module has a function ``generate_bq_schema`` which
+will produce the dictionary representation of the schema.
+
+.. code-block:: python
+
+    df = pandas.DataFrame({'A': [1.0]})
+    gbq.generate_bq_schema(df, default_type='STRING')
+
 .. warning::
 
    To use this module, you will need a valid BigQuery account. See
@@ -3766,13 +3795,13 @@ is lost when exporting.
 
     *Stata* only supports string value labels, and so ``str`` is called on the
     categories when exporting data.  Exporting ``Categorical`` variables with
-    non-string categories produces a warning, and can result a loss of 
+    non-string categories produces a warning, and can result a loss of
     information if the ``str`` representations of the categories are not unique.
 
 Labeled data can similarly be imported from *Stata* data files as ``Categorical``
-variables using the keyword argument ``convert_categoricals`` (``True`` by default).  
+variables using the keyword argument ``convert_categoricals`` (``True`` by default).
 The keyword argument ``order_categoricals`` (``True`` by default) determines
- whether imported ``Categorical`` variables are ordered.
+whether imported ``Categorical`` variables are ordered.
 
 .. note::
 
 
@@ -48,17 +48,67 @@ analysis / manipulation tool available in any language.
 pandas 0.15.2
 -------------
 
-**Release date:** (December ??, 2014)
+**Release date:** (December 12, 2014)
 
-This is a minor release from 0.15.1 and includes a small number of API changes, several new features, enhancements, and
-performance improvements along with a large number of bug fixes.
+This is a minor release from 0.15.1 and includes a large number of bug fixes
+along with several new features, enhancements, and performance improvements.
+A small number of API changes were necessary to fix existing bugs.
 
 See the :ref:`v0.15.2 Whatsnew <whatsnew_0152>` overview for an extensive list
 of all API changes, enhancements and bugs that have been fixed in 0.15.2.
 
 Thanks
 ~~~~~~
 
+- Aaron Staple
+- Angelos Evripiotis
+- Artemy Kolchinsky
+- Benoit Pointet
+- Brian Jacobowski
+- Charalampos Papaloizou
+- Chris Warth
+- David Stephens
+- Fabio Zanini
+- Francesc Via
+- Henry Kleynhans
+- Jake VanderPlas
+- Jan Schulz
+- Jeff Reback
+- Jeff Tratner
+- Joris Van den Bossche
+- Kevin Sheppard
+- Matt Suggit
+- Matthew Brett
+- Phillip Cloud
+- Rupert Thompson
+- Scott E Lasley
+- Stephan Hoyer
+- Stephen Simmons
+- Sylvain Corlay
+- Thomas Grainger
+- Tiago Antao
+- Trent Hauck
+- Victor Chaves
+- Victor Salgado
+- Vikram Bhandoh
+- WANG Aiyong
+- Will Holmgren
+- behzad nouri
+- broessli
+- charalampos papaloizou
+- immerrr
+- jnmclarty
+- jreback
+- mgilbert
+- onesandzeroes
+- peadarcoyle
+- rockg
+- seth-p
+- sinhrks
+- unutbu
+- wavedatalab
+- Åsmund Hjulstad
+
 pandas 0.15.1
 -------------