From 457019b8f618ea1047c2ac2a559508299dffee74 Mon Sep 17 00:00:00 2001 From: John Owens Date: Thu, 15 Dec 2016 15:53:11 -0800 Subject: [PATCH 01/51] added 'separator' argument to json_normalize --- pandas/io/json.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/pandas/io/json.py b/pandas/io/json.py index 0a6b8af179e12..fa123d5783958 100644 --- a/pandas/io/json.py +++ b/pandas/io/json.py @@ -24,8 +24,8 @@ def to_json(path_or_buf, obj, orient=None, date_format='epoch', default_handler=None, lines=False): if lines and orient != 'records': - raise ValueError( - "'lines' keyword only valid when 'orient' is records") + raise ValueError( + "'lines' keyword only valid when 'orient' is records") if isinstance(obj, Series): s = SeriesWriter( @@ -726,8 +726,8 @@ def nested_to_record(ds, prefix="", level=0): def json_normalize(data, record_path=None, meta=None, meta_prefix=None, record_prefix=None, + separator='.', errors='raise'): - """ "Normalize" semi-structured JSON data into a flat table @@ -744,6 +744,9 @@ def json_normalize(data, record_path=None, meta=None, If True, prefix records with dotted (?) path, e.g. foo.bar.field if path to records is ['foo', 'bar'] meta_prefix : string, default None + separator : string, default '.' + Nested records will generate names separated by separator, + e.g., for separator='.', { 'foo' : { 'bar' : 0 } } -> foo.bar errors : {'raise', 'ignore'}, default 'raise' * ignore : will ignore KeyError if keys listed in meta are not always present @@ -828,7 +831,7 @@ def _pull_field(js, spec): lengths = [] meta_vals = defaultdict(list) - meta_keys = ['.'.join(val) for val in meta] + meta_keys = [separator.join(val) for val in meta] def _recursive_extract(data, path, seen_meta, level=0): if len(path) > 1: From c345d6d380042558062c2c3bfc4dd2f96426151d Mon Sep 17 00:00:00 2001 From: John Owens Date: Thu, 15 Dec 2016 16:21:34 -0800 Subject: [PATCH 02/51] test for json_normalize argument 'separator' --- pandas/io/tests/json/test_json_norm.py | 30 ++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/pandas/io/tests/json/test_json_norm.py b/pandas/io/tests/json/test_json_norm.py index 36110898448ea..9935550024915 100644 --- a/pandas/io/tests/json/test_json_norm.py +++ b/pandas/io/tests/json/test_json_norm.py @@ -133,6 +133,36 @@ def test_shallow_nested(self): expected = DataFrame(ex_data, columns=result.columns) tm.assert_frame_equal(result, expected) + def test_shallow_nested_with_separator(self): + data = [{'state': 'Florida', + 'shortname': 'FL', + 'info': { + 'governor': 'Rick Scott' + }, + 'counties': [{'name': 'Dade', 'population': 12345}, + {'name': 'Broward', 'population': 40000}, + {'name': 'Palm Beach', 'population': 60000}]}, + {'state': 'Ohio', + 'shortname': 'OH', + 'info': { + 'governor': 'John Kasich' + }, + 'counties': [{'name': 'Summit', 'population': 1234}, + {'name': 'Cuyahoga', 'population': 1337}]}] + + result = json_normalize(data, 'counties', + ['state', 'shortname', + ['info', 'governor']], + separator='_') + ex_data = {'name': ['Dade', 'Broward', 'Palm Beach', 'Summit', + 'Cuyahoga'], + 'state': ['Florida'] * 3 + ['Ohio'] * 2, + 'shortname': ['FL', 'FL', 'FL', 'OH', 'OH'], + 'info_governor': ['Rick Scott'] * 3 + ['John Kasich'] * 2, + 'population': [12345, 40000, 60000, 1234, 1337]} + expected = DataFrame(ex_data, columns=result.columns) + tm.assert_frame_equal(result, expected) + def test_meta_name_conflict(self): data = [{'foo': 'hello', 'bar': 'there', From def361d9170ff4c29e1859afd162e6c3712e107f Mon Sep 17 00:00:00 2001 From: John Owens Date: Thu, 15 Dec 2016 16:22:09 -0800 Subject: [PATCH 03/51] added new enhancement: json_normalize now takes 'separator' as an optional argument --- doc/source/whatsnew/v0.20.0.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/doc/source/whatsnew/v0.20.0.txt b/doc/source/whatsnew/v0.20.0.txt index 2855cde95ac2a..22c1f87fa31ae 100644 --- a/doc/source/whatsnew/v0.20.0.txt +++ b/doc/source/whatsnew/v0.20.0.txt @@ -84,6 +84,7 @@ Other enhancements - ``pd.DataFrame.plot`` now prints a title above each subplot if ``suplots=True`` and ``title`` is a list of strings (:issue:`14753`) - ``pd.Series.interpolate`` now supports timedelta as an index type with ``method='time'`` (:issue:`6424`) - ``pandas.io.json.json_normalize()`` gained the option ``errors='ignore'|'raise'``; the default is ``errors='raise'`` which is backward compatible. (:issue:`14583`) +- ``pandas.io.json.json_normalize()`` gained the option ``separator=string``; the default is ``separator='.'`` which is backward compatible. (:issue:`14883`) .. _whatsnew_0200.api_breaking: From fac9ac1bc74bda7a4523cc64ec955e82b92dd22c Mon Sep 17 00:00:00 2001 From: John Owens Date: Thu, 15 Dec 2016 19:46:37 -0800 Subject: [PATCH 04/51] rename json_normalize arg separator to sep, simpler test, add version tag --- pandas/io/json.py | 13 ++++++---- pandas/io/tests/json/test_json_norm.py | 36 +++++++------------------- 2 files changed, 17 insertions(+), 32 deletions(-) diff --git a/pandas/io/json.py b/pandas/io/json.py index fa123d5783958..e7823ef9e9c09 100644 --- a/pandas/io/json.py +++ b/pandas/io/json.py @@ -726,8 +726,8 @@ def nested_to_record(ds, prefix="", level=0): def json_normalize(data, record_path=None, meta=None, meta_prefix=None, record_prefix=None, - separator='.', - errors='raise'): + errors='raise', + sep='.'): """ "Normalize" semi-structured JSON data into a flat table @@ -744,9 +744,6 @@ def json_normalize(data, record_path=None, meta=None, If True, prefix records with dotted (?) path, e.g. foo.bar.field if path to records is ['foo', 'bar'] meta_prefix : string, default None - separator : string, default '.' - Nested records will generate names separated by separator, - e.g., for separator='.', { 'foo' : { 'bar' : 0 } } -> foo.bar errors : {'raise', 'ignore'}, default 'raise' * ignore : will ignore KeyError if keys listed in meta are not always present @@ -755,6 +752,12 @@ def json_normalize(data, record_path=None, meta=None, .. versionadded:: 0.20.0 + sep : string, default '.' + Nested records will generate names separated by sep (separator), + e.g., for sep='.', { 'foo' : { 'bar' : 0 } } -> foo.bar + + .. versionadded:: 0.20.0 + Returns ------- frame : DataFrame diff --git a/pandas/io/tests/json/test_json_norm.py b/pandas/io/tests/json/test_json_norm.py index 9935550024915..e65d252ab24d1 100644 --- a/pandas/io/tests/json/test_json_norm.py +++ b/pandas/io/tests/json/test_json_norm.py @@ -133,34 +133,16 @@ def test_shallow_nested(self): expected = DataFrame(ex_data, columns=result.columns) tm.assert_frame_equal(result, expected) - def test_shallow_nested_with_separator(self): - data = [{'state': 'Florida', - 'shortname': 'FL', - 'info': { - 'governor': 'Rick Scott' - }, - 'counties': [{'name': 'Dade', 'population': 12345}, - {'name': 'Broward', 'population': 40000}, - {'name': 'Palm Beach', 'population': 60000}]}, - {'state': 'Ohio', - 'shortname': 'OH', - 'info': { - 'governor': 'John Kasich' - }, - 'counties': [{'name': 'Summit', 'population': 1234}, - {'name': 'Cuyahoga', 'population': 1337}]}] + def test_simple_normalize_with_default_separator(self): + result = json_normalize({"A": {"A": 1, "B": 2}}) + expected = pd.DataFrame([[1, 2]], columns={"A.A", "A.B"}) + assert_frame_equal(result, expected) + tm.assert_frame_equal(result, expected) - result = json_normalize(data, 'counties', - ['state', 'shortname', - ['info', 'governor']], - separator='_') - ex_data = {'name': ['Dade', 'Broward', 'Palm Beach', 'Summit', - 'Cuyahoga'], - 'state': ['Florida'] * 3 + ['Ohio'] * 2, - 'shortname': ['FL', 'FL', 'FL', 'OH', 'OH'], - 'info_governor': ['Rick Scott'] * 3 + ['John Kasich'] * 2, - 'population': [12345, 40000, 60000, 1234, 1337]} - expected = DataFrame(ex_data, columns=result.columns) + def test_simple_normalize_with_user_specified_separator(self): + result = json_normalize({"A": {"A": 1, "B": 2}}, sep='_') + expected = pd.DataFrame([[1, 2]], columns={"A_A", "A_B"}) + assert_frame_equal(result, expected) tm.assert_frame_equal(result, expected) def test_meta_name_conflict(self): From 5f777f40a8a0d0417e8dadde43beaadeee991a23 Mon Sep 17 00:00:00 2001 From: Shyam Saladi Date: Fri, 16 Dec 2016 01:18:25 -0800 Subject: [PATCH 05/51] DOC: fixed typo (#14892) --- doc/source/io.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/source/io.rst b/doc/source/io.rst index 17c7653072526..945b738e52480 100644 --- a/doc/source/io.rst +++ b/doc/source/io.rst @@ -4004,7 +4004,7 @@ and data values from the values and assembles them into a ``data.frame``: name_paths = paste(listing$group[name_nodes], listing$name[name_nodes], sep = "/") columns = list() for (idx in seq(data_paths)) { - # NOTE: matrices returned by h5read have to be transposed to to obtain + # NOTE: matrices returned by h5read have to be transposed to obtain # required Fortran order! data <- data.frame(t(h5read(h5File, data_paths[idx]))) names <- t(h5read(h5File, name_paths[idx])) From 992dfbc6f57e744db7f2271fa8319d02f52611fc Mon Sep 17 00:00:00 2001 From: Joris Van den Bossche Date: Fri, 16 Dec 2016 10:43:42 +0100 Subject: [PATCH 06/51] BUG: regression in DataFrame.combine_first with integer columns (GH14687) (#14886) --- doc/source/whatsnew/v0.19.2.txt | 2 +- pandas/core/frame.py | 6 ++---- pandas/tests/frame/test_combine_concat.py | 10 ++++++++++ 3 files changed, 13 insertions(+), 5 deletions(-) diff --git a/doc/source/whatsnew/v0.19.2.txt b/doc/source/whatsnew/v0.19.2.txt index 82d43db667550..7a7181604c287 100644 --- a/doc/source/whatsnew/v0.19.2.txt +++ b/doc/source/whatsnew/v0.19.2.txt @@ -78,7 +78,7 @@ Bug Fixes - Bug in clipboard functions on linux with python2 with unicode and separators (:issue:`13747`) - Bug in clipboard functions on Windows 10 and python 3 (:issue:`14362`, :issue:`12807`) - Bug in ``.to_clipboard()`` and Excel compat (:issue:`12529`) - +- Bug in ``DataFrame.combine_first()`` for integer columns (:issue:`14687`). - Bug in ``pd.read_csv()`` in which the ``dtype`` parameter was not being respected for empty data (:issue:`14712`) - Bug in ``pd.read_csv()`` in which the ``nrows`` parameter was not being respected for large input when using the C engine for parsing (:issue:`7626`) diff --git a/pandas/core/frame.py b/pandas/core/frame.py index 0d4bcd781cf74..78d0f47d473c8 100644 --- a/pandas/core/frame.py +++ b/pandas/core/frame.py @@ -3665,10 +3665,8 @@ def combine(self, other, func, fill_value=None, overwrite=True): otherSeries[other_mask] = fill_value # if we have different dtypes, possibily promote - if notnull(series).all(): - new_dtype = this_dtype - otherSeries = otherSeries.astype(new_dtype) - else: + new_dtype = this_dtype + if not is_dtype_equal(this_dtype, other_dtype): new_dtype = _find_common_type([this_dtype, other_dtype]) if not is_dtype_equal(this_dtype, new_dtype): series = series.astype(new_dtype) diff --git a/pandas/tests/frame/test_combine_concat.py b/pandas/tests/frame/test_combine_concat.py index 5b5236843643d..c6b69dad3e6b5 100644 --- a/pandas/tests/frame/test_combine_concat.py +++ b/pandas/tests/frame/test_combine_concat.py @@ -725,3 +725,13 @@ def test_combine_first_period(self): exp = pd.DataFrame({'P': exp_dts}, index=[1, 2, 3, 4, 5, 7]) tm.assert_frame_equal(res, exp) self.assertEqual(res['P'].dtype, 'object') + + def test_combine_first_int(self): + # GH14687 - integer series that do no align exactly + + df1 = pd.DataFrame({'a': [0, 1, 3, 5]}, dtype='int64') + df2 = pd.DataFrame({'a': [1, 4]}, dtype='int64') + + res = df1.combine_first(df2) + tm.assert_frame_equal(res, df1) + self.assertEqual(res['a'].dtype, 'int64') From 2083f0dc44615c69ea0938d0f85d1f0ef1edeb83 Mon Sep 17 00:00:00 2001 From: gfyoung Date: Fri, 16 Dec 2016 06:11:01 -0500 Subject: [PATCH 07/51] DOC: Add documentation about cpplint (#14890) --- doc/source/contributing.rst | 93 +++++++++++++++++++++++++++++++------ 1 file changed, 78 insertions(+), 15 deletions(-) diff --git a/doc/source/contributing.rst b/doc/source/contributing.rst index 38718bc5ca19a..ecc2a5e723c45 100644 --- a/doc/source/contributing.rst +++ b/doc/source/contributing.rst @@ -113,11 +113,12 @@ want to clone your fork to your machine:: This creates the directory `pandas-yourname` and connects your repository to the upstream (main project) *pandas* repository. -The testing suite will run automatically on Travis-CI once your pull request is -submitted. However, if you wish to run the test suite on a branch prior to -submitting the pull request, then Travis-CI needs to be hooked up to your -GitHub repository. Instructions for doing so are `here -`__. +The testing suite will run automatically on Travis-CI and Appveyor once your +pull request is submitted. However, if you wish to run the test suite on a +branch prior to submitting the pull request, then Travis-CI and/or AppVeyor +need to be hooked up to your GitHub repository. Instructions for doing so +are `here `__ for +Travis-CI and `here `__ for AppVeyor. Creating a branch ----------------- @@ -142,7 +143,7 @@ To update this branch, you need to retrieve the changes from the master branch:: git fetch upstream git rebase upstream/master -This will replay your commits on top of the lastest pandas git master. If this +This will replay your commits on top of the latest pandas git master. If this leads to merge conflicts, you must resolve these before submitting your pull request. If you have uncommitted changes, you will need to ``stash`` them prior to updating. This will effectively store your changes and they can be reapplied @@ -396,7 +397,7 @@ evocations, sphinx will try to only build the pages that have been modified. If you want to do a full clean build, do:: python make.py clean - python make.py build + python make.py html Starting with *pandas* 0.13.1 you can tell ``make.py`` to compile only a single section of the docs, greatly reducing the turn-around time for checking your changes. @@ -442,18 +443,80 @@ Contributing to the code base Code standards -------------- +Writing good code is not just about what you write. It is also about *how* you +write it. During testing on Travis-CI, several tools will be run to check your +code for stylistic errors. Generating any warnings will cause the test to fail. +Thus, good style is a requirement for submitting code to *pandas*. + +In addition, because a lot of people use our library, it is important that we +do not make sudden changes to the code that could have the potential to break +a lot of user code as a result, that is, we need it to be as *backwards compatible* +as possible to avoid mass breakages. + +Additional standards are outlined on the `code style wiki +page `_. + +C (cpplint) +~~~~~~~~~~~ + +*pandas* uses the `Google `_ +standard. Google provides an open source style checker called ``cpplint``, but we +use a fork of it that can be found `here `_. +Here are *some* of the more common ``cpplint`` issues: + + - we restrict line-length to 80 characters to promote readability + - every header file must include a header guard to avoid name collisions if re-included + +Travis-CI will run the `cpplint `_ tool +and report any stylistic errors in your code. Therefore, it is helpful before +submitting code to run the check yourself:: + + cpplint --extensions=c,h --headers=h --filter=-readability/casting,-runtime/int,-build/include_subdir modified-c-file + +You can also run this command on an entire directory if necessary:: + + cpplint --extensions=c,h --headers=h --filter=-readability/casting,-runtime/int,-build/include_subdir --recursive modified-c-directory + +To make your commits compliant with this standard, you can install the +`ClangFormat `_ tool, which can be +downloaded `here `_. To configure, in your home directory, +run the following command:: + + clang-format style=google -dump-config > .clang-format + +Then modify the file to ensure that any indentation width parameters are at least four. +Once configured, you can run the tool as follows:: + + clang-format modified-c-file + +This will output what your file will look like if the changes are made, and to apply +them, just run the following command:: + + clang-format -i modified-c-file + +To run the tool on an entire directory, you can run the following analogous commands:: + + clang-format modified-c-directory/*.c modified-c-directory/*.h + clang-format -i modified-c-directory/*.c modified-c-directory/*.h + +Do note that this tool is best-effort, meaning that it will try to correct as +many errors as possible, but it may not correct *all* of them. Thus, it is +recommended that you run ``cpplint`` to double check and make any other style +fixes manually. + +Python (PEP8) +~~~~~~~~~~~~~ + *pandas* uses the `PEP8 `_ standard. There are several tools to ensure you abide by this standard. Here are *some* of the more common ``PEP8`` issues: - - we restrict line-length to 80 characters to promote readability + - we restrict line-length to 79 characters to promote readability - passing arguments should have spaces after commas, e.g. ``foo(arg1, arg2, kw1='bar')`` -The Travis-CI will run `flake8 `_ tool and report -any stylistic errors in your code. Generating any warnings will cause the build to fail; -thus these are part of the requirements for submitting code to *pandas*. - -It is helpful before submitting code to run this yourself on the diff:: +Travis-CI will run the `flake8 `_ tool +and report any stylistic errors in your code. Therefore, it is helpful before +submitting code to run the check yourself on the diff:: git diff master | flake8 --diff @@ -466,8 +529,8 @@ and make these changes with:: pep8radius master --diff --in-place -Additional standards are outlined on the `code style wiki -page `_. +Backwards Compatibility +~~~~~~~~~~~~~~~~~~~~~~~ Please try to maintain backward compatibility. *pandas* has lots of users with lots of existing code, so don't break it if at all possible. If you think breakage is required, From d1b1720d4a851271239e13805a0ae7a628e4e6d9 Mon Sep 17 00:00:00 2001 From: Jeff Reback Date: Fri, 16 Dec 2016 08:35:47 -0500 Subject: [PATCH 08/51] BLD: swap 3.6-dev and 3.4 builds, reorg build order (#14899) --- .travis.yml | 115 ++++++++++++++++++++++++++-------------------------- 1 file changed, 58 insertions(+), 57 deletions(-) diff --git a/.travis.yml b/.travis.yml index be167451f3460..3e24f3798ca04 100644 --- a/.travis.yml +++ b/.travis.yml @@ -66,19 +66,6 @@ matrix: apt: packages: - python-gtk2 - - python: 3.4 - env: - - PYTHON_VERSION=3.4 - - JOB_NAME: "34_nslow" - - NOSE_ARGS="not slow and not disabled" - - FULL_DEPS=true - - CLIPBOARD=xsel - - CACHE_NAME="34_nslow" - - USE_CACHE=true - addons: - apt: - packages: - - xsel - python: 3.5 env: - PYTHON_VERSION=3.5 @@ -93,6 +80,33 @@ matrix: apt: packages: - xsel + - python: 3.6-dev + env: + - PYTHON_VERSION=3.6 + - JOB_NAME: "36_dev" + - JOB_TAG=_DEV + - NOSE_ARGS="not slow and not network and not disabled" + - PANDAS_TESTING_MODE="deprecate" + addons: + apt: + packages: + - libatlas-base-dev + - gfortran +# In allow_failures + - python: 2.7 + env: + - PYTHON_VERSION=2.7 + - JOB_NAME: "27_nslow_nnet_COMPAT" + - NOSE_ARGS="not slow and not network and not disabled" + - LOCALE_OVERRIDE="it_IT.UTF-8" + - INSTALL_TEST=true + - JOB_TAG=_COMPAT + - CACHE_NAME="27_nslow_nnet_COMPAT" + - USE_CACHE=true + addons: + apt: + packages: + - language-pack-it # In allow_failures - python: 2.7 env: @@ -103,45 +117,46 @@ matrix: - FULL_DEPS=true - CACHE_NAME="27_slow" - USE_CACHE=true +# In allow_failures + - python: 2.7 + env: + - PYTHON_VERSION=2.7 + - JOB_NAME: "27_build_test_conda" + - JOB_TAG=_BUILD_TEST + - NOSE_ARGS="not slow and not disabled" + - FULL_DEPS=true + - BUILD_TEST=true + - CACHE_NAME="27_build_test_conda" + - USE_CACHE=true # In allow_failures - python: 3.4 env: - PYTHON_VERSION=3.4 - - JOB_NAME: "34_slow" - - JOB_TAG=_SLOW - - NOSE_ARGS="slow and not network and not disabled" + - JOB_NAME: "34_nslow" + - NOSE_ARGS="not slow and not disabled" - FULL_DEPS=true - CLIPBOARD=xsel - - CACHE_NAME="34_slow" + - CACHE_NAME="34_nslow" - USE_CACHE=true addons: apt: packages: - xsel # In allow_failures - - python: 2.7 + - python: 3.4 env: - - PYTHON_VERSION=2.7 - - JOB_NAME: "27_build_test_conda" - - JOB_TAG=_BUILD_TEST - - NOSE_ARGS="not slow and not disabled" + - PYTHON_VERSION=3.4 + - JOB_NAME: "34_slow" + - JOB_TAG=_SLOW + - NOSE_ARGS="slow and not network and not disabled" - FULL_DEPS=true - - BUILD_TEST=true - - CACHE_NAME="27_build_test_conda" + - CLIPBOARD=xsel + - CACHE_NAME="34_slow" - USE_CACHE=true -# In allow_failures - - python: 3.6-dev - env: - - PYTHON_VERSION=3.6 - - JOB_NAME: "36_dev" - - JOB_TAG=_DEV - - NOSE_ARGS="not slow and not network and not disabled" - - PANDAS_TESTING_MODE="deprecate" addons: apt: packages: - - libatlas-base-dev - - gfortran + - xsel # In allow_failures - python: 3.5 env: @@ -157,21 +172,6 @@ matrix: packages: - libatlas-base-dev - gfortran -# In allow_failures - - python: 2.7 - env: - - PYTHON_VERSION=2.7 - - JOB_NAME: "27_nslow_nnet_COMPAT" - - NOSE_ARGS="not slow and not network and not disabled" - - LOCALE_OVERRIDE="it_IT.UTF-8" - - INSTALL_TEST=true - - JOB_TAG=_COMPAT - - CACHE_NAME="27_nslow_nnet_COMPAT" - - USE_CACHE=true - addons: - apt: - packages: - - language-pack-it # In allow_failures - python: 3.5 env: @@ -226,18 +226,19 @@ matrix: - BUILD_TEST=true - CACHE_NAME="27_build_test_conda" - USE_CACHE=true - - python: 3.6-dev + - python: 3.4 env: - - PYTHON_VERSION=3.6 - - JOB_NAME: "36_dev" - - JOB_TAG=_DEV - - NOSE_ARGS="not slow and not network and not disabled" - - PANDAS_TESTING_MODE="deprecate" + - PYTHON_VERSION=3.4 + - JOB_NAME: "34_nslow" + - NOSE_ARGS="not slow and not disabled" + - FULL_DEPS=true + - CLIPBOARD=xsel + - CACHE_NAME="34_nslow" + - USE_CACHE=true addons: apt: packages: - - libatlas-base-dev - - gfortran + - xsel - python: 3.5 env: - PYTHON_VERSION=3.5 From e7df7516ff44185ded46f89a463169c997ae0662 Mon Sep 17 00:00:00 2001 From: "Christopher C. Aycock" Date: Fri, 16 Dec 2016 18:04:53 -0500 Subject: [PATCH 09/51] ENH: merge_asof() has type specializations and can take multiple 'by' parameters (#13936) closes #13936 Author: Christopher C. Aycock Closes #14783 from chrisaycock/GH13936 and squashes the following commits: ffcf0c2 [Christopher C. Aycock] Added test to reject float16; fixed typos 1f208a8 [Christopher C. Aycock] Use tuple representation instead of strings 77eb47b [Christopher C. Aycock] Merge master branch into GH13936 89256f0 [Christopher C. Aycock] Test 8-bit integers and raise error on 16-bit floats; add comments 0ad1687 [Christopher C. Aycock] Fixed whatsnew 2bce3cc [Christopher C. Aycock] Revert dict back to PyObjectHashTable in response to code review fafbb02 [Christopher C. Aycock] Updated benchmarks to reflect new ASV setup 5eeb7d9 [Christopher C. Aycock] Merge master into GH13936 c33c4cb [Christopher C. Aycock] Merge branch 'master' into GH13936 46cc309 [Christopher C. Aycock] Update documentation f01142c [Christopher C. Aycock] Merge master branch 75157fc [Christopher C. Aycock] merge_asof() has type specializations and can take multiple 'by' parameters (#13936) --- asv_bench/benchmarks/join_merge.py | 13 ++ doc/source/whatsnew/v0.19.2.txt | 1 + pandas/src/joins_func_helper.pxi.in | 9 +- pandas/tools/merge.py | 101 ++++++++------ pandas/tools/tests/test_merge_asof.py | 183 ++++++++++++++++++++++++++ 5 files changed, 264 insertions(+), 43 deletions(-) diff --git a/asv_bench/benchmarks/join_merge.py b/asv_bench/benchmarks/join_merge.py index 9eefe80c8e5e4..d9c631fa92efd 100644 --- a/asv_bench/benchmarks/join_merge.py +++ b/asv_bench/benchmarks/join_merge.py @@ -302,12 +302,19 @@ def setup(self): self.df1 = self.df1.sort_values('time') self.df2 = self.df2.sort_values('time') + self.df1['time32'] = np.int32(self.df1.time) + self.df2['time32'] = np.int32(self.df2.time) + self.df1a = self.df1[['time', 'value1']] self.df2a = self.df2[['time', 'value2']] self.df1b = self.df1[['time', 'key', 'value1']] self.df2b = self.df2[['time', 'key', 'value2']] self.df1c = self.df1[['time', 'key2', 'value1']] self.df2c = self.df2[['time', 'key2', 'value2']] + self.df1d = self.df1[['time32', 'value1']] + self.df2d = self.df2[['time32', 'value2']] + self.df1e = self.df1[['time', 'key', 'key2', 'value1']] + self.df2e = self.df2[['time', 'key', 'key2', 'value2']] def time_noby(self): merge_asof(self.df1a, self.df2a, on='time') @@ -318,6 +325,12 @@ def time_by_object(self): def time_by_int(self): merge_asof(self.df1c, self.df2c, on='time', by='key2') + def time_on_int32(self): + merge_asof(self.df1d, self.df2d, on='time32') + + def time_multiby(self): + merge_asof(self.df1e, self.df2e, on='time', by=['key', 'key2']) + #---------------------------------------------------------------------- # data alignment diff --git a/doc/source/whatsnew/v0.19.2.txt b/doc/source/whatsnew/v0.19.2.txt index 7a7181604c287..eaf61e148a8c7 100644 --- a/doc/source/whatsnew/v0.19.2.txt +++ b/doc/source/whatsnew/v0.19.2.txt @@ -29,6 +29,7 @@ Other Enhancements ~~~~~~~~~~~~~~~~~~ - ``pd.merge_asof()`` gained ``left_index``/``right_index`` and ``left_by``/``right_by`` arguments (:issue:`14253`) +- ``pd.merge_asof()`` can take multiple columns in ``by`` parameter and has specialized dtypes for better performace (:issue:`13936`) diff --git a/pandas/src/joins_func_helper.pxi.in b/pandas/src/joins_func_helper.pxi.in index 06c35cfb69e53..33926a23f7f41 100644 --- a/pandas/src/joins_func_helper.pxi.in +++ b/pandas/src/joins_func_helper.pxi.in @@ -1,3 +1,4 @@ +# cython: boundscheck=False, wraparound=False """ Template for each `dtype` helper function for hashtable @@ -14,7 +15,9 @@ WARNING: DO NOT edit .pxi FILE directly, .pxi is generated from .pxi.in by_dtypes = [('PyObjectHashTable', 'object'), ('Int64HashTable', 'int64_t')] # on_dtype -on_dtypes = ['int64_t', 'double'] +on_dtypes = ['uint8_t', 'uint16_t', 'uint32_t', 'uint64_t', + 'int8_t', 'int16_t', 'int32_t', 'int64_t', + 'float', 'double'] }} @@ -98,7 +101,9 @@ def asof_join_{{on_dtype}}_by_{{by_dtype}}(ndarray[{{on_dtype}}] left_values, {{py: # on_dtype -dtypes = ['int64_t', 'double'] +dtypes = ['uint8_t', 'uint16_t', 'uint32_t', 'uint64_t', + 'int8_t', 'int16_t', 'int32_t', 'int64_t', + 'float', 'double'] }} diff --git a/pandas/tools/merge.py b/pandas/tools/merge.py index 198991531e0a7..efae7c63a9d0e 100644 --- a/pandas/tools/merge.py +++ b/pandas/tools/merge.py @@ -5,6 +5,8 @@ import copy import warnings +import string + import numpy as np from pandas.compat import range, lrange, lzip, zip, map, filter import pandas.compat as compat @@ -28,7 +30,8 @@ is_list_like, _ensure_int64, _ensure_float64, - _ensure_object) + _ensure_object, + _get_dtype) from pandas.types.missing import na_value_for_dtype from pandas.core.generic import NDFrame @@ -271,8 +274,8 @@ def merge_asof(left, right, on=None, DataFrame whose 'on' key is less than or equal to the left's key. Both DataFrames must be sorted by the key. - Optionally perform group-wise merge. This searches for the nearest match - on the 'on' key within the same group according to 'by'. + Optionally match on equivalent keys with 'by' before searching for nearest + match with 'on'. .. versionadded:: 0.19.0 @@ -299,16 +302,15 @@ def merge_asof(left, right, on=None, .. versionadded:: 0.19.2 - by : column name - Group both the left and right DataFrames by the group column; perform - the merge operation on these pieces and recombine. + by : column name or list of column names + Match on these columns before performing merge operation. left_by : column name - Field name to group by in the left DataFrame. + Field names to match on in the left DataFrame. .. versionadded:: 0.19.2 right_by : column name - Field name to group by in the right DataFrame. + Field names to match on in the right DataFrame. .. versionadded:: 0.19.2 @@ -997,17 +999,13 @@ def get_result(self): return result -_asof_functions = { - 'int64_t': _join.asof_join_int64_t, - 'double': _join.asof_join_double, -} +def _asof_function(on_type): + return getattr(_join, 'asof_join_%s' % on_type, None) + + +def _asof_by_function(on_type, by_type): + return getattr(_join, 'asof_join_%s_by_%s' % (on_type, by_type), None) -_asof_by_functions = { - ('int64_t', 'int64_t'): _join.asof_join_int64_t_by_int64_t, - ('double', 'int64_t'): _join.asof_join_double_by_int64_t, - ('int64_t', 'object'): _join.asof_join_int64_t_by_object, - ('double', 'object'): _join.asof_join_double_by_object, -} _type_casters = { 'int64_t': _ensure_int64, @@ -1015,9 +1013,32 @@ def get_result(self): 'object': _ensure_object, } +_cython_types = { + 'uint8': 'uint8_t', + 'uint32': 'uint32_t', + 'uint16': 'uint16_t', + 'uint64': 'uint64_t', + 'int8': 'int8_t', + 'int32': 'int32_t', + 'int16': 'int16_t', + 'int64': 'int64_t', + 'float16': 'error', + 'float32': 'float', + 'float64': 'double', +} + def _get_cython_type(dtype): - """ Given a dtype, return 'int64_t', 'double', or 'object' """ + """ Given a dtype, return a C name like 'int64_t' or 'double' """ + type_name = _get_dtype(dtype).name + ctype = _cython_types.get(type_name, 'object') + if ctype == 'error': + raise MergeError('unsupported type: ' + type_name) + return ctype + + +def _get_cython_type_upcast(dtype): + """ Upcast a dtype to 'int64_t', 'double', or 'object' """ if is_integer_dtype(dtype): return 'int64_t' elif is_float_dtype(dtype): @@ -1084,11 +1105,6 @@ def _validate_specification(self): if not is_list_like(self.right_by): self.right_by = [self.right_by] - if len(self.left_by) != 1: - raise MergeError("can only asof by a single key") - if len(self.right_by) != 1: - raise MergeError("can only asof by a single key") - self.left_on = self.left_by + list(self.left_on) self.right_on = self.right_by + list(self.right_on) @@ -1142,6 +1158,13 @@ def _get_merge_keys(self): def _get_join_indexers(self): """ return the join indexers """ + def flip(xs): + """ unlike np.transpose, this returns an array of tuples """ + labels = list(string.ascii_lowercase[:len(xs)]) + dtypes = [x.dtype for x in xs] + labeled_dtypes = list(zip(labels, dtypes)) + return np.array(lzip(*xs), labeled_dtypes) + # values to compare left_values = (self.left.index.values if self.left_index else self.left_join_keys[-1]) @@ -1165,22 +1188,23 @@ def _get_join_indexers(self): # a "by" parameter requires special handling if self.left_by is not None: - left_by_values = self.left_join_keys[0] - right_by_values = self.right_join_keys[0] - - # choose appropriate function by type - on_type = _get_cython_type(left_values.dtype) - by_type = _get_cython_type(left_by_values.dtype) + if len(self.left_join_keys) > 2: + # get tuple representation of values if more than one + left_by_values = flip(self.left_join_keys[0:-1]) + right_by_values = flip(self.right_join_keys[0:-1]) + else: + left_by_values = self.left_join_keys[0] + right_by_values = self.right_join_keys[0] - on_type_caster = _type_casters[on_type] + # upcast 'by' parameter because HashTable is limited + by_type = _get_cython_type_upcast(left_by_values.dtype) by_type_caster = _type_casters[by_type] - func = _asof_by_functions[(on_type, by_type)] - - left_values = on_type_caster(left_values) - right_values = on_type_caster(right_values) left_by_values = by_type_caster(left_by_values) right_by_values = by_type_caster(right_by_values) + # choose appropriate function by type + on_type = _get_cython_type(left_values.dtype) + func = _asof_by_function(on_type, by_type) return func(left_values, right_values, left_by_values, @@ -1190,12 +1214,7 @@ def _get_join_indexers(self): else: # choose appropriate function by type on_type = _get_cython_type(left_values.dtype) - type_caster = _type_casters[on_type] - func = _asof_functions[on_type] - - left_values = type_caster(left_values) - right_values = type_caster(right_values) - + func = _asof_function(on_type) return func(left_values, right_values, self.allow_exact_matches, diff --git a/pandas/tools/tests/test_merge_asof.py b/pandas/tools/tests/test_merge_asof.py index d33ba30d7f032..bbbf1a3bdfff9 100644 --- a/pandas/tools/tests/test_merge_asof.py +++ b/pandas/tools/tests/test_merge_asof.py @@ -221,6 +221,117 @@ def test_missing_right_by(self): expected.loc[expected.ticker == 'MSFT', ['bid', 'ask']] = np.nan assert_frame_equal(result, expected) + def test_multiby(self): + # GH13936 + trades = pd.DataFrame({ + 'time': pd.to_datetime(['20160525 13:30:00.023', + '20160525 13:30:00.023', + '20160525 13:30:00.046', + '20160525 13:30:00.048', + '20160525 13:30:00.050']), + 'ticker': ['MSFT', 'MSFT', + 'GOOG', 'GOOG', 'AAPL'], + 'exch': ['ARCA', 'NSDQ', 'NSDQ', 'BATS', 'NSDQ'], + 'price': [51.95, 51.95, + 720.77, 720.92, 98.00], + 'quantity': [75, 155, + 100, 100, 100]}, + columns=['time', 'ticker', 'exch', + 'price', 'quantity']) + + quotes = pd.DataFrame({ + 'time': pd.to_datetime(['20160525 13:30:00.023', + '20160525 13:30:00.023', + '20160525 13:30:00.030', + '20160525 13:30:00.041', + '20160525 13:30:00.045', + '20160525 13:30:00.049']), + 'ticker': ['GOOG', 'MSFT', 'MSFT', + 'MSFT', 'GOOG', 'AAPL'], + 'exch': ['BATS', 'NSDQ', 'ARCA', 'ARCA', + 'NSDQ', 'ARCA'], + 'bid': [720.51, 51.95, 51.97, 51.99, + 720.50, 97.99], + 'ask': [720.92, 51.96, 51.98, 52.00, + 720.93, 98.01]}, + columns=['time', 'ticker', 'exch', 'bid', 'ask']) + + expected = pd.DataFrame({ + 'time': pd.to_datetime(['20160525 13:30:00.023', + '20160525 13:30:00.023', + '20160525 13:30:00.046', + '20160525 13:30:00.048', + '20160525 13:30:00.050']), + 'ticker': ['MSFT', 'MSFT', + 'GOOG', 'GOOG', 'AAPL'], + 'exch': ['ARCA', 'NSDQ', 'NSDQ', 'BATS', 'NSDQ'], + 'price': [51.95, 51.95, + 720.77, 720.92, 98.00], + 'quantity': [75, 155, + 100, 100, 100], + 'bid': [np.nan, 51.95, 720.50, 720.51, np.nan], + 'ask': [np.nan, 51.96, 720.93, 720.92, np.nan]}, + columns=['time', 'ticker', 'exch', + 'price', 'quantity', 'bid', 'ask']) + + result = pd.merge_asof(trades, quotes, on='time', + by=['ticker', 'exch']) + assert_frame_equal(result, expected) + + def test_multiby_heterogeneous_types(self): + # GH13936 + trades = pd.DataFrame({ + 'time': pd.to_datetime(['20160525 13:30:00.023', + '20160525 13:30:00.023', + '20160525 13:30:00.046', + '20160525 13:30:00.048', + '20160525 13:30:00.050']), + 'ticker': [0, 0, 1, 1, 2], + 'exch': ['ARCA', 'NSDQ', 'NSDQ', 'BATS', 'NSDQ'], + 'price': [51.95, 51.95, + 720.77, 720.92, 98.00], + 'quantity': [75, 155, + 100, 100, 100]}, + columns=['time', 'ticker', 'exch', + 'price', 'quantity']) + + quotes = pd.DataFrame({ + 'time': pd.to_datetime(['20160525 13:30:00.023', + '20160525 13:30:00.023', + '20160525 13:30:00.030', + '20160525 13:30:00.041', + '20160525 13:30:00.045', + '20160525 13:30:00.049']), + 'ticker': [1, 0, 0, 0, 1, 2], + 'exch': ['BATS', 'NSDQ', 'ARCA', 'ARCA', + 'NSDQ', 'ARCA'], + 'bid': [720.51, 51.95, 51.97, 51.99, + 720.50, 97.99], + 'ask': [720.92, 51.96, 51.98, 52.00, + 720.93, 98.01]}, + columns=['time', 'ticker', 'exch', 'bid', 'ask']) + + expected = pd.DataFrame({ + 'time': pd.to_datetime(['20160525 13:30:00.023', + '20160525 13:30:00.023', + '20160525 13:30:00.046', + '20160525 13:30:00.048', + '20160525 13:30:00.050']), + 'ticker': [0, 0, 1, 1, 2], + 'exch': ['ARCA', 'NSDQ', 'NSDQ', 'BATS', 'NSDQ'], + 'price': [51.95, 51.95, + 720.77, 720.92, 98.00], + 'quantity': [75, 155, + 100, 100, 100], + 'bid': [np.nan, 51.95, 720.50, 720.51, np.nan], + 'ask': [np.nan, 51.96, 720.93, 720.92, np.nan]}, + columns=['time', 'ticker', 'exch', + 'price', 'quantity', 'bid', 'ask']) + + result = pd.merge_asof(trades, quotes, on='time', + by=['ticker', 'exch']) + assert_frame_equal(result, expected) + def test_basic2(self): expected = self.read_data('asof2.csv') @@ -542,6 +653,78 @@ def test_on_float(self): assert_frame_equal(result, expected) + def test_on_specialized_type(self): + # GH13936 + for dtype in [np.uint8, np.uint16, np.uint32, np.uint64, + np.int8, np.int16, np.int32, np.int64, + np.float16, np.float32, np.float64]: + df1 = pd.DataFrame({ + 'value': [5, 2, 25, 100, 78, 120, 79], + 'symbol': list("ABCDEFG")}, + columns=['symbol', 'value']) + df1.value = dtype(df1.value) + + df2 = pd.DataFrame({ + 'value': [0, 80, 120, 125], + 'result': list('xyzw')}, + columns=['value', 'result']) + df2.value = dtype(df2.value) + + df1 = df1.sort_values('value').reset_index(drop=True) + + if dtype == np.float16: + with self.assertRaises(MergeError): + pd.merge_asof(df1, df2, on='value') + continue + + result = pd.merge_asof(df1, df2, on='value') + + expected = pd.DataFrame( + {'symbol': list("BACEGDF"), + 'value': [2, 5, 25, 78, 79, 100, 120], + 'result': list('xxxxxyz') + }, columns=['symbol', 'value', 'result']) + expected.value = dtype(expected.value) + + assert_frame_equal(result, expected) + + def test_on_specialized_type_by_int(self): + # GH13936 + for dtype in [np.uint8, np.uint16, np.uint32, np.uint64, + np.int8, np.int16, np.int32, np.int64, + np.float16, np.float32, np.float64]: + df1 = pd.DataFrame({ + 'value': [5, 2, 25, 100, 78, 120, 79], + 'key': [1, 2, 3, 2, 3, 1, 2], + 'symbol': list("ABCDEFG")}, + columns=['symbol', 'key', 'value']) + df1.value = dtype(df1.value) + + df2 = pd.DataFrame({ + 'value': [0, 80, 120, 125], + 'key': [1, 2, 2, 3], + 'result': list('xyzw')}, + columns=['value', 'key', 'result']) + df2.value = dtype(df2.value) + + df1 = df1.sort_values('value').reset_index(drop=True) + + if dtype == np.float16: + with self.assertRaises(MergeError): + pd.merge_asof(df1, df2, on='value', by='key') + else: + result = pd.merge_asof(df1, df2, on='value', by='key') + + expected = pd.DataFrame({ + 'symbol': list("BACEGDF"), + 'key': [2, 1, 3, 3, 2, 2, 1], + 'value': [2, 5, 25, 78, 79, 100, 120], + 'result': [np.nan, 'x', np.nan, np.nan, np.nan, 'y', 'x']}, + columns=['symbol', 'key', 'value', 'result']) + expected.value = dtype(expected.value) + + assert_frame_equal(result, expected) + def test_on_float_by_int(self): # type specialize both "by" and "on" parameters df1 = pd.DataFrame({ From 256622339ae3d9137879f422ccce886920e6d688 Mon Sep 17 00:00:00 2001 From: Matt Roeschke Date: Fri, 16 Dec 2016 18:20:00 -0500 Subject: [PATCH 10/51] TST: to_json keeps column info with empty dataframe (#7445) closes #7445 Author: Matt Roeschke Closes #14893 from mroeschke/test_7445 and squashes the following commits: 740cafe [Matt Roeschke] TST: to_json keeps column info with empty dataframe (#7445) --- pandas/io/tests/json/test_pandas.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pandas/io/tests/json/test_pandas.py b/pandas/io/tests/json/test_pandas.py index e6e6f33669e17..d7f903153fdae 100644 --- a/pandas/io/tests/json/test_pandas.py +++ b/pandas/io/tests/json/test_pandas.py @@ -388,6 +388,10 @@ def test_frame_empty(self): self.assertFalse(df._is_mixed_type) assert_frame_equal(read_json(df.to_json(), dtype=dict(df.dtypes)), df, check_index_type=False) + # GH 7445 + result = pd.DataFrame({'test': []}, index=[]).to_json(orient='columns') + expected = '{"test":{}}' + tm.assert_equal(result, expected) def test_frame_empty_mixedtype(self): # mixed type From 6f4e36a0f8c3638fe5dfe7bf68af079a2f034d00 Mon Sep 17 00:00:00 2001 From: Nate Yoder Date: Fri, 16 Dec 2016 18:22:08 -0500 Subject: [PATCH 11/51] API: map() on Index returns an Index, not array closes #12766 closes #12798 This is a follow on to #12798. Author: Nate Yoder Closes #14506 from nateyoder/index_map_index and squashes the following commits: 95e4440 [Nate Yoder] fix typo and add ref tag in whatsnew b36e83c [Nate Yoder] update whatsnew, fix documentation 4635e6a [Nate Yoder] compare as index a17ddab [Nate Yoder] Fix unused import and docstrings per pep8radius docformatter; change other uses of assert_index_equal to testing instead os self ab168e7 [Nate Yoder] Update whatsnew and add git PR to tests to denote changes 504c2a2 [Nate Yoder] Fix tests that weren't run by PyCharm 23c133d [Nate Yoder] Update tests to match dtype int64 07b772a [Nate Yoder] use the numpy results if we can to avoid repeating the computation just to create the object a110be9 [Nate Yoder] make map on time tseries indices return index if dtype of output is not a tseries; sphinx changes; fix docstring a596744 [Nate Yoder] introspect results from map so that if the output array has tuples we create a multiindex instead of an index 5fc66c3 [Nate Yoder] make map return an index if it operates on an index, multi index, or categorical index; map on a categorical will either return a categorical or an index (rather than a numpy array) --- doc/source/whatsnew/v0.20.0.txt | 71 ++++++++++++++++++++++++- pandas/core/categorical.py | 6 +-- pandas/indexes/base.py | 19 +++++-- pandas/indexes/category.py | 14 ++--- pandas/tests/indexes/test_base.py | 62 +++++++++++++++++---- pandas/tests/indexes/test_category.py | 23 ++++---- pandas/tests/series/test_apply.py | 6 ++- pandas/tests/test_categorical.py | 3 +- pandas/tseries/base.py | 12 +++-- pandas/tseries/tests/test_converter.py | 6 +-- pandas/tseries/tests/test_period.py | 15 +++--- pandas/tseries/tests/test_timedeltas.py | 4 +- pandas/tseries/tests/test_timeseries.py | 8 +-- 13 files changed, 188 insertions(+), 61 deletions(-) diff --git a/doc/source/whatsnew/v0.20.0.txt b/doc/source/whatsnew/v0.20.0.txt index 2855cde95ac2a..e264fb15f3e67 100644 --- a/doc/source/whatsnew/v0.20.0.txt +++ b/doc/source/whatsnew/v0.20.0.txt @@ -91,8 +91,77 @@ Other enhancements Backwards incompatible API changes ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -.. _whatsnew_0200.api: +.. _whatsnew.api_breaking.index_map + +Map on Index types now return other Index types +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +- ``map`` on an ``Index`` now returns an ``Index``, not a numpy array (:issue:`12766`) + + .. ipython:: python + + idx = Index([1, 2]) + idx + mi = MultiIndex.from_tuples([(1, 2), (2, 4)]) + mi + + Previous Behavior: + + .. code-block:: ipython + + In [5]: idx.map(lambda x: x * 2) + Out[5]: array([2, 4]) + + In [6]: idx.map(lambda x: (x, x * 2)) + Out[6]: array([(1, 2), (2, 4)], dtype=object) + + In [7]: mi.map(lambda x: x) + Out[7]: array([(1, 2), (2, 4)], dtype=object) + + In [8]: mi.map(lambda x: x[0]) + Out[8]: array([1, 2]) + + New Behavior: + + .. ipython:: python + + idx.map(lambda x: x * 2) + + idx.map(lambda x: (x, x * 2)) + + mi.map(lambda x: x) + + mi.map(lambda x: x[0]) + + +- ``map`` on a Series with datetime64 values may return int64 dtypes rather than int32 + + .. ipython:: python + + s = Series(date_range('2011-01-02T00:00', '2011-01-02T02:00', freq='H').tz_localize('Asia/Tokyo')) + s + + Previous Behavior: + + .. code-block:: ipython + + In [9]: s.map(lambda x: x.hour) + Out[9]: + 0 0 + 1 1 + 2 2 + dtype: int32 + + + New Behavior: + + .. ipython:: python + + s.map(lambda x: x.hour) + + + .. _whatsnew_0200.api: - ``CParserError`` has been renamed to ``ParserError`` in ``pd.read_csv`` and will be removed in the future (:issue:`12665`) - ``SparseArray.cumsum()`` and ``SparseSeries.cumsum()`` will now always return ``SparseArray`` and ``SparseSeries`` respectively (:issue:`12855`) diff --git a/pandas/core/categorical.py b/pandas/core/categorical.py index 922fb84684729..5124dc44e2fc8 100644 --- a/pandas/core/categorical.py +++ b/pandas/core/categorical.py @@ -930,8 +930,7 @@ def remove_unused_categories(self, inplace=False): return cat def map(self, mapper): - """ - Apply mapper function to its categories (not codes). + """Apply mapper function to its categories (not codes). Parameters ---------- @@ -943,7 +942,8 @@ def map(self, mapper): Returns ------- - applied : Categorical or np.ndarray. + applied : Categorical or Index. + """ new_categories = self.categories.map(mapper) try: diff --git a/pandas/indexes/base.py b/pandas/indexes/base.py index 512abfd88c78c..1cc546629589d 100644 --- a/pandas/indexes/base.py +++ b/pandas/indexes/base.py @@ -2427,8 +2427,7 @@ def groupby(self, values): return result def map(self, mapper): - """ - Apply mapper function to its values. + """Apply mapper function to an index. Parameters ---------- @@ -2437,9 +2436,21 @@ def map(self, mapper): Returns ------- - applied : array + applied : Union[Index, MultiIndex], inferred + The output of the mapping function applied to the index. + If the function returns a tuple with more than one element + a MultiIndex will be returned. + """ - return self._arrmap(self.values, mapper) + from .multi import MultiIndex + mapped_values = self._arrmap(self.values, mapper) + attributes = self._get_attributes_dict() + if mapped_values.size and isinstance(mapped_values[0], tuple): + return MultiIndex.from_tuples(mapped_values, + names=attributes.get('name')) + + attributes['copy'] = False + return Index(mapped_values, **attributes) def isin(self, values, level=None): """ diff --git a/pandas/indexes/category.py b/pandas/indexes/category.py index c1f5d47e1e04f..2c89f72975ade 100644 --- a/pandas/indexes/category.py +++ b/pandas/indexes/category.py @@ -517,22 +517,22 @@ def take(self, indices, axis=0, allow_fill=True, return self._create_from_codes(taken) def map(self, mapper): - """ - Apply mapper function to its categories (not codes). + """Apply mapper function to its categories (not codes). Parameters ---------- mapper : callable Function to be applied. When all categories are mapped - to different categories, the result will be Categorical which has - the same order property as the original. Otherwise, the result will - be np.ndarray. + to different categories, the result will be a CategoricalIndex + which has the same order property as the original. Otherwise, + the result will be a Index. Returns ------- - applied : Categorical or np.ndarray. + applied : CategoricalIndex or Index + """ - return self.values.map(mapper) + return self._shallow_copy_with_infer(self.values.map(mapper)) def delete(self, loc): """ diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py index 9be4935716989..3536a52432b8c 100644 --- a/pandas/tests/indexes/test_base.py +++ b/pandas/tests/indexes/test_base.py @@ -767,6 +767,48 @@ def test_sub(self): self.assertRaises(TypeError, lambda: idx - idx.tolist()) self.assertRaises(TypeError, lambda: idx.tolist() - idx) + def test_map_identity_mapping(self): + # GH 12766 + for name, cur_index in self.indices.items(): + tm.assert_index_equal(cur_index, cur_index.map(lambda x: x)) + + def test_map_with_tuples(self): + # GH 12766 + + # Test that returning a single tuple from an Index + # returns an Index. + boolean_index = tm.makeIntIndex(3).map(lambda x: (x,)) + expected = Index([(0,), (1,), (2,)]) + tm.assert_index_equal(boolean_index, expected) + + # Test that returning a tuple from a map of a single index + # returns a MultiIndex object. + boolean_index = tm.makeIntIndex(3).map(lambda x: (x, x == 1)) + expected = MultiIndex.from_tuples([(0, False), (1, True), (2, False)]) + tm.assert_index_equal(boolean_index, expected) + + # Test that returning a single object from a MultiIndex + # returns an Index. + first_level = ['foo', 'bar', 'baz'] + multi_index = MultiIndex.from_tuples(lzip(first_level, [1, 2, 3])) + reduced_index = multi_index.map(lambda x: x[0]) + tm.assert_index_equal(reduced_index, Index(first_level)) + + def test_map_tseries_indices_return_index(self): + date_index = tm.makeDateIndex(10) + exp = Index([1] * 10) + tm.assert_index_equal(exp, date_index.map(lambda x: 1)) + + period_index = tm.makePeriodIndex(10) + tm.assert_index_equal(exp, period_index.map(lambda x: 1)) + + tdelta_index = tm.makeTimedeltaIndex(10) + tm.assert_index_equal(exp, tdelta_index.map(lambda x: 1)) + + date_index = tm.makeDateIndex(24, freq='h', name='hourly') + exp = Index(range(24), name='hourly') + tm.assert_index_equal(exp, date_index.map(lambda x: x.hour)) + def test_append_multiple(self): index = Index(['a', 'b', 'c', 'd', 'e', 'f']) @@ -1194,16 +1236,16 @@ def check_slice(in_slice, expected): self.assert_index_equal(result, expected) for in_slice, expected in [ - (SLC[::-1], 'yxdcb'), (SLC['b':'y':-1], ''), - (SLC['b'::-1], 'b'), (SLC[:'b':-1], 'yxdcb'), - (SLC[:'y':-1], 'y'), (SLC['y'::-1], 'yxdcb'), - (SLC['y'::-4], 'yb'), - # absent labels - (SLC[:'a':-1], 'yxdcb'), (SLC[:'a':-2], 'ydb'), - (SLC['z'::-1], 'yxdcb'), (SLC['z'::-3], 'yc'), - (SLC['m'::-1], 'dcb'), (SLC[:'m':-1], 'yx'), - (SLC['a':'a':-1], ''), (SLC['z':'z':-1], ''), - (SLC['m':'m':-1], '') + (SLC[::-1], 'yxdcb'), (SLC['b':'y':-1], ''), + (SLC['b'::-1], 'b'), (SLC[:'b':-1], 'yxdcb'), + (SLC[:'y':-1], 'y'), (SLC['y'::-1], 'yxdcb'), + (SLC['y'::-4], 'yb'), + # absent labels + (SLC[:'a':-1], 'yxdcb'), (SLC[:'a':-2], 'ydb'), + (SLC['z'::-1], 'yxdcb'), (SLC['z'::-3], 'yc'), + (SLC['m'::-1], 'dcb'), (SLC[:'m':-1], 'yx'), + (SLC['a':'a':-1], ''), (SLC['z':'z':-1], ''), + (SLC['m':'m':-1], '') ]: check_slice(in_slice, expected) diff --git a/pandas/tests/indexes/test_category.py b/pandas/tests/indexes/test_category.py index 819b88bf4c5d3..708f424d9bad1 100644 --- a/pandas/tests/indexes/test_category.py +++ b/pandas/tests/indexes/test_category.py @@ -207,19 +207,20 @@ def test_map(self): ci = pd.CategoricalIndex(list('ABABC'), categories=list('CBA'), ordered=True) result = ci.map(lambda x: x.lower()) - exp = pd.Categorical(list('ababc'), categories=list('cba'), - ordered=True) - tm.assert_categorical_equal(result, exp) + exp = pd.CategoricalIndex(list('ababc'), categories=list('cba'), + ordered=True) + tm.assert_index_equal(result, exp) ci = pd.CategoricalIndex(list('ABABC'), categories=list('BAC'), ordered=False, name='XXX') result = ci.map(lambda x: x.lower()) - exp = pd.Categorical(list('ababc'), categories=list('bac'), - ordered=False) - tm.assert_categorical_equal(result, exp) + exp = pd.CategoricalIndex(list('ababc'), categories=list('bac'), + ordered=False, name='XXX') + tm.assert_index_equal(result, exp) - tm.assert_numpy_array_equal(ci.map(lambda x: 1), - np.array([1] * 5, dtype=np.int64)) + # GH 12766: Return an index not an array + tm.assert_index_equal(ci.map(lambda x: 1), + Index(np.array([1] * 5, dtype=np.int64), name='XXX')) # change categories dtype ci = pd.CategoricalIndex(list('ABABC'), categories=list('BAC'), @@ -228,9 +229,9 @@ def f(x): return {'A': 10, 'B': 20, 'C': 30}.get(x) result = ci.map(f) - exp = pd.Categorical([10, 20, 10, 20, 30], categories=[20, 10, 30], - ordered=False) - tm.assert_categorical_equal(result, exp) + exp = pd.CategoricalIndex([10, 20, 10, 20, 30], categories=[20, 10, 30], + ordered=False) + tm.assert_index_equal(result, exp) def test_where(self): i = self.create_index() diff --git a/pandas/tests/series/test_apply.py b/pandas/tests/series/test_apply.py index 8d7676bef4d72..ec7ffde344d31 100644 --- a/pandas/tests/series/test_apply.py +++ b/pandas/tests/series/test_apply.py @@ -123,8 +123,9 @@ def test_apply_datetimetz(self): tm.assert_series_equal(result, exp) # change dtype + # GH 14506 : Returned dtype changed from int32 to int64 result = s.apply(lambda x: x.hour) - exp = pd.Series(list(range(24)) + [0], name='XX', dtype=np.int32) + exp = pd.Series(list(range(24)) + [0], name='XX', dtype=np.int64) tm.assert_series_equal(result, exp) # not vectorized @@ -317,8 +318,9 @@ def test_map_datetimetz(self): tm.assert_series_equal(result, exp) # change dtype + # GH 14506 : Returned dtype changed from int32 to int64 result = s.map(lambda x: x.hour) - exp = pd.Series(list(range(24)) + [0], name='XX', dtype=np.int32) + exp = pd.Series(list(range(24)) + [0], name='XX', dtype=np.int64) tm.assert_series_equal(result, exp) with tm.assertRaises(NotImplementedError): diff --git a/pandas/tests/test_categorical.py b/pandas/tests/test_categorical.py index 5320b2216ee40..5d2c317cc0f81 100644 --- a/pandas/tests/test_categorical.py +++ b/pandas/tests/test_categorical.py @@ -1669,7 +1669,8 @@ def test_map(self): tm.assert_categorical_equal(result, exp) result = c.map(lambda x: 1) - tm.assert_numpy_array_equal(result, np.array([1] * 5, dtype=np.int64)) + # GH 12766: Return an index not an array + tm.assert_index_equal(result, Index(np.array([1] * 5, dtype=np.int64))) class TestCategoricalAsBlock(tm.TestCase): diff --git a/pandas/tseries/base.py b/pandas/tseries/base.py index 4645ae24684ff..8e24f430108b3 100644 --- a/pandas/tseries/base.py +++ b/pandas/tseries/base.py @@ -27,7 +27,6 @@ from pandas.util.decorators import Appender, cache_readonly import pandas.types.concat as _concat import pandas.tseries.frequencies as frequencies -import pandas.algos as _algos class DatelikeOps(object): @@ -330,11 +329,16 @@ def _nat_new(self, box=True): def map(self, f): try: result = f(self) - if not isinstance(result, (np.ndarray, Index)): - raise TypeError + + # Try to use this result if we can + if isinstance(result, np.ndarray): + self._shallow_copy(result) + + if not isinstance(result, Index): + raise TypeError('The map function must return an Index object') return result except Exception: - return _algos.arrmap_object(self.asobject.values, f) + return self.asobject.map(f) def sort_values(self, return_indexer=False, ascending=True): """ diff --git a/pandas/tseries/tests/test_converter.py b/pandas/tseries/tests/test_converter.py index 37d9c35639c32..7e4ed288e31c1 100644 --- a/pandas/tseries/tests/test_converter.py +++ b/pandas/tseries/tests/test_converter.py @@ -3,7 +3,7 @@ import nose import numpy as np -from pandas import Timestamp, Period +from pandas import Timestamp, Period, Index from pandas.compat import u import pandas.util.testing as tm from pandas.tseries.offsets import Second, Milli, Micro @@ -104,8 +104,8 @@ def test_dateindex_conversion(self): for freq in ('B', 'L', 'S'): dateindex = tm.makeDateIndex(k=10, freq=freq) rs = self.dtc.convert(dateindex, None, None) - xp = converter.dates.date2num(dateindex._mpl_repr()) - tm.assert_almost_equal(rs, xp, decimals) + xp = Index(converter.dates.date2num(dateindex._mpl_repr())) + tm.assert_index_equal(rs, xp, decimals) def test_resolution(self): def _assert_less(ts1, ts2): diff --git a/pandas/tseries/tests/test_period.py b/pandas/tseries/tests/test_period.py index fe0d28dd9c508..dae1554c0930e 100644 --- a/pandas/tseries/tests/test_period.py +++ b/pandas/tseries/tests/test_period.py @@ -3521,8 +3521,8 @@ def test_map(self): tm.assert_index_equal(result, expected) result = index.map(lambda x: x.ordinal) - exp = np.array([x.ordinal for x in index], dtype=np.int64) - tm.assert_numpy_array_equal(result, exp) + exp = Index([x.ordinal for x in index]) + tm.assert_index_equal(result, exp) def test_map_with_string_constructor(self): raw = [2005, 2007, 2009] @@ -3534,20 +3534,17 @@ def test_map_with_string_constructor(self): types += text_type, for t in types: - expected = np.array(lmap(t, raw), dtype=object) + expected = Index(lmap(t, raw)) res = index.map(t) - # should return an array - tm.assertIsInstance(res, np.ndarray) + # should return an Index + tm.assertIsInstance(res, Index) # preserve element types self.assertTrue(all(isinstance(resi, t) for resi in res)) - # dtype should be object - self.assertEqual(res.dtype, np.dtype('object').type) - # lastly, values should compare equal - tm.assert_numpy_array_equal(res, expected) + tm.assert_index_equal(res, expected) def test_convert_array_of_periods(self): rng = period_range('1/1/2000', periods=20, freq='D') diff --git a/pandas/tseries/tests/test_timedeltas.py b/pandas/tseries/tests/test_timedeltas.py index f0d14014d6559..ca957ca0394d1 100644 --- a/pandas/tseries/tests/test_timedeltas.py +++ b/pandas/tseries/tests/test_timedeltas.py @@ -1513,8 +1513,8 @@ def test_map(self): f = lambda x: x.days result = rng.map(f) - exp = np.array([f(x) for x in rng], dtype=np.int64) - self.assert_numpy_array_equal(result, exp) + exp = Int64Index([f(x) for x in rng]) + tm.assert_index_equal(result, exp) def test_misc_coverage(self): diff --git a/pandas/tseries/tests/test_timeseries.py b/pandas/tseries/tests/test_timeseries.py index beacc21912edc..cd22ac561c6f7 100644 --- a/pandas/tseries/tests/test_timeseries.py +++ b/pandas/tseries/tests/test_timeseries.py @@ -3003,8 +3003,8 @@ def test_map(self): f = lambda x: x.strftime('%Y%m%d') result = rng.map(f) - exp = np.array([f(x) for x in rng], dtype='=U8') - tm.assert_almost_equal(result, exp) + exp = Index([f(x) for x in rng], dtype=' Date: Fri, 16 Dec 2016 18:30:26 -0500 Subject: [PATCH 12/51] BUG: Patch read_csv NA values behaviour Patches the following behaviour when `na_values` is passed in as a dictionary: 1. Prevent aliasing in case `na_values` was defined in a broader scope. 2. Respect column indices as keys when doing NA conversions. Closes #14203. Author: gfyoung Closes #14751 from gfyoung/csv-na-values-patching and squashes the following commits: cac422c [gfyoung] BUG: Respect column indices for dict-like na_values 1439c27 [gfyoung] BUG: Prevent aliasing of dict na_values --- doc/source/whatsnew/v0.19.2.txt | 2 ++ pandas/io/parsers.py | 25 ++++++++++++++++++++++--- pandas/io/tests/parser/na_values.py | 23 +++++++++++++++++++++++ pandas/parser.pyx | 26 +++++++++++++++----------- 4 files changed, 62 insertions(+), 14 deletions(-) diff --git a/doc/source/whatsnew/v0.19.2.txt b/doc/source/whatsnew/v0.19.2.txt index eaf61e148a8c7..4cd58f0148ae8 100644 --- a/doc/source/whatsnew/v0.19.2.txt +++ b/doc/source/whatsnew/v0.19.2.txt @@ -40,6 +40,8 @@ Bug Fixes - Compat with ``dateutil==2.6.0``; segfault reported in the testing suite (:issue:`14621`) - Allow ``nanoseconds`` in ``Timestamp.replace`` as a kwarg (:issue:`14621`) +- Bug in ``pd.read_csv`` in which aliasing was being done for ``na_values`` when passed in as a dictionary (:issue:`14203`) +- Bug in ``pd.read_csv`` in which column indices for a dict-like ``na_values`` were not being respected (:issue:`14203`) - Bug in ``pd.read_csv`` where reading files fails, if the number of headers is equal to the number of lines in the file (:issue:`14515`) - Bug in ``pd.read_csv`` for the Python engine in which an unhelpful error message was being raised when multi-char delimiters were not being respected with quotes (:issue:`14582`) - Fix bugs (:issue:`14734`, :issue:`13654`) in ``pd.read_sas`` and ``pandas.io.sas.sas7bdat.SAS7BDATReader`` that caused problems when reading a SAS file incrementally. diff --git a/pandas/io/parsers.py b/pandas/io/parsers.py index 200943324ce66..8e4246787ed5b 100755 --- a/pandas/io/parsers.py +++ b/pandas/io/parsers.py @@ -2055,9 +2055,27 @@ def _clean_mapping(mapping): else: clean_dtypes = _clean_mapping(self.dtype) - return self._convert_to_ndarrays(data, self.na_values, self.na_fvalues, - self.verbose, clean_conv, - clean_dtypes) + # Apply NA values. + clean_na_values = {} + clean_na_fvalues = {} + + if isinstance(self.na_values, dict): + for col in self.na_values: + na_value = self.na_values[col] + na_fvalue = self.na_fvalues[col] + + if isinstance(col, int) and col not in self.orig_names: + col = self.orig_names[col] + + clean_na_values[col] = na_value + clean_na_fvalues[col] = na_fvalue + else: + clean_na_values = self.na_values + clean_na_fvalues = self.na_fvalues + + return self._convert_to_ndarrays(data, clean_na_values, + clean_na_fvalues, self.verbose, + clean_conv, clean_dtypes) def _to_recarray(self, data, columns): dtypes = [] @@ -2767,6 +2785,7 @@ def _clean_na_values(na_values, keep_default_na=True): na_values = [] na_fvalues = set() elif isinstance(na_values, dict): + na_values = na_values.copy() # Prevent aliasing. if keep_default_na: for k, v in compat.iteritems(na_values): if not is_list_like(v): diff --git a/pandas/io/tests/parser/na_values.py b/pandas/io/tests/parser/na_values.py index 92107cf2e82a7..e245bc5589145 100644 --- a/pandas/io/tests/parser/na_values.py +++ b/pandas/io/tests/parser/na_values.py @@ -266,3 +266,26 @@ def test_na_values_scalar(self): out = self.read_csv(StringIO(data), names=names, na_values={'a': 2, 'b': 1}) tm.assert_frame_equal(out, expected) + + def test_na_values_dict_aliasing(self): + na_values = {'a': 2, 'b': 1} + na_values_copy = na_values.copy() + + names = ['a', 'b'] + data = '1,2\n2,1' + + expected = DataFrame([[1.0, 2.0], [np.nan, np.nan]], columns=names) + out = self.read_csv(StringIO(data), names=names, na_values=na_values) + + tm.assert_frame_equal(out, expected) + tm.assert_dict_equal(na_values, na_values_copy) + + def test_na_values_dict_col_index(self): + # see gh-14203 + + data = 'a\nfoo\n1' + na_values = {0: 'foo'} + + out = self.read_csv(StringIO(data), na_values=na_values) + expected = DataFrame({'a': [np.nan, 1]}) + tm.assert_frame_equal(out, expected) diff --git a/pandas/parser.pyx b/pandas/parser.pyx index d94a4ef278dee..8e52fc117b401 100644 --- a/pandas/parser.pyx +++ b/pandas/parser.pyx @@ -1262,19 +1262,23 @@ cdef class TextReader: return None, set() if isinstance(self.na_values, dict): + key = None values = None + if name is not None and name in self.na_values: - values = self.na_values[name] - if values is not None and not isinstance(values, list): - values = list(values) - fvalues = self.na_fvalues[name] - if fvalues is not None and not isinstance(fvalues, set): - fvalues = set(fvalues) - else: - if i in self.na_values: - return self.na_values[i], self.na_fvalues[i] - else: - return _NA_VALUES, set() + key = name + elif i in self.na_values: + key = i + else: # No na_values provided for this column. + return _NA_VALUES, set() + + values = self.na_values[key] + if values is not None and not isinstance(values, list): + values = list(values) + + fvalues = self.na_fvalues[key] + if fvalues is not None and not isinstance(fvalues, set): + fvalues = set(fvalues) return _ensure_encoded(values), fvalues else: From 73bc6cfb35a886b18955b1f0a07f7647f1f1d409 Mon Sep 17 00:00:00 2001 From: Ajay Saxena Date: Sat, 17 Dec 2016 10:37:59 -0500 Subject: [PATCH 13/51] Groupby tests restructure closes #14813 Author: Ajay Saxena Closes #14817 from aileronajay/groupby_test_restructure and squashes the following commits: 860574d [Ajay Saxena] removed duplicate file f6e1cda [Ajay Saxena] further split the tests 2cc0734 [Ajay Saxena] branched out the filter tests into a new file --- pandas/tests/groupby/test_aggregate.py | 494 ++++++++ pandas/tests/groupby/test_categorical.py | 467 +++++++ pandas/tests/groupby/test_filters.py | 635 ++++++++++ pandas/tests/{ => groupby}/test_groupby.py | 1275 -------------------- setup.py | 1 + 5 files changed, 1597 insertions(+), 1275 deletions(-) create mode 100644 pandas/tests/groupby/test_aggregate.py create mode 100644 pandas/tests/groupby/test_categorical.py create mode 100644 pandas/tests/groupby/test_filters.py rename pandas/tests/{ => groupby}/test_groupby.py (81%) diff --git a/pandas/tests/groupby/test_aggregate.py b/pandas/tests/groupby/test_aggregate.py new file mode 100644 index 0000000000000..6b162b71f79de --- /dev/null +++ b/pandas/tests/groupby/test_aggregate.py @@ -0,0 +1,494 @@ +# -*- coding: utf-8 -*- +from __future__ import print_function +import nose +from datetime import datetime + + +from pandas import date_range +from pandas.core.index import MultiIndex +from pandas.core.api import DataFrame + +from pandas.core.series import Series + +from pandas.util.testing import (assert_frame_equal, assert_series_equal + ) + +from pandas.core.groupby import (SpecificationError) +from pandas.compat import (lmap, OrderedDict) +from pandas.formats.printing import pprint_thing + +from pandas import compat + +import pandas.core.common as com +import numpy as np + +import pandas.util.testing as tm +import pandas as pd + + +class TestGroupByAggregate(tm.TestCase): + + _multiprocess_can_split_ = True + + def setUp(self): + self.ts = tm.makeTimeSeries() + + self.seriesd = tm.getSeriesData() + self.tsd = tm.getTimeSeriesData() + self.frame = DataFrame(self.seriesd) + self.tsframe = DataFrame(self.tsd) + + self.df = DataFrame( + {'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'], + 'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'], + 'C': np.random.randn(8), + 'D': np.random.randn(8)}) + + self.df_mixed_floats = DataFrame( + {'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'], + 'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'], + 'C': np.random.randn(8), + 'D': np.array( + np.random.randn(8), dtype='float32')}) + + index = MultiIndex(levels=[['foo', 'bar', 'baz', 'qux'], ['one', 'two', + 'three']], + labels=[[0, 0, 0, 1, 1, 2, 2, 3, 3, 3], + [0, 1, 2, 0, 1, 1, 2, 0, 1, 2]], + names=['first', 'second']) + self.mframe = DataFrame(np.random.randn(10, 3), index=index, + columns=['A', 'B', 'C']) + + self.three_group = DataFrame( + {'A': ['foo', 'foo', 'foo', 'foo', 'bar', 'bar', 'bar', 'bar', + 'foo', 'foo', 'foo'], + 'B': ['one', 'one', 'one', 'two', 'one', 'one', 'one', 'two', + 'two', 'two', 'one'], + 'C': ['dull', 'dull', 'shiny', 'dull', 'dull', 'shiny', 'shiny', + 'dull', 'shiny', 'shiny', 'shiny'], + 'D': np.random.randn(11), + 'E': np.random.randn(11), + 'F': np.random.randn(11)}) + + def test_agg_api(self): + + # GH 6337 + # http://stackoverflow.com/questions/21706030/pandas-groupby-agg-function-column-dtype-error + # different api for agg when passed custom function with mixed frame + + df = DataFrame({'data1': np.random.randn(5), + 'data2': np.random.randn(5), + 'key1': ['a', 'a', 'b', 'b', 'a'], + 'key2': ['one', 'two', 'one', 'two', 'one']}) + grouped = df.groupby('key1') + + def peak_to_peak(arr): + return arr.max() - arr.min() + + expected = grouped.agg([peak_to_peak]) + expected.columns = ['data1', 'data2'] + result = grouped.agg(peak_to_peak) + assert_frame_equal(result, expected) + + def test_agg_regression1(self): + grouped = self.tsframe.groupby([lambda x: x.year, lambda x: x.month]) + result = grouped.agg(np.mean) + expected = grouped.mean() + assert_frame_equal(result, expected) + + def test_agg_datetimes_mixed(self): + data = [[1, '2012-01-01', 1.0], [2, '2012-01-02', 2.0], [3, None, 3.0]] + + df1 = DataFrame({'key': [x[0] for x in data], + 'date': [x[1] for x in data], + 'value': [x[2] for x in data]}) + + data = [[row[0], datetime.strptime(row[1], '%Y-%m-%d').date() if row[1] + else None, row[2]] for row in data] + + df2 = DataFrame({'key': [x[0] for x in data], + 'date': [x[1] for x in data], + 'value': [x[2] for x in data]}) + + df1['weights'] = df1['value'] / df1['value'].sum() + gb1 = df1.groupby('date').aggregate(np.sum) + + df2['weights'] = df1['value'] / df1['value'].sum() + gb2 = df2.groupby('date').aggregate(np.sum) + + assert (len(gb1) == len(gb2)) + + def test_agg_period_index(self): + from pandas import period_range, PeriodIndex + prng = period_range('2012-1-1', freq='M', periods=3) + df = DataFrame(np.random.randn(3, 2), index=prng) + rs = df.groupby(level=0).sum() + tm.assertIsInstance(rs.index, PeriodIndex) + + # GH 3579 + index = period_range(start='1999-01', periods=5, freq='M') + s1 = Series(np.random.rand(len(index)), index=index) + s2 = Series(np.random.rand(len(index)), index=index) + series = [('s1', s1), ('s2', s2)] + df = DataFrame.from_items(series) + grouped = df.groupby(df.index.month) + list(grouped) + + def test_agg_dict_parameter_cast_result_dtypes(self): + # GH 12821 + + df = DataFrame( + {'class': ['A', 'A', 'B', 'B', 'C', 'C', 'D', 'D'], + 'time': date_range('1/1/2011', periods=8, freq='H')}) + df.loc[[0, 1, 2, 5], 'time'] = None + + # test for `first` function + exp = df.loc[[0, 3, 4, 6]].set_index('class') + grouped = df.groupby('class') + assert_frame_equal(grouped.first(), exp) + assert_frame_equal(grouped.agg('first'), exp) + assert_frame_equal(grouped.agg({'time': 'first'}), exp) + assert_series_equal(grouped.time.first(), exp['time']) + assert_series_equal(grouped.time.agg('first'), exp['time']) + + # test for `last` function + exp = df.loc[[0, 3, 4, 7]].set_index('class') + grouped = df.groupby('class') + assert_frame_equal(grouped.last(), exp) + assert_frame_equal(grouped.agg('last'), exp) + assert_frame_equal(grouped.agg({'time': 'last'}), exp) + assert_series_equal(grouped.time.last(), exp['time']) + assert_series_equal(grouped.time.agg('last'), exp['time']) + + def test_agg_must_agg(self): + grouped = self.df.groupby('A')['C'] + self.assertRaises(Exception, grouped.agg, lambda x: x.describe()) + self.assertRaises(Exception, grouped.agg, lambda x: x.index[:2]) + + def test_agg_ser_multi_key(self): + # TODO(wesm): unused + ser = self.df.C # noqa + + f = lambda x: x.sum() + results = self.df.C.groupby([self.df.A, self.df.B]).aggregate(f) + expected = self.df.groupby(['A', 'B']).sum()['C'] + assert_series_equal(results, expected) + + def test_agg_apply_corner(self): + # nothing to group, all NA + grouped = self.ts.groupby(self.ts * np.nan) + self.assertEqual(self.ts.dtype, np.float64) + + # groupby float64 values results in Float64Index + exp = Series([], dtype=np.float64, index=pd.Index( + [], dtype=np.float64)) + assert_series_equal(grouped.sum(), exp) + assert_series_equal(grouped.agg(np.sum), exp) + assert_series_equal(grouped.apply(np.sum), exp, check_index_type=False) + + # DataFrame + grouped = self.tsframe.groupby(self.tsframe['A'] * np.nan) + exp_df = DataFrame(columns=self.tsframe.columns, dtype=float, + index=pd.Index([], dtype=np.float64)) + assert_frame_equal(grouped.sum(), exp_df, check_names=False) + assert_frame_equal(grouped.agg(np.sum), exp_df, check_names=False) + assert_frame_equal(grouped.apply(np.sum), exp_df.iloc[:, :0], + check_names=False) + + def test_agg_grouping_is_list_tuple(self): + from pandas.core.groupby import Grouping + + df = tm.makeTimeDataFrame() + + grouped = df.groupby(lambda x: x.year) + grouper = grouped.grouper.groupings[0].grouper + grouped.grouper.groupings[0] = Grouping(self.ts.index, list(grouper)) + + result = grouped.agg(np.mean) + expected = grouped.mean() + tm.assert_frame_equal(result, expected) + + grouped.grouper.groupings[0] = Grouping(self.ts.index, tuple(grouper)) + + result = grouped.agg(np.mean) + expected = grouped.mean() + tm.assert_frame_equal(result, expected) + + def test_aggregate_api_consistency(self): + # GH 9052 + # make sure that the aggregates via dict + # are consistent + + df = DataFrame({'A': ['foo', 'bar', 'foo', 'bar', + 'foo', 'bar', 'foo', 'foo'], + 'B': ['one', 'one', 'two', 'two', + 'two', 'two', 'one', 'two'], + 'C': np.random.randn(8) + 1.0, + 'D': np.arange(8)}) + + grouped = df.groupby(['A', 'B']) + c_mean = grouped['C'].mean() + c_sum = grouped['C'].sum() + d_mean = grouped['D'].mean() + d_sum = grouped['D'].sum() + + result = grouped['D'].agg(['sum', 'mean']) + expected = pd.concat([d_sum, d_mean], + axis=1) + expected.columns = ['sum', 'mean'] + assert_frame_equal(result, expected, check_like=True) + + result = grouped.agg([np.sum, np.mean]) + expected = pd.concat([c_sum, + c_mean, + d_sum, + d_mean], + axis=1) + expected.columns = MultiIndex.from_product([['C', 'D'], + ['sum', 'mean']]) + assert_frame_equal(result, expected, check_like=True) + + result = grouped[['D', 'C']].agg([np.sum, np.mean]) + expected = pd.concat([d_sum, + d_mean, + c_sum, + c_mean], + axis=1) + expected.columns = MultiIndex.from_product([['D', 'C'], + ['sum', 'mean']]) + assert_frame_equal(result, expected, check_like=True) + + result = grouped.agg({'C': 'mean', 'D': 'sum'}) + expected = pd.concat([d_sum, + c_mean], + axis=1) + assert_frame_equal(result, expected, check_like=True) + + result = grouped.agg({'C': ['mean', 'sum'], + 'D': ['mean', 'sum']}) + expected = pd.concat([c_mean, + c_sum, + d_mean, + d_sum], + axis=1) + expected.columns = MultiIndex.from_product([['C', 'D'], + ['mean', 'sum']]) + + result = grouped[['D', 'C']].agg({'r': np.sum, + 'r2': np.mean}) + expected = pd.concat([d_sum, + c_sum, + d_mean, + c_mean], + axis=1) + expected.columns = MultiIndex.from_product([['r', 'r2'], + ['D', 'C']]) + assert_frame_equal(result, expected, check_like=True) + + def test_agg_compat(self): + + # GH 12334 + + df = DataFrame({'A': ['foo', 'bar', 'foo', 'bar', + 'foo', 'bar', 'foo', 'foo'], + 'B': ['one', 'one', 'two', 'two', + 'two', 'two', 'one', 'two'], + 'C': np.random.randn(8) + 1.0, + 'D': np.arange(8)}) + + g = df.groupby(['A', 'B']) + + expected = pd.concat([g['D'].sum(), + g['D'].std()], + axis=1) + expected.columns = MultiIndex.from_tuples([('C', 'sum'), + ('C', 'std')]) + result = g['D'].agg({'C': ['sum', 'std']}) + assert_frame_equal(result, expected, check_like=True) + + expected = pd.concat([g['D'].sum(), + g['D'].std()], + axis=1) + expected.columns = ['C', 'D'] + result = g['D'].agg({'C': 'sum', 'D': 'std'}) + assert_frame_equal(result, expected, check_like=True) + + def test_agg_nested_dicts(self): + + # API change for disallowing these types of nested dicts + df = DataFrame({'A': ['foo', 'bar', 'foo', 'bar', + 'foo', 'bar', 'foo', 'foo'], + 'B': ['one', 'one', 'two', 'two', + 'two', 'two', 'one', 'two'], + 'C': np.random.randn(8) + 1.0, + 'D': np.arange(8)}) + + g = df.groupby(['A', 'B']) + + def f(): + g.aggregate({'r1': {'C': ['mean', 'sum']}, + 'r2': {'D': ['mean', 'sum']}}) + + self.assertRaises(SpecificationError, f) + + result = g.agg({'C': {'ra': ['mean', 'std']}, + 'D': {'rb': ['mean', 'std']}}) + expected = pd.concat([g['C'].mean(), g['C'].std(), g['D'].mean(), + g['D'].std()], axis=1) + expected.columns = pd.MultiIndex.from_tuples([('ra', 'mean'), ( + 'ra', 'std'), ('rb', 'mean'), ('rb', 'std')]) + assert_frame_equal(result, expected, check_like=True) + + # same name as the original column + # GH9052 + expected = g['D'].agg({'result1': np.sum, 'result2': np.mean}) + expected = expected.rename(columns={'result1': 'D'}) + result = g['D'].agg({'D': np.sum, 'result2': np.mean}) + assert_frame_equal(result, expected, check_like=True) + + def test_agg_python_multiindex(self): + grouped = self.mframe.groupby(['A', 'B']) + + result = grouped.agg(np.mean) + expected = grouped.mean() + tm.assert_frame_equal(result, expected) + + def test_aggregate_str_func(self): + def _check_results(grouped): + # single series + result = grouped['A'].agg('std') + expected = grouped['A'].std() + assert_series_equal(result, expected) + + # group frame by function name + result = grouped.aggregate('var') + expected = grouped.var() + assert_frame_equal(result, expected) + + # group frame by function dict + result = grouped.agg(OrderedDict([['A', 'var'], ['B', 'std'], + ['C', 'mean'], ['D', 'sem']])) + expected = DataFrame(OrderedDict([['A', grouped['A'].var( + )], ['B', grouped['B'].std()], ['C', grouped['C'].mean()], + ['D', grouped['D'].sem()]])) + assert_frame_equal(result, expected) + + by_weekday = self.tsframe.groupby(lambda x: x.weekday()) + _check_results(by_weekday) + + by_mwkday = self.tsframe.groupby([lambda x: x.month, + lambda x: x.weekday()]) + _check_results(by_mwkday) + + def test_aggregate_item_by_item(self): + + df = self.df.copy() + df['E'] = ['a'] * len(self.df) + grouped = self.df.groupby('A') + + # API change in 0.11 + # def aggfun(ser): + # return len(ser + 'a') + # result = grouped.agg(aggfun) + # self.assertEqual(len(result.columns), 1) + + aggfun = lambda ser: ser.size + result = grouped.agg(aggfun) + foo = (self.df.A == 'foo').sum() + bar = (self.df.A == 'bar').sum() + K = len(result.columns) + + # GH5782 + # odd comparisons can result here, so cast to make easy + exp = pd.Series(np.array([foo] * K), index=list('BCD'), + dtype=np.float64, name='foo') + tm.assert_series_equal(result.xs('foo'), exp) + + exp = pd.Series(np.array([bar] * K), index=list('BCD'), + dtype=np.float64, name='bar') + tm.assert_almost_equal(result.xs('bar'), exp) + + def aggfun(ser): + return ser.size + + result = DataFrame().groupby(self.df.A).agg(aggfun) + tm.assertIsInstance(result, DataFrame) + self.assertEqual(len(result), 0) + + def test_agg_item_by_item_raise_typeerror(self): + from numpy.random import randint + + df = DataFrame(randint(10, size=(20, 10))) + + def raiseException(df): + pprint_thing('----------------------------------------') + pprint_thing(df.to_string()) + raise TypeError + + self.assertRaises(TypeError, df.groupby(0).agg, raiseException) + + def test_series_agg_multikey(self): + ts = tm.makeTimeSeries() + grouped = ts.groupby([lambda x: x.year, lambda x: x.month]) + + result = grouped.agg(np.sum) + expected = grouped.sum() + assert_series_equal(result, expected) + + def test_series_agg_multi_pure_python(self): + data = DataFrame( + {'A': ['foo', 'foo', 'foo', 'foo', 'bar', 'bar', 'bar', 'bar', + 'foo', 'foo', 'foo'], + 'B': ['one', 'one', 'one', 'two', 'one', 'one', 'one', 'two', + 'two', 'two', 'one'], + 'C': ['dull', 'dull', 'shiny', 'dull', 'dull', 'shiny', 'shiny', + 'dull', 'shiny', 'shiny', 'shiny'], + 'D': np.random.randn(11), + 'E': np.random.randn(11), + 'F': np.random.randn(11)}) + + def bad(x): + assert (len(x.base) > 0) + return 'foo' + + result = data.groupby(['A', 'B']).agg(bad) + expected = data.groupby(['A', 'B']).agg(lambda x: 'foo') + assert_frame_equal(result, expected) + + +def assert_fp_equal(a, b): + assert (np.abs(a - b) < 1e-12).all() + + +def _check_groupby(df, result, keys, field, f=lambda x: x.sum()): + tups = lmap(tuple, df[keys].values) + tups = com._asarray_tuplesafe(tups) + expected = f(df.groupby(tups)[field]) + for k, v in compat.iteritems(expected): + assert (result[k] == v) + + +def test_decons(): + from pandas.core.groupby import decons_group_index, get_group_index + + def testit(label_list, shape): + group_index = get_group_index(label_list, shape, sort=True, xnull=True) + label_list2 = decons_group_index(group_index, shape) + + for a, b in zip(label_list, label_list2): + assert (np.array_equal(a, b)) + + shape = (4, 5, 6) + label_list = [np.tile([0, 1, 2, 3, 0, 1, 2, 3], 100), np.tile( + [0, 2, 4, 3, 0, 1, 2, 3], 100), np.tile( + [5, 1, 0, 2, 3, 0, 5, 4], 100)] + testit(label_list, shape) + + shape = (10000, 10000) + label_list = [np.tile(np.arange(10000), 5), np.tile(np.arange(10000), 5)] + testit(label_list, shape) + + +if __name__ == '__main__': + nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure', '-s' + ], exit=False) diff --git a/pandas/tests/groupby/test_categorical.py b/pandas/tests/groupby/test_categorical.py new file mode 100644 index 0000000000000..d3c7bc2adbb4a --- /dev/null +++ b/pandas/tests/groupby/test_categorical.py @@ -0,0 +1,467 @@ +# -*- coding: utf-8 -*- +from __future__ import print_function +import nose +from numpy import nan + + +from pandas.core.index import Index, MultiIndex, CategoricalIndex +from pandas.core.api import DataFrame, Categorical + +from pandas.core.series import Series + +from pandas.util.testing import (assert_frame_equal, assert_series_equal + ) + +from pandas.compat import (lmap) + +from pandas import compat + +import pandas.core.common as com +import numpy as np + +import pandas.util.testing as tm +import pandas as pd + + +class TestGroupByCategorical(tm.TestCase): + + _multiprocess_can_split_ = True + + def setUp(self): + self.ts = tm.makeTimeSeries() + + self.seriesd = tm.getSeriesData() + self.tsd = tm.getTimeSeriesData() + self.frame = DataFrame(self.seriesd) + self.tsframe = DataFrame(self.tsd) + + self.df = DataFrame( + {'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'], + 'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'], + 'C': np.random.randn(8), + 'D': np.random.randn(8)}) + + self.df_mixed_floats = DataFrame( + {'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'], + 'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'], + 'C': np.random.randn(8), + 'D': np.array( + np.random.randn(8), dtype='float32')}) + + index = MultiIndex(levels=[['foo', 'bar', 'baz', 'qux'], ['one', 'two', + 'three']], + labels=[[0, 0, 0, 1, 1, 2, 2, 3, 3, 3], + [0, 1, 2, 0, 1, 1, 2, 0, 1, 2]], + names=['first', 'second']) + self.mframe = DataFrame(np.random.randn(10, 3), index=index, + columns=['A', 'B', 'C']) + + self.three_group = DataFrame( + {'A': ['foo', 'foo', 'foo', 'foo', 'bar', 'bar', 'bar', 'bar', + 'foo', 'foo', 'foo'], + 'B': ['one', 'one', 'one', 'two', 'one', 'one', 'one', 'two', + 'two', 'two', 'one'], + 'C': ['dull', 'dull', 'shiny', 'dull', 'dull', 'shiny', 'shiny', + 'dull', 'shiny', 'shiny', 'shiny'], + 'D': np.random.randn(11), + 'E': np.random.randn(11), + 'F': np.random.randn(11)}) + + def test_apply_use_categorical_name(self): + from pandas import qcut + cats = qcut(self.df.C, 4) + + def get_stats(group): + return {'min': group.min(), + 'max': group.max(), + 'count': group.count(), + 'mean': group.mean()} + + result = self.df.groupby(cats).D.apply(get_stats) + self.assertEqual(result.index.names[0], 'C') + + def test_apply_categorical_data(self): + # GH 10138 + for ordered in [True, False]: + dense = Categorical(list('abc'), ordered=ordered) + # 'b' is in the categories but not in the list + missing = Categorical( + list('aaa'), categories=['a', 'b'], ordered=ordered) + values = np.arange(len(dense)) + df = DataFrame({'missing': missing, + 'dense': dense, + 'values': values}) + grouped = df.groupby(['missing', 'dense']) + + # missing category 'b' should still exist in the output index + idx = MultiIndex.from_product( + [Categorical(['a', 'b'], ordered=ordered), + Categorical(['a', 'b', 'c'], ordered=ordered)], + names=['missing', 'dense']) + expected = DataFrame([0, 1, 2, np.nan, np.nan, np.nan], + index=idx, + columns=['values']) + + assert_frame_equal(grouped.apply(lambda x: np.mean(x)), expected) + assert_frame_equal(grouped.mean(), expected) + assert_frame_equal(grouped.agg(np.mean), expected) + + # but for transform we should still get back the original index + idx = MultiIndex.from_product([['a'], ['a', 'b', 'c']], + names=['missing', 'dense']) + expected = Series(1, index=idx) + assert_series_equal(grouped.apply(lambda x: 1), expected) + + def test_groupby_categorical(self): + levels = ['foo', 'bar', 'baz', 'qux'] + codes = np.random.randint(0, 4, size=100) + + cats = Categorical.from_codes(codes, levels, ordered=True) + + data = DataFrame(np.random.randn(100, 4)) + + result = data.groupby(cats).mean() + + expected = data.groupby(np.asarray(cats)).mean() + exp_idx = CategoricalIndex(levels, categories=cats.categories, + ordered=True) + expected = expected.reindex(exp_idx) + + assert_frame_equal(result, expected) + + grouped = data.groupby(cats) + desc_result = grouped.describe() + + idx = cats.codes.argsort() + ord_labels = np.asarray(cats).take(idx) + ord_data = data.take(idx) + + exp_cats = Categorical(ord_labels, ordered=True, + categories=['foo', 'bar', 'baz', 'qux']) + expected = ord_data.groupby(exp_cats, sort=False).describe() + expected.index.names = [None, None] + assert_frame_equal(desc_result, expected) + + # GH 10460 + expc = Categorical.from_codes(np.arange(4).repeat(8), + levels, ordered=True) + exp = CategoricalIndex(expc) + self.assert_index_equal(desc_result.index.get_level_values(0), exp) + exp = Index(['count', 'mean', 'std', 'min', '25%', '50%', + '75%', 'max'] * 4) + self.assert_index_equal(desc_result.index.get_level_values(1), exp) + + def test_groupby_datetime_categorical(self): + # GH9049: ensure backward compatibility + levels = pd.date_range('2014-01-01', periods=4) + codes = np.random.randint(0, 4, size=100) + + cats = Categorical.from_codes(codes, levels, ordered=True) + + data = DataFrame(np.random.randn(100, 4)) + result = data.groupby(cats).mean() + + expected = data.groupby(np.asarray(cats)).mean() + expected = expected.reindex(levels) + expected.index = CategoricalIndex(expected.index, + categories=expected.index, + ordered=True) + + assert_frame_equal(result, expected) + + grouped = data.groupby(cats) + desc_result = grouped.describe() + + idx = cats.codes.argsort() + ord_labels = cats.take_nd(idx) + ord_data = data.take(idx) + expected = ord_data.groupby(ord_labels).describe() + expected.index.names = [None, None] + assert_frame_equal(desc_result, expected) + tm.assert_index_equal(desc_result.index, expected.index) + tm.assert_index_equal( + desc_result.index.get_level_values(0), + expected.index.get_level_values(0)) + + # GH 10460 + expc = Categorical.from_codes( + np.arange(4).repeat(8), levels, ordered=True) + exp = CategoricalIndex(expc) + self.assert_index_equal(desc_result.index.get_level_values(0), exp) + exp = Index(['count', 'mean', 'std', 'min', '25%', '50%', + '75%', 'max'] * 4) + self.assert_index_equal(desc_result.index.get_level_values(1), exp) + + def test_groupby_categorical_index(self): + + levels = ['foo', 'bar', 'baz', 'qux'] + codes = np.random.randint(0, 4, size=20) + cats = Categorical.from_codes(codes, levels, ordered=True) + df = DataFrame( + np.repeat( + np.arange(20), 4).reshape(-1, 4), columns=list('abcd')) + df['cats'] = cats + + # with a cat index + result = df.set_index('cats').groupby(level=0).sum() + expected = df[list('abcd')].groupby(cats.codes).sum() + expected.index = CategoricalIndex( + Categorical.from_codes( + [0, 1, 2, 3], levels, ordered=True), name='cats') + assert_frame_equal(result, expected) + + # with a cat column, should produce a cat index + result = df.groupby('cats').sum() + expected = df[list('abcd')].groupby(cats.codes).sum() + expected.index = CategoricalIndex( + Categorical.from_codes( + [0, 1, 2, 3], levels, ordered=True), name='cats') + assert_frame_equal(result, expected) + + def test_groupby_describe_categorical_columns(self): + # GH 11558 + cats = pd.CategoricalIndex(['qux', 'foo', 'baz', 'bar'], + categories=['foo', 'bar', 'baz', 'qux'], + ordered=True) + df = DataFrame(np.random.randn(20, 4), columns=cats) + result = df.groupby([1, 2, 3, 4] * 5).describe() + + tm.assert_index_equal(result.columns, cats) + tm.assert_categorical_equal(result.columns.values, cats.values) + + def test_groupby_unstack_categorical(self): + # GH11558 (example is taken from the original issue) + df = pd.DataFrame({'a': range(10), + 'medium': ['A', 'B'] * 5, + 'artist': list('XYXXY') * 2}) + df['medium'] = df['medium'].astype('category') + + gcat = df.groupby(['artist', 'medium'])['a'].count().unstack() + result = gcat.describe() + + exp_columns = pd.CategoricalIndex(['A', 'B'], ordered=False, + name='medium') + tm.assert_index_equal(result.columns, exp_columns) + tm.assert_categorical_equal(result.columns.values, exp_columns.values) + + result = gcat['A'] + gcat['B'] + expected = pd.Series([6, 4], index=pd.Index(['X', 'Y'], name='artist')) + tm.assert_series_equal(result, expected) + + def test_groupby_categorical_unequal_len(self): + # GH3011 + series = Series([np.nan, np.nan, 1, 1, 2, 2, 3, 3, 4, 4]) + # The raises only happens with categorical, not with series of types + # category + bins = pd.cut(series.dropna().values, 4) + + # len(bins) != len(series) here + self.assertRaises(ValueError, lambda: series.groupby(bins).mean()) + + def test_groupby_categorical_two_columns(self): + + # https://github.com/pandas-dev/pandas/issues/8138 + d = {'cat': + pd.Categorical(["a", "b", "a", "b"], categories=["a", "b", "c"], + ordered=True), + 'ints': [1, 1, 2, 2], + 'val': [10, 20, 30, 40]} + test = pd.DataFrame(d) + + # Grouping on a single column + groups_single_key = test.groupby("cat") + res = groups_single_key.agg('mean') + + exp_index = pd.CategoricalIndex(["a", "b", "c"], name="cat", + ordered=True) + exp = DataFrame({"ints": [1.5, 1.5, np.nan], "val": [20, 30, np.nan]}, + index=exp_index) + tm.assert_frame_equal(res, exp) + + # Grouping on two columns + groups_double_key = test.groupby(["cat", "ints"]) + res = groups_double_key.agg('mean') + exp = DataFrame({"val": [10, 30, 20, 40, np.nan, np.nan], + "cat": pd.Categorical(["a", "a", "b", "b", "c", "c"], + ordered=True), + "ints": [1, 2, 1, 2, 1, 2]}).set_index(["cat", "ints" + ]) + tm.assert_frame_equal(res, exp) + + # GH 10132 + for key in [('a', 1), ('b', 2), ('b', 1), ('a', 2)]: + c, i = key + result = groups_double_key.get_group(key) + expected = test[(test.cat == c) & (test.ints == i)] + assert_frame_equal(result, expected) + + d = {'C1': [3, 3, 4, 5], 'C2': [1, 2, 3, 4], 'C3': [10, 100, 200, 34]} + test = pd.DataFrame(d) + values = pd.cut(test['C1'], [1, 2, 3, 6]) + values.name = "cat" + groups_double_key = test.groupby([values, 'C2']) + + res = groups_double_key.agg('mean') + nan = np.nan + idx = MultiIndex.from_product( + [Categorical(["(1, 2]", "(2, 3]", "(3, 6]"], ordered=True), + [1, 2, 3, 4]], + names=["cat", "C2"]) + exp = DataFrame({"C1": [nan, nan, nan, nan, 3, 3, + nan, nan, nan, nan, 4, 5], + "C3": [nan, nan, nan, nan, 10, 100, + nan, nan, nan, nan, 200, 34]}, index=idx) + tm.assert_frame_equal(res, exp) + + def test_groupby_multi_categorical_as_index(self): + # GH13204 + df = DataFrame({'cat': Categorical([1, 2, 2], [1, 2, 3]), + 'A': [10, 11, 11], + 'B': [101, 102, 103]}) + result = df.groupby(['cat', 'A'], as_index=False).sum() + expected = DataFrame({'cat': Categorical([1, 1, 2, 2, 3, 3]), + 'A': [10, 11, 10, 11, 10, 11], + 'B': [101.0, nan, nan, 205.0, nan, nan]}, + columns=['cat', 'A', 'B']) + tm.assert_frame_equal(result, expected) + + # function grouper + f = lambda r: df.loc[r, 'A'] + result = df.groupby(['cat', f], as_index=False).sum() + expected = DataFrame({'cat': Categorical([1, 1, 2, 2, 3, 3]), + 'A': [10.0, nan, nan, 22.0, nan, nan], + 'B': [101.0, nan, nan, 205.0, nan, nan]}, + columns=['cat', 'A', 'B']) + tm.assert_frame_equal(result, expected) + + # another not in-axis grouper (conflicting names in index) + s = Series(['a', 'b', 'b'], name='cat') + result = df.groupby(['cat', s], as_index=False).sum() + expected = DataFrame({'cat': Categorical([1, 1, 2, 2, 3, 3]), + 'A': [10.0, nan, nan, 22.0, nan, nan], + 'B': [101.0, nan, nan, 205.0, nan, nan]}, + columns=['cat', 'A', 'B']) + tm.assert_frame_equal(result, expected) + + # is original index dropped? + expected = DataFrame({'cat': Categorical([1, 1, 2, 2, 3, 3]), + 'A': [10, 11, 10, 11, 10, 11], + 'B': [101.0, nan, nan, 205.0, nan, nan]}, + columns=['cat', 'A', 'B']) + + for name in [None, 'X', 'B', 'cat']: + df.index = Index(list("abc"), name=name) + result = df.groupby(['cat', 'A'], as_index=False).sum() + tm.assert_frame_equal(result, expected, check_index_type=True) + + def test_groupby_preserve_categorical_dtype(self): + # GH13743, GH13854 + df = DataFrame({'A': [1, 2, 1, 1, 2], + 'B': [10, 16, 22, 28, 34], + 'C1': Categorical(list("abaab"), + categories=list("bac"), + ordered=False), + 'C2': Categorical(list("abaab"), + categories=list("bac"), + ordered=True)}) + # single grouper + exp_full = DataFrame({'A': [2.0, 1.0, np.nan], + 'B': [25.0, 20.0, np.nan], + 'C1': Categorical(list("bac"), + categories=list("bac"), + ordered=False), + 'C2': Categorical(list("bac"), + categories=list("bac"), + ordered=True)}) + for col in ['C1', 'C2']: + result1 = df.groupby(by=col, as_index=False).mean() + result2 = df.groupby(by=col, as_index=True).mean().reset_index() + expected = exp_full.reindex(columns=result1.columns) + tm.assert_frame_equal(result1, expected) + tm.assert_frame_equal(result2, expected) + + # multiple grouper + exp_full = DataFrame({'A': [1, 1, 1, 2, 2, 2], + 'B': [np.nan, 20.0, np.nan, 25.0, np.nan, + np.nan], + 'C1': Categorical(list("bacbac"), + categories=list("bac"), + ordered=False), + 'C2': Categorical(list("bacbac"), + categories=list("bac"), + ordered=True)}) + for cols in [['A', 'C1'], ['A', 'C2']]: + result1 = df.groupby(by=cols, as_index=False).mean() + result2 = df.groupby(by=cols, as_index=True).mean().reset_index() + expected = exp_full.reindex(columns=result1.columns) + tm.assert_frame_equal(result1, expected) + tm.assert_frame_equal(result2, expected) + + def test_groupby_categorical_no_compress(self): + data = Series(np.random.randn(9)) + + codes = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2]) + cats = Categorical.from_codes(codes, [0, 1, 2], ordered=True) + + result = data.groupby(cats).mean() + exp = data.groupby(codes).mean() + + exp.index = CategoricalIndex(exp.index, categories=cats.categories, + ordered=cats.ordered) + assert_series_equal(result, exp) + + codes = np.array([0, 0, 0, 1, 1, 1, 3, 3, 3]) + cats = Categorical.from_codes(codes, [0, 1, 2, 3], ordered=True) + + result = data.groupby(cats).mean() + exp = data.groupby(codes).mean().reindex(cats.categories) + exp.index = CategoricalIndex(exp.index, categories=cats.categories, + ordered=cats.ordered) + assert_series_equal(result, exp) + + cats = Categorical(["a", "a", "a", "b", "b", "b", "c", "c", "c"], + categories=["a", "b", "c", "d"], ordered=True) + data = DataFrame({"a": [1, 1, 1, 2, 2, 2, 3, 4, 5], "b": cats}) + + result = data.groupby("b").mean() + result = result["a"].values + exp = np.array([1, 2, 4, np.nan]) + self.assert_numpy_array_equal(result, exp) + + +def assert_fp_equal(a, b): + assert (np.abs(a - b) < 1e-12).all() + + +def _check_groupby(df, result, keys, field, f=lambda x: x.sum()): + tups = lmap(tuple, df[keys].values) + tups = com._asarray_tuplesafe(tups) + expected = f(df.groupby(tups)[field]) + for k, v in compat.iteritems(expected): + assert (result[k] == v) + + +def test_decons(): + from pandas.core.groupby import decons_group_index, get_group_index + + def testit(label_list, shape): + group_index = get_group_index(label_list, shape, sort=True, xnull=True) + label_list2 = decons_group_index(group_index, shape) + + for a, b in zip(label_list, label_list2): + assert (np.array_equal(a, b)) + + shape = (4, 5, 6) + label_list = [np.tile([0, 1, 2, 3, 0, 1, 2, 3], 100), np.tile( + [0, 2, 4, 3, 0, 1, 2, 3], 100), np.tile( + [5, 1, 0, 2, 3, 0, 5, 4], 100)] + testit(label_list, shape) + + shape = (10000, 10000) + label_list = [np.tile(np.arange(10000), 5), np.tile(np.arange(10000), 5)] + testit(label_list, shape) + + +if __name__ == '__main__': + nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure', '-s' + ], exit=False) diff --git a/pandas/tests/groupby/test_filters.py b/pandas/tests/groupby/test_filters.py new file mode 100644 index 0000000000000..81bf977e924d8 --- /dev/null +++ b/pandas/tests/groupby/test_filters.py @@ -0,0 +1,635 @@ +# -*- coding: utf-8 -*- +from __future__ import print_function +import nose + +from numpy import nan + + +from pandas import Timestamp +from pandas.core.index import MultiIndex +from pandas.core.api import DataFrame + +from pandas.core.series import Series + +from pandas.util.testing import (assert_frame_equal, assert_series_equal + ) +from pandas.compat import (lmap) + +from pandas import compat + +import pandas.core.common as com +import numpy as np + +import pandas.util.testing as tm +import pandas as pd + + +class TestGroupByFilter(tm.TestCase): + + _multiprocess_can_split_ = True + + def setUp(self): + self.ts = tm.makeTimeSeries() + + self.seriesd = tm.getSeriesData() + self.tsd = tm.getTimeSeriesData() + self.frame = DataFrame(self.seriesd) + self.tsframe = DataFrame(self.tsd) + + self.df = DataFrame( + {'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'], + 'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'], + 'C': np.random.randn(8), + 'D': np.random.randn(8)}) + + self.df_mixed_floats = DataFrame( + {'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'], + 'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'], + 'C': np.random.randn(8), + 'D': np.array( + np.random.randn(8), dtype='float32')}) + + index = MultiIndex(levels=[['foo', 'bar', 'baz', 'qux'], ['one', 'two', + 'three']], + labels=[[0, 0, 0, 1, 1, 2, 2, 3, 3, 3], + [0, 1, 2, 0, 1, 1, 2, 0, 1, 2]], + names=['first', 'second']) + self.mframe = DataFrame(np.random.randn(10, 3), index=index, + columns=['A', 'B', 'C']) + + self.three_group = DataFrame( + {'A': ['foo', 'foo', 'foo', 'foo', 'bar', 'bar', 'bar', 'bar', + 'foo', 'foo', 'foo'], + 'B': ['one', 'one', 'one', 'two', 'one', 'one', 'one', 'two', + 'two', 'two', 'one'], + 'C': ['dull', 'dull', 'shiny', 'dull', 'dull', 'shiny', 'shiny', + 'dull', 'shiny', 'shiny', 'shiny'], + 'D': np.random.randn(11), + 'E': np.random.randn(11), + 'F': np.random.randn(11)}) + + def test_filter_series(self): + s = pd.Series([1, 3, 20, 5, 22, 24, 7]) + expected_odd = pd.Series([1, 3, 5, 7], index=[0, 1, 3, 6]) + expected_even = pd.Series([20, 22, 24], index=[2, 4, 5]) + grouper = s.apply(lambda x: x % 2) + grouped = s.groupby(grouper) + assert_series_equal( + grouped.filter(lambda x: x.mean() < 10), expected_odd) + assert_series_equal( + grouped.filter(lambda x: x.mean() > 10), expected_even) + # Test dropna=False. + assert_series_equal( + grouped.filter(lambda x: x.mean() < 10, dropna=False), + expected_odd.reindex(s.index)) + assert_series_equal( + grouped.filter(lambda x: x.mean() > 10, dropna=False), + expected_even.reindex(s.index)) + + def test_filter_single_column_df(self): + df = pd.DataFrame([1, 3, 20, 5, 22, 24, 7]) + expected_odd = pd.DataFrame([1, 3, 5, 7], index=[0, 1, 3, 6]) + expected_even = pd.DataFrame([20, 22, 24], index=[2, 4, 5]) + grouper = df[0].apply(lambda x: x % 2) + grouped = df.groupby(grouper) + assert_frame_equal( + grouped.filter(lambda x: x.mean() < 10), expected_odd) + assert_frame_equal( + grouped.filter(lambda x: x.mean() > 10), expected_even) + # Test dropna=False. + assert_frame_equal( + grouped.filter(lambda x: x.mean() < 10, dropna=False), + expected_odd.reindex(df.index)) + assert_frame_equal( + grouped.filter(lambda x: x.mean() > 10, dropna=False), + expected_even.reindex(df.index)) + + def test_filter_multi_column_df(self): + df = pd.DataFrame({'A': [1, 12, 12, 1], 'B': [1, 1, 1, 1]}) + grouper = df['A'].apply(lambda x: x % 2) + grouped = df.groupby(grouper) + expected = pd.DataFrame({'A': [12, 12], 'B': [1, 1]}, index=[1, 2]) + assert_frame_equal( + grouped.filter(lambda x: x['A'].sum() - x['B'].sum() > 10), + expected) + + def test_filter_mixed_df(self): + df = pd.DataFrame({'A': [1, 12, 12, 1], 'B': 'a b c d'.split()}) + grouper = df['A'].apply(lambda x: x % 2) + grouped = df.groupby(grouper) + expected = pd.DataFrame({'A': [12, 12], 'B': ['b', 'c']}, index=[1, 2]) + assert_frame_equal( + grouped.filter(lambda x: x['A'].sum() > 10), expected) + + def test_filter_out_all_groups(self): + s = pd.Series([1, 3, 20, 5, 22, 24, 7]) + grouper = s.apply(lambda x: x % 2) + grouped = s.groupby(grouper) + assert_series_equal(grouped.filter(lambda x: x.mean() > 1000), s[[]]) + df = pd.DataFrame({'A': [1, 12, 12, 1], 'B': 'a b c d'.split()}) + grouper = df['A'].apply(lambda x: x % 2) + grouped = df.groupby(grouper) + assert_frame_equal( + grouped.filter(lambda x: x['A'].sum() > 1000), df.ix[[]]) + + def test_filter_out_no_groups(self): + s = pd.Series([1, 3, 20, 5, 22, 24, 7]) + grouper = s.apply(lambda x: x % 2) + grouped = s.groupby(grouper) + filtered = grouped.filter(lambda x: x.mean() > 0) + assert_series_equal(filtered, s) + df = pd.DataFrame({'A': [1, 12, 12, 1], 'B': 'a b c d'.split()}) + grouper = df['A'].apply(lambda x: x % 2) + grouped = df.groupby(grouper) + filtered = grouped.filter(lambda x: x['A'].mean() > 0) + assert_frame_equal(filtered, df) + + def test_filter_out_all_groups_in_df(self): + # GH12768 + df = pd.DataFrame({'a': [1, 1, 2], 'b': [1, 2, 0]}) + res = df.groupby('a') + res = res.filter(lambda x: x['b'].sum() > 5, dropna=False) + expected = pd.DataFrame({'a': [nan] * 3, 'b': [nan] * 3}) + assert_frame_equal(expected, res) + + df = pd.DataFrame({'a': [1, 1, 2], 'b': [1, 2, 0]}) + res = df.groupby('a') + res = res.filter(lambda x: x['b'].sum() > 5, dropna=True) + expected = pd.DataFrame({'a': [], 'b': []}, dtype="int64") + assert_frame_equal(expected, res) + + def test_filter_condition_raises(self): + def raise_if_sum_is_zero(x): + if x.sum() == 0: + raise ValueError + else: + return x.sum() > 0 + + s = pd.Series([-1, 0, 1, 2]) + grouper = s.apply(lambda x: x % 2) + grouped = s.groupby(grouper) + self.assertRaises(TypeError, + lambda: grouped.filter(raise_if_sum_is_zero)) + + def test_filter_with_axis_in_groupby(self): + # issue 11041 + index = pd.MultiIndex.from_product([range(10), [0, 1]]) + data = pd.DataFrame( + np.arange(100).reshape(-1, 20), columns=index, dtype='int64') + result = data.groupby(level=0, + axis=1).filter(lambda x: x.iloc[0, 0] > 10) + expected = data.iloc[:, 12:20] + assert_frame_equal(result, expected) + + def test_filter_bad_shapes(self): + df = DataFrame({'A': np.arange(8), + 'B': list('aabbbbcc'), + 'C': np.arange(8)}) + s = df['B'] + g_df = df.groupby('B') + g_s = s.groupby(s) + + f = lambda x: x + self.assertRaises(TypeError, lambda: g_df.filter(f)) + self.assertRaises(TypeError, lambda: g_s.filter(f)) + + f = lambda x: x == 1 + self.assertRaises(TypeError, lambda: g_df.filter(f)) + self.assertRaises(TypeError, lambda: g_s.filter(f)) + + f = lambda x: np.outer(x, x) + self.assertRaises(TypeError, lambda: g_df.filter(f)) + self.assertRaises(TypeError, lambda: g_s.filter(f)) + + def test_filter_nan_is_false(self): + df = DataFrame({'A': np.arange(8), + 'B': list('aabbbbcc'), + 'C': np.arange(8)}) + s = df['B'] + g_df = df.groupby(df['B']) + g_s = s.groupby(s) + + f = lambda x: np.nan + assert_frame_equal(g_df.filter(f), df.loc[[]]) + assert_series_equal(g_s.filter(f), s[[]]) + + def test_filter_against_workaround(self): + np.random.seed(0) + # Series of ints + s = Series(np.random.randint(0, 100, 1000)) + grouper = s.apply(lambda x: np.round(x, -1)) + grouped = s.groupby(grouper) + f = lambda x: x.mean() > 10 + old_way = s[grouped.transform(f).astype('bool')] + new_way = grouped.filter(f) + assert_series_equal(new_way.sort_values(), old_way.sort_values()) + + # Series of floats + s = 100 * Series(np.random.random(1000)) + grouper = s.apply(lambda x: np.round(x, -1)) + grouped = s.groupby(grouper) + f = lambda x: x.mean() > 10 + old_way = s[grouped.transform(f).astype('bool')] + new_way = grouped.filter(f) + assert_series_equal(new_way.sort_values(), old_way.sort_values()) + + # Set up DataFrame of ints, floats, strings. + from string import ascii_lowercase + letters = np.array(list(ascii_lowercase)) + N = 1000 + random_letters = letters.take(np.random.randint(0, 26, N)) + df = DataFrame({'ints': Series(np.random.randint(0, 100, N)), + 'floats': N / 10 * Series(np.random.random(N)), + 'letters': Series(random_letters)}) + + # Group by ints; filter on floats. + grouped = df.groupby('ints') + old_way = df[grouped.floats. + transform(lambda x: x.mean() > N / 20).astype('bool')] + new_way = grouped.filter(lambda x: x['floats'].mean() > N / 20) + assert_frame_equal(new_way, old_way) + + # Group by floats (rounded); filter on strings. + grouper = df.floats.apply(lambda x: np.round(x, -1)) + grouped = df.groupby(grouper) + old_way = df[grouped.letters. + transform(lambda x: len(x) < N / 10).astype('bool')] + new_way = grouped.filter(lambda x: len(x.letters) < N / 10) + assert_frame_equal(new_way, old_way) + + # Group by strings; filter on ints. + grouped = df.groupby('letters') + old_way = df[grouped.ints. + transform(lambda x: x.mean() > N / 20).astype('bool')] + new_way = grouped.filter(lambda x: x['ints'].mean() > N / 20) + assert_frame_equal(new_way, old_way) + + def test_filter_using_len(self): + # BUG GH4447 + df = DataFrame({'A': np.arange(8), + 'B': list('aabbbbcc'), + 'C': np.arange(8)}) + grouped = df.groupby('B') + actual = grouped.filter(lambda x: len(x) > 2) + expected = DataFrame( + {'A': np.arange(2, 6), + 'B': list('bbbb'), + 'C': np.arange(2, 6)}, index=np.arange(2, 6)) + assert_frame_equal(actual, expected) + + actual = grouped.filter(lambda x: len(x) > 4) + expected = df.ix[[]] + assert_frame_equal(actual, expected) + + # Series have always worked properly, but we'll test anyway. + s = df['B'] + grouped = s.groupby(s) + actual = grouped.filter(lambda x: len(x) > 2) + expected = Series(4 * ['b'], index=np.arange(2, 6), name='B') + assert_series_equal(actual, expected) + + actual = grouped.filter(lambda x: len(x) > 4) + expected = s[[]] + assert_series_equal(actual, expected) + + def test_filter_maintains_ordering(self): + # Simple case: index is sequential. #4621 + df = DataFrame({'pid': [1, 1, 1, 2, 2, 3, 3, 3], + 'tag': [23, 45, 62, 24, 45, 34, 25, 62]}) + s = df['pid'] + grouped = df.groupby('tag') + actual = grouped.filter(lambda x: len(x) > 1) + expected = df.iloc[[1, 2, 4, 7]] + assert_frame_equal(actual, expected) + + grouped = s.groupby(df['tag']) + actual = grouped.filter(lambda x: len(x) > 1) + expected = s.iloc[[1, 2, 4, 7]] + assert_series_equal(actual, expected) + + # Now index is sequentially decreasing. + df.index = np.arange(len(df) - 1, -1, -1) + s = df['pid'] + grouped = df.groupby('tag') + actual = grouped.filter(lambda x: len(x) > 1) + expected = df.iloc[[1, 2, 4, 7]] + assert_frame_equal(actual, expected) + + grouped = s.groupby(df['tag']) + actual = grouped.filter(lambda x: len(x) > 1) + expected = s.iloc[[1, 2, 4, 7]] + assert_series_equal(actual, expected) + + # Index is shuffled. + SHUFFLED = [4, 6, 7, 2, 1, 0, 5, 3] + df.index = df.index[SHUFFLED] + s = df['pid'] + grouped = df.groupby('tag') + actual = grouped.filter(lambda x: len(x) > 1) + expected = df.iloc[[1, 2, 4, 7]] + assert_frame_equal(actual, expected) + + grouped = s.groupby(df['tag']) + actual = grouped.filter(lambda x: len(x) > 1) + expected = s.iloc[[1, 2, 4, 7]] + assert_series_equal(actual, expected) + + def test_filter_multiple_timestamp(self): + # GH 10114 + df = DataFrame({'A': np.arange(5, dtype='int64'), + 'B': ['foo', 'bar', 'foo', 'bar', 'bar'], + 'C': Timestamp('20130101')}) + + grouped = df.groupby(['B', 'C']) + + result = grouped['A'].filter(lambda x: True) + assert_series_equal(df['A'], result) + + result = grouped['A'].transform(len) + expected = Series([2, 3, 2, 3, 3], name='A') + assert_series_equal(result, expected) + + result = grouped.filter(lambda x: True) + assert_frame_equal(df, result) + + result = grouped.transform('sum') + expected = DataFrame({'A': [2, 8, 2, 8, 8]}) + assert_frame_equal(result, expected) + + result = grouped.transform(len) + expected = DataFrame({'A': [2, 3, 2, 3, 3]}) + assert_frame_equal(result, expected) + + def test_filter_and_transform_with_non_unique_int_index(self): + # GH4620 + index = [1, 1, 1, 2, 1, 1, 0, 1] + df = DataFrame({'pid': [1, 1, 1, 2, 2, 3, 3, 3], + 'tag': [23, 45, 62, 24, 45, 34, 25, 62]}, index=index) + grouped_df = df.groupby('tag') + ser = df['pid'] + grouped_ser = ser.groupby(df['tag']) + expected_indexes = [1, 2, 4, 7] + + # Filter DataFrame + actual = grouped_df.filter(lambda x: len(x) > 1) + expected = df.iloc[expected_indexes] + assert_frame_equal(actual, expected) + + actual = grouped_df.filter(lambda x: len(x) > 1, dropna=False) + expected = df.copy() + expected.iloc[[0, 3, 5, 6]] = np.nan + assert_frame_equal(actual, expected) + + # Filter Series + actual = grouped_ser.filter(lambda x: len(x) > 1) + expected = ser.take(expected_indexes) + assert_series_equal(actual, expected) + + actual = grouped_ser.filter(lambda x: len(x) > 1, dropna=False) + NA = np.nan + expected = Series([NA, 1, 1, NA, 2, NA, NA, 3], index, name='pid') + # ^ made manually because this can get confusing! + assert_series_equal(actual, expected) + + # Transform Series + actual = grouped_ser.transform(len) + expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index, name='pid') + assert_series_equal(actual, expected) + + # Transform (a column from) DataFrameGroupBy + actual = grouped_df.pid.transform(len) + assert_series_equal(actual, expected) + + def test_filter_and_transform_with_multiple_non_unique_int_index(self): + # GH4620 + index = [1, 1, 1, 2, 0, 0, 0, 1] + df = DataFrame({'pid': [1, 1, 1, 2, 2, 3, 3, 3], + 'tag': [23, 45, 62, 24, 45, 34, 25, 62]}, index=index) + grouped_df = df.groupby('tag') + ser = df['pid'] + grouped_ser = ser.groupby(df['tag']) + expected_indexes = [1, 2, 4, 7] + + # Filter DataFrame + actual = grouped_df.filter(lambda x: len(x) > 1) + expected = df.iloc[expected_indexes] + assert_frame_equal(actual, expected) + + actual = grouped_df.filter(lambda x: len(x) > 1, dropna=False) + expected = df.copy() + expected.iloc[[0, 3, 5, 6]] = np.nan + assert_frame_equal(actual, expected) + + # Filter Series + actual = grouped_ser.filter(lambda x: len(x) > 1) + expected = ser.take(expected_indexes) + assert_series_equal(actual, expected) + + actual = grouped_ser.filter(lambda x: len(x) > 1, dropna=False) + NA = np.nan + expected = Series([NA, 1, 1, NA, 2, NA, NA, 3], index, name='pid') + # ^ made manually because this can get confusing! + assert_series_equal(actual, expected) + + # Transform Series + actual = grouped_ser.transform(len) + expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index, name='pid') + assert_series_equal(actual, expected) + + # Transform (a column from) DataFrameGroupBy + actual = grouped_df.pid.transform(len) + assert_series_equal(actual, expected) + + def test_filter_and_transform_with_non_unique_float_index(self): + # GH4620 + index = np.array([1, 1, 1, 2, 1, 1, 0, 1], dtype=float) + df = DataFrame({'pid': [1, 1, 1, 2, 2, 3, 3, 3], + 'tag': [23, 45, 62, 24, 45, 34, 25, 62]}, index=index) + grouped_df = df.groupby('tag') + ser = df['pid'] + grouped_ser = ser.groupby(df['tag']) + expected_indexes = [1, 2, 4, 7] + + # Filter DataFrame + actual = grouped_df.filter(lambda x: len(x) > 1) + expected = df.iloc[expected_indexes] + assert_frame_equal(actual, expected) + + actual = grouped_df.filter(lambda x: len(x) > 1, dropna=False) + expected = df.copy() + expected.iloc[[0, 3, 5, 6]] = np.nan + assert_frame_equal(actual, expected) + + # Filter Series + actual = grouped_ser.filter(lambda x: len(x) > 1) + expected = ser.take(expected_indexes) + assert_series_equal(actual, expected) + + actual = grouped_ser.filter(lambda x: len(x) > 1, dropna=False) + NA = np.nan + expected = Series([NA, 1, 1, NA, 2, NA, NA, 3], index, name='pid') + # ^ made manually because this can get confusing! + assert_series_equal(actual, expected) + + # Transform Series + actual = grouped_ser.transform(len) + expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index, name='pid') + assert_series_equal(actual, expected) + + # Transform (a column from) DataFrameGroupBy + actual = grouped_df.pid.transform(len) + assert_series_equal(actual, expected) + + def test_filter_and_transform_with_non_unique_timestamp_index(self): + # GH4620 + t0 = Timestamp('2013-09-30 00:05:00') + t1 = Timestamp('2013-10-30 00:05:00') + t2 = Timestamp('2013-11-30 00:05:00') + index = [t1, t1, t1, t2, t1, t1, t0, t1] + df = DataFrame({'pid': [1, 1, 1, 2, 2, 3, 3, 3], + 'tag': [23, 45, 62, 24, 45, 34, 25, 62]}, index=index) + grouped_df = df.groupby('tag') + ser = df['pid'] + grouped_ser = ser.groupby(df['tag']) + expected_indexes = [1, 2, 4, 7] + + # Filter DataFrame + actual = grouped_df.filter(lambda x: len(x) > 1) + expected = df.iloc[expected_indexes] + assert_frame_equal(actual, expected) + + actual = grouped_df.filter(lambda x: len(x) > 1, dropna=False) + expected = df.copy() + expected.iloc[[0, 3, 5, 6]] = np.nan + assert_frame_equal(actual, expected) + + # Filter Series + actual = grouped_ser.filter(lambda x: len(x) > 1) + expected = ser.take(expected_indexes) + assert_series_equal(actual, expected) + + actual = grouped_ser.filter(lambda x: len(x) > 1, dropna=False) + NA = np.nan + expected = Series([NA, 1, 1, NA, 2, NA, NA, 3], index, name='pid') + # ^ made manually because this can get confusing! + assert_series_equal(actual, expected) + + # Transform Series + actual = grouped_ser.transform(len) + expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index, name='pid') + assert_series_equal(actual, expected) + + # Transform (a column from) DataFrameGroupBy + actual = grouped_df.pid.transform(len) + assert_series_equal(actual, expected) + + def test_filter_and_transform_with_non_unique_string_index(self): + # GH4620 + index = list('bbbcbbab') + df = DataFrame({'pid': [1, 1, 1, 2, 2, 3, 3, 3], + 'tag': [23, 45, 62, 24, 45, 34, 25, 62]}, index=index) + grouped_df = df.groupby('tag') + ser = df['pid'] + grouped_ser = ser.groupby(df['tag']) + expected_indexes = [1, 2, 4, 7] + + # Filter DataFrame + actual = grouped_df.filter(lambda x: len(x) > 1) + expected = df.iloc[expected_indexes] + assert_frame_equal(actual, expected) + + actual = grouped_df.filter(lambda x: len(x) > 1, dropna=False) + expected = df.copy() + expected.iloc[[0, 3, 5, 6]] = np.nan + assert_frame_equal(actual, expected) + + # Filter Series + actual = grouped_ser.filter(lambda x: len(x) > 1) + expected = ser.take(expected_indexes) + assert_series_equal(actual, expected) + + actual = grouped_ser.filter(lambda x: len(x) > 1, dropna=False) + NA = np.nan + expected = Series([NA, 1, 1, NA, 2, NA, NA, 3], index, name='pid') + # ^ made manually because this can get confusing! + assert_series_equal(actual, expected) + + # Transform Series + actual = grouped_ser.transform(len) + expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index, name='pid') + assert_series_equal(actual, expected) + + # Transform (a column from) DataFrameGroupBy + actual = grouped_df.pid.transform(len) + assert_series_equal(actual, expected) + + def test_filter_has_access_to_grouped_cols(self): + df = DataFrame([[1, 2], [1, 3], [5, 6]], columns=['A', 'B']) + g = df.groupby('A') + # previously didn't have access to col A #???? + filt = g.filter(lambda x: x['A'].sum() == 2) + assert_frame_equal(filt, df.iloc[[0, 1]]) + + def test_filter_enforces_scalarness(self): + df = pd.DataFrame([ + ['best', 'a', 'x'], + ['worst', 'b', 'y'], + ['best', 'c', 'x'], + ['best', 'd', 'y'], + ['worst', 'd', 'y'], + ['worst', 'd', 'y'], + ['best', 'd', 'z'], + ], columns=['a', 'b', 'c']) + with tm.assertRaisesRegexp(TypeError, 'filter function returned a.*'): + df.groupby('c').filter(lambda g: g['a'] == 'best') + + def test_filter_non_bool_raises(self): + df = pd.DataFrame([ + ['best', 'a', 1], + ['worst', 'b', 1], + ['best', 'c', 1], + ['best', 'd', 1], + ['worst', 'd', 1], + ['worst', 'd', 1], + ['best', 'd', 1], + ], columns=['a', 'b', 'c']) + with tm.assertRaisesRegexp(TypeError, 'filter function returned a.*'): + df.groupby('a').filter(lambda g: g.c.mean()) + + +def assert_fp_equal(a, b): + assert (np.abs(a - b) < 1e-12).all() + + +def _check_groupby(df, result, keys, field, f=lambda x: x.sum()): + tups = lmap(tuple, df[keys].values) + tups = com._asarray_tuplesafe(tups) + expected = f(df.groupby(tups)[field]) + for k, v in compat.iteritems(expected): + assert (result[k] == v) + + +def test_decons(): + from pandas.core.groupby import decons_group_index, get_group_index + + def testit(label_list, shape): + group_index = get_group_index(label_list, shape, sort=True, xnull=True) + label_list2 = decons_group_index(group_index, shape) + + for a, b in zip(label_list, label_list2): + assert (np.array_equal(a, b)) + + shape = (4, 5, 6) + label_list = [np.tile([0, 1, 2, 3, 0, 1, 2, 3], 100), np.tile( + [0, 2, 4, 3, 0, 1, 2, 3], 100), np.tile( + [5, 1, 0, 2, 3, 0, 5, 4], 100)] + testit(label_list, shape) + + shape = (10000, 10000) + label_list = [np.tile(np.arange(10000), 5), np.tile(np.arange(10000), 5)] + testit(label_list, shape) + + +if __name__ == '__main__': + nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure', '-s' + ], exit=False) diff --git a/pandas/tests/test_groupby.py b/pandas/tests/groupby/test_groupby.py similarity index 81% rename from pandas/tests/test_groupby.py rename to pandas/tests/groupby/test_groupby.py index 7b98a45395752..97e1f7dc94866 100644 --- a/pandas/tests/test_groupby.py +++ b/pandas/tests/groupby/test_groupby.py @@ -14,7 +14,6 @@ _lexsort_indexer) from pandas.core.series import Series from pandas.core.config import option_context -from pandas.formats.printing import pprint_thing from pandas.util.testing import (assert_panel_equal, assert_frame_equal, assert_series_equal, assert_almost_equal, assert_index_equal, assertRaisesRegexp) @@ -864,110 +863,6 @@ def f(grp): e.name = None assert_series_equal(result, e) - def test_agg_api(self): - - # GH 6337 - # http://stackoverflow.com/questions/21706030/pandas-groupby-agg-function-column-dtype-error - # different api for agg when passed custom function with mixed frame - - df = DataFrame({'data1': np.random.randn(5), - 'data2': np.random.randn(5), - 'key1': ['a', 'a', 'b', 'b', 'a'], - 'key2': ['one', 'two', 'one', 'two', 'one']}) - grouped = df.groupby('key1') - - def peak_to_peak(arr): - return arr.max() - arr.min() - - expected = grouped.agg([peak_to_peak]) - expected.columns = ['data1', 'data2'] - result = grouped.agg(peak_to_peak) - assert_frame_equal(result, expected) - - def test_agg_regression1(self): - grouped = self.tsframe.groupby([lambda x: x.year, lambda x: x.month]) - result = grouped.agg(np.mean) - expected = grouped.mean() - assert_frame_equal(result, expected) - - def test_agg_datetimes_mixed(self): - data = [[1, '2012-01-01', 1.0], [2, '2012-01-02', 2.0], [3, None, 3.0]] - - df1 = DataFrame({'key': [x[0] for x in data], - 'date': [x[1] for x in data], - 'value': [x[2] for x in data]}) - - data = [[row[0], datetime.strptime(row[1], '%Y-%m-%d').date() if row[1] - else None, row[2]] for row in data] - - df2 = DataFrame({'key': [x[0] for x in data], - 'date': [x[1] for x in data], - 'value': [x[2] for x in data]}) - - df1['weights'] = df1['value'] / df1['value'].sum() - gb1 = df1.groupby('date').aggregate(np.sum) - - df2['weights'] = df1['value'] / df1['value'].sum() - gb2 = df2.groupby('date').aggregate(np.sum) - - assert (len(gb1) == len(gb2)) - - def test_agg_period_index(self): - from pandas import period_range, PeriodIndex - prng = period_range('2012-1-1', freq='M', periods=3) - df = DataFrame(np.random.randn(3, 2), index=prng) - rs = df.groupby(level=0).sum() - tm.assertIsInstance(rs.index, PeriodIndex) - - # GH 3579 - index = period_range(start='1999-01', periods=5, freq='M') - s1 = Series(np.random.rand(len(index)), index=index) - s2 = Series(np.random.rand(len(index)), index=index) - series = [('s1', s1), ('s2', s2)] - df = DataFrame.from_items(series) - grouped = df.groupby(df.index.month) - list(grouped) - - def test_agg_dict_parameter_cast_result_dtypes(self): - # GH 12821 - - df = DataFrame( - {'class': ['A', 'A', 'B', 'B', 'C', 'C', 'D', 'D'], - 'time': date_range('1/1/2011', periods=8, freq='H')}) - df.loc[[0, 1, 2, 5], 'time'] = None - - # test for `first` function - exp = df.loc[[0, 3, 4, 6]].set_index('class') - grouped = df.groupby('class') - assert_frame_equal(grouped.first(), exp) - assert_frame_equal(grouped.agg('first'), exp) - assert_frame_equal(grouped.agg({'time': 'first'}), exp) - assert_series_equal(grouped.time.first(), exp['time']) - assert_series_equal(grouped.time.agg('first'), exp['time']) - - # test for `last` function - exp = df.loc[[0, 3, 4, 7]].set_index('class') - grouped = df.groupby('class') - assert_frame_equal(grouped.last(), exp) - assert_frame_equal(grouped.agg('last'), exp) - assert_frame_equal(grouped.agg({'time': 'last'}), exp) - assert_series_equal(grouped.time.last(), exp['time']) - assert_series_equal(grouped.time.agg('last'), exp['time']) - - def test_agg_must_agg(self): - grouped = self.df.groupby('A')['C'] - self.assertRaises(Exception, grouped.agg, lambda x: x.describe()) - self.assertRaises(Exception, grouped.agg, lambda x: x.index[:2]) - - def test_agg_ser_multi_key(self): - # TODO(wesm): unused - ser = self.df.C # noqa - - f = lambda x: x.sum() - results = self.df.C.groupby([self.df.A, self.df.B]).aggregate(f) - expected = self.df.groupby(['A', 'B']).sum()['C'] - assert_series_equal(results, expected) - def test_get_group(self): wp = tm.makePanel() grouped = wp.groupby(lambda x: x.month, axis='major') @@ -1034,58 +929,11 @@ def test_get_group_grouped_by_tuple(self): expected = DataFrame({'ids': [(dt[0], ), (dt[0], )]}, index=[0, 2]) assert_frame_equal(result, expected) - def test_agg_apply_corner(self): - # nothing to group, all NA - grouped = self.ts.groupby(self.ts * np.nan) - self.assertEqual(self.ts.dtype, np.float64) - - # groupby float64 values results in Float64Index - exp = Series([], dtype=np.float64, index=pd.Index( - [], dtype=np.float64)) - assert_series_equal(grouped.sum(), exp) - assert_series_equal(grouped.agg(np.sum), exp) - assert_series_equal(grouped.apply(np.sum), exp, check_index_type=False) - - # DataFrame - grouped = self.tsframe.groupby(self.tsframe['A'] * np.nan) - exp_df = DataFrame(columns=self.tsframe.columns, dtype=float, - index=pd.Index([], dtype=np.float64)) - assert_frame_equal(grouped.sum(), exp_df, check_names=False) - assert_frame_equal(grouped.agg(np.sum), exp_df, check_names=False) - assert_frame_equal(grouped.apply(np.sum), exp_df.iloc[:, :0], - check_names=False) - - def test_agg_grouping_is_list_tuple(self): - from pandas.core.groupby import Grouping - - df = tm.makeTimeDataFrame() - - grouped = df.groupby(lambda x: x.year) - grouper = grouped.grouper.groupings[0].grouper - grouped.grouper.groupings[0] = Grouping(self.ts.index, list(grouper)) - - result = grouped.agg(np.mean) - expected = grouped.mean() - tm.assert_frame_equal(result, expected) - - grouped.grouper.groupings[0] = Grouping(self.ts.index, tuple(grouper)) - - result = grouped.agg(np.mean) - expected = grouped.mean() - tm.assert_frame_equal(result, expected) - def test_grouping_error_on_multidim_input(self): from pandas.core.groupby import Grouping self.assertRaises(ValueError, Grouping, self.df.index, self.df[['A', 'A']]) - def test_agg_python_multiindex(self): - grouped = self.mframe.groupby(['A', 'B']) - - result = grouped.agg(np.mean) - expected = grouped.mean() - tm.assert_frame_equal(result, expected) - def test_apply_describe_bug(self): grouped = self.mframe.groupby(level='first') grouped.describe() # it works! @@ -1185,80 +1033,6 @@ def test_groups(self): self.assertTrue((self.df.ix[v]['A'] == k[0]).all()) self.assertTrue((self.df.ix[v]['B'] == k[1]).all()) - def test_aggregate_str_func(self): - def _check_results(grouped): - # single series - result = grouped['A'].agg('std') - expected = grouped['A'].std() - assert_series_equal(result, expected) - - # group frame by function name - result = grouped.aggregate('var') - expected = grouped.var() - assert_frame_equal(result, expected) - - # group frame by function dict - result = grouped.agg(OrderedDict([['A', 'var'], ['B', 'std'], - ['C', 'mean'], ['D', 'sem']])) - expected = DataFrame(OrderedDict([['A', grouped['A'].var( - )], ['B', grouped['B'].std()], ['C', grouped['C'].mean()], - ['D', grouped['D'].sem()]])) - assert_frame_equal(result, expected) - - by_weekday = self.tsframe.groupby(lambda x: x.weekday()) - _check_results(by_weekday) - - by_mwkday = self.tsframe.groupby([lambda x: x.month, - lambda x: x.weekday()]) - _check_results(by_mwkday) - - def test_aggregate_item_by_item(self): - - df = self.df.copy() - df['E'] = ['a'] * len(self.df) - grouped = self.df.groupby('A') - - # API change in 0.11 - # def aggfun(ser): - # return len(ser + 'a') - # result = grouped.agg(aggfun) - # self.assertEqual(len(result.columns), 1) - - aggfun = lambda ser: ser.size - result = grouped.agg(aggfun) - foo = (self.df.A == 'foo').sum() - bar = (self.df.A == 'bar').sum() - K = len(result.columns) - - # GH5782 - # odd comparisons can result here, so cast to make easy - exp = pd.Series(np.array([foo] * K), index=list('BCD'), - dtype=np.float64, name='foo') - tm.assert_series_equal(result.xs('foo'), exp) - - exp = pd.Series(np.array([bar] * K), index=list('BCD'), - dtype=np.float64, name='bar') - tm.assert_almost_equal(result.xs('bar'), exp) - - def aggfun(ser): - return ser.size - - result = DataFrame().groupby(self.df.A).agg(aggfun) - tm.assertIsInstance(result, DataFrame) - self.assertEqual(len(result), 0) - - def test_agg_item_by_item_raise_typeerror(self): - from numpy.random import randint - - df = DataFrame(randint(10, size=(20, 10))) - - def raiseException(df): - pprint_thing('----------------------------------------') - pprint_thing(df.to_string()) - raise TypeError - - self.assertRaises(TypeError, df.groupby(0).agg, raiseException) - def test_basic_regression(self): # regression T = [1.0 * x for x in lrange(1, 10) * 10][:1095] @@ -1687,34 +1461,6 @@ def test_series_describe_single(self): expected = grouped.describe() assert_series_equal(result, expected) - def test_series_agg_multikey(self): - ts = tm.makeTimeSeries() - grouped = ts.groupby([lambda x: x.year, lambda x: x.month]) - - result = grouped.agg(np.sum) - expected = grouped.sum() - assert_series_equal(result, expected) - - def test_series_agg_multi_pure_python(self): - data = DataFrame( - {'A': ['foo', 'foo', 'foo', 'foo', 'bar', 'bar', 'bar', 'bar', - 'foo', 'foo', 'foo'], - 'B': ['one', 'one', 'one', 'two', 'one', 'one', 'one', 'two', - 'two', 'two', 'one'], - 'C': ['dull', 'dull', 'shiny', 'dull', 'dull', 'shiny', 'shiny', - 'dull', 'shiny', 'shiny', 'shiny'], - 'D': np.random.randn(11), - 'E': np.random.randn(11), - 'F': np.random.randn(11)}) - - def bad(x): - assert (len(x.base) > 0) - return 'foo' - - result = data.groupby(['A', 'B']).agg(bad) - expected = data.groupby(['A', 'B']).agg(lambda x: 'foo') - assert_frame_equal(result, expected) - def test_series_index_name(self): grouped = self.df.ix[:, ['C']].groupby(self.df['A']) result = grouped.agg(lambda x: x.mean()) @@ -1828,138 +1574,6 @@ def test_frame_set_name_single(self): result = grouped['C'].agg({'foo': np.mean, 'bar': np.std}) self.assertEqual(result.index.name, 'A') - def test_aggregate_api_consistency(self): - # GH 9052 - # make sure that the aggregates via dict - # are consistent - - df = DataFrame({'A': ['foo', 'bar', 'foo', 'bar', - 'foo', 'bar', 'foo', 'foo'], - 'B': ['one', 'one', 'two', 'two', - 'two', 'two', 'one', 'two'], - 'C': np.random.randn(8) + 1.0, - 'D': np.arange(8)}) - - grouped = df.groupby(['A', 'B']) - c_mean = grouped['C'].mean() - c_sum = grouped['C'].sum() - d_mean = grouped['D'].mean() - d_sum = grouped['D'].sum() - - result = grouped['D'].agg(['sum', 'mean']) - expected = pd.concat([d_sum, d_mean], - axis=1) - expected.columns = ['sum', 'mean'] - assert_frame_equal(result, expected, check_like=True) - - result = grouped.agg([np.sum, np.mean]) - expected = pd.concat([c_sum, - c_mean, - d_sum, - d_mean], - axis=1) - expected.columns = MultiIndex.from_product([['C', 'D'], - ['sum', 'mean']]) - assert_frame_equal(result, expected, check_like=True) - - result = grouped[['D', 'C']].agg([np.sum, np.mean]) - expected = pd.concat([d_sum, - d_mean, - c_sum, - c_mean], - axis=1) - expected.columns = MultiIndex.from_product([['D', 'C'], - ['sum', 'mean']]) - assert_frame_equal(result, expected, check_like=True) - - result = grouped.agg({'C': 'mean', 'D': 'sum'}) - expected = pd.concat([d_sum, - c_mean], - axis=1) - assert_frame_equal(result, expected, check_like=True) - - result = grouped.agg({'C': ['mean', 'sum'], - 'D': ['mean', 'sum']}) - expected = pd.concat([c_mean, - c_sum, - d_mean, - d_sum], - axis=1) - expected.columns = MultiIndex.from_product([['C', 'D'], - ['mean', 'sum']]) - - result = grouped[['D', 'C']].agg({'r': np.sum, - 'r2': np.mean}) - expected = pd.concat([d_sum, - c_sum, - d_mean, - c_mean], - axis=1) - expected.columns = MultiIndex.from_product([['r', 'r2'], - ['D', 'C']]) - assert_frame_equal(result, expected, check_like=True) - - def test_agg_compat(self): - - # GH 12334 - - df = DataFrame({'A': ['foo', 'bar', 'foo', 'bar', - 'foo', 'bar', 'foo', 'foo'], - 'B': ['one', 'one', 'two', 'two', - 'two', 'two', 'one', 'two'], - 'C': np.random.randn(8) + 1.0, - 'D': np.arange(8)}) - - g = df.groupby(['A', 'B']) - - expected = pd.concat([g['D'].sum(), - g['D'].std()], - axis=1) - expected.columns = MultiIndex.from_tuples([('C', 'sum'), - ('C', 'std')]) - result = g['D'].agg({'C': ['sum', 'std']}) - assert_frame_equal(result, expected, check_like=True) - - expected = pd.concat([g['D'].sum(), - g['D'].std()], - axis=1) - expected.columns = ['C', 'D'] - result = g['D'].agg({'C': 'sum', 'D': 'std'}) - assert_frame_equal(result, expected, check_like=True) - - def test_agg_nested_dicts(self): - - # API change for disallowing these types of nested dicts - df = DataFrame({'A': ['foo', 'bar', 'foo', 'bar', - 'foo', 'bar', 'foo', 'foo'], - 'B': ['one', 'one', 'two', 'two', - 'two', 'two', 'one', 'two'], - 'C': np.random.randn(8) + 1.0, - 'D': np.arange(8)}) - - g = df.groupby(['A', 'B']) - - def f(): - g.aggregate({'r1': {'C': ['mean', 'sum']}, - 'r2': {'D': ['mean', 'sum']}}) - - self.assertRaises(SpecificationError, f) - - result = g.agg({'C': {'ra': ['mean', 'std']}, - 'D': {'rb': ['mean', 'std']}}) - expected = pd.concat([g['C'].mean(), g['C'].std(), g['D'].mean(), - g['D'].std()], axis=1) - expected.columns = pd.MultiIndex.from_tuples([('ra', 'mean'), ( - 'ra', 'std'), ('rb', 'mean'), ('rb', 'std')]) - assert_frame_equal(result, expected, check_like=True) - - # same name as the original column - # GH9052 - expected = g['D'].agg({'result1': np.sum, 'result2': np.mean}) - expected = expected.rename(columns={'result1': 'D'}) - result = g['D'].agg({'D': np.sum, 'result2': np.mean}) - assert_frame_equal(result, expected, check_like=True) - def test_multi_iter(self): s = Series(np.arange(6)) k1 = np.array(['a', 'a', 'a', 'b', 'b', 'b']) @@ -3351,51 +2965,6 @@ def filt2(x): result = data.groupby('id_field').apply(filt2) assert_frame_equal(result, expected) - def test_apply_use_categorical_name(self): - from pandas import qcut - cats = qcut(self.df.C, 4) - - def get_stats(group): - return {'min': group.min(), - 'max': group.max(), - 'count': group.count(), - 'mean': group.mean()} - - result = self.df.groupby(cats).D.apply(get_stats) - self.assertEqual(result.index.names[0], 'C') - - def test_apply_categorical_data(self): - # GH 10138 - for ordered in [True, False]: - dense = Categorical(list('abc'), ordered=ordered) - # 'b' is in the categories but not in the list - missing = Categorical( - list('aaa'), categories=['a', 'b'], ordered=ordered) - values = np.arange(len(dense)) - df = DataFrame({'missing': missing, - 'dense': dense, - 'values': values}) - grouped = df.groupby(['missing', 'dense']) - - # missing category 'b' should still exist in the output index - idx = MultiIndex.from_product( - [Categorical(['a', 'b'], ordered=ordered), - Categorical(['a', 'b', 'c'], ordered=ordered)], - names=['missing', 'dense']) - expected = DataFrame([0, 1, 2, np.nan, np.nan, np.nan], - index=idx, - columns=['values']) - - assert_frame_equal(grouped.apply(lambda x: np.mean(x)), expected) - assert_frame_equal(grouped.mean(), expected) - assert_frame_equal(grouped.agg(np.mean), expected) - - # but for transform we should still get back the original index - idx = MultiIndex.from_product([['a'], ['a', 'b', 'c']], - names=['missing', 'dense']) - expected = Series(1, index=idx) - assert_series_equal(grouped.apply(lambda x: 1), expected) - def test_apply_corner_cases(self): # #535, can't use sliding iterator @@ -4342,142 +3911,6 @@ def test_groupby_sort_multiindex_series(self): result = mseries.groupby(level=['a', 'b'], sort=True).first() assert_series_equal(result, mseries_result.sort_index()) - def test_groupby_categorical(self): - levels = ['foo', 'bar', 'baz', 'qux'] - codes = np.random.randint(0, 4, size=100) - - cats = Categorical.from_codes(codes, levels, ordered=True) - - data = DataFrame(np.random.randn(100, 4)) - - result = data.groupby(cats).mean() - - expected = data.groupby(np.asarray(cats)).mean() - exp_idx = CategoricalIndex(levels, categories=cats.categories, - ordered=True) - expected = expected.reindex(exp_idx) - - assert_frame_equal(result, expected) - - grouped = data.groupby(cats) - desc_result = grouped.describe() - - idx = cats.codes.argsort() - ord_labels = np.asarray(cats).take(idx) - ord_data = data.take(idx) - - exp_cats = Categorical(ord_labels, ordered=True, - categories=['foo', 'bar', 'baz', 'qux']) - expected = ord_data.groupby(exp_cats, sort=False).describe() - expected.index.names = [None, None] - assert_frame_equal(desc_result, expected) - - # GH 10460 - expc = Categorical.from_codes(np.arange(4).repeat(8), - levels, ordered=True) - exp = CategoricalIndex(expc) - self.assert_index_equal(desc_result.index.get_level_values(0), exp) - exp = Index(['count', 'mean', 'std', 'min', '25%', '50%', - '75%', 'max'] * 4) - self.assert_index_equal(desc_result.index.get_level_values(1), exp) - - def test_groupby_datetime_categorical(self): - # GH9049: ensure backward compatibility - levels = pd.date_range('2014-01-01', periods=4) - codes = np.random.randint(0, 4, size=100) - - cats = Categorical.from_codes(codes, levels, ordered=True) - - data = DataFrame(np.random.randn(100, 4)) - result = data.groupby(cats).mean() - - expected = data.groupby(np.asarray(cats)).mean() - expected = expected.reindex(levels) - expected.index = CategoricalIndex(expected.index, - categories=expected.index, - ordered=True) - - assert_frame_equal(result, expected) - - grouped = data.groupby(cats) - desc_result = grouped.describe() - - idx = cats.codes.argsort() - ord_labels = cats.take_nd(idx) - ord_data = data.take(idx) - expected = ord_data.groupby(ord_labels).describe() - expected.index.names = [None, None] - assert_frame_equal(desc_result, expected) - tm.assert_index_equal(desc_result.index, expected.index) - tm.assert_index_equal( - desc_result.index.get_level_values(0), - expected.index.get_level_values(0)) - - # GH 10460 - expc = Categorical.from_codes( - np.arange(4).repeat(8), levels, ordered=True) - exp = CategoricalIndex(expc) - self.assert_index_equal(desc_result.index.get_level_values(0), exp) - exp = Index(['count', 'mean', 'std', 'min', '25%', '50%', - '75%', 'max'] * 4) - self.assert_index_equal(desc_result.index.get_level_values(1), exp) - - def test_groupby_categorical_index(self): - - levels = ['foo', 'bar', 'baz', 'qux'] - codes = np.random.randint(0, 4, size=20) - cats = Categorical.from_codes(codes, levels, ordered=True) - df = DataFrame( - np.repeat( - np.arange(20), 4).reshape(-1, 4), columns=list('abcd')) - df['cats'] = cats - - # with a cat index - result = df.set_index('cats').groupby(level=0).sum() - expected = df[list('abcd')].groupby(cats.codes).sum() - expected.index = CategoricalIndex( - Categorical.from_codes( - [0, 1, 2, 3], levels, ordered=True), name='cats') - assert_frame_equal(result, expected) - - # with a cat column, should produce a cat index - result = df.groupby('cats').sum() - expected = df[list('abcd')].groupby(cats.codes).sum() - expected.index = CategoricalIndex( - Categorical.from_codes( - [0, 1, 2, 3], levels, ordered=True), name='cats') - assert_frame_equal(result, expected) - - def test_groupby_describe_categorical_columns(self): - # GH 11558 - cats = pd.CategoricalIndex(['qux', 'foo', 'baz', 'bar'], - categories=['foo', 'bar', 'baz', 'qux'], - ordered=True) - df = DataFrame(np.random.randn(20, 4), columns=cats) - result = df.groupby([1, 2, 3, 4] * 5).describe() - - tm.assert_index_equal(result.columns, cats) - tm.assert_categorical_equal(result.columns.values, cats.values) - - def test_groupby_unstack_categorical(self): - # GH11558 (example is taken from the original issue) - df = pd.DataFrame({'a': range(10), - 'medium': ['A', 'B'] * 5, - 'artist': list('XYXXY') * 2}) - df['medium'] = df['medium'].astype('category') - - gcat = df.groupby(['artist', 'medium'])['a'].count().unstack() - result = gcat.describe() - - exp_columns = pd.CategoricalIndex(['A', 'B'], ordered=False, - name='medium') - tm.assert_index_equal(result.columns, exp_columns) - tm.assert_categorical_equal(result.columns.values, exp_columns.values) - - result = gcat['A'] + gcat['B'] - expected = pd.Series([6, 4], index=pd.Index(['X', 'Y'], name='artist')) - tm.assert_series_equal(result, expected) - def test_groupby_groups_datetimeindex(self): # #1430 from pandas.tseries.api import DatetimeIndex @@ -4695,37 +4128,6 @@ def test_median_empty_bins(self): expected = df.groupby(bins).agg(lambda x: x.median()) assert_frame_equal(result, expected) - def test_groupby_categorical_no_compress(self): - data = Series(np.random.randn(9)) - - codes = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2]) - cats = Categorical.from_codes(codes, [0, 1, 2], ordered=True) - - result = data.groupby(cats).mean() - exp = data.groupby(codes).mean() - - exp.index = CategoricalIndex(exp.index, categories=cats.categories, - ordered=cats.ordered) - assert_series_equal(result, exp) - - codes = np.array([0, 0, 0, 1, 1, 1, 3, 3, 3]) - cats = Categorical.from_codes(codes, [0, 1, 2, 3], ordered=True) - - result = data.groupby(cats).mean() - exp = data.groupby(codes).mean().reindex(cats.categories) - exp.index = CategoricalIndex(exp.index, categories=cats.categories, - ordered=cats.ordered) - assert_series_equal(result, exp) - - cats = Categorical(["a", "a", "a", "b", "b", "b", "c", "c", "c"], - categories=["a", "b", "c", "d"], ordered=True) - data = DataFrame({"a": [1, 1, 1, 2, 2, 2, 3, 4, 5], "b": cats}) - - result = data.groupby("b").mean() - result = result["a"].values - exp = np.array([1, 2, 4, np.nan]) - self.assert_numpy_array_equal(result, exp) - def test_groupby_non_arithmetic_agg_types(self): # GH9311, GH6620 df = pd.DataFrame([{'a': 1, @@ -4837,16 +4239,6 @@ def test_groupby_datetime64_32_bit(self): expected = Series([pd.Timestamp('2000-01-1')] * 2, name='B') assert_series_equal(result, expected) - def test_groupby_categorical_unequal_len(self): - # GH3011 - series = Series([np.nan, np.nan, 1, 1, 2, 2, 3, 3, 4, 4]) - # The raises only happens with categorical, not with series of types - # category - bins = pd.cut(series.dropna().values, 4) - - # len(bins) != len(series) here - self.assertRaises(ValueError, lambda: series.groupby(bins).mean()) - def test_groupby_multiindex_missing_pair(self): # GH9049 df = DataFrame({'group1': ['a', 'a', 'a', 'b'], @@ -5444,534 +4836,6 @@ def test_cumcount_groupby_not_col(self): assert_series_equal(expected, g.cumcount()) assert_series_equal(expected, sg.cumcount()) - def test_filter_series(self): - s = pd.Series([1, 3, 20, 5, 22, 24, 7]) - expected_odd = pd.Series([1, 3, 5, 7], index=[0, 1, 3, 6]) - expected_even = pd.Series([20, 22, 24], index=[2, 4, 5]) - grouper = s.apply(lambda x: x % 2) - grouped = s.groupby(grouper) - assert_series_equal( - grouped.filter(lambda x: x.mean() < 10), expected_odd) - assert_series_equal( - grouped.filter(lambda x: x.mean() > 10), expected_even) - # Test dropna=False. - assert_series_equal( - grouped.filter(lambda x: x.mean() < 10, dropna=False), - expected_odd.reindex(s.index)) - assert_series_equal( - grouped.filter(lambda x: x.mean() > 10, dropna=False), - expected_even.reindex(s.index)) - - def test_filter_single_column_df(self): - df = pd.DataFrame([1, 3, 20, 5, 22, 24, 7]) - expected_odd = pd.DataFrame([1, 3, 5, 7], index=[0, 1, 3, 6]) - expected_even = pd.DataFrame([20, 22, 24], index=[2, 4, 5]) - grouper = df[0].apply(lambda x: x % 2) - grouped = df.groupby(grouper) - assert_frame_equal( - grouped.filter(lambda x: x.mean() < 10), expected_odd) - assert_frame_equal( - grouped.filter(lambda x: x.mean() > 10), expected_even) - # Test dropna=False. - assert_frame_equal( - grouped.filter(lambda x: x.mean() < 10, dropna=False), - expected_odd.reindex(df.index)) - assert_frame_equal( - grouped.filter(lambda x: x.mean() > 10, dropna=False), - expected_even.reindex(df.index)) - - def test_filter_multi_column_df(self): - df = pd.DataFrame({'A': [1, 12, 12, 1], 'B': [1, 1, 1, 1]}) - grouper = df['A'].apply(lambda x: x % 2) - grouped = df.groupby(grouper) - expected = pd.DataFrame({'A': [12, 12], 'B': [1, 1]}, index=[1, 2]) - assert_frame_equal( - grouped.filter(lambda x: x['A'].sum() - x['B'].sum() > 10), - expected) - - def test_filter_mixed_df(self): - df = pd.DataFrame({'A': [1, 12, 12, 1], 'B': 'a b c d'.split()}) - grouper = df['A'].apply(lambda x: x % 2) - grouped = df.groupby(grouper) - expected = pd.DataFrame({'A': [12, 12], 'B': ['b', 'c']}, index=[1, 2]) - assert_frame_equal( - grouped.filter(lambda x: x['A'].sum() > 10), expected) - - def test_filter_out_all_groups(self): - s = pd.Series([1, 3, 20, 5, 22, 24, 7]) - grouper = s.apply(lambda x: x % 2) - grouped = s.groupby(grouper) - assert_series_equal(grouped.filter(lambda x: x.mean() > 1000), s[[]]) - df = pd.DataFrame({'A': [1, 12, 12, 1], 'B': 'a b c d'.split()}) - grouper = df['A'].apply(lambda x: x % 2) - grouped = df.groupby(grouper) - assert_frame_equal( - grouped.filter(lambda x: x['A'].sum() > 1000), df.ix[[]]) - - def test_filter_out_no_groups(self): - s = pd.Series([1, 3, 20, 5, 22, 24, 7]) - grouper = s.apply(lambda x: x % 2) - grouped = s.groupby(grouper) - filtered = grouped.filter(lambda x: x.mean() > 0) - assert_series_equal(filtered, s) - df = pd.DataFrame({'A': [1, 12, 12, 1], 'B': 'a b c d'.split()}) - grouper = df['A'].apply(lambda x: x % 2) - grouped = df.groupby(grouper) - filtered = grouped.filter(lambda x: x['A'].mean() > 0) - assert_frame_equal(filtered, df) - - def test_filter_out_all_groups_in_df(self): - # GH12768 - df = pd.DataFrame({'a': [1, 1, 2], 'b': [1, 2, 0]}) - res = df.groupby('a') - res = res.filter(lambda x: x['b'].sum() > 5, dropna=False) - expected = pd.DataFrame({'a': [nan] * 3, 'b': [nan] * 3}) - assert_frame_equal(expected, res) - - df = pd.DataFrame({'a': [1, 1, 2], 'b': [1, 2, 0]}) - res = df.groupby('a') - res = res.filter(lambda x: x['b'].sum() > 5, dropna=True) - expected = pd.DataFrame({'a': [], 'b': []}, dtype="int64") - assert_frame_equal(expected, res) - - def test_filter_condition_raises(self): - def raise_if_sum_is_zero(x): - if x.sum() == 0: - raise ValueError - else: - return x.sum() > 0 - - s = pd.Series([-1, 0, 1, 2]) - grouper = s.apply(lambda x: x % 2) - grouped = s.groupby(grouper) - self.assertRaises(TypeError, - lambda: grouped.filter(raise_if_sum_is_zero)) - - def test_filter_with_axis_in_groupby(self): - # issue 11041 - index = pd.MultiIndex.from_product([range(10), [0, 1]]) - data = pd.DataFrame( - np.arange(100).reshape(-1, 20), columns=index, dtype='int64') - result = data.groupby(level=0, - axis=1).filter(lambda x: x.iloc[0, 0] > 10) - expected = data.iloc[:, 12:20] - assert_frame_equal(result, expected) - - def test_filter_bad_shapes(self): - df = DataFrame({'A': np.arange(8), - 'B': list('aabbbbcc'), - 'C': np.arange(8)}) - s = df['B'] - g_df = df.groupby('B') - g_s = s.groupby(s) - - f = lambda x: x - self.assertRaises(TypeError, lambda: g_df.filter(f)) - self.assertRaises(TypeError, lambda: g_s.filter(f)) - - f = lambda x: x == 1 - self.assertRaises(TypeError, lambda: g_df.filter(f)) - self.assertRaises(TypeError, lambda: g_s.filter(f)) - - f = lambda x: np.outer(x, x) - self.assertRaises(TypeError, lambda: g_df.filter(f)) - self.assertRaises(TypeError, lambda: g_s.filter(f)) - - def test_filter_nan_is_false(self): - df = DataFrame({'A': np.arange(8), - 'B': list('aabbbbcc'), - 'C': np.arange(8)}) - s = df['B'] - g_df = df.groupby(df['B']) - g_s = s.groupby(s) - - f = lambda x: np.nan - assert_frame_equal(g_df.filter(f), df.loc[[]]) - assert_series_equal(g_s.filter(f), s[[]]) - - def test_filter_against_workaround(self): - np.random.seed(0) - # Series of ints - s = Series(np.random.randint(0, 100, 1000)) - grouper = s.apply(lambda x: np.round(x, -1)) - grouped = s.groupby(grouper) - f = lambda x: x.mean() > 10 - old_way = s[grouped.transform(f).astype('bool')] - new_way = grouped.filter(f) - assert_series_equal(new_way.sort_values(), old_way.sort_values()) - - # Series of floats - s = 100 * Series(np.random.random(1000)) - grouper = s.apply(lambda x: np.round(x, -1)) - grouped = s.groupby(grouper) - f = lambda x: x.mean() > 10 - old_way = s[grouped.transform(f).astype('bool')] - new_way = grouped.filter(f) - assert_series_equal(new_way.sort_values(), old_way.sort_values()) - - # Set up DataFrame of ints, floats, strings. - from string import ascii_lowercase - letters = np.array(list(ascii_lowercase)) - N = 1000 - random_letters = letters.take(np.random.randint(0, 26, N)) - df = DataFrame({'ints': Series(np.random.randint(0, 100, N)), - 'floats': N / 10 * Series(np.random.random(N)), - 'letters': Series(random_letters)}) - - # Group by ints; filter on floats. - grouped = df.groupby('ints') - old_way = df[grouped.floats. - transform(lambda x: x.mean() > N / 20).astype('bool')] - new_way = grouped.filter(lambda x: x['floats'].mean() > N / 20) - assert_frame_equal(new_way, old_way) - - # Group by floats (rounded); filter on strings. - grouper = df.floats.apply(lambda x: np.round(x, -1)) - grouped = df.groupby(grouper) - old_way = df[grouped.letters. - transform(lambda x: len(x) < N / 10).astype('bool')] - new_way = grouped.filter(lambda x: len(x.letters) < N / 10) - assert_frame_equal(new_way, old_way) - - # Group by strings; filter on ints. - grouped = df.groupby('letters') - old_way = df[grouped.ints. - transform(lambda x: x.mean() > N / 20).astype('bool')] - new_way = grouped.filter(lambda x: x['ints'].mean() > N / 20) - assert_frame_equal(new_way, old_way) - - def test_filter_using_len(self): - # BUG GH4447 - df = DataFrame({'A': np.arange(8), - 'B': list('aabbbbcc'), - 'C': np.arange(8)}) - grouped = df.groupby('B') - actual = grouped.filter(lambda x: len(x) > 2) - expected = DataFrame( - {'A': np.arange(2, 6), - 'B': list('bbbb'), - 'C': np.arange(2, 6)}, index=np.arange(2, 6)) - assert_frame_equal(actual, expected) - - actual = grouped.filter(lambda x: len(x) > 4) - expected = df.ix[[]] - assert_frame_equal(actual, expected) - - # Series have always worked properly, but we'll test anyway. - s = df['B'] - grouped = s.groupby(s) - actual = grouped.filter(lambda x: len(x) > 2) - expected = Series(4 * ['b'], index=np.arange(2, 6), name='B') - assert_series_equal(actual, expected) - - actual = grouped.filter(lambda x: len(x) > 4) - expected = s[[]] - assert_series_equal(actual, expected) - - def test_filter_maintains_ordering(self): - # Simple case: index is sequential. #4621 - df = DataFrame({'pid': [1, 1, 1, 2, 2, 3, 3, 3], - 'tag': [23, 45, 62, 24, 45, 34, 25, 62]}) - s = df['pid'] - grouped = df.groupby('tag') - actual = grouped.filter(lambda x: len(x) > 1) - expected = df.iloc[[1, 2, 4, 7]] - assert_frame_equal(actual, expected) - - grouped = s.groupby(df['tag']) - actual = grouped.filter(lambda x: len(x) > 1) - expected = s.iloc[[1, 2, 4, 7]] - assert_series_equal(actual, expected) - - # Now index is sequentially decreasing. - df.index = np.arange(len(df) - 1, -1, -1) - s = df['pid'] - grouped = df.groupby('tag') - actual = grouped.filter(lambda x: len(x) > 1) - expected = df.iloc[[1, 2, 4, 7]] - assert_frame_equal(actual, expected) - - grouped = s.groupby(df['tag']) - actual = grouped.filter(lambda x: len(x) > 1) - expected = s.iloc[[1, 2, 4, 7]] - assert_series_equal(actual, expected) - - # Index is shuffled. - SHUFFLED = [4, 6, 7, 2, 1, 0, 5, 3] - df.index = df.index[SHUFFLED] - s = df['pid'] - grouped = df.groupby('tag') - actual = grouped.filter(lambda x: len(x) > 1) - expected = df.iloc[[1, 2, 4, 7]] - assert_frame_equal(actual, expected) - - grouped = s.groupby(df['tag']) - actual = grouped.filter(lambda x: len(x) > 1) - expected = s.iloc[[1, 2, 4, 7]] - assert_series_equal(actual, expected) - - def test_filter_multiple_timestamp(self): - # GH 10114 - df = DataFrame({'A': np.arange(5, dtype='int64'), - 'B': ['foo', 'bar', 'foo', 'bar', 'bar'], - 'C': Timestamp('20130101')}) - - grouped = df.groupby(['B', 'C']) - - result = grouped['A'].filter(lambda x: True) - assert_series_equal(df['A'], result) - - result = grouped['A'].transform(len) - expected = Series([2, 3, 2, 3, 3], name='A') - assert_series_equal(result, expected) - - result = grouped.filter(lambda x: True) - assert_frame_equal(df, result) - - result = grouped.transform('sum') - expected = DataFrame({'A': [2, 8, 2, 8, 8]}) - assert_frame_equal(result, expected) - - result = grouped.transform(len) - expected = DataFrame({'A': [2, 3, 2, 3, 3]}) - assert_frame_equal(result, expected) - - def test_filter_and_transform_with_non_unique_int_index(self): - # GH4620 - index = [1, 1, 1, 2, 1, 1, 0, 1] - df = DataFrame({'pid': [1, 1, 1, 2, 2, 3, 3, 3], - 'tag': [23, 45, 62, 24, 45, 34, 25, 62]}, index=index) - grouped_df = df.groupby('tag') - ser = df['pid'] - grouped_ser = ser.groupby(df['tag']) - expected_indexes = [1, 2, 4, 7] - - # Filter DataFrame - actual = grouped_df.filter(lambda x: len(x) > 1) - expected = df.iloc[expected_indexes] - assert_frame_equal(actual, expected) - - actual = grouped_df.filter(lambda x: len(x) > 1, dropna=False) - expected = df.copy() - expected.iloc[[0, 3, 5, 6]] = np.nan - assert_frame_equal(actual, expected) - - # Filter Series - actual = grouped_ser.filter(lambda x: len(x) > 1) - expected = ser.take(expected_indexes) - assert_series_equal(actual, expected) - - actual = grouped_ser.filter(lambda x: len(x) > 1, dropna=False) - NA = np.nan - expected = Series([NA, 1, 1, NA, 2, NA, NA, 3], index, name='pid') - # ^ made manually because this can get confusing! - assert_series_equal(actual, expected) - - # Transform Series - actual = grouped_ser.transform(len) - expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index, name='pid') - assert_series_equal(actual, expected) - - # Transform (a column from) DataFrameGroupBy - actual = grouped_df.pid.transform(len) - assert_series_equal(actual, expected) - - def test_filter_and_transform_with_multiple_non_unique_int_index(self): - # GH4620 - index = [1, 1, 1, 2, 0, 0, 0, 1] - df = DataFrame({'pid': [1, 1, 1, 2, 2, 3, 3, 3], - 'tag': [23, 45, 62, 24, 45, 34, 25, 62]}, index=index) - grouped_df = df.groupby('tag') - ser = df['pid'] - grouped_ser = ser.groupby(df['tag']) - expected_indexes = [1, 2, 4, 7] - - # Filter DataFrame - actual = grouped_df.filter(lambda x: len(x) > 1) - expected = df.iloc[expected_indexes] - assert_frame_equal(actual, expected) - - actual = grouped_df.filter(lambda x: len(x) > 1, dropna=False) - expected = df.copy() - expected.iloc[[0, 3, 5, 6]] = np.nan - assert_frame_equal(actual, expected) - - # Filter Series - actual = grouped_ser.filter(lambda x: len(x) > 1) - expected = ser.take(expected_indexes) - assert_series_equal(actual, expected) - - actual = grouped_ser.filter(lambda x: len(x) > 1, dropna=False) - NA = np.nan - expected = Series([NA, 1, 1, NA, 2, NA, NA, 3], index, name='pid') - # ^ made manually because this can get confusing! - assert_series_equal(actual, expected) - - # Transform Series - actual = grouped_ser.transform(len) - expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index, name='pid') - assert_series_equal(actual, expected) - - # Transform (a column from) DataFrameGroupBy - actual = grouped_df.pid.transform(len) - assert_series_equal(actual, expected) - - def test_filter_and_transform_with_non_unique_float_index(self): - # GH4620 - index = np.array([1, 1, 1, 2, 1, 1, 0, 1], dtype=float) - df = DataFrame({'pid': [1, 1, 1, 2, 2, 3, 3, 3], - 'tag': [23, 45, 62, 24, 45, 34, 25, 62]}, index=index) - grouped_df = df.groupby('tag') - ser = df['pid'] - grouped_ser = ser.groupby(df['tag']) - expected_indexes = [1, 2, 4, 7] - - # Filter DataFrame - actual = grouped_df.filter(lambda x: len(x) > 1) - expected = df.iloc[expected_indexes] - assert_frame_equal(actual, expected) - - actual = grouped_df.filter(lambda x: len(x) > 1, dropna=False) - expected = df.copy() - expected.iloc[[0, 3, 5, 6]] = np.nan - assert_frame_equal(actual, expected) - - # Filter Series - actual = grouped_ser.filter(lambda x: len(x) > 1) - expected = ser.take(expected_indexes) - assert_series_equal(actual, expected) - - actual = grouped_ser.filter(lambda x: len(x) > 1, dropna=False) - NA = np.nan - expected = Series([NA, 1, 1, NA, 2, NA, NA, 3], index, name='pid') - # ^ made manually because this can get confusing! - assert_series_equal(actual, expected) - - # Transform Series - actual = grouped_ser.transform(len) - expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index, name='pid') - assert_series_equal(actual, expected) - - # Transform (a column from) DataFrameGroupBy - actual = grouped_df.pid.transform(len) - assert_series_equal(actual, expected) - - def test_filter_and_transform_with_non_unique_timestamp_index(self): - # GH4620 - t0 = Timestamp('2013-09-30 00:05:00') - t1 = Timestamp('2013-10-30 00:05:00') - t2 = Timestamp('2013-11-30 00:05:00') - index = [t1, t1, t1, t2, t1, t1, t0, t1] - df = DataFrame({'pid': [1, 1, 1, 2, 2, 3, 3, 3], - 'tag': [23, 45, 62, 24, 45, 34, 25, 62]}, index=index) - grouped_df = df.groupby('tag') - ser = df['pid'] - grouped_ser = ser.groupby(df['tag']) - expected_indexes = [1, 2, 4, 7] - - # Filter DataFrame - actual = grouped_df.filter(lambda x: len(x) > 1) - expected = df.iloc[expected_indexes] - assert_frame_equal(actual, expected) - - actual = grouped_df.filter(lambda x: len(x) > 1, dropna=False) - expected = df.copy() - expected.iloc[[0, 3, 5, 6]] = np.nan - assert_frame_equal(actual, expected) - - # Filter Series - actual = grouped_ser.filter(lambda x: len(x) > 1) - expected = ser.take(expected_indexes) - assert_series_equal(actual, expected) - - actual = grouped_ser.filter(lambda x: len(x) > 1, dropna=False) - NA = np.nan - expected = Series([NA, 1, 1, NA, 2, NA, NA, 3], index, name='pid') - # ^ made manually because this can get confusing! - assert_series_equal(actual, expected) - - # Transform Series - actual = grouped_ser.transform(len) - expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index, name='pid') - assert_series_equal(actual, expected) - - # Transform (a column from) DataFrameGroupBy - actual = grouped_df.pid.transform(len) - assert_series_equal(actual, expected) - - def test_filter_and_transform_with_non_unique_string_index(self): - # GH4620 - index = list('bbbcbbab') - df = DataFrame({'pid': [1, 1, 1, 2, 2, 3, 3, 3], - 'tag': [23, 45, 62, 24, 45, 34, 25, 62]}, index=index) - grouped_df = df.groupby('tag') - ser = df['pid'] - grouped_ser = ser.groupby(df['tag']) - expected_indexes = [1, 2, 4, 7] - - # Filter DataFrame - actual = grouped_df.filter(lambda x: len(x) > 1) - expected = df.iloc[expected_indexes] - assert_frame_equal(actual, expected) - - actual = grouped_df.filter(lambda x: len(x) > 1, dropna=False) - expected = df.copy() - expected.iloc[[0, 3, 5, 6]] = np.nan - assert_frame_equal(actual, expected) - - # Filter Series - actual = grouped_ser.filter(lambda x: len(x) > 1) - expected = ser.take(expected_indexes) - assert_series_equal(actual, expected) - - actual = grouped_ser.filter(lambda x: len(x) > 1, dropna=False) - NA = np.nan - expected = Series([NA, 1, 1, NA, 2, NA, NA, 3], index, name='pid') - # ^ made manually because this can get confusing! - assert_series_equal(actual, expected) - - # Transform Series - actual = grouped_ser.transform(len) - expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index, name='pid') - assert_series_equal(actual, expected) - - # Transform (a column from) DataFrameGroupBy - actual = grouped_df.pid.transform(len) - assert_series_equal(actual, expected) - - def test_filter_has_access_to_grouped_cols(self): - df = DataFrame([[1, 2], [1, 3], [5, 6]], columns=['A', 'B']) - g = df.groupby('A') - # previously didn't have access to col A #???? - filt = g.filter(lambda x: x['A'].sum() == 2) - assert_frame_equal(filt, df.iloc[[0, 1]]) - - def test_filter_enforces_scalarness(self): - df = pd.DataFrame([ - ['best', 'a', 'x'], - ['worst', 'b', 'y'], - ['best', 'c', 'x'], - ['best', 'd', 'y'], - ['worst', 'd', 'y'], - ['worst', 'd', 'y'], - ['best', 'd', 'z'], - ], columns=['a', 'b', 'c']) - with tm.assertRaisesRegexp(TypeError, 'filter function returned a.*'): - df.groupby('c').filter(lambda g: g['a'] == 'best') - - def test_filter_non_bool_raises(self): - df = pd.DataFrame([ - ['best', 'a', 1], - ['worst', 'b', 1], - ['best', 'c', 1], - ['best', 'd', 1], - ['worst', 'd', 1], - ['worst', 'd', 1], - ['best', 'd', 1], - ], columns=['a', 'b', 'c']) - with tm.assertRaisesRegexp(TypeError, 'filter function returned a.*'): - df.groupby('a').filter(lambda g: g.c.mean()) - def test_fill_constistency(self): # GH9221 @@ -6687,145 +5551,6 @@ def test_transform_doesnt_clobber_ints(self): expected = gb2.transform('mean') tm.assert_frame_equal(result, expected) - def test_groupby_categorical_two_columns(self): - - # https://github.com/pandas-dev/pandas/issues/8138 - d = {'cat': - pd.Categorical(["a", "b", "a", "b"], categories=["a", "b", "c"], - ordered=True), - 'ints': [1, 1, 2, 2], - 'val': [10, 20, 30, 40]} - test = pd.DataFrame(d) - - # Grouping on a single column - groups_single_key = test.groupby("cat") - res = groups_single_key.agg('mean') - - exp_index = pd.CategoricalIndex(["a", "b", "c"], name="cat", - ordered=True) - exp = DataFrame({"ints": [1.5, 1.5, np.nan], "val": [20, 30, np.nan]}, - index=exp_index) - tm.assert_frame_equal(res, exp) - - # Grouping on two columns - groups_double_key = test.groupby(["cat", "ints"]) - res = groups_double_key.agg('mean') - exp = DataFrame({"val": [10, 30, 20, 40, np.nan, np.nan], - "cat": pd.Categorical(["a", "a", "b", "b", "c", "c"], - ordered=True), - "ints": [1, 2, 1, 2, 1, 2]}).set_index(["cat", "ints" - ]) - tm.assert_frame_equal(res, exp) - - # GH 10132 - for key in [('a', 1), ('b', 2), ('b', 1), ('a', 2)]: - c, i = key - result = groups_double_key.get_group(key) - expected = test[(test.cat == c) & (test.ints == i)] - assert_frame_equal(result, expected) - - d = {'C1': [3, 3, 4, 5], 'C2': [1, 2, 3, 4], 'C3': [10, 100, 200, 34]} - test = pd.DataFrame(d) - values = pd.cut(test['C1'], [1, 2, 3, 6]) - values.name = "cat" - groups_double_key = test.groupby([values, 'C2']) - - res = groups_double_key.agg('mean') - nan = np.nan - idx = MultiIndex.from_product( - [Categorical(["(1, 2]", "(2, 3]", "(3, 6]"], ordered=True), - [1, 2, 3, 4]], - names=["cat", "C2"]) - exp = DataFrame({"C1": [nan, nan, nan, nan, 3, 3, - nan, nan, nan, nan, 4, 5], - "C3": [nan, nan, nan, nan, 10, 100, - nan, nan, nan, nan, 200, 34]}, index=idx) - tm.assert_frame_equal(res, exp) - - def test_groupby_multi_categorical_as_index(self): - # GH13204 - df = DataFrame({'cat': Categorical([1, 2, 2], [1, 2, 3]), - 'A': [10, 11, 11], - 'B': [101, 102, 103]}) - result = df.groupby(['cat', 'A'], as_index=False).sum() - expected = DataFrame({'cat': Categorical([1, 1, 2, 2, 3, 3]), - 'A': [10, 11, 10, 11, 10, 11], - 'B': [101.0, nan, nan, 205.0, nan, nan]}, - columns=['cat', 'A', 'B']) - tm.assert_frame_equal(result, expected) - - # function grouper - f = lambda r: df.loc[r, 'A'] - result = df.groupby(['cat', f], as_index=False).sum() - expected = DataFrame({'cat': Categorical([1, 1, 2, 2, 3, 3]), - 'A': [10.0, nan, nan, 22.0, nan, nan], - 'B': [101.0, nan, nan, 205.0, nan, nan]}, - columns=['cat', 'A', 'B']) - tm.assert_frame_equal(result, expected) - - # another not in-axis grouper (conflicting names in index) - s = Series(['a', 'b', 'b'], name='cat') - result = df.groupby(['cat', s], as_index=False).sum() - expected = DataFrame({'cat': Categorical([1, 1, 2, 2, 3, 3]), - 'A': [10.0, nan, nan, 22.0, nan, nan], - 'B': [101.0, nan, nan, 205.0, nan, nan]}, - columns=['cat', 'A', 'B']) - tm.assert_frame_equal(result, expected) - - # is original index dropped? - expected = DataFrame({'cat': Categorical([1, 1, 2, 2, 3, 3]), - 'A': [10, 11, 10, 11, 10, 11], - 'B': [101.0, nan, nan, 205.0, nan, nan]}, - columns=['cat', 'A', 'B']) - - for name in [None, 'X', 'B', 'cat']: - df.index = Index(list("abc"), name=name) - result = df.groupby(['cat', 'A'], as_index=False).sum() - tm.assert_frame_equal(result, expected, check_index_type=True) - - def test_groupby_preserve_categorical_dtype(self): - # GH13743, GH13854 - df = DataFrame({'A': [1, 2, 1, 1, 2], - 'B': [10, 16, 22, 28, 34], - 'C1': Categorical(list("abaab"), - categories=list("bac"), - ordered=False), - 'C2': Categorical(list("abaab"), - categories=list("bac"), - ordered=True)}) - # single grouper - exp_full = DataFrame({'A': [2.0, 1.0, np.nan], - 'B': [25.0, 20.0, np.nan], - 'C1': Categorical(list("bac"), - categories=list("bac"), - ordered=False), - 'C2': Categorical(list("bac"), - categories=list("bac"), - ordered=True)}) - for col in ['C1', 'C2']: - result1 = df.groupby(by=col, as_index=False).mean() - result2 = df.groupby(by=col, as_index=True).mean().reset_index() - expected = exp_full.reindex(columns=result1.columns) - tm.assert_frame_equal(result1, expected) - tm.assert_frame_equal(result2, expected) - - # multiple grouper - exp_full = DataFrame({'A': [1, 1, 1, 2, 2, 2], - 'B': [np.nan, 20.0, np.nan, 25.0, np.nan, - np.nan], - 'C1': Categorical(list("bacbac"), - categories=list("bac"), - ordered=False), - 'C2': Categorical(list("bacbac"), - categories=list("bac"), - ordered=True)}) - for cols in [['A', 'C1'], ['A', 'C2']]: - result1 = df.groupby(by=cols, as_index=False).mean() - result2 = df.groupby(by=cols, as_index=True).mean().reset_index() - expected = exp_full.reindex(columns=result1.columns) - tm.assert_frame_equal(result1, expected) - tm.assert_frame_equal(result2, expected) - def test_groupby_apply_all_none(self): # Tests to make sure no errors if apply function returns all None # values. Issue 9684. diff --git a/setup.py b/setup.py index 7a55daa74b1c5..e3774d8e36ce9 100755 --- a/setup.py +++ b/setup.py @@ -637,6 +637,7 @@ def pxd(name): 'pandas.tests', 'pandas.tests.frame', 'pandas.tests.indexes', + 'pandas.tests.groupby', 'pandas.tests.series', 'pandas.tests.formats', 'pandas.tests.types', From f5c8d54d9dcf174bc434b3e24454b27bd17beca4 Mon Sep 17 00:00:00 2001 From: "Jon M. Mease" Date: Sat, 17 Dec 2016 18:01:52 -0500 Subject: [PATCH 14/51] Catch warning introduced by GH14432 in test case Follow on to #14432 to catch the newly introduced `FutureWarning` in the `test_groupby_multi_categorical_as_index` test case. Author: Jon M. Mease Closes #14902 from jmmease/GH14432_follow_on and squashes the following commits: c30fa2b [Jon M. Mease] Trap warning introduced by GH14432 in test_groupby_multi_categorical_as_index --- pandas/tests/groupby/test_categorical.py | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/pandas/tests/groupby/test_categorical.py b/pandas/tests/groupby/test_categorical.py index d3c7bc2adbb4a..99bea3a10115b 100644 --- a/pandas/tests/groupby/test_categorical.py +++ b/pandas/tests/groupby/test_categorical.py @@ -349,9 +349,19 @@ def test_groupby_multi_categorical_as_index(self): 'B': [101.0, nan, nan, 205.0, nan, nan]}, columns=['cat', 'A', 'B']) + group_columns = ['cat', 'A'] + for name in [None, 'X', 'B', 'cat']: df.index = Index(list("abc"), name=name) - result = df.groupby(['cat', 'A'], as_index=False).sum() + + if name in group_columns and name in df.index.names: + with tm.assert_produces_warning(FutureWarning, + check_stacklevel=False): + result = df.groupby(group_columns, as_index=False).sum() + + else: + result = df.groupby(group_columns, as_index=False).sum() + tm.assert_frame_equal(result, expected, check_index_type=True) def test_groupby_preserve_categorical_dtype(self): From e80a2b9ab6ff40a628426f1da509b05c99e6c06d Mon Sep 17 00:00:00 2001 From: Daniel Himmelstein Date: Sat, 17 Dec 2016 18:05:01 -0500 Subject: [PATCH 15/51] DOC for refactored compression (GH14576) + BUG: bz2-compressed URL with C engine (GH14874) Follow up on https://github.com/pandas-dev/pandas/pull/14576, which refactored compression code to expand URL support. Fixes up some small remaining issues and adds a what's new entry. - [x] Closes #14874 Author: Daniel Himmelstein Closes #14880 from dhimmel/whats-new and squashes the following commits: e1b5d42 [Daniel Himmelstein] Address what's new review comments 8568aed [Daniel Himmelstein] TST: Read bz2 files from S3 in PY2 09dcbff [Daniel Himmelstein] DOC: Improve what's new c4ea3d3 [Daniel Himmelstein] STY: PEP8 fixes f8a7900 [Daniel Himmelstein] TST: check bz2 compression in PY2 c engine 0e0fa0a [Daniel Himmelstein] DOC: Reword get_filepath_or_buffer docstring 210fb20 [Daniel Himmelstein] DOC: What's New for refactored compression code cb91007 [Daniel Himmelstein] TST: Read compressed URLs with c engine 85630ea [Daniel Himmelstein] ENH: Support bz2 compression in PY2 for c engine a7960f6 [Daniel Himmelstein] DOC: Improve _infer_compression docstring --- doc/source/whatsnew/v0.20.0.txt | 21 ++++++++ pandas/io/common.py | 17 ++++--- pandas/io/tests/parser/compression.py | 9 +--- pandas/io/tests/parser/test_network.py | 69 ++++++++++---------------- pandas/parser.pyx | 5 +- 5 files changed, 61 insertions(+), 60 deletions(-) diff --git a/doc/source/whatsnew/v0.20.0.txt b/doc/source/whatsnew/v0.20.0.txt index e264fb15f3e67..97a50800ff3d5 100644 --- a/doc/source/whatsnew/v0.20.0.txt +++ b/doc/source/whatsnew/v0.20.0.txt @@ -64,6 +64,27 @@ Strings passed to ``DataFrame.groupby()`` as the ``by`` parameter may now refere df.groupby(['second', 'A']).sum() +.. _whatsnew_0200.enhancements.compressed_urls: + +Better support for compressed URLs in ``read_csv`` +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +The compression code was refactored (:issue:`12688`). As a result, reading +dataframes from URLs in :func:`read_csv` or :func:`read_table` now supports +additional compression methods: ``xz``, ``bz2``, and ``zip`` (:issue:`14570`). +Previously, only ``gzip`` compression was supported. By default, compression of +URLs and paths are now both inferred using their file extensions. Additionally, +support for bz2 compression in the python 2 c-engine improved (:issue:`14874`). + +.. ipython:: python + url = 'https://github.com/{repo}/raw/{branch}/{path}'.format( + repo = 'pandas-dev/pandas', + branch = 'master', + path = 'pandas/io/tests/parser/data/salaries.csv.bz2', + ) + df = pd.read_table(url, compression='infer') # default, infer compression + df = pd.read_table(url, compression='bz2') # explicitly specify compression + df.head(2) .. _whatsnew_0200.enhancements.other: diff --git a/pandas/io/common.py b/pandas/io/common.py index c115fab217fba..fa1022b882124 100644 --- a/pandas/io/common.py +++ b/pandas/io/common.py @@ -187,8 +187,8 @@ def _stringify_path(filepath_or_buffer): def get_filepath_or_buffer(filepath_or_buffer, encoding=None, compression=None): """ - If the filepath_or_buffer is a url, translate and return the buffer - passthru otherwise. + If the filepath_or_buffer is a url, translate and return the buffer. + Otherwise passthrough. Parameters ---------- @@ -247,23 +247,26 @@ def file_path_to_url(path): def _infer_compression(filepath_or_buffer, compression): """ - Get file handle for given path/buffer and mode. + Get the compression method for filepath_or_buffer. If compression='infer', + the inferred compression method is returned. Otherwise, the input + compression method is returned unchanged, unless it's invalid, in which + case an error is raised. Parameters ---------- filepath_or_buf : a path (str) or buffer - compression : str, or None + compression : str or None + the compression method including None for no compression and 'infer' Returns ------- - string compression method, None + string or None : + compression method Raises ------ ValueError on invalid compression specified - - If compression='infer', infer compression. If compression """ # No compression has been explicitly specified diff --git a/pandas/io/tests/parser/compression.py b/pandas/io/tests/parser/compression.py index 3b0c571032fe6..e95617faf2071 100644 --- a/pandas/io/tests/parser/compression.py +++ b/pandas/io/tests/parser/compression.py @@ -8,7 +8,6 @@ import nose import pandas.util.testing as tm -from pandas import compat class CompressionTests(object): @@ -114,12 +113,8 @@ def test_bz2(self): path, compression='bz3') with open(path, 'rb') as fin: - if compat.PY3: - result = self.read_csv(fin, compression='bz2') - tm.assert_frame_equal(result, expected) - elif self.engine is not 'python': - self.assertRaises(ValueError, self.read_csv, - fin, compression='bz2') + result = self.read_csv(fin, compression='bz2') + tm.assert_frame_equal(result, expected) with tm.ensure_clean('test.bz2') as path: tmp = bz2.BZ2File(path, mode='wb') diff --git a/pandas/io/tests/parser/test_network.py b/pandas/io/tests/parser/test_network.py index fd7a1babe4e01..4258749b8d897 100644 --- a/pandas/io/tests/parser/test_network.py +++ b/pandas/io/tests/parser/test_network.py @@ -12,7 +12,6 @@ import pandas.util.testing as tm from pandas import DataFrame -from pandas import compat from pandas.io.parsers import read_csv, read_table @@ -39,7 +38,7 @@ def test_compressed_urls(self): for compression, extension in self.compression_to_extension.items(): url = self.base_url + extension # args is a (compression, engine) tuple - for args in product([compression, 'infer'], ['python']): + for args in product([compression, 'infer'], ['python', 'c']): # test_fxn is a workaround for more descriptive nose reporting. # See http://stackoverflow.com/a/37393684/4651668. test_fxn = functools.partial(self.check_table) @@ -64,18 +63,12 @@ def setUp(self): @tm.network def test_parse_public_s3_bucket(self): for ext, comp in [('', None), ('.gz', 'gzip'), ('.bz2', 'bz2')]: - if comp == 'bz2' and compat.PY2: - # The Python 2 C parser can't read bz2 from S3. - self.assertRaises(ValueError, read_csv, - 's3://pandas-test/tips.csv' + ext, - compression=comp) - else: - df = read_csv('s3://pandas-test/tips.csv' + - ext, compression=comp) - self.assertTrue(isinstance(df, DataFrame)) - self.assertFalse(df.empty) - tm.assert_frame_equal(read_csv( - tm.get_data_path('tips.csv')), df) + df = read_csv('s3://pandas-test/tips.csv' + + ext, compression=comp) + self.assertTrue(isinstance(df, DataFrame)) + self.assertFalse(df.empty) + tm.assert_frame_equal(read_csv( + tm.get_data_path('tips.csv')), df) # Read public file from bucket with not-public contents df = read_csv('s3://cant_get_it/tips.csv') @@ -104,18 +97,12 @@ def test_parse_public_s3a_bucket(self): @tm.network def test_parse_public_s3_bucket_nrows(self): for ext, comp in [('', None), ('.gz', 'gzip'), ('.bz2', 'bz2')]: - if comp == 'bz2' and compat.PY2: - # The Python 2 C parser can't read bz2 from S3. - self.assertRaises(ValueError, read_csv, - 's3://pandas-test/tips.csv' + ext, - compression=comp) - else: - df = read_csv('s3://pandas-test/tips.csv' + - ext, nrows=10, compression=comp) - self.assertTrue(isinstance(df, DataFrame)) - self.assertFalse(df.empty) - tm.assert_frame_equal(read_csv( - tm.get_data_path('tips.csv')).iloc[:10], df) + df = read_csv('s3://pandas-test/tips.csv' + + ext, nrows=10, compression=comp) + self.assertTrue(isinstance(df, DataFrame)) + self.assertFalse(df.empty) + tm.assert_frame_equal(read_csv( + tm.get_data_path('tips.csv')).iloc[:10], df) @tm.network def test_parse_public_s3_bucket_chunked(self): @@ -123,24 +110,18 @@ def test_parse_public_s3_bucket_chunked(self): chunksize = 5 local_tips = read_csv(tm.get_data_path('tips.csv')) for ext, comp in [('', None), ('.gz', 'gzip'), ('.bz2', 'bz2')]: - if comp == 'bz2' and compat.PY2: - # The Python 2 C parser can't read bz2 from S3. - self.assertRaises(ValueError, read_csv, - 's3://pandas-test/tips.csv' + ext, - compression=comp) - else: - df_reader = read_csv('s3://pandas-test/tips.csv' + ext, - chunksize=chunksize, compression=comp) - self.assertEqual(df_reader.chunksize, chunksize) - for i_chunk in [0, 1, 2]: - # Read a couple of chunks and make sure we see them - # properly. - df = df_reader.get_chunk() - self.assertTrue(isinstance(df, DataFrame)) - self.assertFalse(df.empty) - true_df = local_tips.iloc[ - chunksize * i_chunk: chunksize * (i_chunk + 1)] - tm.assert_frame_equal(true_df, df) + df_reader = read_csv('s3://pandas-test/tips.csv' + ext, + chunksize=chunksize, compression=comp) + self.assertEqual(df_reader.chunksize, chunksize) + for i_chunk in [0, 1, 2]: + # Read a couple of chunks and make sure we see them + # properly. + df = df_reader.get_chunk() + self.assertTrue(isinstance(df, DataFrame)) + self.assertFalse(df.empty) + true_df = local_tips.iloc[ + chunksize * i_chunk: chunksize * (i_chunk + 1)] + tm.assert_frame_equal(true_df, df) @tm.network def test_parse_public_s3_bucket_chunked_python(self): diff --git a/pandas/parser.pyx b/pandas/parser.pyx index 8e52fc117b401..2464ee15b36b7 100644 --- a/pandas/parser.pyx +++ b/pandas/parser.pyx @@ -621,8 +621,9 @@ cdef class TextReader: if isinstance(source, basestring) or PY3: source = bz2.BZ2File(source, 'rb') else: - raise ValueError('Python 2 cannot read bz2 from open file ' - 'handle') + content = source.read() + source.close() + source = compat.StringIO(bz2.decompress(content)) elif self.compression == 'zip': import zipfile zip_file = zipfile.ZipFile(source) From 906b51a441a503b9293c6301b65ae0052d5cfa30 Mon Sep 17 00:00:00 2001 From: Matthew Roeschke Date: Sat, 17 Dec 2016 15:13:43 -0800 Subject: [PATCH 16/51] TST: Test datetime array assignment with different units (#7492) (#14884) --- pandas/tests/frame/test_timeseries.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/pandas/tests/frame/test_timeseries.py b/pandas/tests/frame/test_timeseries.py index 9758c2b9c805e..c6c3b4f43b55a 100644 --- a/pandas/tests/frame/test_timeseries.py +++ b/pandas/tests/frame/test_timeseries.py @@ -366,6 +366,21 @@ def test_operation_on_NaT(self): exp = pd.Series([pd.NaT], index=["foo"]) tm.assert_series_equal(res, exp) + def test_datetime_assignment_with_NaT_and_diff_time_units(self): + # GH 7492 + data_ns = np.array([1, 'nat'], dtype='datetime64[ns]') + result = pd.Series(data_ns).to_frame() + result['new'] = data_ns + expected = pd.DataFrame({0: [1, None], + 'new': [1, None]}, dtype='datetime64[ns]') + tm.assert_frame_equal(result, expected) + # OutOfBoundsDatetime error shouldn't occur + data_s = np.array([1, 'nat'], dtype='datetime64[s]') + result['new'] = data_s + expected = pd.DataFrame({0: [1, None], + 'new': [1e9, None]}, dtype='datetime64[ns]') + tm.assert_frame_equal(result, expected) + if __name__ == '__main__': import nose From bdbebc4f3be9c14ad7ff03796eb36d415b397a52 Mon Sep 17 00:00:00 2001 From: gfyoung Date: Sat, 17 Dec 2016 18:25:08 -0500 Subject: [PATCH 17/51] BUG: Prevent addition overflow with TimedeltaIndex (#14816) Expands checked-add array addition introduced in gh-14237 to include all other addition cases (i.e. TimedeltaIndex and Timedelta). Follow-up to gh-14453. In addition, move checked add function to core/algorithms. --- asv_bench/benchmarks/algorithms.py | 15 ++++- doc/source/whatsnew/v0.20.0.txt | 1 + pandas/core/algorithms.py | 90 +++++++++++++++++++++++++ pandas/core/nanops.py | 55 --------------- pandas/tests/test_algos.py | 49 ++++++++++++++ pandas/tests/test_nanops.py | 22 ------ pandas/tseries/base.py | 8 ++- pandas/tseries/tdi.py | 4 +- pandas/tseries/tests/test_timedeltas.py | 23 +++++++ 9 files changed, 185 insertions(+), 82 deletions(-) diff --git a/asv_bench/benchmarks/algorithms.py b/asv_bench/benchmarks/algorithms.py index 20d149493951f..fe657936c403e 100644 --- a/asv_bench/benchmarks/algorithms.py +++ b/asv_bench/benchmarks/algorithms.py @@ -18,7 +18,7 @@ def setup(self): self.float = pd.Float64Index(np.random.randn(N).repeat(5)) # Convenience naming. - self.checked_add = pd.core.nanops._checked_add_with_arr + self.checked_add = pd.core.algorithms.checked_add_with_arr self.arr = np.arange(1000000) self.arrpos = np.arange(1000000) @@ -26,6 +26,9 @@ def setup(self): self.arrmixed = np.array([1, -1]).repeat(500000) self.strings = tm.makeStringIndex(100000) + self.arr_nan = np.random.choice([True, False], size=1000000) + self.arrmixed_nan = np.random.choice([True, False], size=1000000) + # match self.uniques = tm.makeStringIndex(1000).values self.all = self.uniques.repeat(10) @@ -69,6 +72,16 @@ def time_add_overflow_neg_arr(self): def time_add_overflow_mixed_arr(self): self.checked_add(self.arr, self.arrmixed) + def time_add_overflow_first_arg_nan(self): + self.checked_add(self.arr, self.arrmixed, arr_mask=self.arr_nan) + + def time_add_overflow_second_arg_nan(self): + self.checked_add(self.arr, self.arrmixed, b_mask=self.arrmixed_nan) + + def time_add_overflow_both_arg_nan(self): + self.checked_add(self.arr, self.arrmixed, arr_mask=self.arr_nan, + b_mask=self.arrmixed_nan) + class Hashing(object): goal_time = 0.2 diff --git a/doc/source/whatsnew/v0.20.0.txt b/doc/source/whatsnew/v0.20.0.txt index 97a50800ff3d5..76ba4a5f723fa 100644 --- a/doc/source/whatsnew/v0.20.0.txt +++ b/doc/source/whatsnew/v0.20.0.txt @@ -234,6 +234,7 @@ Performance Improvements Bug Fixes ~~~~~~~~~ +- Bug in ``TimedeltaIndex`` addition where overflow was being allowed without error (:issue:`14816`) - Bug in ``astype()`` where ``inf`` values were incorrectly converted to integers. Now raises error now with ``astype()`` for Series and DataFrames (:issue:`14265`) diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py index 0d4d4143e6b9b..b2702ea0acca7 100644 --- a/pandas/core/algorithms.py +++ b/pandas/core/algorithms.py @@ -27,6 +27,7 @@ _ensure_float64, _ensure_int64, is_list_like) +from pandas.compat.numpy import _np_version_under1p10 from pandas.types.missing import isnull import pandas.core.common as com @@ -550,6 +551,95 @@ def rank(values, axis=0, method='average', na_option='keep', return ranks + +def checked_add_with_arr(arr, b, arr_mask=None, b_mask=None): + """ + Perform array addition that checks for underflow and overflow. + + Performs the addition of an int64 array and an int64 integer (or array) + but checks that they do not result in overflow first. For elements that + are indicated to be NaN, whether or not there is overflow for that element + is automatically ignored. + + Parameters + ---------- + arr : array addend. + b : array or scalar addend. + arr_mask : boolean array or None + array indicating which elements to exclude from checking + b_mask : boolean array or boolean or None + array or scalar indicating which element(s) to exclude from checking + + Returns + ------- + sum : An array for elements x + b for each element x in arr if b is + a scalar or an array for elements x + y for each element pair + (x, y) in (arr, b). + + Raises + ------ + OverflowError if any x + y exceeds the maximum or minimum int64 value. + """ + def _broadcast(arr_or_scalar, shape): + """ + Helper function to broadcast arrays / scalars to the desired shape. + """ + if _np_version_under1p10: + if lib.isscalar(arr_or_scalar): + out = np.empty(shape) + out.fill(arr_or_scalar) + else: + out = arr_or_scalar + else: + out = np.broadcast_to(arr_or_scalar, shape) + return out + + # For performance reasons, we broadcast 'b' to the new array 'b2' + # so that it has the same size as 'arr'. + b2 = _broadcast(b, arr.shape) + if b_mask is not None: + # We do the same broadcasting for b_mask as well. + b2_mask = _broadcast(b_mask, arr.shape) + else: + b2_mask = None + + # For elements that are NaN, regardless of their value, we should + # ignore whether they overflow or not when doing the checked add. + if arr_mask is not None and b2_mask is not None: + not_nan = np.logical_not(arr_mask | b2_mask) + elif arr_mask is not None: + not_nan = np.logical_not(arr_mask) + elif b_mask is not None: + not_nan = np.logical_not(b2_mask) + else: + not_nan = np.empty(arr.shape, dtype=bool) + not_nan.fill(True) + + # gh-14324: For each element in 'arr' and its corresponding element + # in 'b2', we check the sign of the element in 'b2'. If it is positive, + # we then check whether its sum with the element in 'arr' exceeds + # np.iinfo(np.int64).max. If so, we have an overflow error. If it + # it is negative, we then check whether its sum with the element in + # 'arr' exceeds np.iinfo(np.int64).min. If so, we have an overflow + # error as well. + mask1 = b2 > 0 + mask2 = b2 < 0 + + if not mask1.any(): + to_raise = ((np.iinfo(np.int64).min - b2 > arr) & not_nan).any() + elif not mask2.any(): + to_raise = ((np.iinfo(np.int64).max - b2 < arr) & not_nan).any() + else: + to_raise = (((np.iinfo(np.int64).max - + b2[mask1] < arr[mask1]) & not_nan[mask1]).any() or + ((np.iinfo(np.int64).min - + b2[mask2] > arr[mask2]) & not_nan[mask2]).any()) + + if to_raise: + raise OverflowError("Overflow in int64 addition") + return arr + b + + _rank1d_functions = { 'float64': algos.rank_1d_float64, 'int64': algos.rank_1d_int64, diff --git a/pandas/core/nanops.py b/pandas/core/nanops.py index d7d68ad536be5..a76e348b7dee2 100644 --- a/pandas/core/nanops.py +++ b/pandas/core/nanops.py @@ -11,7 +11,6 @@ import pandas.hashtable as _hash from pandas import compat, lib, algos, tslib -from pandas.compat.numpy import _np_version_under1p10 from pandas.types.common import (_ensure_int64, _ensure_object, _ensure_float64, _get_dtype, is_float, is_scalar, @@ -810,57 +809,3 @@ def unique1d(values): table = _hash.PyObjectHashTable(len(values)) uniques = table.unique(_ensure_object(values)) return uniques - - -def _checked_add_with_arr(arr, b): - """ - Performs the addition of an int64 array and an int64 integer (or array) - but checks that they do not result in overflow first. - - Parameters - ---------- - arr : array addend. - b : array or scalar addend. - - Returns - ------- - sum : An array for elements x + b for each element x in arr if b is - a scalar or an array for elements x + y for each element pair - (x, y) in (arr, b). - - Raises - ------ - OverflowError if any x + y exceeds the maximum or minimum int64 value. - """ - # For performance reasons, we broadcast 'b' to the new array 'b2' - # so that it has the same size as 'arr'. - if _np_version_under1p10: - if lib.isscalar(b): - b2 = np.empty(arr.shape) - b2.fill(b) - else: - b2 = b - else: - b2 = np.broadcast_to(b, arr.shape) - - # gh-14324: For each element in 'arr' and its corresponding element - # in 'b2', we check the sign of the element in 'b2'. If it is positive, - # we then check whether its sum with the element in 'arr' exceeds - # np.iinfo(np.int64).max. If so, we have an overflow error. If it - # it is negative, we then check whether its sum with the element in - # 'arr' exceeds np.iinfo(np.int64).min. If so, we have an overflow - # error as well. - mask1 = b2 > 0 - mask2 = b2 < 0 - - if not mask1.any(): - to_raise = (np.iinfo(np.int64).min - b2 > arr).any() - elif not mask2.any(): - to_raise = (np.iinfo(np.int64).max - b2 < arr).any() - else: - to_raise = ((np.iinfo(np.int64).max - b2[mask1] < arr[mask1]).any() or - (np.iinfo(np.int64).min - b2[mask2] > arr[mask2]).any()) - - if to_raise: - raise OverflowError("Overflow in int64 addition") - return arr + b diff --git a/pandas/tests/test_algos.py b/pandas/tests/test_algos.py index f89f41abd0d35..d0c909b9c1b30 100644 --- a/pandas/tests/test_algos.py +++ b/pandas/tests/test_algos.py @@ -1129,6 +1129,55 @@ def test_ensure_platform_int(): assert (result is arr) +def test_int64_add_overflow(): + # see gh-14068 + msg = "Overflow in int64 addition" + m = np.iinfo(np.int64).max + n = np.iinfo(np.int64).min + + with tm.assertRaisesRegexp(OverflowError, msg): + algos.checked_add_with_arr(np.array([m, m]), m) + with tm.assertRaisesRegexp(OverflowError, msg): + algos.checked_add_with_arr(np.array([m, m]), np.array([m, m])) + with tm.assertRaisesRegexp(OverflowError, msg): + algos.checked_add_with_arr(np.array([n, n]), n) + with tm.assertRaisesRegexp(OverflowError, msg): + algos.checked_add_with_arr(np.array([n, n]), np.array([n, n])) + with tm.assertRaisesRegexp(OverflowError, msg): + algos.checked_add_with_arr(np.array([m, n]), np.array([n, n])) + with tm.assertRaisesRegexp(OverflowError, msg): + algos.checked_add_with_arr(np.array([m, m]), np.array([m, m]), + arr_mask=np.array([False, True])) + with tm.assertRaisesRegexp(OverflowError, msg): + algos.checked_add_with_arr(np.array([m, m]), np.array([m, m]), + b_mask=np.array([False, True])) + with tm.assertRaisesRegexp(OverflowError, msg): + algos.checked_add_with_arr(np.array([m, m]), np.array([m, m]), + arr_mask=np.array([False, True]), + b_mask=np.array([False, True])) + with tm.assertRaisesRegexp(OverflowError, msg): + with tm.assert_produces_warning(RuntimeWarning): + algos.checked_add_with_arr(np.array([m, m]), + np.array([np.nan, m])) + + # Check that the nan boolean arrays override whether or not + # the addition overflows. We don't check the result but just + # the fact that an OverflowError is not raised. + with tm.assertRaises(AssertionError): + with tm.assertRaisesRegexp(OverflowError, msg): + algos.checked_add_with_arr(np.array([m, m]), np.array([m, m]), + arr_mask=np.array([True, True])) + with tm.assertRaises(AssertionError): + with tm.assertRaisesRegexp(OverflowError, msg): + algos.checked_add_with_arr(np.array([m, m]), np.array([m, m]), + b_mask=np.array([True, True])) + with tm.assertRaises(AssertionError): + with tm.assertRaisesRegexp(OverflowError, msg): + algos.checked_add_with_arr(np.array([m, m]), np.array([m, m]), + arr_mask=np.array([True, False]), + b_mask=np.array([False, True])) + + if __name__ == '__main__': import nose nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'], diff --git a/pandas/tests/test_nanops.py b/pandas/tests/test_nanops.py index be634228b1b6e..dd3a49de55d73 100644 --- a/pandas/tests/test_nanops.py +++ b/pandas/tests/test_nanops.py @@ -1002,28 +1002,6 @@ def prng(self): return np.random.RandomState(1234) -def test_int64_add_overflow(): - # see gh-14068 - msg = "Overflow in int64 addition" - m = np.iinfo(np.int64).max - n = np.iinfo(np.int64).min - - with tm.assertRaisesRegexp(OverflowError, msg): - nanops._checked_add_with_arr(np.array([m, m]), m) - with tm.assertRaisesRegexp(OverflowError, msg): - nanops._checked_add_with_arr(np.array([m, m]), np.array([m, m])) - with tm.assertRaisesRegexp(OverflowError, msg): - nanops._checked_add_with_arr(np.array([n, n]), n) - with tm.assertRaisesRegexp(OverflowError, msg): - nanops._checked_add_with_arr(np.array([n, n]), np.array([n, n])) - with tm.assertRaisesRegexp(OverflowError, msg): - nanops._checked_add_with_arr(np.array([m, n]), np.array([n, n])) - with tm.assertRaisesRegexp(OverflowError, msg): - with tm.assert_produces_warning(RuntimeWarning): - nanops._checked_add_with_arr(np.array([m, m]), - np.array([np.nan, m])) - - if __name__ == '__main__': import nose nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure', '-s' diff --git a/pandas/tseries/base.py b/pandas/tseries/base.py index 8e24f430108b3..63e56e09e91fe 100644 --- a/pandas/tseries/base.py +++ b/pandas/tseries/base.py @@ -16,6 +16,7 @@ ABCPeriodIndex, ABCIndexClass) from pandas.types.missing import isnull from pandas.core import common as com, algorithms +from pandas.core.algorithms import checked_add_with_arr from pandas.core.common import AbstractMethodError import pandas.formats.printing as printing @@ -688,7 +689,8 @@ def _add_delta_td(self, other): # return the i8 result view inc = tslib._delta_to_nanoseconds(other) - new_values = (self.asi8 + inc).view('i8') + new_values = checked_add_with_arr(self.asi8, inc, + arr_mask=self._isnan).view('i8') if self.hasnans: new_values[self._isnan] = tslib.iNaT return new_values.view('i8') @@ -703,7 +705,9 @@ def _add_delta_tdi(self, other): self_i8 = self.asi8 other_i8 = other.asi8 - new_values = self_i8 + other_i8 + new_values = checked_add_with_arr(self_i8, other_i8, + arr_mask=self._isnan, + b_mask=other._isnan) if self.hasnans or other.hasnans: mask = (self._isnan) | (other._isnan) new_values[mask] = tslib.iNaT diff --git a/pandas/tseries/tdi.py b/pandas/tseries/tdi.py index 7e77d8baf3b2c..1585aac0c8ead 100644 --- a/pandas/tseries/tdi.py +++ b/pandas/tseries/tdi.py @@ -20,8 +20,8 @@ import pandas.compat as compat from pandas.compat import u from pandas.tseries.frequencies import to_offset +from pandas.core.algorithms import checked_add_with_arr from pandas.core.base import _shared_docs -from pandas.core.nanops import _checked_add_with_arr from pandas.indexes.base import _index_shared_docs import pandas.core.common as com import pandas.types.concat as _concat @@ -347,7 +347,7 @@ def _add_datelike(self, other): else: other = Timestamp(other) i8 = self.asi8 - result = _checked_add_with_arr(i8, other.value) + result = checked_add_with_arr(i8, other.value) result = self._maybe_mask_results(result, fill_value=tslib.iNaT) return DatetimeIndex(result, name=self.name, copy=False) diff --git a/pandas/tseries/tests/test_timedeltas.py b/pandas/tseries/tests/test_timedeltas.py index ca957ca0394d1..fc95b17b9b52d 100644 --- a/pandas/tseries/tests/test_timedeltas.py +++ b/pandas/tseries/tests/test_timedeltas.py @@ -1958,11 +1958,34 @@ def test_add_overflow(self): with tm.assertRaisesRegexp(OverflowError, msg): Timestamp('2000') + to_timedelta(106580, 'D') + _NaT = int(pd.NaT) + 1 msg = "Overflow in int64 addition" with tm.assertRaisesRegexp(OverflowError, msg): to_timedelta([106580], 'D') + Timestamp('2000') with tm.assertRaisesRegexp(OverflowError, msg): Timestamp('2000') + to_timedelta([106580], 'D') + with tm.assertRaisesRegexp(OverflowError, msg): + to_timedelta([_NaT]) - Timedelta('1 days') + with tm.assertRaisesRegexp(OverflowError, msg): + to_timedelta(['5 days', _NaT]) - Timedelta('1 days') + with tm.assertRaisesRegexp(OverflowError, msg): + (to_timedelta([_NaT, '5 days', '1 hours']) - + to_timedelta(['7 seconds', _NaT, '4 hours'])) + + # These should not overflow! + exp = TimedeltaIndex([pd.NaT]) + result = to_timedelta([pd.NaT]) - Timedelta('1 days') + tm.assert_index_equal(result, exp) + + exp = TimedeltaIndex(['4 days', pd.NaT]) + result = to_timedelta(['5 days', pd.NaT]) - Timedelta('1 days') + tm.assert_index_equal(result, exp) + + exp = TimedeltaIndex([pd.NaT, pd.NaT, '5 hours']) + result = (to_timedelta([pd.NaT, '5 days', '1 hours']) + + to_timedelta(['7 seconds', pd.NaT, '4 hours'])) + tm.assert_index_equal(result, exp) + if __name__ == '__main__': nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'], From e503d40ace473556990e5453ed5b4c9aa96e24ff Mon Sep 17 00:00:00 2001 From: Nate Yoder Date: Sat, 17 Dec 2016 18:27:32 -0500 Subject: [PATCH 18/51] Clean up construction of Series with dictionary and datetime index closes #14894 Fix usage of fast_multiget with index which was always throwing an exception that was then caught; add ASV that show slight improvement Author: Nate Yoder Closes #14895 from nateyoder/series_dict_index and squashes the following commits: 56be091 [Nate Yoder] Update whatsnew and fix pep8 issue 5f05fdc [Nate Yoder] Fix usage of fast_multiget with index which was always throwing an exception that was then caught; add ASV that show slight improvement --- asv_bench/benchmarks/series_methods.py | 19 +++++++++++++++++-- doc/source/whatsnew/v0.19.2.txt | 1 + pandas/core/series.py | 3 ++- 3 files changed, 20 insertions(+), 3 deletions(-) diff --git a/asv_bench/benchmarks/series_methods.py b/asv_bench/benchmarks/series_methods.py index 4e368c6d7cde2..413c4e044fd3a 100644 --- a/asv_bench/benchmarks/series_methods.py +++ b/asv_bench/benchmarks/series_methods.py @@ -8,13 +8,28 @@ def setup(self): self.dr = pd.date_range( start=datetime(2015,10,26), end=datetime(2016,1,1), - freq='10s' - ) # ~500k long + freq='50s' + ) # ~100k long def time_series_constructor_no_data_datetime_index(self): Series(data=None, index=self.dr) +class series_constructor_dict_data_datetime_index(object): + goal_time = 0.2 + + def setup(self): + self.dr = pd.date_range( + start=datetime(2015, 10, 26), + end=datetime(2016, 1, 1), + freq='50s' + ) # ~100k long + self.data = {d: v for d, v in zip(self.dr, range(len(self.dr)))} + + def time_series_constructor_no_data_datetime_index(self): + Series(data=self.data, index=self.dr) + + class series_isin_int64(object): goal_time = 0.2 diff --git a/doc/source/whatsnew/v0.19.2.txt b/doc/source/whatsnew/v0.19.2.txt index 4cd58f0148ae8..42e2265780c94 100644 --- a/doc/source/whatsnew/v0.19.2.txt +++ b/doc/source/whatsnew/v0.19.2.txt @@ -22,6 +22,7 @@ Performance Improvements ~~~~~~~~~~~~~~~~~~~~~~~~ - Improved performance of ``.replace()`` (:issue:`12745`) +- Improved performance ``Series`` creation with a datetime index and dictionary data (:issue:`14894`) .. _whatsnew_0192.enhancements.other: diff --git a/pandas/core/series.py b/pandas/core/series.py index 7018865e5b3ec..f656d72296e3a 100644 --- a/pandas/core/series.py +++ b/pandas/core/series.py @@ -188,7 +188,8 @@ def __init__(self, data=None, index=None, dtype=None, name=None, if len(data): # coerce back to datetime objects for lookup data = _dict_compat(data) - data = lib.fast_multiget(data, index.astype('O'), + data = lib.fast_multiget(data, + index.asobject.values, default=np.nan) else: data = np.nan From f3c5a427cc632e89cc5d2cb0df5b5e875cb6e23b Mon Sep 17 00:00:00 2001 From: Rodolfo Fernandez Date: Sun, 18 Dec 2016 14:36:21 -0500 Subject: [PATCH 19/51] BUG: .fillna() for datetime64 with tz is passing thru floats closes #14872 Author: Rodolfo Fernandez Closes #14905 from RodolfoRFR/pandas-14872-e and squashes the following commits: 18802b4 [Rodolfo Fernandez] added 'self' to test_dtype_utc function in pandas/tests/series/test_missing e0c6c7c [Rodolfo Fernandez] added line to whatsnew v0.19.2 and test to test_missing.py in series folder e4ba7e0 [Rodolfo Fernandez] removed all references to _DATELIKE_DTYPES from /pandas/core/missing.py 5d37ce8 [Rodolfo Fernandez] added is_datetime64tz_dtype and changed evaluation from 'values' to dtype 19eecb2 [Rodolfo Fernandez] fixed style errors using flake8 59b91a1 [Rodolfo Fernandez] test modified 5a59eac [Rodolfo Fernandez] test modified bc68bf7 [Rodolfo Fernandez] test modified ba83fc8 [Rodolfo Fernandez] test b7358de [Rodolfo Fernandez] bug fixed --- doc/source/whatsnew/v0.19.2.txt | 1 + pandas/core/missing.py | 13 ++++++------- pandas/tests/series/test_missing.py | 23 ++++++++++++++++++++--- pandas/types/common.py | 1 + 4 files changed, 28 insertions(+), 10 deletions(-) diff --git a/doc/source/whatsnew/v0.19.2.txt b/doc/source/whatsnew/v0.19.2.txt index 42e2265780c94..ea59f3fbf493a 100644 --- a/doc/source/whatsnew/v0.19.2.txt +++ b/doc/source/whatsnew/v0.19.2.txt @@ -47,6 +47,7 @@ Bug Fixes - Bug in ``pd.read_csv`` for the Python engine in which an unhelpful error message was being raised when multi-char delimiters were not being respected with quotes (:issue:`14582`) - Fix bugs (:issue:`14734`, :issue:`13654`) in ``pd.read_sas`` and ``pandas.io.sas.sas7bdat.SAS7BDATReader`` that caused problems when reading a SAS file incrementally. - Bug in ``pd.read_csv`` for the Python engine in which an unhelpful error message was being raised when ``skipfooter`` was not being respected by Python's CSV library (:issue:`13879`) +- Bug in ``.fillna()`` in which timezone aware datetime64 values were incorrectly rounded (:issue:`14872`) - Bug in ``.groupby(..., sort=True)`` of a non-lexsorted MultiIndex when grouping with multiple levels (:issue:`14776`) diff --git a/pandas/core/missing.py b/pandas/core/missing.py index f1191ff1c7009..e83a0518d97f6 100644 --- a/pandas/core/missing.py +++ b/pandas/core/missing.py @@ -10,9 +10,8 @@ from pandas.compat import range, string_types from pandas.types.common import (is_numeric_v_string_like, is_float_dtype, is_datetime64_dtype, - is_integer_dtype, _ensure_float64, - is_scalar, - _DATELIKE_DTYPES, + is_datetime64tz_dtype, is_integer_dtype, + _ensure_float64, is_scalar, needs_i8_conversion) from pandas.types.missing import isnull @@ -450,7 +449,7 @@ def pad_1d(values, limit=None, mask=None, dtype=None): _method = None if is_float_dtype(values): _method = getattr(algos, 'pad_inplace_%s' % dtype.name, None) - elif dtype in _DATELIKE_DTYPES or is_datetime64_dtype(values): + elif is_datetime64_dtype(dtype) or is_datetime64tz_dtype(dtype): _method = _pad_1d_datetime elif is_integer_dtype(values): values = _ensure_float64(values) @@ -475,7 +474,7 @@ def backfill_1d(values, limit=None, mask=None, dtype=None): _method = None if is_float_dtype(values): _method = getattr(algos, 'backfill_inplace_%s' % dtype.name, None) - elif dtype in _DATELIKE_DTYPES or is_datetime64_dtype(values): + elif is_datetime64_dtype(dtype) or is_datetime64tz_dtype(dtype): _method = _backfill_1d_datetime elif is_integer_dtype(values): values = _ensure_float64(values) @@ -501,7 +500,7 @@ def pad_2d(values, limit=None, mask=None, dtype=None): _method = None if is_float_dtype(values): _method = getattr(algos, 'pad_2d_inplace_%s' % dtype.name, None) - elif dtype in _DATELIKE_DTYPES or is_datetime64_dtype(values): + elif is_datetime64_dtype(dtype) or is_datetime64tz_dtype(dtype): _method = _pad_2d_datetime elif is_integer_dtype(values): values = _ensure_float64(values) @@ -531,7 +530,7 @@ def backfill_2d(values, limit=None, mask=None, dtype=None): _method = None if is_float_dtype(values): _method = getattr(algos, 'backfill_2d_inplace_%s' % dtype.name, None) - elif dtype in _DATELIKE_DTYPES or is_datetime64_dtype(values): + elif is_datetime64_dtype(dtype) or is_datetime64tz_dtype(dtype): _method = _backfill_2d_datetime elif is_integer_dtype(values): values = _ensure_float64(values) diff --git a/pandas/tests/series/test_missing.py b/pandas/tests/series/test_missing.py index 5666a07cad4b8..ed558275674c7 100644 --- a/pandas/tests/series/test_missing.py +++ b/pandas/tests/series/test_missing.py @@ -1,7 +1,8 @@ # coding=utf-8 # pylint: disable-msg=E1101,W0612 -from datetime import timedelta +import pytz +from datetime import timedelta, datetime from numpy import nan import numpy as np @@ -10,7 +11,6 @@ from pandas import (Series, isnull, date_range, MultiIndex, Index) from pandas.tseries.index import Timestamp - from pandas.compat import range from pandas.util.testing import assert_series_equal import pandas.util.testing as tm @@ -250,6 +250,24 @@ def test_datetime64_tz_fillna(self): self.assert_series_equal(expected, result) self.assert_series_equal(pd.isnull(s), null_loc) + def test_datetime64tz_fillna_round_issue(self): + # GH 14872 + + data = pd.Series([pd.NaT, pd.NaT, + datetime(2016, 12, 12, 22, 24, 6, 100001, + tzinfo=pytz.utc)]) + + filled = data.fillna(method='bfill') + + expected = pd.Series([datetime(2016, 12, 12, 22, 24, 6, + 100001, tzinfo=pytz.utc), + datetime(2016, 12, 12, 22, 24, 6, + 100001, tzinfo=pytz.utc), + datetime(2016, 12, 12, 22, 24, 6, + 100001, tzinfo=pytz.utc)]) + + assert_series_equal(filled, expected) + def test_fillna_int(self): s = Series(np.random.randint(-100, 100, 50)) s.fillna(method='ffill', inplace=True) @@ -908,7 +926,6 @@ def test_interp_timedelta64(self): index=pd.to_timedelta([1, 2, 4])) assert_series_equal(result, expected) - if __name__ == '__main__': import nose nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'], diff --git a/pandas/types/common.py b/pandas/types/common.py index 754ff80924c07..5d161efa838de 100644 --- a/pandas/types/common.py +++ b/pandas/types/common.py @@ -22,6 +22,7 @@ _NS_DTYPE = np.dtype('M8[ns]') _TD_DTYPE = np.dtype('m8[ns]') _INT64_DTYPE = np.dtype(np.int64) + _DATELIKE_DTYPES = set([np.dtype(t) for t in ['M8[ns]', 'M8[ns]', 'm8[ns]', 'm8[ns]']]) From 37b22c7046195bf93e46712fa1221ded4ae6cbdf Mon Sep 17 00:00:00 2001 From: Matthew Roeschke Date: Sun, 18 Dec 2016 12:22:24 -0800 Subject: [PATCH 20/51] TST: Test timedelta arithmetic (#9396) (#14906) --- pandas/tseries/tests/test_timedeltas.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/pandas/tseries/tests/test_timedeltas.py b/pandas/tseries/tests/test_timedeltas.py index fc95b17b9b52d..1d07b4ab39a99 100644 --- a/pandas/tseries/tests/test_timedeltas.py +++ b/pandas/tseries/tests/test_timedeltas.py @@ -1203,6 +1203,28 @@ def test_implementation_limits(self): with tm.assertRaises(OverflowError): Timedelta(max_td.value + 1, 'ns') + def test_timedelta_arithmetic(self): + data = pd.Series(['nat', '32 days'], dtype='timedelta64[ns]') + deltas = [timedelta(days=1), Timedelta(1, unit='D')] + for delta in deltas: + result_method = data.add(delta) + result_operator = data + delta + expected = pd.Series(['nat', '33 days'], dtype='timedelta64[ns]') + tm.assert_series_equal(result_operator, expected) + tm.assert_series_equal(result_method, expected) + + result_method = data.sub(delta) + result_operator = data - delta + expected = pd.Series(['nat', '31 days'], dtype='timedelta64[ns]') + tm.assert_series_equal(result_operator, expected) + tm.assert_series_equal(result_method, expected) + # GH 9396 + result_method = data.div(delta) + result_operator = data / delta + expected = pd.Series([np.nan, 32.], dtype='float64') + tm.assert_series_equal(result_operator, expected) + tm.assert_series_equal(result_method, expected) + class TestTimedeltaIndex(tm.TestCase): _multiprocess_can_split_ = True From a71896259e5538590117c5e35909b0a58495d2df Mon Sep 17 00:00:00 2001 From: Matthew Roeschke Date: Sun, 18 Dec 2016 12:24:11 -0800 Subject: [PATCH 21/51] TST: Groupby/transform with grouped NaN (#9941) (#14907) --- pandas/tests/groupby/test_groupby.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py index 97e1f7dc94866..f8d9d73590a60 100644 --- a/pandas/tests/groupby/test_groupby.py +++ b/pandas/tests/groupby/test_groupby.py @@ -1374,6 +1374,15 @@ def test_groupby_transform_with_int(self): expected = DataFrame(dict(B=1, C=[2, 3, 4, 10, 5, -1])) assert_frame_equal(result, expected) + def test_groupby_transform_with_nan_group(self): + # GH 9941 + df = pd.DataFrame({'a': range(10), + 'b': [1, 1, 2, 3, np.nan, 4, 4, 5, 5, 5]}) + result = df.groupby(df.b)['a'].transform(max) + expected = pd.Series([1., 1., 2., 3., np.nan, 6., 6., 9., 9., 9.], + name='a') + assert_series_equal(result, expected) + def test_indices_concatenation_order(self): # GH 2808 From f1cfe5b4eb614f9b4e201e764e9bd25f2389b355 Mon Sep 17 00:00:00 2001 From: Jeff Reback Date: Sun, 18 Dec 2016 15:28:35 -0500 Subject: [PATCH 22/51] CLN: remove simple _DATELIKE_DTYPES test and replace with is_datetimelike accessor this was some older code Author: Jeff Reback Closes #14909 from jreback/clean_datelike and squashes the following commits: 58ff2c4 [Jeff Reback] CLN: remove simple _DATELIKE_DTYPES test and replace with is_datetimelike accessor --- pandas/core/groupby.py | 8 ++++---- pandas/types/cast.py | 7 ++++--- pandas/types/common.py | 7 ++----- pandas/types/missing.py | 5 ++--- 4 files changed, 12 insertions(+), 15 deletions(-) diff --git a/pandas/core/groupby.py b/pandas/core/groupby.py index b249cded39133..950ad53abe5e0 100644 --- a/pandas/core/groupby.py +++ b/pandas/core/groupby.py @@ -14,10 +14,10 @@ from pandas.compat.numpy import function as nv from pandas.compat.numpy import _np_version_under1p8 -from pandas.types.common import (_DATELIKE_DTYPES, - is_numeric_dtype, +from pandas.types.common import (is_numeric_dtype, is_timedelta64_dtype, is_datetime64_dtype, is_categorical_dtype, + is_datetimelike, is_datetime_or_timedelta_dtype, is_bool, is_integer_dtype, is_complex_dtype, @@ -3453,10 +3453,10 @@ def first_non_None_value(values): # if we have date/time like in the original, then coerce dates # as we are stacking can easily have object dtypes here so = self._selected_obj - if (so.ndim == 2 and so.dtypes.isin(_DATELIKE_DTYPES).any()): + if (so.ndim == 2 and so.dtypes.apply(is_datetimelike).any()): result = result._convert(numeric=True) date_cols = self._selected_obj.select_dtypes( - include=list(_DATELIKE_DTYPES)).columns + include=['datetime', 'timedelta']).columns date_cols = date_cols.intersection(result.columns) result[date_cols] = (result[date_cols] ._convert(datetime=True, diff --git a/pandas/types/cast.py b/pandas/types/cast.py index d4beab5655e5c..4f4f95d5a455b 100644 --- a/pandas/types/cast.py +++ b/pandas/types/cast.py @@ -7,6 +7,7 @@ from pandas.compat import string_types, text_type, PY3 from .common import (_ensure_object, is_bool, is_integer, is_float, is_complex, is_datetimetz, is_categorical_dtype, + is_datetimelike, is_extension_type, is_object_dtype, is_datetime64tz_dtype, is_datetime64_dtype, is_timedelta64_dtype, is_dtype_equal, @@ -18,7 +19,7 @@ _ensure_int8, _ensure_int16, _ensure_int32, _ensure_int64, _NS_DTYPE, _TD_DTYPE, _INT64_DTYPE, - _DATELIKE_DTYPES, _POSSIBLY_CAST_DTYPES) + _POSSIBLY_CAST_DTYPES) from .dtypes import ExtensionDtype from .generic import ABCDatetimeIndex, ABCPeriodIndex, ABCSeries from .missing import isnull, notnull @@ -164,7 +165,7 @@ def _maybe_upcast_putmask(result, mask, other): # in np.place: # NaN -> NaT # integer or integer array -> date-like array - if result.dtype in _DATELIKE_DTYPES: + if is_datetimelike(result.dtype): if is_scalar(other): if isnull(other): other = result.dtype.type('nat') @@ -666,7 +667,7 @@ def _possibly_castable(arr): # otherwise try to coerce kind = arr.dtype.kind if kind == 'M' or kind == 'm': - return arr.dtype in _DATELIKE_DTYPES + return is_datetime64_dtype(arr.dtype) return arr.dtype.name not in _POSSIBLY_CAST_DTYPES diff --git a/pandas/types/common.py b/pandas/types/common.py index 5d161efa838de..b9d4c112c00d6 100644 --- a/pandas/types/common.py +++ b/pandas/types/common.py @@ -23,10 +23,6 @@ _TD_DTYPE = np.dtype('m8[ns]') _INT64_DTYPE = np.dtype(np.int64) -_DATELIKE_DTYPES = set([np.dtype(t) - for t in ['M8[ns]', 'M8[ns]', - 'm8[ns]', 'm8[ns]']]) - _ensure_float64 = algos.ensure_float64 _ensure_float32 = algos.ensure_float32 @@ -127,7 +123,8 @@ def is_datetime_arraylike(arr): def is_datetimelike(arr): - return (arr.dtype in _DATELIKE_DTYPES or + return (is_datetime64_dtype(arr) or is_datetime64tz_dtype(arr) or + is_timedelta64_dtype(arr) or isinstance(arr, ABCPeriodIndex) or is_datetimetz(arr)) diff --git a/pandas/types/missing.py b/pandas/types/missing.py index a4af127e0c381..e6791b79bf3bd 100644 --- a/pandas/types/missing.py +++ b/pandas/types/missing.py @@ -19,8 +19,7 @@ is_object_dtype, is_integer, _TD_DTYPE, - _NS_DTYPE, - _DATELIKE_DTYPES) + _NS_DTYPE) from .inference import is_list_like @@ -169,7 +168,7 @@ def _isnull_ndarraylike_old(obj): vec = lib.isnullobj_old(values.ravel()) result[:] = vec.reshape(shape) - elif dtype in _DATELIKE_DTYPES: + elif is_datetime64_dtype(dtype): # this is the NaT pattern result = values.view('i8') == iNaT else: From 8b98104c96eac0590718370e67f5551b09e54f11 Mon Sep 17 00:00:00 2001 From: Jeff Reback Date: Mon, 19 Dec 2016 06:02:26 -0500 Subject: [PATCH 23/51] ENH: select_dtypes now allows 'datetimetz' for generically selecting datetimes with timezones (#14910) --- doc/source/whatsnew/v0.20.0.txt | 2 +- pandas/core/frame.py | 5 +++++ pandas/tests/frame/test_dtypes.py | 37 +++++++++++++++++++++++++++++-- pandas/types/common.py | 5 +++++ 4 files changed, 46 insertions(+), 3 deletions(-) diff --git a/doc/source/whatsnew/v0.20.0.txt b/doc/source/whatsnew/v0.20.0.txt index 76ba4a5f723fa..3eb8acdd300b5 100644 --- a/doc/source/whatsnew/v0.20.0.txt +++ b/doc/source/whatsnew/v0.20.0.txt @@ -106,6 +106,7 @@ Other enhancements - ``pd.Series.interpolate`` now supports timedelta as an index type with ``method='time'`` (:issue:`6424`) - ``pandas.io.json.json_normalize()`` gained the option ``errors='ignore'|'raise'``; the default is ``errors='raise'`` which is backward compatible. (:issue:`14583`) +- ``.select_dtypes()`` now allows `datetimetz` to generically select datetimes with tz (:issue:`14910`) .. _whatsnew_0200.api_breaking: @@ -249,5 +250,4 @@ Bug Fixes - - Require at least 0.23 version of cython to avoid problems with character encodings (:issue:`14699`) diff --git a/pandas/core/frame.py b/pandas/core/frame.py index 78d0f47d473c8..7305df0f57736 100644 --- a/pandas/core/frame.py +++ b/pandas/core/frame.py @@ -2257,7 +2257,12 @@ def select_dtypes(self, include=None, exclude=None): this will return *all* object dtype columns * See the `numpy dtype hierarchy `__ + * To select datetimes, use np.datetime64, 'datetime' or 'datetime64' + * To select timedeltas, use np.timedelta64, 'timedelta' or + 'timedelta64' * To select Pandas categorical dtypes, use 'category' + * To select Pandas datetimetz dtypes, use 'datetimetz' (new in 0.20.0), + or a 'datetime64[ns, tz]' string Examples -------- diff --git a/pandas/tests/frame/test_dtypes.py b/pandas/tests/frame/test_dtypes.py index 61030c262a44b..43a108e9acc80 100644 --- a/pandas/tests/frame/test_dtypes.py +++ b/pandas/tests/frame/test_dtypes.py @@ -109,15 +109,48 @@ def test_select_dtypes_include(self): 'c': np.arange(3, 6).astype('u1'), 'd': np.arange(4.0, 7.0, dtype='float64'), 'e': [True, False, True], - 'f': pd.Categorical(list('abc'))}) + 'f': pd.Categorical(list('abc')), + 'g': pd.date_range('20130101', periods=3), + 'h': pd.date_range('20130101', periods=3, + tz='US/Eastern'), + 'i': pd.date_range('20130101', periods=3, + tz='CET'), + 'j': pd.period_range('2013-01', periods=3, + freq='M'), + 'k': pd.timedelta_range('1 day', periods=3)}) + ri = df.select_dtypes(include=[np.number]) + ei = df[['b', 'c', 'd', 'k']] + assert_frame_equal(ri, ei) + + ri = df.select_dtypes(include=[np.number], exclude=['timedelta']) ei = df[['b', 'c', 'd']] assert_frame_equal(ri, ei) - ri = df.select_dtypes(include=[np.number, 'category']) + ri = df.select_dtypes(include=[np.number, 'category'], + exclude=['timedelta']) ei = df[['b', 'c', 'd', 'f']] assert_frame_equal(ri, ei) + ri = df.select_dtypes(include=['datetime']) + ei = df[['g']] + assert_frame_equal(ri, ei) + + ri = df.select_dtypes(include=['datetime64']) + ei = df[['g']] + assert_frame_equal(ri, ei) + + ri = df.select_dtypes(include=['datetimetz']) + ei = df[['h', 'i']] + assert_frame_equal(ri, ei) + + ri = df.select_dtypes(include=['timedelta']) + ei = df[['k']] + assert_frame_equal(ri, ei) + + self.assertRaises(NotImplementedError, + lambda: df.select_dtypes(include=['period'])) + def test_select_dtypes_exclude(self): df = DataFrame({'a': list('abc'), 'b': list(range(1, 4)), diff --git a/pandas/types/common.py b/pandas/types/common.py index b9d4c112c00d6..a7ba96f95e31b 100644 --- a/pandas/types/common.py +++ b/pandas/types/common.py @@ -400,6 +400,11 @@ def _get_dtype_from_object(dtype): pass return dtype.type elif isinstance(dtype, string_types): + if dtype in ['datetimetz', 'datetime64tz']: + return DatetimeTZDtype.type + elif dtype in ['period']: + raise NotImplementedError + if dtype == 'datetime' or dtype == 'timedelta': dtype += '64' From 8c798c085a1e60b1caa059053e68ea6d9a753acc Mon Sep 17 00:00:00 2001 From: Matthew Roeschke Date: Mon, 19 Dec 2016 03:20:42 -0800 Subject: [PATCH 24/51] TST:Test to_sparse with nan dataframe (#10079) (#14913) --- pandas/sparse/tests/test_frame.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/pandas/sparse/tests/test_frame.py b/pandas/sparse/tests/test_frame.py index 5cc765a2c1cf3..ab12099b5624d 100644 --- a/pandas/sparse/tests/test_frame.py +++ b/pandas/sparse/tests/test_frame.py @@ -215,6 +215,21 @@ def test_constructor_preserve_attr(self): self.assertEqual(df['x'].dtype, np.int64) self.assertEqual(df['x'].fill_value, 0) + def test_constructor_nan_dataframe(self): + # GH 10079 + trains = np.arange(100) + tresholds = [10, 20, 30, 40, 50, 60] + tuples = [(i, j) for i in trains for j in tresholds] + index = pd.MultiIndex.from_tuples(tuples, + names=['trains', 'tresholds']) + matrix = np.empty((len(index), len(trains))) + matrix.fill(np.nan) + df = pd.DataFrame(matrix, index=index, columns=trains, dtype=float) + result = df.to_sparse() + expected = pd.SparseDataFrame(matrix, index=index, columns=trains, + dtype=float) + tm.assert_sp_frame_equal(result, expected) + def test_dtypes(self): df = DataFrame(np.random.randn(10000, 4)) df.ix[:9998] = np.nan From dc4b0708f36b971f71890bfdf830d9a5dc019c7b Mon Sep 17 00:00:00 2001 From: Tom Augspurger Date: Mon, 19 Dec 2016 07:45:02 -0500 Subject: [PATCH 25/51] COMPAT/REF: Use s3fs for s3 IO closes #11915 Author: Tom Augspurger Closes #13137 from TomAugspurger/s3fs and squashes the following commits: 92ac063 [Tom Augspurger] CI: Update deps, docs 81690b5 [Tom Augspurger] COMPAT/REF: Use s3fs for s3 IO --- asv_bench/benchmarks/io_bench.py | 2 +- ci/requirements-2.7-64.run | 2 +- ci/requirements-2.7.run | 2 +- ci/requirements-2.7_SLOW.run | 2 +- ci/requirements-3.5.run | 2 +- ci/requirements-3.5_OSX.run | 2 +- doc/source/install.rst | 2 +- doc/source/io.rst | 17 ++++ doc/source/whatsnew/v0.20.0.txt | 13 ++- pandas/io/common.py | 16 ++-- pandas/io/s3.py | 111 ++++--------------------- pandas/io/tests/parser/test_network.py | 11 +-- pandas/io/tests/test_excel.py | 8 +- pandas/util/print_versions.py | 2 +- 14 files changed, 72 insertions(+), 120 deletions(-) diff --git a/asv_bench/benchmarks/io_bench.py b/asv_bench/benchmarks/io_bench.py index 0f15ab6e5e142..2ce3c4726b783 100644 --- a/asv_bench/benchmarks/io_bench.py +++ b/asv_bench/benchmarks/io_bench.py @@ -153,7 +153,7 @@ def setup(self, compression, engine): # The Python 2 C parser can't read bz2 from open files. raise NotImplementedError try: - import boto + import s3fs except ImportError: # Skip these benchmarks if `boto` is not installed. raise NotImplementedError diff --git a/ci/requirements-2.7-64.run b/ci/requirements-2.7-64.run index 42b5a789ae31a..94472dafd565d 100644 --- a/ci/requirements-2.7-64.run +++ b/ci/requirements-2.7-64.run @@ -11,7 +11,7 @@ sqlalchemy lxml=3.2.1 scipy xlsxwriter -boto +s3fs bottleneck html5lib beautiful-soup diff --git a/ci/requirements-2.7.run b/ci/requirements-2.7.run index 560d6571b8771..2bfb8a3777fdf 100644 --- a/ci/requirements-2.7.run +++ b/ci/requirements-2.7.run @@ -11,7 +11,7 @@ sqlalchemy=0.9.6 lxml=3.2.1 scipy xlsxwriter=0.4.6 -boto=2.36.0 +s3fs bottleneck psycopg2=2.5.2 patsy diff --git a/ci/requirements-2.7_SLOW.run b/ci/requirements-2.7_SLOW.run index f02a7cb8a309a..630d22636f284 100644 --- a/ci/requirements-2.7_SLOW.run +++ b/ci/requirements-2.7_SLOW.run @@ -13,7 +13,7 @@ numexpr pytables sqlalchemy lxml -boto +s3fs bottleneck psycopg2 pymysql diff --git a/ci/requirements-3.5.run b/ci/requirements-3.5.run index 333641caf26c4..1d1cb38fd57a6 100644 --- a/ci/requirements-3.5.run +++ b/ci/requirements-3.5.run @@ -17,7 +17,7 @@ sqlalchemy pymysql psycopg2 xarray -boto +s3fs # incompat with conda ATM # beautiful-soup diff --git a/ci/requirements-3.5_OSX.run b/ci/requirements-3.5_OSX.run index ffa291ab7ff77..eceb2f9cdcebc 100644 --- a/ci/requirements-3.5_OSX.run +++ b/ci/requirements-3.5_OSX.run @@ -12,7 +12,7 @@ matplotlib jinja2 bottleneck xarray -boto +s3fs # incompat with conda ATM # beautiful-soup diff --git a/doc/source/install.rst b/doc/source/install.rst index d45b8765cfd8a..f62342fa52e5c 100644 --- a/doc/source/install.rst +++ b/doc/source/install.rst @@ -262,7 +262,7 @@ Optional Dependencies * `XlsxWriter `__: Alternative Excel writer * `Jinja2 `__: Template engine for conditional HTML formatting. -* `boto `__: necessary for Amazon S3 access. +* `s3fs `__: necessary for Amazon S3 access (s3fs >= 0.0.7). * `blosc `__: for msgpack compression using ``blosc`` * One of `PyQt4 `__, `PySide diff --git a/doc/source/io.rst b/doc/source/io.rst index 945b738e52480..9d51d2599d668 100644 --- a/doc/source/io.rst +++ b/doc/source/io.rst @@ -1487,6 +1487,23 @@ options include: Specifying any of the above options will produce a ``ParserWarning`` unless the python engine is selected explicitly using ``engine='python'``. +Reading remote files +'''''''''''''''''''' + +You can pass in a URL to a CSV file: + +.. code-block:: python + + df = pd.read_csv('https://download.bls.gov/pub/time.series/cu/cu.item', + sep='\t') + +S3 URLs are handled as well: + +.. code-block:: python + + df = pd.read_csv('s3://pandas-test/tips.csv') + + Writing out Data '''''''''''''''' diff --git a/doc/source/whatsnew/v0.20.0.txt b/doc/source/whatsnew/v0.20.0.txt index 3eb8acdd300b5..3884aa29dfe7b 100644 --- a/doc/source/whatsnew/v0.20.0.txt +++ b/doc/source/whatsnew/v0.20.0.txt @@ -108,12 +108,12 @@ Other enhancements - ``.select_dtypes()`` now allows `datetimetz` to generically select datetimes with tz (:issue:`14910`) + .. _whatsnew_0200.api_breaking: Backwards incompatible API changes ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - .. _whatsnew.api_breaking.index_map Map on Index types now return other Index types @@ -182,8 +182,16 @@ Map on Index types now return other Index types s.map(lambda x: x.hour) +.. _whatsnew_0200.s3: + +S3 File Handling +^^^^^^^^^^^^^^^^ - .. _whatsnew_0200.api: +pandas now uses `s3fs `_ for handling S3 connections. This shouldn't break +any code. However, since s3fs is not a required dependency, you will need to install it separately (like boto +in prior versions of pandas) (:issue:`11915`). + +.. _whatsnew_0200.api: - ``CParserError`` has been renamed to ``ParserError`` in ``pd.read_csv`` and will be removed in the future (:issue:`12665`) - ``SparseArray.cumsum()`` and ``SparseSeries.cumsum()`` will now always return ``SparseArray`` and ``SparseSeries`` respectively (:issue:`12855`) @@ -194,7 +202,6 @@ Map on Index types now return other Index types Other API Changes ^^^^^^^^^^^^^^^^^ - .. _whatsnew_0200.deprecations: Deprecations diff --git a/pandas/io/common.py b/pandas/io/common.py index fa1022b882124..6817c824ad786 100644 --- a/pandas/io/common.py +++ b/pandas/io/common.py @@ -12,6 +12,12 @@ from pandas.core.common import AbstractMethodError from pandas.types.common import is_number +try: + from s3fs import S3File + need_text_wrapping = (BytesIO, S3File) +except ImportError: + need_text_wrapping = (BytesIO,) + # common NA values # no longer excluding inf representations # '1.#INF','-1.#INF', '1.#INF000000', @@ -212,10 +218,10 @@ def get_filepath_or_buffer(filepath_or_buffer, encoding=None, return reader, encoding, compression if _is_s3_url(filepath_or_buffer): - from pandas.io.s3 import get_filepath_or_buffer - return get_filepath_or_buffer(filepath_or_buffer, - encoding=encoding, - compression=compression) + from pandas.io import s3 + return s3.get_filepath_or_buffer(filepath_or_buffer, + encoding=encoding, + compression=compression) # It is a pathlib.Path/py.path.local or string filepath_or_buffer = _stringify_path(filepath_or_buffer) @@ -391,7 +397,7 @@ def _get_handle(path_or_buf, mode, encoding=None, compression=None, handles.append(f) # in Python 3, convert BytesIO or fileobjects passed with an encoding - if compat.PY3 and (compression or isinstance(f, compat.BytesIO)): + if compat.PY3 and (compression or isinstance(f, need_text_wrapping)): from io import TextIOWrapper f = TextIOWrapper(f, encoding=encoding) handles.append(f) diff --git a/pandas/io/s3.py b/pandas/io/s3.py index 8aa3694834a0a..5e48de757d00e 100644 --- a/pandas/io/s3.py +++ b/pandas/io/s3.py @@ -1,14 +1,10 @@ """ s3 support for remote file interactivity """ - -import os from pandas import compat -from pandas.compat import BytesIO - try: - import boto - from boto.s3 import key + import s3fs + from botocore.exceptions import NoCredentialsError except: - raise ImportError("boto is required to handle s3 files") + raise ImportError("The s3fs library is required to handle s3 files") if compat.PY3: from urllib.parse import urlparse as parse_url @@ -16,95 +12,24 @@ from urlparse import urlparse as parse_url -class BotoFileLikeReader(key.Key): - """boto Key modified to be more file-like - - This modification of the boto Key will read through a supplied - S3 key once, then stop. The unmodified boto Key object will repeatedly - cycle through a file in S3: after reaching the end of the file, - boto will close the file. Then the next call to `read` or `next` will - re-open the file and start reading from the beginning. - - Also adds a `readline` function which will split the returned - values by the `\n` character. - """ - - def __init__(self, *args, **kwargs): - encoding = kwargs.pop("encoding", None) # Python 2 compat - super(BotoFileLikeReader, self).__init__(*args, **kwargs) - # Add a flag to mark the end of the read. - self.finished_read = False - self.buffer = "" - self.lines = [] - if encoding is None and compat.PY3: - encoding = "utf-8" - self.encoding = encoding - self.lines = [] - - def next(self): - return self.readline() - - __next__ = next - - def read(self, *args, **kwargs): - if self.finished_read: - return b'' if compat.PY3 else '' - return super(BotoFileLikeReader, self).read(*args, **kwargs) - - def close(self, *args, **kwargs): - self.finished_read = True - return super(BotoFileLikeReader, self).close(*args, **kwargs) - - def seekable(self): - """Needed for reading by bz2""" - return False - - def readline(self): - """Split the contents of the Key by '\n' characters.""" - if self.lines: - retval = self.lines[0] - self.lines = self.lines[1:] - return retval - if self.finished_read: - if self.buffer: - retval, self.buffer = self.buffer, "" - return retval - else: - raise StopIteration - - if self.encoding: - self.buffer = "{}{}".format( - self.buffer, self.read(8192).decode(self.encoding)) - else: - self.buffer = "{}{}".format(self.buffer, self.read(8192)) - - split_buffer = self.buffer.split("\n") - self.lines.extend(split_buffer[:-1]) - self.buffer = split_buffer[-1] - - return self.readline() +def _strip_schema(url): + """Returns the url without the s3:// part""" + result = parse_url(url) + return result.netloc + result.path def get_filepath_or_buffer(filepath_or_buffer, encoding=None, compression=None): - - # Assuming AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY and AWS_S3_HOST - # are environment variables - parsed_url = parse_url(filepath_or_buffer) - s3_host = os.environ.get('AWS_S3_HOST', 's3.amazonaws.com') - + fs = s3fs.S3FileSystem(anon=False) try: - conn = boto.connect_s3(host=s3_host) - except boto.exception.NoAuthHandlerFound: - conn = boto.connect_s3(host=s3_host, anon=True) - - b = conn.get_bucket(parsed_url.netloc, validate=False) - if compat.PY2 and compression: - k = boto.s3.key.Key(b, parsed_url.path) - filepath_or_buffer = BytesIO(k.get_contents_as_string( - encoding=encoding)) - else: - k = BotoFileLikeReader(b, parsed_url.path, encoding=encoding) - k.open('r') # Expose read errors immediately - filepath_or_buffer = k + filepath_or_buffer = fs.open(_strip_schema(filepath_or_buffer)) + except (OSError, NoCredentialsError): + # boto3 has troubles when trying to access a public file + # when credentialed... + # An OSError is raised if you have credentials, but they + # aren't valid for that bucket. + # A NoCredentialsError is raised if you don't have creds + # for that bucket. + fs = s3fs.S3FileSystem(anon=True) + filepath_or_buffer = fs.open(_strip_schema(filepath_or_buffer)) return filepath_or_buffer, None, compression diff --git a/pandas/io/tests/parser/test_network.py b/pandas/io/tests/parser/test_network.py index 4258749b8d897..8e71cf1cc7e4c 100644 --- a/pandas/io/tests/parser/test_network.py +++ b/pandas/io/tests/parser/test_network.py @@ -56,9 +56,9 @@ class TestS3(tm.TestCase): def setUp(self): try: - import boto # noqa + import s3fs # noqa except ImportError: - raise nose.SkipTest("boto not installed") + raise nose.SkipTest("s3fs not installed") @tm.network def test_parse_public_s3_bucket(self): @@ -174,15 +174,12 @@ def test_parse_public_s3_bucket_nrows_python(self): @tm.network def test_s3_fails(self): - import boto - with tm.assertRaisesRegexp(boto.exception.S3ResponseError, - 'S3ResponseError: 404 Not Found'): + with tm.assertRaises(IOError): read_csv('s3://nyqpug/asdf.csv') # Receive a permission error when trying to read a private bucket. # It's irrelevant here that this isn't actually a table. - with tm.assertRaisesRegexp(boto.exception.S3ResponseError, - 'S3ResponseError: 403 Forbidden'): + with tm.assertRaises(IOError): read_csv('s3://cant_get_it/') if __name__ == '__main__': diff --git a/pandas/io/tests/test_excel.py b/pandas/io/tests/test_excel.py index 7a1b5655cfbf7..8db0e6202f7fc 100644 --- a/pandas/io/tests/test_excel.py +++ b/pandas/io/tests/test_excel.py @@ -64,11 +64,11 @@ def _skip_if_no_excelsuite(): _skip_if_no_openpyxl() -def _skip_if_no_boto(): +def _skip_if_no_s3fs(): try: - import boto # NOQA + import s3fs # noqa except ImportError: - raise nose.SkipTest('boto not installed, skipping') + raise nose.SkipTest('s3fs not installed, skipping') _seriesd = tm.getSeriesData() @@ -582,7 +582,7 @@ def test_read_from_http_url(self): @tm.network(check_before_test=True) def test_read_from_s3_url(self): - _skip_if_no_boto() + _skip_if_no_s3fs() url = ('s3://pandas-test/test1' + self.ext) url_table = read_excel(url) diff --git a/pandas/util/print_versions.py b/pandas/util/print_versions.py index 3747e2ff6ca8f..657681d4c33ce 100644 --- a/pandas/util/print_versions.py +++ b/pandas/util/print_versions.py @@ -94,7 +94,7 @@ def show_versions(as_json=False): ("pymysql", lambda mod: mod.__version__), ("psycopg2", lambda mod: mod.__version__), ("jinja2", lambda mod: mod.__version__), - ("boto", lambda mod: mod.__version__), + ("s3fs", lambda mod: mod.__version__), ("pandas_datareader", lambda mod: mod.__version__) ] From 39efbbce6e20a48b37809393714788bf67db8067 Mon Sep 17 00:00:00 2001 From: Jeff Reback Date: Mon, 19 Dec 2016 09:03:00 -0500 Subject: [PATCH 26/51] CLN: move unique1d to algorithms from nanops (#14919) TST: consolidate hashtable testing to test_algos.py --- pandas/core/algorithms.py | 32 ++++++++++++++++++++++ pandas/core/base.py | 2 +- pandas/core/categorical.py | 3 +-- pandas/core/nanops.py | 29 +------------------- pandas/tests/test_algos.py | 55 +++++++++++++++++++++++--------------- pandas/tests/test_base.py | 11 -------- pandas/tseries/util.py | 4 +-- 7 files changed, 70 insertions(+), 66 deletions(-) diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py index b2702ea0acca7..6bcd3776867b6 100644 --- a/pandas/core/algorithms.py +++ b/pandas/core/algorithms.py @@ -113,6 +113,38 @@ def _unique_generic(values, table_type, type_caster): return type_caster(uniques) +def unique1d(values): + """ + Hash table-based unique + """ + if np.issubdtype(values.dtype, np.floating): + table = htable.Float64HashTable(len(values)) + uniques = np.array(table.unique(_ensure_float64(values)), + dtype=np.float64) + elif np.issubdtype(values.dtype, np.datetime64): + table = htable.Int64HashTable(len(values)) + uniques = table.unique(_ensure_int64(values)) + uniques = uniques.view('M8[ns]') + elif np.issubdtype(values.dtype, np.timedelta64): + table = htable.Int64HashTable(len(values)) + uniques = table.unique(_ensure_int64(values)) + uniques = uniques.view('m8[ns]') + elif np.issubdtype(values.dtype, np.integer): + table = htable.Int64HashTable(len(values)) + uniques = table.unique(_ensure_int64(values)) + else: + + # its cheaper to use a String Hash Table than Object + if lib.infer_dtype(values) in ['string']: + table = htable.StringHashTable(len(values)) + else: + table = htable.PyObjectHashTable(len(values)) + + uniques = table.unique(_ensure_object(values)) + + return uniques + + def isin(comps, values): """ Compute the isin boolean array diff --git a/pandas/core/base.py b/pandas/core/base.py index d412349447794..a0365ce484a5a 100644 --- a/pandas/core/base.py +++ b/pandas/core/base.py @@ -969,7 +969,7 @@ def unique(self): if hasattr(values, 'unique'): result = values.unique() else: - from pandas.core.nanops import unique1d + from pandas.core.algorithms import unique1d result = unique1d(values) return result diff --git a/pandas/core/categorical.py b/pandas/core/categorical.py index 5124dc44e2fc8..7f2e6093d0f4c 100644 --- a/pandas/core/categorical.py +++ b/pandas/core/categorical.py @@ -25,7 +25,7 @@ is_scalar) from pandas.core.common import is_null_slice -from pandas.core.algorithms import factorize, take_1d +from pandas.core.algorithms import factorize, take_1d, unique1d from pandas.core.base import (PandasObject, PandasDelegate, NoNewAttributesMixin, _shared_docs) import pandas.core.common as com @@ -1834,7 +1834,6 @@ def unique(self): unique values : ``Categorical`` """ - from pandas.core.nanops import unique1d # unlike np.unique, unique1d does not sort unique_codes = unique1d(self.codes) cat = self.copy() diff --git a/pandas/core/nanops.py b/pandas/core/nanops.py index a76e348b7dee2..1f76bc850cee9 100644 --- a/pandas/core/nanops.py +++ b/pandas/core/nanops.py @@ -9,10 +9,8 @@ except ImportError: # pragma: no cover _USE_BOTTLENECK = False -import pandas.hashtable as _hash from pandas import compat, lib, algos, tslib -from pandas.types.common import (_ensure_int64, _ensure_object, - _ensure_float64, _get_dtype, +from pandas.types.common import (_get_dtype, is_float, is_scalar, is_integer, is_complex, is_float_dtype, is_complex_dtype, is_integer_dtype, @@ -784,28 +782,3 @@ def f(x, y): nanle = make_nancomp(operator.le) naneq = make_nancomp(operator.eq) nanne = make_nancomp(operator.ne) - - -def unique1d(values): - """ - Hash table-based unique - """ - if np.issubdtype(values.dtype, np.floating): - table = _hash.Float64HashTable(len(values)) - uniques = np.array(table.unique(_ensure_float64(values)), - dtype=np.float64) - elif np.issubdtype(values.dtype, np.datetime64): - table = _hash.Int64HashTable(len(values)) - uniques = table.unique(_ensure_int64(values)) - uniques = uniques.view('M8[ns]') - elif np.issubdtype(values.dtype, np.timedelta64): - table = _hash.Int64HashTable(len(values)) - uniques = table.unique(_ensure_int64(values)) - uniques = uniques.view('m8[ns]') - elif np.issubdtype(values.dtype, np.integer): - table = _hash.Int64HashTable(len(values)) - uniques = table.unique(_ensure_int64(values)) - else: - table = _hash.PyObjectHashTable(len(values)) - uniques = table.unique(_ensure_object(values)) - return uniques diff --git a/pandas/tests/test_algos.py b/pandas/tests/test_algos.py index d0c909b9c1b30..92a9184ad30fc 100644 --- a/pandas/tests/test_algos.py +++ b/pandas/tests/test_algos.py @@ -277,28 +277,6 @@ def test_factorize_nan(self): self.assertTrue( np.array_equal(pd.isnull(key), expected == na_sentinel)) - def test_vector_resize(self): - # Test for memory errors after internal vector - # reallocations (pull request #7157) - - def _test_vector_resize(htable, uniques, dtype, nvals): - vals = np.array(np.random.randn(1000), dtype=dtype) - # get_labels appends to the vector - htable.get_labels(vals[:nvals], uniques, 0, -1) - # to_array resizes the vector - uniques.to_array() - htable.get_labels(vals, uniques, 0, -1) - - test_cases = [ - (hashtable.PyObjectHashTable, hashtable.ObjectVector, 'object'), - (hashtable.Float64HashTable, hashtable.Float64Vector, 'float64'), - (hashtable.Int64HashTable, hashtable.Int64Vector, 'int64')] - - for (tbl, vect, dtype) in test_cases: - # resizing to empty is a special case - _test_vector_resize(tbl(), vect(), dtype, 0) - _test_vector_resize(tbl(), vect(), dtype, 10) - def test_complex_sorting(self): # gh 12666 - check no segfault # Test not valid numpy versions older than 1.11 @@ -912,6 +890,39 @@ class TestGroupVarFloat32(tm.TestCase, GroupVarTestMixin): rtol = 1e-2 +class TestHashTable(tm.TestCase): + + def test_lookup_nan(self): + xs = np.array([2.718, 3.14, np.nan, -7, 5, 2, 3]) + m = hashtable.Float64HashTable() + m.map_locations(xs) + self.assert_numpy_array_equal(m.lookup(xs), + np.arange(len(xs), dtype=np.int64)) + + def test_vector_resize(self): + # Test for memory errors after internal vector + # reallocations (pull request #7157) + + def _test_vector_resize(htable, uniques, dtype, nvals): + vals = np.array(np.random.randn(1000), dtype=dtype) + # get_labels appends to the vector + htable.get_labels(vals[:nvals], uniques, 0, -1) + # to_array resizes the vector + uniques.to_array() + htable.get_labels(vals, uniques, 0, -1) + + test_cases = [ + (hashtable.PyObjectHashTable, hashtable.ObjectVector, 'object'), + (hashtable.StringHashTable, hashtable.ObjectVector, 'object'), + (hashtable.Float64HashTable, hashtable.Float64Vector, 'float64'), + (hashtable.Int64HashTable, hashtable.Int64Vector, 'int64')] + + for (tbl, vect, dtype) in test_cases: + # resizing to empty is a special case + _test_vector_resize(tbl(), vect(), dtype, 0) + _test_vector_resize(tbl(), vect(), dtype, 10) + + def test_quantile(): s = Series(np.random.randn(100)) diff --git a/pandas/tests/test_base.py b/pandas/tests/test_base.py index a5cd0bbc28369..717eae3e59715 100644 --- a/pandas/tests/test_base.py +++ b/pandas/tests/test_base.py @@ -1051,17 +1051,6 @@ def test_searchsorted(self): self.assertTrue(0 <= index <= len(o)) -class TestFloat64HashTable(tm.TestCase): - - def test_lookup_nan(self): - from pandas.hashtable import Float64HashTable - xs = np.array([2.718, 3.14, np.nan, -7, 5, 2, 3]) - m = Float64HashTable() - m.map_locations(xs) - self.assert_numpy_array_equal(m.lookup(xs), - np.arange(len(xs), dtype=np.int64)) - - class TestTranspose(Ops): errmsg = "the 'axes' parameter is not supported" diff --git a/pandas/tseries/util.py b/pandas/tseries/util.py index 59daa8d7780b4..dc460dee8415b 100644 --- a/pandas/tseries/util.py +++ b/pandas/tseries/util.py @@ -4,7 +4,7 @@ import numpy as np from pandas.types.common import _ensure_platform_int from pandas.core.frame import DataFrame -import pandas.core.nanops as nanops +import pandas.core.algorithms as algorithms def pivot_annual(series, freq=None): @@ -45,7 +45,7 @@ def pivot_annual(series, freq=None): index = series.index year = index.year - years = nanops.unique1d(year) + years = algorithms.unique1d(year) if freq is not None: freq = freq.upper() From 0ac3d98fa000bc4fa33b8a3c74d087f0106c57bb Mon Sep 17 00:00:00 2001 From: gfyoung Date: Mon, 19 Dec 2016 11:59:50 -0500 Subject: [PATCH 27/51] BUG: Don't convert uint64 to object in DataFrame init (#14917) The hack used to resolve gh-2355 is no longer needed. Removes the hack and patches several tests that relied on this hacky (and buggy) behavior. Closes gh-14881. --- doc/source/whatsnew/v0.20.0.txt | 1 + pandas/core/internals.py | 5 ----- pandas/tests/frame/test_constructors.py | 7 ++++--- pandas/tests/frame/test_operators.py | 8 ++++---- 4 files changed, 9 insertions(+), 12 deletions(-) diff --git a/doc/source/whatsnew/v0.20.0.txt b/doc/source/whatsnew/v0.20.0.txt index 3884aa29dfe7b..b52026b0798a6 100644 --- a/doc/source/whatsnew/v0.20.0.txt +++ b/doc/source/whatsnew/v0.20.0.txt @@ -243,6 +243,7 @@ Bug Fixes ~~~~~~~~~ - Bug in ``TimedeltaIndex`` addition where overflow was being allowed without error (:issue:`14816`) +- Bug in ``DataFrame`` construction in which unsigned 64-bit integer elements were being converted to objects (:issue:`14881`) - Bug in ``astype()`` where ``inf`` values were incorrectly converted to integers. Now raises error now with ``astype()`` for Series and DataFrames (:issue:`14265`) diff --git a/pandas/core/internals.py b/pandas/core/internals.py index 120a9cbcd1a75..05ac3356c1770 100644 --- a/pandas/core/internals.py +++ b/pandas/core/internals.py @@ -4314,11 +4314,6 @@ def form_blocks(arrays, names, axes): elif is_datetimetz(v): datetime_tz_items.append((i, k, v)) elif issubclass(v.dtype.type, np.integer): - if v.dtype == np.uint64: - # HACK #2355 definite overflow - if (v > 2**63 - 1).any(): - object_items.append((i, k, v)) - continue int_items.append((i, k, v)) elif v.dtype == np.bool_: bool_items.append((i, k, v)) diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py index 489c85a7234b8..bf0fabaf3e402 100644 --- a/pandas/tests/frame/test_constructors.py +++ b/pandas/tests/frame/test_constructors.py @@ -183,13 +183,14 @@ def test_constructor_bool(self): self.assertEqual(df.values.dtype, np.bool_) def test_constructor_overflow_int64(self): + # see gh-14881 values = np.array([2 ** 64 - i for i in range(1, 10)], dtype=np.uint64) result = DataFrame({'a': values}) - self.assertEqual(result['a'].dtype, object) + self.assertEqual(result['a'].dtype, np.uint64) - # #2355 + # see gh-2355 data_scores = [(6311132704823138710, 273), (2685045978526272070, 23), (8921811264899370420, 45), (long(17019687244989530680), 270), @@ -198,7 +199,7 @@ def test_constructor_overflow_int64(self): data = np.zeros((len(data_scores),), dtype=dtype) data[:] = data_scores df_crawls = DataFrame(data) - self.assertEqual(df_crawls['uid'].dtype, object) + self.assertEqual(df_crawls['uid'].dtype, np.uint64) def test_constructor_ordereddict(self): import random diff --git a/pandas/tests/frame/test_operators.py b/pandas/tests/frame/test_operators.py index 85aadee8b0900..8462d5cd9bcf6 100644 --- a/pandas/tests/frame/test_operators.py +++ b/pandas/tests/frame/test_operators.py @@ -378,10 +378,10 @@ def test_arith_flex_frame(self): result = getattr(self.mixed_int, op)(2 + self.mixed_int) exp = f(self.mixed_int, 2 + self.mixed_int) - # overflow in the uint + # no overflow in the uint dtype = None if op in ['sub']: - dtype = dict(B='object', C=None) + dtype = dict(B='uint64', C=None) elif op in ['add', 'mul']: dtype = dict(C=None) assert_frame_equal(result, exp) @@ -410,10 +410,10 @@ def test_arith_flex_frame(self): 2 + self.mixed_int) exp = f(self.mixed_int, 2 + self.mixed_int) - # overflow in the uint + # no overflow in the uint dtype = None if op in ['sub']: - dtype = dict(B='object', C=None) + dtype = dict(B='uint64', C=None) elif op in ['add', 'mul']: dtype = dict(C=None) assert_frame_equal(result, exp) From f11501ad28ccc086831266823175e5e222366ab8 Mon Sep 17 00:00:00 2001 From: gfyoung Date: Mon, 19 Dec 2016 14:20:51 -0500 Subject: [PATCH 28/51] MAINT: Only output errors in C style check (#14924) * MAINT: Only output errors in C style check * Move cpplint install before checks --- ci/lint.sh | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ci/lint.sh b/ci/lint.sh index d7df6215450b4..32ac606a4d30a 100755 --- a/ci/lint.sh +++ b/ci/lint.sh @@ -7,6 +7,8 @@ source activate pandas RET=0 if [ "$LINT" ]; then + pip install cpplint + # pandas/rpy is deprecated and will be removed. # pandas/src is C code, so no need to search there. echo "Linting *.py" @@ -43,13 +45,11 @@ if [ "$LINT" ]; then # from Cython files nor do we want to lint C files that we didn't modify for # this particular codebase (e.g. src/headers, src/klib, src/msgpack). However, # we can lint all header files since they aren't "generated" like C files are. - pip install cpplint - echo "Linting *.c and *.h" for path in '*.h' 'period_helper.c' 'datetime' 'parser' 'ujson' do echo "linting -> pandas/src/$path" - cpplint --extensions=c,h --headers=h --filter=-readability/casting,-runtime/int,-build/include_subdir --recursive pandas/src/$path + cpplint --quiet --extensions=c,h --headers=h --filter=-readability/casting,-runtime/int,-build/include_subdir --recursive pandas/src/$path if [ $? -ne "0" ]; then RET=1 fi From 8e630b63010ffdb4ed3c9b47309dc237f8141fdc Mon Sep 17 00:00:00 2001 From: pbreach Date: Mon, 19 Dec 2016 15:29:33 -0500 Subject: [PATCH 29/51] BUG: Fixed DataFrame.describe percentiles are ndarray w/ no median Explicit conversion to list for `percentiles`. Fixes the case where `percentiles` is passed as a numpy with no median (0.5) present. Closes #14908. Author: pbreach Closes #14914 from pbreach/df-describe-percentile-ndarray-no-median and squashes the following commits: 5c8199b [pbreach] Minor test fix b5d09a6 [pbreach] Added test for median insertion with ndarray 72fe0cb [pbreach] Added what's new entry f954392 [pbreach] Moved conversion to if percentiles is not None d192ac7 [pbreach] Fixed whitespace issue a06794d [pbreach] BUG: Fixed bug in DataFrame.describe when percentiles are passed as array with no median --- doc/source/whatsnew/v0.20.0.txt | 2 +- pandas/core/generic.py | 3 +++ pandas/tests/test_generic.py | 7 +++++++ 3 files changed, 11 insertions(+), 1 deletion(-) diff --git a/doc/source/whatsnew/v0.20.0.txt b/doc/source/whatsnew/v0.20.0.txt index b52026b0798a6..83a70aa34fccf 100644 --- a/doc/source/whatsnew/v0.20.0.txt +++ b/doc/source/whatsnew/v0.20.0.txt @@ -245,7 +245,7 @@ Bug Fixes - Bug in ``TimedeltaIndex`` addition where overflow was being allowed without error (:issue:`14816`) - Bug in ``DataFrame`` construction in which unsigned 64-bit integer elements were being converted to objects (:issue:`14881`) - Bug in ``astype()`` where ``inf`` values were incorrectly converted to integers. Now raises error now with ``astype()`` for Series and DataFrames (:issue:`14265`) - +- Bug in ``describe()`` when passing a numpy array which does not contain the median to the ``percentiles`` keyword argument (:issue:`14908`) diff --git a/pandas/core/generic.py b/pandas/core/generic.py index 48d799811aa94..3678168890444 100644 --- a/pandas/core/generic.py +++ b/pandas/core/generic.py @@ -5262,6 +5262,9 @@ def describe(self, percentiles=None, include=None, exclude=None): raise ValueError("Cannot describe a DataFrame without columns") if percentiles is not None: + # explicit conversion of `percentiles` to list + percentiles = list(percentiles) + # get them all to be in [0, 1] self._check_percentile(percentiles) diff --git a/pandas/tests/test_generic.py b/pandas/tests/test_generic.py index 84df82db69f77..3500ce913462a 100644 --- a/pandas/tests/test_generic.py +++ b/pandas/tests/test_generic.py @@ -996,6 +996,13 @@ def test_describe_percentiles_insert_median(self): self.assertTrue('0%' in d1.index) self.assertTrue('100%' in d2.index) + def test_describe_percentiles_insert_median_ndarray(self): + # GH14908 + df = tm.makeDataFrame() + result = df.describe(percentiles=np.array([.25, .75])) + expected = df.describe(percentiles=[.25, .75]) + assert_frame_equal(result, expected) + def test_describe_percentiles_unique(self): # GH13104 df = tm.makeDataFrame() From 3ccb50131b698bccee21780c660a70bed87396d0 Mon Sep 17 00:00:00 2001 From: Chris Ham Date: Mon, 19 Dec 2016 18:44:05 -0500 Subject: [PATCH 30/51] =?UTF-8?q?CLN:=20Resubmit=20of=20GH14700.=20=20Fixe?= =?UTF-8?q?s=20GH14554.=20=20Errors=20other=20than=20Indexing=E2=80=A6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit IdnexError and KeyError now bubble up appropriately. closes #14554 Author: Chris Ham Closes #14912 from clham/gh14554-b and squashes the following commits: 458c0cc [Chris Ham] CLN: Resubmit of GH14700. Fixes GH14554. Errors other than IndexingError and KeyError now bubble up appropriately. --- doc/source/whatsnew/v0.19.2.txt | 1 + pandas/core/indexing.py | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/doc/source/whatsnew/v0.19.2.txt b/doc/source/whatsnew/v0.19.2.txt index ea59f3fbf493a..c94e08ec41760 100644 --- a/doc/source/whatsnew/v0.19.2.txt +++ b/doc/source/whatsnew/v0.19.2.txt @@ -70,6 +70,7 @@ Bug Fixes - Compat with python 3.6 for Timestamp pickles (:issue:`14689`) - Bug in resampling a ``DatetimeIndex`` in local TZ, covering a DST change, which would raise ``AmbiguousTimeError`` (:issue:`14682`) +- Bug in indexing that transformed ``RecursionError`` into ``KeyError`` or ``IndexingError`` (:issue:`14554`) - Bug in ``HDFStore`` when writing a ``MultiIndex`` when using ``data_columns=True`` (:issue:`14435`) diff --git a/pandas/core/indexing.py b/pandas/core/indexing.py index c4ae3dcca8367..107d68c192ead 100755 --- a/pandas/core/indexing.py +++ b/pandas/core/indexing.py @@ -848,7 +848,7 @@ def _multi_take(self, tup): [(a, self._convert_for_reindex(t, axis=o._get_axis_number(a))) for t, a in zip(tup, o._AXIS_ORDERS)]) return o.reindex(**d) - except: + except(KeyError, IndexingError): raise self._exception def _convert_for_reindex(self, key, axis=0): From 5faf32a62b52912bc0c4a26622bfc3d72b5121ff Mon Sep 17 00:00:00 2001 From: Roger Thomas Date: Tue, 20 Dec 2016 08:27:47 -0500 Subject: [PATCH 31/51] BUG: Fix to numeric on decimal fields closes #14827 Author: Roger Thomas Author: Roger Thomas Closes #14842 from RogerThomas/fix_to_numeric_on_decimal_fields and squashes the following commits: 91d989b [Roger Thomas] Merge branch 'master' of github.com:pandas-dev/pandas into fix_to_numeric_on_decimal_fields d7972d7 [Roger Thomas] Move isdecimal to internal api 1f1c62c [Roger Thomas] Add Test And Refactor is_decimal f1b69da [Roger Thomas] Merge branch 'master' of github.com:pandas-dev/pandas into fix_to_numeric_on_decimal_fields 2d2488c [Roger Thomas] Fix To Numeric on Decimal Fields --- doc/source/whatsnew/v0.20.0.txt | 1 + pandas/lib.pyx | 4 +++- pandas/src/inference.pyx | 8 +++++++ pandas/tools/tests/test_util.py | 41 +++++++++++++++++++++++++++++++++ pandas/tools/util.py | 9 ++++++-- pandas/types/inference.py | 2 ++ 6 files changed, 62 insertions(+), 3 deletions(-) diff --git a/doc/source/whatsnew/v0.20.0.txt b/doc/source/whatsnew/v0.20.0.txt index 83a70aa34fccf..e34330f18a52d 100644 --- a/doc/source/whatsnew/v0.20.0.txt +++ b/doc/source/whatsnew/v0.20.0.txt @@ -245,6 +245,7 @@ Bug Fixes - Bug in ``TimedeltaIndex`` addition where overflow was being allowed without error (:issue:`14816`) - Bug in ``DataFrame`` construction in which unsigned 64-bit integer elements were being converted to objects (:issue:`14881`) - Bug in ``astype()`` where ``inf`` values were incorrectly converted to integers. Now raises error now with ``astype()`` for Series and DataFrames (:issue:`14265`) +- Bug in ``DataFrame(..).apply(to_numeric)`` when values are of type decimal.Decimal. (:issue:`14827`) - Bug in ``describe()`` when passing a numpy array which does not contain the median to the ``percentiles`` keyword argument (:issue:`14908`) diff --git a/pandas/lib.pyx b/pandas/lib.pyx index b09a1c2755a06..548a96780d37a 100644 --- a/pandas/lib.pyx +++ b/pandas/lib.pyx @@ -313,6 +313,7 @@ def isscalar(object val): - instances of datetime.datetime - instances of datetime.timedelta - Period + - instances of decimal.Decimal """ @@ -325,7 +326,8 @@ def isscalar(object val): or PyDate_Check(val) or PyDelta_Check(val) or PyTime_Check(val) - or util.is_period_object(val)) + or util.is_period_object(val) + or is_decimal(val)) def item_from_zerodim(object val): diff --git a/pandas/src/inference.pyx b/pandas/src/inference.pyx index 5ac2c70bb1808..a8b694d7ba008 100644 --- a/pandas/src/inference.pyx +++ b/pandas/src/inference.pyx @@ -1,4 +1,5 @@ import sys +from decimal import Decimal cimport util from tslib import NaT, get_timezone from datetime import datetime, timedelta @@ -28,6 +29,10 @@ def is_bool(object obj): def is_complex(object obj): return util.is_complex_object(obj) + +def is_decimal(object obj): + return isinstance(obj, Decimal) + cpdef bint is_period(object val): """ Return a boolean if this is a Period object """ return util.is_period_object(val) @@ -673,6 +678,9 @@ def maybe_convert_numeric(object[:] values, set na_values, elif util.is_complex_object(val): complexes[i] = val seen_complex = True + elif is_decimal(val): + floats[i] = complexes[i] = val + seen_float = True else: try: status = floatify(val, &fval, &maybe_int) diff --git a/pandas/tools/tests/test_util.py b/pandas/tools/tests/test_util.py index f9647721e3c5b..f808abcda9418 100644 --- a/pandas/tools/tests/test_util.py +++ b/pandas/tools/tests/test_util.py @@ -2,6 +2,7 @@ import locale import codecs import nose +import decimal import numpy as np from numpy import iinfo @@ -208,6 +209,46 @@ def test_numeric(self): res = to_numeric(s) tm.assert_series_equal(res, expected) + # GH 14827 + df = pd.DataFrame(dict( + a=[1.2, decimal.Decimal(3.14), decimal.Decimal("infinity"), '0.1'], + b=[1.0, 2.0, 3.0, 4.0], + )) + expected = pd.DataFrame(dict( + a=[1.2, 3.14, np.inf, 0.1], + b=[1.0, 2.0, 3.0, 4.0], + )) + + # Test to_numeric over one column + df_copy = df.copy() + df_copy['a'] = df_copy['a'].apply(to_numeric) + tm.assert_frame_equal(df_copy, expected) + + # Test to_numeric over multiple columns + df_copy = df.copy() + df_copy[['a', 'b']] = df_copy[['a', 'b']].apply(to_numeric) + tm.assert_frame_equal(df_copy, expected) + + def test_numeric_lists_and_arrays(self): + # Test to_numeric with embedded lists and arrays + df = pd.DataFrame(dict( + a=[[decimal.Decimal(3.14), 1.0], decimal.Decimal(1.6), 0.1] + )) + df['a'] = df['a'].apply(to_numeric) + expected = pd.DataFrame(dict( + a=[[3.14, 1.0], 1.6, 0.1], + )) + tm.assert_frame_equal(df, expected) + + df = pd.DataFrame(dict( + a=[np.array([decimal.Decimal(3.14), 1.0]), 0.1] + )) + df['a'] = df['a'].apply(to_numeric) + expected = pd.DataFrame(dict( + a=[[3.14, 1.0], 0.1], + )) + tm.assert_frame_equal(df, expected) + def test_all_nan(self): s = pd.Series(['a', 'b', 'c']) res = to_numeric(s, errors='coerce') diff --git a/pandas/tools/util.py b/pandas/tools/util.py index b50bf9dc448bc..daecf3d093680 100644 --- a/pandas/tools/util.py +++ b/pandas/tools/util.py @@ -5,7 +5,10 @@ is_numeric_dtype, is_datetime_or_timedelta_dtype, is_list_like, - _ensure_object) + _ensure_object, + is_decimal, + is_scalar as isscalar) + from pandas.types.cast import _possibly_downcast_to_dtype import pandas as pd @@ -173,7 +176,9 @@ def to_numeric(arg, errors='raise', downcast=None): values = arg.values elif isinstance(arg, (list, tuple)): values = np.array(arg, dtype='O') - elif np.isscalar(arg): + elif isscalar(arg): + if is_decimal(arg): + return float(arg) if is_number(arg): return arg is_scalar = True diff --git a/pandas/types/inference.py b/pandas/types/inference.py index 35a2dc2fb831b..d2a2924b27659 100644 --- a/pandas/types/inference.py +++ b/pandas/types/inference.py @@ -18,6 +18,8 @@ is_scalar = lib.isscalar +is_decimal = lib.is_decimal + def is_number(obj): return isinstance(obj, (Number, np.number)) From b35c68996d4dfcd565dfbd7e27b53b392efe14cf Mon Sep 17 00:00:00 2001 From: gfyoung Date: Tue, 20 Dec 2016 08:43:31 -0500 Subject: [PATCH 32/51] BUG: Prevent uint64 overflow in Series.unique Introduces a `UInt64HashTable` class to hash `uint64` elements and prevent overflow in functions like `Series.unique`. Closes #14721. Author: gfyoung Closes #14915 from gfyoung/uint64-hashtable-patch and squashes the following commits: 380c580 [gfyoung] BUG: Prevent uint64 overflow in Series.unique --- doc/source/whatsnew/v0.20.0.txt | 2 ++ pandas/core/algorithms.py | 6 +++++- pandas/hashtable.pxd | 9 ++++++++- pandas/src/algos_common_helper.pxi.in | 1 + pandas/src/hashtable_class_helper.pxi.in | 6 +++++- pandas/src/hashtable_func_helper.pxi.in | 2 +- pandas/src/khash.pxd | 21 +++++++++++++++++++-- pandas/src/klib/khash.h | 2 ++ pandas/tests/test_algos.py | 15 ++++++++++++++- pandas/types/common.py | 2 ++ 10 files changed, 59 insertions(+), 7 deletions(-) diff --git a/doc/source/whatsnew/v0.20.0.txt b/doc/source/whatsnew/v0.20.0.txt index e34330f18a52d..dd790e89cbc08 100644 --- a/doc/source/whatsnew/v0.20.0.txt +++ b/doc/source/whatsnew/v0.20.0.txt @@ -259,4 +259,6 @@ Bug Fixes + +- Bug in ``Series.unique()`` in which unsigned 64-bit integers were causing overflow (:issue:`14721`) - Require at least 0.23 version of cython to avoid problems with character encodings (:issue:`14699`) diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py index 6bcd3776867b6..e51774ce4d9b4 100644 --- a/pandas/core/algorithms.py +++ b/pandas/core/algorithms.py @@ -25,6 +25,7 @@ _ensure_platform_int, _ensure_object, _ensure_float64, + _ensure_uint64, _ensure_int64, is_list_like) from pandas.compat.numpy import _np_version_under1p10 @@ -129,9 +130,12 @@ def unique1d(values): table = htable.Int64HashTable(len(values)) uniques = table.unique(_ensure_int64(values)) uniques = uniques.view('m8[ns]') - elif np.issubdtype(values.dtype, np.integer): + elif np.issubdtype(values.dtype, np.signedinteger): table = htable.Int64HashTable(len(values)) uniques = table.unique(_ensure_int64(values)) + elif np.issubdtype(values.dtype, np.unsignedinteger): + table = htable.UInt64HashTable(len(values)) + uniques = table.unique(_ensure_uint64(values)) else: # its cheaper to use a String Hash Table than Object diff --git a/pandas/hashtable.pxd b/pandas/hashtable.pxd index f3ea7ad792160..cd06b938310a8 100644 --- a/pandas/hashtable.pxd +++ b/pandas/hashtable.pxd @@ -1,10 +1,17 @@ -from khash cimport kh_int64_t, kh_float64_t, kh_pymap_t, kh_str_t, int64_t, float64_t +from khash cimport (kh_int64_t, kh_uint64_t, kh_float64_t, kh_pymap_t, + kh_str_t, uint64_t, int64_t, float64_t) # prototypes for sharing cdef class HashTable: pass +cdef class UInt64HashTable(HashTable): + cdef kh_uint64_t *table + + cpdef get_item(self, uint64_t val) + cpdef set_item(self, uint64_t key, Py_ssize_t val) + cdef class Int64HashTable(HashTable): cdef kh_int64_t *table diff --git a/pandas/src/algos_common_helper.pxi.in b/pandas/src/algos_common_helper.pxi.in index c52c734f727e9..c1c190704b4c7 100644 --- a/pandas/src/algos_common_helper.pxi.in +++ b/pandas/src/algos_common_helper.pxi.in @@ -553,6 +553,7 @@ dtypes = [('float64', 'FLOAT64', 'float64'), ('int16', 'INT16', 'int16'), ('int32', 'INT32', 'int32'), ('int64', 'INT64', 'int64'), + ('uint64', 'UINT64', 'uint64'), # ('platform_int', 'INT', 'int_'), # ('object', 'OBJECT', 'object_'), ] diff --git a/pandas/src/hashtable_class_helper.pxi.in b/pandas/src/hashtable_class_helper.pxi.in index 22714e6305677..55c840b20c78b 100644 --- a/pandas/src/hashtable_class_helper.pxi.in +++ b/pandas/src/hashtable_class_helper.pxi.in @@ -17,7 +17,8 @@ WARNING: DO NOT edit .pxi FILE directly, .pxi is generated from .pxi.in dtypes = [('Float64', 'float64', 'float64_t'), ('Int64', 'int64', 'int64_t'), - ('String', 'string', 'char *')] + ('String', 'string', 'char *'), + ('UInt64', 'uint64', 'uint64_t')] }} {{for name, dtype, arg in dtypes}} @@ -40,6 +41,7 @@ cdef inline void append_data_{{dtype}}({{name}}VectorData *data, ctypedef fused vector_data: Int64VectorData + UInt64VectorData Float64VectorData StringVectorData @@ -54,6 +56,7 @@ cdef inline bint needs_resize(vector_data *data) nogil: # name, dtype, arg, idtype dtypes = [('Float64', 'float64', 'float64_t', 'np.float64'), + ('UInt64', 'uint64', 'uint64_t', 'np.uint64'), ('Int64', 'int64', 'int64_t', 'np.int64')] }} @@ -201,6 +204,7 @@ cdef class HashTable: # name, dtype, null_condition, float_group dtypes = [('Float64', 'float64', 'val != val', True), + ('UInt64', 'uint64', 'val == 0', False), ('Int64', 'int64', 'val == iNaT', False)] }} diff --git a/pandas/src/hashtable_func_helper.pxi.in b/pandas/src/hashtable_func_helper.pxi.in index 1840b914f3328..f3e16cfd32963 100644 --- a/pandas/src/hashtable_func_helper.pxi.in +++ b/pandas/src/hashtable_func_helper.pxi.in @@ -11,7 +11,7 @@ WARNING: DO NOT edit .pxi FILE directly, .pxi is generated from .pxi.in {{py: # name -dtypes = ['float64', 'int64'] +dtypes = ['float64', 'int64', 'uint64'] }} diff --git a/pandas/src/khash.pxd b/pandas/src/khash.pxd index b28f43eecfac7..adb0fe285dbb8 100644 --- a/pandas/src/khash.pxd +++ b/pandas/src/khash.pxd @@ -1,5 +1,5 @@ from cpython cimport PyObject -from numpy cimport int64_t, int32_t, uint32_t, float64_t +from numpy cimport int64_t, uint64_t, int32_t, uint32_t, float64_t cdef extern from "khash_python.h": ctypedef uint32_t khint_t @@ -55,7 +55,6 @@ cdef extern from "khash_python.h": bint kh_exist_str(kh_str_t*, khiter_t) nogil - ctypedef struct kh_int64_t: khint_t n_buckets, size, n_occupied, upper_bound uint32_t *flags @@ -72,6 +71,24 @@ cdef extern from "khash_python.h": bint kh_exist_int64(kh_int64_t*, khiter_t) nogil + ctypedef uint64_t khuint64_t + + ctypedef struct kh_uint64_t: + khint_t n_buckets, size, n_occupied, upper_bound + uint32_t *flags + khuint64_t *keys + size_t *vals + + inline kh_uint64_t* kh_init_uint64() nogil + inline void kh_destroy_uint64(kh_uint64_t*) nogil + inline void kh_clear_uint64(kh_uint64_t*) nogil + inline khint_t kh_get_uint64(kh_uint64_t*, int64_t) nogil + inline void kh_resize_uint64(kh_uint64_t*, khint_t) nogil + inline khint_t kh_put_uint64(kh_uint64_t*, int64_t, int*) nogil + inline void kh_del_uint64(kh_uint64_t*, khint_t) nogil + + bint kh_exist_uint64(kh_uint64_t*, khiter_t) nogil + ctypedef struct kh_float64_t: khint_t n_buckets, size, n_occupied, upper_bound uint32_t *flags diff --git a/pandas/src/klib/khash.h b/pandas/src/klib/khash.h index dc004a0e1770b..869607a44c001 100644 --- a/pandas/src/klib/khash.h +++ b/pandas/src/klib/khash.h @@ -567,12 +567,14 @@ typedef const char *kh_cstr_t; #define kh_exist_str(h, k) (kh_exist(h, k)) #define kh_exist_float64(h, k) (kh_exist(h, k)) +#define kh_exist_uint64(h, k) (kh_exist(h, k)) #define kh_exist_int64(h, k) (kh_exist(h, k)) #define kh_exist_int32(h, k) (kh_exist(h, k)) KHASH_MAP_INIT_STR(str, size_t) KHASH_MAP_INIT_INT(int32, size_t) KHASH_MAP_INIT_INT64(int64, size_t) +KHASH_MAP_INIT_UINT64(uint64, size_t) #endif /* __AC_KHASH_H */ diff --git a/pandas/tests/test_algos.py b/pandas/tests/test_algos.py index 92a9184ad30fc..7f1745edbb816 100644 --- a/pandas/tests/test_algos.py +++ b/pandas/tests/test_algos.py @@ -899,6 +899,18 @@ def test_lookup_nan(self): self.assert_numpy_array_equal(m.lookup(xs), np.arange(len(xs), dtype=np.int64)) + def test_lookup_overflow(self): + xs = np.array([1, 2, 2**63], dtype=np.uint64) + m = hashtable.UInt64HashTable() + m.map_locations(xs) + self.assert_numpy_array_equal(m.lookup(xs), + np.arange(len(xs), dtype=np.int64)) + + def test_get_unique(self): + s = pd.Series([1, 2, 2**63, 2**63], dtype=np.uint64) + exp = np.array([1, 2, 2**63], dtype=np.uint64) + self.assert_numpy_array_equal(s.unique(), exp) + def test_vector_resize(self): # Test for memory errors after internal vector # reallocations (pull request #7157) @@ -915,7 +927,8 @@ def _test_vector_resize(htable, uniques, dtype, nvals): (hashtable.PyObjectHashTable, hashtable.ObjectVector, 'object'), (hashtable.StringHashTable, hashtable.ObjectVector, 'object'), (hashtable.Float64HashTable, hashtable.Float64Vector, 'float64'), - (hashtable.Int64HashTable, hashtable.Int64Vector, 'int64')] + (hashtable.Int64HashTable, hashtable.Int64Vector, 'int64'), + (hashtable.UInt64HashTable, hashtable.UInt64Vector, 'uint64')] for (tbl, vect, dtype) in test_cases: # resizing to empty is a special case diff --git a/pandas/types/common.py b/pandas/types/common.py index a7ba96f95e31b..06c8ef6e35cd7 100644 --- a/pandas/types/common.py +++ b/pandas/types/common.py @@ -32,6 +32,8 @@ def _ensure_float(arr): arr = arr.astype(float) return arr + +_ensure_uint64 = algos.ensure_uint64 _ensure_int64 = algos.ensure_int64 _ensure_int32 = algos.ensure_int32 _ensure_int16 = algos.ensure_int16 From 0c5281305baa203151d1b19cd0268a85f37c028d Mon Sep 17 00:00:00 2001 From: gfyoung Date: Tue, 20 Dec 2016 08:48:45 -0500 Subject: [PATCH 33/51] BUG: Convert uint64 in maybe_convert_objects Adds handling for `uint64` objects during conversion. When negative numbers and `uint64` are detected, we then convert the result to `object`. Picks up where #4845 left off. Closes #4471. Author: gfyoung Closes #14916 from gfyoung/convert-objects-uint64 and squashes the following commits: ed325cd [gfyoung] BUG: Convert uint64 in maybe_convert_objects --- doc/source/whatsnew/v0.20.0.txt | 1 + pandas/src/inference.pyx | 32 ++++++++++++++++++---- pandas/tests/frame/test_block_internals.py | 2 +- pandas/tests/types/test_inference.py | 14 ++++++++++ 4 files changed, 43 insertions(+), 6 deletions(-) diff --git a/doc/source/whatsnew/v0.20.0.txt b/doc/source/whatsnew/v0.20.0.txt index dd790e89cbc08..dc06fbd159457 100644 --- a/doc/source/whatsnew/v0.20.0.txt +++ b/doc/source/whatsnew/v0.20.0.txt @@ -262,3 +262,4 @@ Bug Fixes - Bug in ``Series.unique()`` in which unsigned 64-bit integers were causing overflow (:issue:`14721`) - Require at least 0.23 version of cython to avoid problems with character encodings (:issue:`14699`) +- Bug in converting object elements of array-like objects to unsigned 64-bit integers (:issue:`4471`) diff --git a/pandas/src/inference.pyx b/pandas/src/inference.pyx index a8b694d7ba008..a4eda9f83ef03 100644 --- a/pandas/src/inference.pyx +++ b/pandas/src/inference.pyx @@ -13,6 +13,8 @@ from util cimport (UINT8_MAX, UINT16_MAX, UINT32_MAX, UINT64_MAX, # core.common import for fast inference checks +npy_int64_max = np.iinfo(np.int64).max + def is_float(object obj): return util.is_float_object(obj) @@ -730,6 +732,7 @@ def maybe_convert_objects(ndarray[object] objects, bint try_float=0, ndarray[float64_t] floats ndarray[complex128_t] complexes ndarray[int64_t] ints + ndarray[uint64_t] uints ndarray[uint8_t] bools ndarray[int64_t] idatetimes ndarray[int64_t] itimedeltas @@ -739,6 +742,8 @@ def maybe_convert_objects(ndarray[object] objects, bint try_float=0, bint seen_datetimetz = 0 bint seen_timedelta = 0 bint seen_int = 0 + bint seen_uint = 0 + bint seen_sint = 0 bint seen_bool = 0 bint seen_object = 0 bint seen_null = 0 @@ -751,6 +756,7 @@ def maybe_convert_objects(ndarray[object] objects, bint try_float=0, floats = np.empty(n, dtype='f8') complexes = np.empty(n, dtype='c16') ints = np.empty(n, dtype='i8') + uints = np.empty(n, dtype='u8') bools = np.empty(n, dtype=np.uint8) if convert_datetime: @@ -806,11 +812,21 @@ def maybe_convert_objects(ndarray[object] objects, bint try_float=0, floats[i] = val complexes[i] = val if not seen_null: - try: - ints[i] = val - except OverflowError: + seen_uint = seen_uint or (val > npy_int64_max) + seen_sint = seen_sint or (val < 0) + + if seen_uint and seen_sint: seen_object = 1 break + + if seen_uint: + uints[i] = val + elif seen_sint: + ints[i] = val + else: + uints[i] = val + ints[i] = val + elif util.is_complex_object(val): complexes[i] = val seen_complex = 1 @@ -873,7 +889,10 @@ def maybe_convert_objects(ndarray[object] objects, bint try_float=0, elif seen_float: return floats elif seen_int: - return ints + if seen_uint: + return uints + else: + return ints elif (not seen_datetime and not seen_numeric and not seen_timedelta): return bools.view(np.bool_) @@ -904,7 +923,10 @@ def maybe_convert_objects(ndarray[object] objects, bint try_float=0, if not seen_int: return floats elif seen_int: - return ints + if seen_uint: + return uints + else: + return ints elif (not seen_datetime and not seen_numeric and not seen_timedelta): return bools.view(np.bool_) diff --git a/pandas/tests/frame/test_block_internals.py b/pandas/tests/frame/test_block_internals.py index e51cc0f5a6ec7..706820b06b12e 100644 --- a/pandas/tests/frame/test_block_internals.py +++ b/pandas/tests/frame/test_block_internals.py @@ -142,7 +142,7 @@ def test_constructor_with_convert(self): df = DataFrame({'A': [2 ** 63]}) result = df['A'] - expected = Series(np.asarray([2 ** 63], np.object_), name='A') + expected = Series(np.asarray([2 ** 63], np.uint64), name='A') assert_series_equal(result, expected) df = DataFrame({'A': [datetime(2005, 1, 1), True]}) diff --git a/pandas/tests/types/test_inference.py b/pandas/tests/types/test_inference.py index a63ae5f7cf74e..f83ad51c2f648 100644 --- a/pandas/tests/types/test_inference.py +++ b/pandas/tests/types/test_inference.py @@ -254,6 +254,20 @@ def test_convert_non_hashable(self): result = lib.maybe_convert_numeric(arr, set(), False, True) tm.assert_numpy_array_equal(result, np.array([np.nan, 1.0, np.nan])) + def test_maybe_convert_objects_uint64(self): + # see gh-4471 + arr = np.array([2**63], dtype=object) + exp = np.array([2**63], dtype=np.uint64) + tm.assert_numpy_array_equal(lib.maybe_convert_objects(arr), exp) + + arr = np.array([2, -1], dtype=object) + exp = np.array([2, -1], dtype=np.int64) + tm.assert_numpy_array_equal(lib.maybe_convert_objects(arr), exp) + + arr = np.array([2**63, -1], dtype=object) + exp = np.array([2**63, -1], dtype=object) + tm.assert_numpy_array_equal(lib.maybe_convert_objects(arr), exp) + class TestTypeInference(tm.TestCase): _multiprocess_can_split_ = True From 3ab0e552c9bac85048dc001d764bb7b903f73a36 Mon Sep 17 00:00:00 2001 From: Jeff Reback Date: Tue, 20 Dec 2016 09:10:33 -0500 Subject: [PATCH 34/51] PERF: make all inference routines cpdef bint Author: Jeff Reback Closes #14925 from jreback/inference and squashes the following commits: ff8ecd1 [Jeff Reback] PERF: make all inference routines cpdef bint --- pandas/lib.pyx | 10 ++++---- pandas/src/inference.pyx | 50 +++++++++++++++++++--------------------- 2 files changed, 29 insertions(+), 31 deletions(-) diff --git a/pandas/lib.pyx b/pandas/lib.pyx index 548a96780d37a..761969491cfc7 100644 --- a/pandas/lib.pyx +++ b/pandas/lib.pyx @@ -257,7 +257,7 @@ cdef double INF = np.inf cdef double NEGINF = -INF -cpdef checknull(object val): +cpdef bint checknull(object val): if util.is_float_object(val) or util.is_complex_object(val): return val != val # and val != INF and val != NEGINF elif util.is_datetime64_object(val): @@ -272,7 +272,7 @@ cpdef checknull(object val): return _checknull(val) -cpdef checknull_old(object val): +cpdef bint checknull_old(object val): if util.is_float_object(val) or util.is_complex_object(val): return val != val or val == INF or val == NEGINF elif util.is_datetime64_object(val): @@ -287,21 +287,21 @@ cpdef checknull_old(object val): return util._checknull(val) -cpdef isposinf_scalar(object val): +cpdef bint isposinf_scalar(object val): if util.is_float_object(val) and val == INF: return True else: return False -cpdef isneginf_scalar(object val): +cpdef bint isneginf_scalar(object val): if util.is_float_object(val) and val == NEGINF: return True else: return False -def isscalar(object val): +cpdef bint isscalar(object val): """ Return True if given value is scalar. diff --git a/pandas/src/inference.pyx b/pandas/src/inference.pyx index a4eda9f83ef03..2f829417f9bb2 100644 --- a/pandas/src/inference.pyx +++ b/pandas/src/inference.pyx @@ -16,29 +16,31 @@ from util cimport (UINT8_MAX, UINT16_MAX, UINT32_MAX, UINT64_MAX, npy_int64_max = np.iinfo(np.int64).max -def is_float(object obj): +cpdef bint is_float(object obj): return util.is_float_object(obj) -def is_integer(object obj): +cpdef bint is_integer(object obj): return util.is_integer_object(obj) -def is_bool(object obj): +cpdef bint is_bool(object obj): return util.is_bool_object(obj) -def is_complex(object obj): +cpdef bint is_complex(object obj): return util.is_complex_object(obj) -def is_decimal(object obj): +cpdef bint is_decimal(object obj): return isinstance(obj, Decimal) + cpdef bint is_period(object val): """ Return a boolean if this is a Period object """ return util.is_period_object(val) + _TYPE_MAP = { 'categorical': 'categorical', 'category': 'categorical', @@ -236,7 +238,7 @@ def infer_dtype(object _values): return 'mixed' -def is_possible_datetimelike_array(object arr): +cpdef bint is_possible_datetimelike_array(object arr): # determine if we have a possible datetimelike (or null-like) array cdef: Py_ssize_t i, n = len(arr) @@ -321,7 +323,7 @@ cdef inline bint is_timedelta(object o): return PyDelta_Check(o) or util.is_timedelta64_object(o) -def is_bool_array(ndarray values): +cpdef bint is_bool_array(ndarray values): cdef: Py_ssize_t i, n = len(values) ndarray[object] objbuf @@ -342,11 +344,7 @@ def is_bool_array(ndarray values): return False -def is_integer(object o): - return util.is_integer_object(o) - - -def is_integer_array(ndarray values): +cpdef bint is_integer_array(ndarray values): cdef: Py_ssize_t i, n = len(values) ndarray[object] objbuf @@ -367,7 +365,7 @@ def is_integer_array(ndarray values): return False -def is_integer_float_array(ndarray values): +cpdef bint is_integer_float_array(ndarray values): cdef: Py_ssize_t i, n = len(values) ndarray[object] objbuf @@ -390,7 +388,7 @@ def is_integer_float_array(ndarray values): return False -def is_float_array(ndarray values): +cpdef bint is_float_array(ndarray values): cdef: Py_ssize_t i, n = len(values) ndarray[object] objbuf @@ -411,7 +409,7 @@ def is_float_array(ndarray values): return False -def is_string_array(ndarray values): +cpdef bint is_string_array(ndarray values): cdef: Py_ssize_t i, n = len(values) ndarray[object] objbuf @@ -433,7 +431,7 @@ def is_string_array(ndarray values): return False -def is_unicode_array(ndarray values): +cpdef bint is_unicode_array(ndarray values): cdef: Py_ssize_t i, n = len(values) ndarray[object] objbuf @@ -454,7 +452,7 @@ def is_unicode_array(ndarray values): return False -def is_bytes_array(ndarray values): +cpdef bint is_bytes_array(ndarray values): cdef: Py_ssize_t i, n = len(values) ndarray[object] objbuf @@ -475,7 +473,7 @@ def is_bytes_array(ndarray values): return False -def is_datetime_array(ndarray[object] values): +cpdef bint is_datetime_array(ndarray[object] values): cdef Py_ssize_t i, null_count = 0, n = len(values) cdef object v if n == 0: @@ -493,7 +491,7 @@ def is_datetime_array(ndarray[object] values): return null_count != n -def is_datetime64_array(ndarray values): +cpdef bint is_datetime64_array(ndarray values): cdef Py_ssize_t i, null_count = 0, n = len(values) cdef object v if n == 0: @@ -511,7 +509,7 @@ def is_datetime64_array(ndarray values): return null_count != n -cpdef is_datetime_with_singletz_array(ndarray[object] values): +cpdef bint is_datetime_with_singletz_array(ndarray[object] values): """ Check values have the same tzinfo attribute. Doesn't check values are datetime-like types. @@ -539,7 +537,7 @@ cpdef is_datetime_with_singletz_array(ndarray[object] values): return True -def is_timedelta_array(ndarray values): +cpdef bint is_timedelta_array(ndarray values): cdef Py_ssize_t i, null_count = 0, n = len(values) cdef object v if n == 0: @@ -555,7 +553,7 @@ def is_timedelta_array(ndarray values): return null_count != n -def is_timedelta64_array(ndarray values): +cpdef bint is_timedelta64_array(ndarray values): cdef Py_ssize_t i, null_count = 0, n = len(values) cdef object v if n == 0: @@ -571,7 +569,7 @@ def is_timedelta64_array(ndarray values): return null_count != n -def is_timedelta_or_timedelta64_array(ndarray values): +cpdef bint is_timedelta_or_timedelta64_array(ndarray values): """ infer with timedeltas and/or nat/none """ cdef Py_ssize_t i, null_count = 0, n = len(values) cdef object v @@ -588,7 +586,7 @@ def is_timedelta_or_timedelta64_array(ndarray values): return null_count != n -def is_date_array(ndarray[object] values): +cpdef bint is_date_array(ndarray[object] values): cdef Py_ssize_t i, n = len(values) if n == 0: return False @@ -598,7 +596,7 @@ def is_date_array(ndarray[object] values): return True -def is_time_array(ndarray[object] values): +cpdef bint is_time_array(ndarray[object] values): cdef Py_ssize_t i, n = len(values) if n == 0: return False @@ -608,7 +606,7 @@ def is_time_array(ndarray[object] values): return True -def is_period_array(ndarray[object] values): +cpdef bint is_period_array(ndarray[object] values): cdef Py_ssize_t i, null_count = 0, n = len(values) cdef object v if n == 0: From 02906ce7bcbde2e9f352aa565615285cb147b839 Mon Sep 17 00:00:00 2001 From: Jeff Carey Date: Tue, 20 Dec 2016 08:03:23 -0800 Subject: [PATCH 35/51] TST: Test empty input for read_csv (#14867) (#14920) Fixed flake8 issues Added blank csv file Removing unneeded test --- pandas/io/tests/parser/test_textreader.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/pandas/io/tests/parser/test_textreader.py b/pandas/io/tests/parser/test_textreader.py index 49b70fc5e8703..98cb09cd85480 100644 --- a/pandas/io/tests/parser/test_textreader.py +++ b/pandas/io/tests/parser/test_textreader.py @@ -392,6 +392,12 @@ def test_empty_field_eof(self): names=list('abcd'), engine='c') assert_frame_equal(df, c) + def test_empty_csv_input(self): + # GH14867 + df = read_csv(StringIO(), chunksize=20, header=None, + names=['a', 'b', 'c']) + self.assertTrue(isinstance(df, TextFileReader)) + def assert_array_dicts_equal(left, right): for k, v in compat.iteritems(left): From 50930a9879b580ab4f30d8b741229391e41afa76 Mon Sep 17 00:00:00 2001 From: "Ilya V. Schurov" Date: Tue, 20 Dec 2016 12:43:55 -0500 Subject: [PATCH 36/51] API/BUG: Fix inconsistency in Partial String Index with 'second' resolution Closes #14826 Fix inconsistency in Partial String Index with 'second' resolution. See #14826. Now if the timestamp and the index both have resolution `second`, timestamp is considered as an exact match try and not a slice. Therefore, for `Series`, scalar will be returned, for `DataFrame` `KeyError` raised. Author: Ilya V. Schurov Closes #14856 from ischurov/datetimeindex-slices and squashes the following commits: 2881a53 [Ilya V. Schurov] Merge branch 'datetimeindex-slices' of https://github.com/ischurov/pandas into datetimeindex-slices ac8758e [Ilya V. Schurov] resolved merge conflict in whatsnew/v0.20.0.txt 0e87874 [Ilya V. Schurov] resolved merge conflict in whatsnew/v0.20.0.txt 0814e5b [Ilya V. Schurov] - Addressing code review: added reference to new docs section in whatsnew. d215905 [Ilya V. Schurov] - Addressing code review: documentation clarification. c287845 [Ilya V. Schurov] conflict PR #14856 resolved 40eddc3 [Ilya V. Schurov] - Documentation fixes e17d210 [Ilya V. Schurov] - Whatsnew section added - Documentation section added 67e6bab [Ilya V. Schurov] Addressing code review: more comments added c901588 [Ilya V. Schurov] Addressing code review: testing different combinations with the loop instead of copy-pasting of the code 9b55117 [Ilya V. Schurov] Addressing code review b30039d [Ilya V. Schurov] Make flake8 happy. cc86bdd [Ilya V. Schurov] Fix inconsistency in Partial String Index with 'second' resolution ea51437 [Ilya V. Schurov] Made this code clearer. --- doc/source/timeseries.rst | 87 ++++++++++++++++++++----- doc/source/whatsnew/v0.20.0.txt | 32 ++++++++- pandas/tseries/index.py | 10 ++- pandas/tseries/tests/test_timeseries.py | 72 +++++++++++++++++++- 4 files changed, 173 insertions(+), 28 deletions(-) diff --git a/doc/source/timeseries.rst b/doc/source/timeseries.rst index 9253124f7e8b2..6d56a28170645 100644 --- a/doc/source/timeseries.rst +++ b/doc/source/timeseries.rst @@ -457,22 +457,6 @@ We are stopping on the included end-point as it is part of the index dft['2013-1-15':'2013-1-15 12:30:00'] -.. warning:: - - The following selection will raise a ``KeyError``; otherwise this selection methodology - would be inconsistent with other selection methods in pandas (as this is not a *slice*, nor does it - resolve to one) - - .. code-block:: python - - dft['2013-1-15 12:30:00'] - - To select a single row, use ``.loc`` - - .. ipython:: python - - dft.loc['2013-1-15 12:30:00'] - .. versionadded:: 0.18.0 DatetimeIndex Partial String Indexing also works on DataFrames with a ``MultiIndex``. For example: @@ -491,10 +475,79 @@ DatetimeIndex Partial String Indexing also works on DataFrames with a ``MultiInd dft2 = dft2.swaplevel(0, 1).sort_index() dft2.loc[idx[:, '2013-01-05'], :] +.. _timeseries.slice_vs_exact_match: + +Slice vs. exact match +^^^^^^^^^^^^^^^^^^^^^ + +The same string used as an indexing parameter can be treated either as a slice or as an exact match depending on the resolution of an index. If the string is less accurate than the index, it will be treated as a slice, otherwise as an exact match. + +For example, let us consider ``Series`` object which index has minute resolution. + +.. ipython:: python + + series_minute = pd.Series([1, 2, 3], + pd.DatetimeIndex(['2011-12-31 23:59:00', + '2012-01-01 00:00:00', + '2012-01-01 00:02:00'])) + series_minute.index.resolution + +Timestamp string less accurate than minute gives ``Series`` object. + +.. ipython:: python + + series_minute['2011-12-31 23'] + +Timestamp string with minute resolution (or more accurate) gives scalar instead, i.e. it is not casted to a slice. + +.. ipython:: python + + series_minute['2011-12-31 23:59'] + series_minute['2011-12-31 23:59:00'] + +If index resolution is second, the minute-accurate timestamp gives ``Series``. + +.. ipython:: python + + series_second = pd.Series([1, 2, 3], + pd.DatetimeIndex(['2011-12-31 23:59:59', + '2012-01-01 00:00:00', + '2012-01-01 00:00:01'])) + series_second.index.resolution + series_second['2011-12-31 23:59'] + +If the timestamp string is treated as a slice, it can be used to index ``DataFrame`` with ``[]`` as well. + +.. ipython:: python + + dft_minute = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]}, + index=series_minute.index) + dft_minute['2011-12-31 23'] + +However if the string is treated as an exact match the selection in ``DataFrame``'s ``[]`` will be column-wise and not row-wise, see :ref:`Indexing Basics `. For example ``dft_minute['2011-12-31 23:59']`` will raise ``KeyError`` as ``'2012-12-31 23:59'`` has the same resolution as index and there is no column with such name: + +To select a single row, use ``.loc``. + +.. ipython:: python + + dft_minute.loc['2011-12-31 23:59'] + +Note also that ``DatetimeIndex`` resolution cannot be less precise than day. + +.. ipython:: python + + series_monthly = pd.Series([1, 2, 3], + pd.DatetimeIndex(['2011-12', + '2012-01', + '2012-02'])) + series_monthly.index.resolution + series_monthly['2011-12'] # returns Series + + Datetime Indexing ~~~~~~~~~~~~~~~~~ -Indexing a ``DateTimeIndex`` with a partial string depends on the "accuracy" of the period, in other words how specific the interval is in relation to the frequency of the index. In contrast, indexing with datetime objects is exact, because the objects have exact meaning. These also follow the semantics of *including both endpoints*. +As discussed in previous section, indexing a ``DateTimeIndex`` with a partial string depends on the "accuracy" of the period, in other words how specific the interval is in relation to the resolution of the index. In contrast, indexing with datetime objects is exact, because the objects have exact meaning. These also follow the semantics of *including both endpoints*. These ``datetime`` objects are specific ``hours, minutes,`` and ``seconds`` even though they were not explicitly specified (they are ``0``). diff --git a/doc/source/whatsnew/v0.20.0.txt b/doc/source/whatsnew/v0.20.0.txt index dc06fbd159457..6a51e7f519174 100644 --- a/doc/source/whatsnew/v0.20.0.txt +++ b/doc/source/whatsnew/v0.20.0.txt @@ -193,14 +193,42 @@ in prior versions of pandas) (:issue:`11915`). .. _whatsnew_0200.api: +Other API Changes +^^^^^^^^^^^^^^^^^ + - ``CParserError`` has been renamed to ``ParserError`` in ``pd.read_csv`` and will be removed in the future (:issue:`12665`) - ``SparseArray.cumsum()`` and ``SparseSeries.cumsum()`` will now always return ``SparseArray`` and ``SparseSeries`` respectively (:issue:`12855`) +- :ref:`DatetimeIndex Partial String Indexing ` now works as exact match provided that string resolution coincides with index resolution, including a case when both are seconds (:issue:`14826`). See :ref:`Slice vs. Exact Match ` for details. + .. ipython:: python + df = DataFrame({'a': [1, 2, 3]}, DatetimeIndex(['2011-12-31 23:59:59', + '2012-01-01 00:00:00', + '2012-01-01 00:00:01'])) + Previous Behavior: + .. code-block:: ipython -Other API Changes -^^^^^^^^^^^^^^^^^ + In [4]: df['2011-12-31 23:59:59'] + Out[4]: + a + 2011-12-31 23:59:59 1 + + In [5]: df['a']['2011-12-31 23:59:59'] + Out[5]: + 2011-12-31 23:59:59 1 + Name: a, dtype: int64 + + + New Behavior: + + .. code-block:: ipython + + In [4]: df['2011-12-31 23:59:59'] + KeyError: '2011-12-31 23:59:59' + + In [5]: df['a']['2011-12-31 23:59:59'] + Out[5]: 1 .. _whatsnew_0200.deprecations: diff --git a/pandas/tseries/index.py b/pandas/tseries/index.py index 3edf75fbb82ae..aca962c8178d3 100644 --- a/pandas/tseries/index.py +++ b/pandas/tseries/index.py @@ -1293,14 +1293,12 @@ def _parsed_string_to_bounds(self, reso, parsed): def _partial_date_slice(self, reso, parsed, use_lhs=True, use_rhs=True): is_monotonic = self.is_monotonic - if ((reso in ['day', 'hour', 'minute'] and - not (self._resolution < Resolution.get_reso(reso) or - not is_monotonic)) or - (reso == 'second' and - not (self._resolution <= Resolution.RESO_SEC or - not is_monotonic))): + if (is_monotonic and reso in ['day', 'hour', 'minute', 'second'] and + self._resolution >= Resolution.get_reso(reso)): # These resolution/monotonicity validations came from GH3931, # GH3452 and GH2369. + + # See also GH14826 raise KeyError if reso == 'microsecond': diff --git a/pandas/tseries/tests/test_timeseries.py b/pandas/tseries/tests/test_timeseries.py index cd22ac561c6f7..3f4a10619f7f5 100644 --- a/pandas/tseries/tests/test_timeseries.py +++ b/pandas/tseries/tests/test_timeseries.py @@ -266,16 +266,15 @@ def test_indexing(self): expected = ts['2013'] assert_series_equal(expected, ts) - # GH 3925, indexing with a seconds resolution string / datetime object + # GH14826, indexing with a seconds resolution string / datetime object df = DataFrame(randn(5, 5), columns=['open', 'high', 'low', 'close', 'volume'], index=date_range('2012-01-02 18:01:00', periods=5, tz='US/Central', freq='s')) expected = df.loc[[df.index[2]]] - result = df['2012-01-02 18:01:02'] - assert_frame_equal(result, expected) # this is a single date, so will raise + self.assertRaises(KeyError, df.__getitem__, '2012-01-02 18:01:02', ) self.assertRaises(KeyError, df.__getitem__, df.index[2], ) def test_recreate_from_data(self): @@ -4953,6 +4952,73 @@ def test_partial_slice_second_precision(self): self.assertRaisesRegexp(KeyError, '2005-1-1 00:00:00', lambda: s['2005-1-1 00:00:00']) + def test_partial_slicing_dataframe(self): + # GH14856 + # Test various combinations of string slicing resolution vs. + # index resolution + # - If string resolution is less precise than index resolution, + # string is considered a slice + # - If string resolution is equal to or more precise than index + # resolution, string is considered an exact match + formats = ['%Y', '%Y-%m', '%Y-%m-%d', '%Y-%m-%d %H', + '%Y-%m-%d %H:%M', '%Y-%m-%d %H:%M:%S'] + resolutions = ['year', 'month', 'day', 'hour', 'minute', 'second'] + for rnum, resolution in enumerate(resolutions[2:], 2): + # we check only 'day', 'hour', 'minute' and 'second' + unit = Timedelta("1 " + resolution) + middate = datetime(2012, 1, 1, 0, 0, 0) + index = DatetimeIndex([middate - unit, + middate, middate + unit]) + values = [1, 2, 3] + df = DataFrame({'a': values}, index, dtype=np.int64) + self.assertEqual(df.index.resolution, resolution) + + # Timestamp with the same resolution as index + # Should be exact match for Series (return scalar) + # and raise KeyError for Frame + for timestamp, expected in zip(index, values): + ts_string = timestamp.strftime(formats[rnum]) + # make ts_string as precise as index + result = df['a'][ts_string] + self.assertIsInstance(result, np.int64) + self.assertEqual(result, expected) + self.assertRaises(KeyError, df.__getitem__, ts_string) + + # Timestamp with resolution less precise than index + for fmt in formats[:rnum]: + for element, theslice in [[0, slice(None, 1)], + [1, slice(1, None)]]: + ts_string = index[element].strftime(fmt) + + # Series should return slice + result = df['a'][ts_string] + expected = df['a'][theslice] + assert_series_equal(result, expected) + + # Frame should return slice as well + result = df[ts_string] + expected = df[theslice] + assert_frame_equal(result, expected) + + # Timestamp with resolution more precise than index + # Compatible with existing key + # Should return scalar for Series + # and raise KeyError for Frame + for fmt in formats[rnum + 1:]: + ts_string = index[1].strftime(fmt) + result = df['a'][ts_string] + self.assertIsInstance(result, np.int64) + self.assertEqual(result, 2) + self.assertRaises(KeyError, df.__getitem__, ts_string) + + # Not compatible with existing key + # Should raise KeyError + for fmt, res in list(zip(formats, resolutions))[rnum + 1:]: + ts = index[1] + Timedelta("1 " + res) + ts_string = ts.strftime(fmt) + self.assertRaises(KeyError, df['a'].__getitem__, ts_string) + self.assertRaises(KeyError, df.__getitem__, ts_string) + def test_partial_slicing_with_multiindex(self): # GH 4758 From 24fb26d29579f38615ef1c5c85d50ea8769e872a Mon Sep 17 00:00:00 2001 From: Jeff Reback Date: Tue, 20 Dec 2016 12:47:50 -0500 Subject: [PATCH 37/51] BUG: bug in Series construction from UTC xref #14918 Author: Jeff Reback Closes #14928 from jreback/timez_construction and squashes the following commits: 3dd8e99 [Jeff Reback] BUG: bug in Series construction from UTC --- doc/source/whatsnew/v0.20.0.txt | 2 +- pandas/core/ops.py | 4 ++-- pandas/tests/series/test_constructors.py | 15 +++++++++++++++ pandas/types/cast.py | 7 ++++--- 4 files changed, 22 insertions(+), 6 deletions(-) diff --git a/doc/source/whatsnew/v0.20.0.txt b/doc/source/whatsnew/v0.20.0.txt index 6a51e7f519174..46d275df00431 100644 --- a/doc/source/whatsnew/v0.20.0.txt +++ b/doc/source/whatsnew/v0.20.0.txt @@ -281,7 +281,7 @@ Bug Fixes - +- Bug in ``Series`` construction with a datetimetz (:issue:`14928`) diff --git a/pandas/core/ops.py b/pandas/core/ops.py index 80de3cd85d4db..396b0e048bc49 100644 --- a/pandas/core/ops.py +++ b/pandas/core/ops.py @@ -545,9 +545,9 @@ def _offset(lvalues, rvalues): # with tz, convert to UTC if self.is_datetime64tz_lhs: - lvalues = lvalues.tz_localize(None) + lvalues = lvalues.tz_convert('UTC').tz_localize(None) if self.is_datetime64tz_rhs: - rvalues = rvalues.tz_localize(None) + rvalues = rvalues.tz_convert('UTC').tz_localize(None) lvalues = lvalues.view(np.int64) rvalues = rvalues.view(np.int64) diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py index ed7b0fda19cb7..a7e3ebdfc43d0 100644 --- a/pandas/tests/series/test_constructors.py +++ b/pandas/tests/series/test_constructors.py @@ -529,6 +529,21 @@ def test_constructor_with_datetime_tz(self): expected = Series(pd.DatetimeIndex(['NaT', 'NaT'], tz='US/Eastern')) assert_series_equal(s, expected) + def test_construction_consistency(self): + + # make sure that we are not re-localizing upon construction + # GH 14928 + s = Series(pd.date_range('20130101', periods=3, tz='US/Eastern')) + + result = Series(s, dtype=s.dtype) + tm.assert_series_equal(result, s) + + result = Series(s.dt.tz_convert('UTC'), dtype=s.dtype) + tm.assert_series_equal(result, s) + + result = Series(s.values, dtype=s.dtype) + tm.assert_series_equal(result, s) + def test_constructor_periodindex(self): # GH7932 # converting a PeriodIndex when put in a Series diff --git a/pandas/types/cast.py b/pandas/types/cast.py index 4f4f95d5a455b..ff4fb73d6a9b6 100644 --- a/pandas/types/cast.py +++ b/pandas/types/cast.py @@ -823,9 +823,10 @@ def _possibly_cast_to_datetime(value, dtype, errors='raise'): elif is_datetime64tz: # input has to be UTC at this point, so just # localize - value = to_datetime( - value, - errors=errors).tz_localize(dtype.tz) + value = (to_datetime(value, errors=errors) + .tz_localize('UTC') + .tz_convert(dtype.tz) + ) elif is_timedelta64: value = to_timedelta(value, errors=errors)._values except (AttributeError, ValueError, TypeError): From 708792aa62981f7bef8645c2779e5c0920d9f8ff Mon Sep 17 00:00:00 2001 From: Jeff Reback Date: Tue, 20 Dec 2016 13:09:26 -0500 Subject: [PATCH 38/51] DOC: cleanup of timeseries.rst --- doc/source/timeseries.rst | 43 +++++++++++++++++++++++---------------- 1 file changed, 25 insertions(+), 18 deletions(-) diff --git a/doc/source/timeseries.rst b/doc/source/timeseries.rst index 6d56a28170645..33694e22c4f02 100644 --- a/doc/source/timeseries.rst +++ b/doc/source/timeseries.rst @@ -358,8 +358,8 @@ See :ref:`here ` for ways to represent data outside these bound. .. _timeseries.datetimeindex: -DatetimeIndex -------------- +Indexing +-------- One of the main uses for ``DatetimeIndex`` is as an index for pandas objects. The ``DatetimeIndex`` class contains many timeseries related optimizations: @@ -399,8 +399,8 @@ intelligent functionality like selection, slicing, etc. .. _timeseries.partialindexing: -DatetimeIndex Partial String Indexing -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Partial String Indexing +~~~~~~~~~~~~~~~~~~~~~~~ You can pass in dates and strings that parse to dates as indexing parameters: @@ -478,7 +478,9 @@ DatetimeIndex Partial String Indexing also works on DataFrames with a ``MultiInd .. _timeseries.slice_vs_exact_match: Slice vs. exact match -^^^^^^^^^^^^^^^^^^^^^ +~~~~~~~~~~~~~~~~~~~~~ + +.. versionchanged:: 0.20.0 The same string used as an indexing parameter can be treated either as a slice or as an exact match depending on the resolution of an index. If the string is less accurate than the index, it will be treated as a slice, otherwise as an exact match. @@ -492,20 +494,20 @@ For example, let us consider ``Series`` object which index has minute resolution '2012-01-01 00:02:00'])) series_minute.index.resolution -Timestamp string less accurate than minute gives ``Series`` object. +A Timestamp string less accurate than a minute gives a ``Series`` object. .. ipython:: python series_minute['2011-12-31 23'] -Timestamp string with minute resolution (or more accurate) gives scalar instead, i.e. it is not casted to a slice. +A Timestamp string with minute resolution (or more accurate), gives a scalar instead, i.e. it is not casted to a slice. .. ipython:: python series_minute['2011-12-31 23:59'] series_minute['2011-12-31 23:59:00'] -If index resolution is second, the minute-accurate timestamp gives ``Series``. +If index resolution is second, then, the minute-accurate timestamp gives a ``Series``. .. ipython:: python @@ -524,13 +526,16 @@ If the timestamp string is treated as a slice, it can be used to index ``DataFra index=series_minute.index) dft_minute['2011-12-31 23'] -However if the string is treated as an exact match the selection in ``DataFrame``'s ``[]`` will be column-wise and not row-wise, see :ref:`Indexing Basics `. For example ``dft_minute['2011-12-31 23:59']`` will raise ``KeyError`` as ``'2012-12-31 23:59'`` has the same resolution as index and there is no column with such name: -To select a single row, use ``.loc``. +:: warning: -.. ipython:: python + However if the string is treated as an exact match the selection in ``DataFrame``'s ``[]`` will be column-wise and not row-wise, see :ref:`Indexing Basics `. For example ``dft_minute['2011-12-31 23:59']`` will raise ``KeyError`` as ``'2012-12-31 23:59'`` has the same resolution as index and there is no column with such name: + + To select a single row, use ``.loc``. + + .. ipython:: python - dft_minute.loc['2011-12-31 23:59'] + dft_minute.loc['2011-12-31 23:59'] Note also that ``DatetimeIndex`` resolution cannot be less precise than day. @@ -544,12 +549,12 @@ Note also that ``DatetimeIndex`` resolution cannot be less precise than day. series_monthly['2011-12'] # returns Series -Datetime Indexing -~~~~~~~~~~~~~~~~~ +Exact Indexing +~~~~~~~~~~~~~~ -As discussed in previous section, indexing a ``DateTimeIndex`` with a partial string depends on the "accuracy" of the period, in other words how specific the interval is in relation to the resolution of the index. In contrast, indexing with datetime objects is exact, because the objects have exact meaning. These also follow the semantics of *including both endpoints*. +As discussed in previous section, indexing a ``DateTimeIndex`` with a partial string depends on the "accuracy" of the period, in other words how specific the interval is in relation to the resolution of the index. In contrast, indexing with ``Timestamp`` or ``datetime`` objects is exact, because the objects have exact meaning. These also follow the semantics of *including both endpoints*. -These ``datetime`` objects are specific ``hours, minutes,`` and ``seconds`` even though they were not explicitly specified (they are ``0``). +These ``Timestamp`` and ``datetime`` objects have exact ``hours, minutes,`` and ``seconds``, even though they were not explicitly specified (they are ``0``). .. ipython:: python @@ -578,10 +583,10 @@ regularity will result in a ``DatetimeIndex`` (but frequency is lost): ts[[0, 2, 6]].index -.. _timeseries.offsets: +.. _timeseries.components: Time/Date Components -~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-------------------- There are several time/date properties that one can access from ``Timestamp`` or a collection of timestamps like a ``DateTimeIndex``. @@ -617,6 +622,8 @@ There are several time/date properties that one can access from ``Timestamp`` or Furthermore, if you have a ``Series`` with datetimelike values, then you can access these properties via the ``.dt`` accessor, see the :ref:`docs ` +.. _timeseries.offsets: + DateOffset objects ------------------ From 3ab369ca6da880285fd75e555bc3d3b150067bff Mon Sep 17 00:00:00 2001 From: Matthew Roeschke Date: Tue, 20 Dec 2016 12:44:26 -0800 Subject: [PATCH 39/51] TST: Groupby.filter dropna=False with empty group (#10780) (#14926) Add test for dropna = True --- pandas/tests/groupby/test_filters.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/pandas/tests/groupby/test_filters.py b/pandas/tests/groupby/test_filters.py index 81bf977e924d8..fb0f52886ec31 100644 --- a/pandas/tests/groupby/test_filters.py +++ b/pandas/tests/groupby/test_filters.py @@ -596,6 +596,19 @@ def test_filter_non_bool_raises(self): with tm.assertRaisesRegexp(TypeError, 'filter function returned a.*'): df.groupby('a').filter(lambda g: g.c.mean()) + def test_filter_dropna_with_empty_groups(self): + # GH 10780 + data = pd.Series(np.random.rand(9), index=np.repeat([1, 2, 3], 3)) + groupped = data.groupby(level=0) + result_false = groupped.filter(lambda x: x.mean() > 1, dropna=False) + expected_false = pd.Series([np.nan] * 9, + index=np.repeat([1, 2, 3], 3)) + tm.assert_series_equal(result_false, expected_false) + + result_true = groupped.filter(lambda x: x.mean() > 1, dropna=True) + expected_true = pd.Series(index=pd.Index([], dtype=int)) + tm.assert_series_equal(result_true, expected_true) + def assert_fp_equal(a, b): assert (np.abs(a - b) < 1e-12).all() From 1678f147cfa4951022076d8a30331e1ca2b9947c Mon Sep 17 00:00:00 2001 From: Jeff Reback Date: Tue, 20 Dec 2016 19:01:15 -0500 Subject: [PATCH 40/51] DOC: small edits in timeseries.rst --- doc/source/timeseries.rst | 27 +++++++++++++++------------ 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/doc/source/timeseries.rst b/doc/source/timeseries.rst index 33694e22c4f02..7add24903ad78 100644 --- a/doc/source/timeseries.rst +++ b/doc/source/timeseries.rst @@ -527,7 +527,7 @@ If the timestamp string is treated as a slice, it can be used to index ``DataFra dft_minute['2011-12-31 23'] -:: warning: +:: warning:: However if the string is treated as an exact match the selection in ``DataFrame``'s ``[]`` will be column-wise and not row-wise, see :ref:`Indexing Basics `. For example ``dft_minute['2011-12-31 23:59']`` will raise ``KeyError`` as ``'2012-12-31 23:59'`` has the same resolution as index and there is no column with such name: @@ -688,12 +688,12 @@ We could have done the same thing with ``DateOffset``: The key features of a ``DateOffset`` object are: - - it can be added / subtracted to/from a datetime object to obtain a - shifted date - - it can be multiplied by an integer (positive or negative) so that the - increment will be applied multiple times - - it has ``rollforward`` and ``rollback`` methods for moving a date forward - or backward to the next or previous "offset date" +- it can be added / subtracted to/from a datetime object to obtain a + shifted date +- it can be multiplied by an integer (positive or negative) so that the + increment will be applied multiple times +- it has ``rollforward`` and ``rollback`` methods for moving a date forward + or backward to the next or previous "offset date" Subclasses of ``DateOffset`` define the ``apply`` function which dictates custom date increment logic, such as adding business days: @@ -805,7 +805,7 @@ used exactly like a ``Timedelta`` - see the Note that some offsets (such as ``BQuarterEnd``) do not have a vectorized implementation. They can still be used but may -calculate significantly slower and will raise a ``PerformanceWarning`` +calculate significantly slower and will show a ``PerformanceWarning`` .. ipython:: python :okwarning: @@ -815,8 +815,8 @@ calculate significantly slower and will raise a ``PerformanceWarning`` .. _timeseries.custombusinessdays: -Custom Business Days (Experimental) -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Custom Business Days +~~~~~~~~~~~~~~~~~~~~ The ``CDay`` or ``CustomBusinessDay`` class provides a parametric ``BusinessDay`` class which can be used to create customized business day @@ -845,7 +845,7 @@ Let's map to the weekday names pd.Series(dts.weekday, dts).map(pd.Series('Mon Tue Wed Thu Fri Sat Sun'.split())) -As of v0.14 holiday calendars can be used to provide the list of holidays. See the +Holiday calendars can be used to provide the list of holidays. See the :ref:`holiday calendar` section for more information. .. ipython:: python @@ -1349,12 +1349,15 @@ limited to, financial applications. See some :ref:`cookbook examples ` for some advanced strategies Starting in version 0.18.1, the ``resample()`` function can be used directly from -DataFrameGroupBy objects, see the :ref:`groupby docs `. +``DataFrameGroupBy`` objects, see the :ref:`groupby docs `. .. note:: ``.resample()`` is similar to using a ``.rolling()`` operation with a time-based offset, see a discussion :ref:`here ` +Basics +~~~~~~ + .. ipython:: python rng = pd.date_range('1/1/2012', periods=100, freq='S') From 4c3d4d4fbb5e1093a324d81dfd9de5d7650012c6 Mon Sep 17 00:00:00 2001 From: Maximilian Roos Date: Tue, 20 Dec 2016 20:58:19 -0500 Subject: [PATCH 41/51] cache and remove boxing (#14931) --- asv_bench/benchmarks/period.py | 25 +++++++++++++++++++++++++ doc/source/whatsnew/v0.19.2.txt | 1 + pandas/core/base.py | 10 +++++----- pandas/tseries/period.py | 8 +++++--- pandas/tseries/tests/test_period.py | 8 -------- 5 files changed, 36 insertions(+), 16 deletions(-) diff --git a/asv_bench/benchmarks/period.py b/asv_bench/benchmarks/period.py index ff5a201057bcd..f9837191a7bae 100644 --- a/asv_bench/benchmarks/period.py +++ b/asv_bench/benchmarks/period.py @@ -49,3 +49,28 @@ def time_value_counts_pindex(self): self.i.value_counts() +class period_standard_indexing(object): + goal_time = 0.2 + + def setup(self): + self.index = PeriodIndex(start='1985', periods=1000, freq='D') + self.series = Series(range(1000), index=self.index) + self.period = self.index[500] + + def time_get_loc(self): + self.index.get_loc(self.period) + + def time_shape(self): + self.index.shape + + def time_shallow_copy(self): + self.index._shallow_copy() + + def time_series_loc(self): + self.series.loc[self.period] + + def time_align(self): + pd.DataFrame({'a': self.series, 'b': self.series[:500]}) + + def time_intersection(self): + self.index[:750].intersection(self.index[250:]) diff --git a/doc/source/whatsnew/v0.19.2.txt b/doc/source/whatsnew/v0.19.2.txt index c94e08ec41760..72dbca223ef71 100644 --- a/doc/source/whatsnew/v0.19.2.txt +++ b/doc/source/whatsnew/v0.19.2.txt @@ -22,6 +22,7 @@ Performance Improvements ~~~~~~~~~~~~~~~~~~~~~~~~ - Improved performance of ``.replace()`` (:issue:`12745`) +- Improved performance of ``PeriodIndex`` (:issue:`14822`) - Improved performance ``Series`` creation with a datetime index and dictionary data (:issue:`14894`) .. _whatsnew_0192.enhancements.other: diff --git a/pandas/core/base.py b/pandas/core/base.py index a0365ce484a5a..49e43a60403ca 100644 --- a/pandas/core/base.py +++ b/pandas/core/base.py @@ -814,7 +814,7 @@ def transpose(self, *args, **kwargs): @property def shape(self): """ return a tuple of the shape of the underlying data """ - return self.values.shape + return self._values.shape @property def ndim(self): @@ -842,22 +842,22 @@ def data(self): @property def itemsize(self): """ return the size of the dtype of the item of the underlying data """ - return self.values.itemsize + return self._values.itemsize @property def nbytes(self): """ return the number of bytes in the underlying data """ - return self.values.nbytes + return self._values.nbytes @property def strides(self): """ return the strides of the underlying data """ - return self.values.strides + return self._values.strides @property def size(self): """ return the number of elements in the underlying data """ - return self.values.size + return self._values.size @property def flags(self): diff --git a/pandas/tseries/period.py b/pandas/tseries/period.py index 4bab3bc14461e..8c75195b25ef5 100644 --- a/pandas/tseries/period.py +++ b/pandas/tseries/period.py @@ -65,6 +65,7 @@ def dt64arr_to_periodarr(data, freq, tz): # --- Period index sketch + _DIFFERENT_FREQ_INDEX = period._DIFFERENT_FREQ_INDEX @@ -305,7 +306,7 @@ def _simple_new(cls, values, name=None, freq=None, **kwargs): if (len(values) > 0 and is_float_dtype(values)): raise TypeError("PeriodIndex can't take floats") else: - return PeriodIndex(values, name=name, freq=freq, **kwargs) + return cls(values, name=name, freq=freq, **kwargs) values = np.array(values, dtype='int64', copy=False) @@ -326,6 +327,8 @@ def _shallow_copy(self, values=None, **kwargs): if kwargs.get('freq') is None: # freq must be provided kwargs['freq'] = self.freq + if values is None: + values = self._values return super(PeriodIndex, self)._shallow_copy(values=values, **kwargs) def _coerce_scalar_to_index(self, item): @@ -356,9 +359,8 @@ def __contains__(self, key): def asi8(self): return self._values.view('i8') - @property + @cache_readonly def _int64index(self): - # do not cache, same as .asi8 return Int64Index(self.asi8, name=self.name, fastpath=True) @property diff --git a/pandas/tseries/tests/test_period.py b/pandas/tseries/tests/test_period.py index dae1554c0930e..ad4f669fceb42 100644 --- a/pandas/tseries/tests/test_period.py +++ b/pandas/tseries/tests/test_period.py @@ -2101,14 +2101,6 @@ def test_comp_period(self): exp = idx.values < idx.values[10] self.assert_numpy_array_equal(result, exp) - def test_getitem_ndim2(self): - idx = period_range('2007-01', periods=3, freq='M') - - result = idx[:, None] - # MPL kludge, internally has incorrect shape - tm.assertIsInstance(result, PeriodIndex) - self.assertEqual(result.shape, (len(idx), )) - def test_getitem_index(self): idx = period_range('2007-01', periods=10, freq='M', name='x') From 0a7cd9783e2b38d3895274b6d401ffc30bc00fe8 Mon Sep 17 00:00:00 2001 From: Jeff Reback Date: Wed, 21 Dec 2016 06:07:41 -0500 Subject: [PATCH 42/51] DOC: whatsnew 0.20 and timeseries doc fixes --- doc/source/timeseries.rst | 6 +-- doc/source/whatsnew/v0.20.0.txt | 68 ++++++++++++++++++--------------- 2 files changed, 41 insertions(+), 33 deletions(-) diff --git a/doc/source/timeseries.rst b/doc/source/timeseries.rst index 7add24903ad78..6de6abed9a681 100644 --- a/doc/source/timeseries.rst +++ b/doc/source/timeseries.rst @@ -527,11 +527,11 @@ If the timestamp string is treated as a slice, it can be used to index ``DataFra dft_minute['2011-12-31 23'] -:: warning:: +.. warning:: - However if the string is treated as an exact match the selection in ``DataFrame``'s ``[]`` will be column-wise and not row-wise, see :ref:`Indexing Basics `. For example ``dft_minute['2011-12-31 23:59']`` will raise ``KeyError`` as ``'2012-12-31 23:59'`` has the same resolution as index and there is no column with such name: + However if the string is treated as an exact match, the selection in ``DataFrame``'s ``[]`` will be column-wise and not row-wise, see :ref:`Indexing Basics `. For example ``dft_minute['2011-12-31 23:59']`` will raise ``KeyError`` as ``'2012-12-31 23:59'`` has the same resolution as index and there is no column with such name: - To select a single row, use ``.loc``. + To *always* have unambiguous selection, whether the row is treated as a slice or a single selection, use ``.loc``. .. ipython:: python diff --git a/doc/source/whatsnew/v0.20.0.txt b/doc/source/whatsnew/v0.20.0.txt index 46d275df00431..b27737bf7229a 100644 --- a/doc/source/whatsnew/v0.20.0.txt +++ b/doc/source/whatsnew/v0.20.0.txt @@ -23,6 +23,8 @@ New features ~~~~~~~~~~~~ +.. _whatsnew_0200.enhancements.dataio_dtype: + ``dtype`` keyword for data IO ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -106,7 +108,7 @@ Other enhancements - ``pd.Series.interpolate`` now supports timedelta as an index type with ``method='time'`` (:issue:`6424`) - ``pandas.io.json.json_normalize()`` gained the option ``errors='ignore'|'raise'``; the default is ``errors='raise'`` which is backward compatible. (:issue:`14583`) -- ``.select_dtypes()`` now allows `datetimetz` to generically select datetimes with tz (:issue:`14910`) +- ``.select_dtypes()`` now allows the string 'datetimetz' to generically select datetimes with tz (:issue:`14910`) .. _whatsnew_0200.api_breaking: @@ -157,7 +159,7 @@ Map on Index types now return other Index types mi.map(lambda x: x[0]) -- ``map`` on a Series with datetime64 values may return int64 dtypes rather than int32 +- ``map`` on a ``Series`` with ``datetime64`` values may return ``int64`` dtypes rather than ``int32`` .. ipython:: python @@ -182,53 +184,59 @@ Map on Index types now return other Index types s.map(lambda x: x.hour) -.. _whatsnew_0200.s3: +.. _whatsnew_0200.api_breaking.s3: S3 File Handling ^^^^^^^^^^^^^^^^ pandas now uses `s3fs `_ for handling S3 connections. This shouldn't break -any code. However, since s3fs is not a required dependency, you will need to install it separately (like boto -in prior versions of pandas) (:issue:`11915`). +any code. However, since s3fs is not a required dependency, you will need to install it separately, like ``boto`` +in prior versions of pandas. (:issue:`11915`). -.. _whatsnew_0200.api: +.. _whatsnew_0200.api_breaking.partial_string_indexing: -Other API Changes -^^^^^^^^^^^^^^^^^ +Partial String Indexing Changes +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -- ``CParserError`` has been renamed to ``ParserError`` in ``pd.read_csv`` and will be removed in the future (:issue:`12665`) -- ``SparseArray.cumsum()`` and ``SparseSeries.cumsum()`` will now always return ``SparseArray`` and ``SparseSeries`` respectively (:issue:`12855`) -- :ref:`DatetimeIndex Partial String Indexing ` now works as exact match provided that string resolution coincides with index resolution, including a case when both are seconds (:issue:`14826`). See :ref:`Slice vs. Exact Match ` for details. +:ref:`DatetimeIndex Partial String Indexing ` now works as exact match, provided that string resolution coincides with index resolution, including a case when both are seconds (:issue:`14826`). See :ref:`Slice vs. Exact Match ` for details. - .. ipython:: python +.. ipython:: python - df = DataFrame({'a': [1, 2, 3]}, DatetimeIndex(['2011-12-31 23:59:59', - '2012-01-01 00:00:00', - '2012-01-01 00:00:01'])) - Previous Behavior: + df = DataFrame({'a': [1, 2, 3]}, DatetimeIndex(['2011-12-31 23:59:59', + '2012-01-01 00:00:00', + '2012-01-01 00:00:01'])) +Previous Behavior: - .. code-block:: ipython +.. code-block:: ipython - In [4]: df['2011-12-31 23:59:59'] - Out[4]: + In [4]: df['2011-12-31 23:59:59'] + Out[4]: a - 2011-12-31 23:59:59 1 + 2011-12-31 23:59:59 1 - In [5]: df['a']['2011-12-31 23:59:59'] - Out[5]: - 2011-12-31 23:59:59 1 - Name: a, dtype: int64 + In [5]: df['a']['2011-12-31 23:59:59'] + Out[5]: + 2011-12-31 23:59:59 1 + Name: a, dtype: int64 - New Behavior: +New Behavior: - .. code-block:: ipython +.. code-block:: ipython + + In [4]: df['2011-12-31 23:59:59'] + KeyError: '2011-12-31 23:59:59' + + In [5]: df['a']['2011-12-31 23:59:59'] + Out[5]: 1 + +.. _whatsnew_0200.api: - In [4]: df['2011-12-31 23:59:59'] - KeyError: '2011-12-31 23:59:59' +Other API Changes +^^^^^^^^^^^^^^^^^ - In [5]: df['a']['2011-12-31 23:59:59'] - Out[5]: 1 +- ``CParserError`` has been renamed to ``ParserError`` in ``pd.read_csv`` and will be removed in the future (:issue:`12665`) +- ``SparseArray.cumsum()`` and ``SparseSeries.cumsum()`` will now always return ``SparseArray`` and ``SparseSeries`` respectively (:issue:`12855`) .. _whatsnew_0200.deprecations: From 07c83eedba7494ff293acd7d800190cc29ebb888 Mon Sep 17 00:00:00 2001 From: Jeff Reback Date: Wed, 21 Dec 2016 06:09:28 -0500 Subject: [PATCH 43/51] PERF: fix getitem unique_check / initialization issue closes #14930 Author: Jeff Reback Closes #14933 from jreback/perf and squashes the following commits: dc32b39 [Jeff Reback] PERF: fix getitem unique_check / initialization issue --- asv_bench/benchmarks/frame_methods.py | 7 +++ doc/source/whatsnew/v0.19.2.txt | 1 + pandas/index.pyx | 66 +++++++++++++-------------- 3 files changed, 40 insertions(+), 34 deletions(-) diff --git a/asv_bench/benchmarks/frame_methods.py b/asv_bench/benchmarks/frame_methods.py index 8cbf5b8d97b70..adbe73aa5c5ef 100644 --- a/asv_bench/benchmarks/frame_methods.py +++ b/asv_bench/benchmarks/frame_methods.py @@ -68,6 +68,8 @@ class Iteration(object): def setup(self): self.df = DataFrame(randn(10000, 1000)) self.df2 = DataFrame(np.random.randn(50000, 10)) + self.df3 = pd.DataFrame(np.random.randn(1000,5000), + columns=['C'+str(c) for c in range(5000)]) def f(self): if hasattr(self.df, '_item_cache'): @@ -85,6 +87,11 @@ def time_iteritems(self): def time_iteritems_cached(self): self.g() + def time_iteritems_indexing(self): + df = self.df3 + for col in df: + df[col] + def time_itertuples(self): for row in self.df2.itertuples(): pass diff --git a/doc/source/whatsnew/v0.19.2.txt b/doc/source/whatsnew/v0.19.2.txt index 72dbca223ef71..ef40faf5457e7 100644 --- a/doc/source/whatsnew/v0.19.2.txt +++ b/doc/source/whatsnew/v0.19.2.txt @@ -23,6 +23,7 @@ Performance Improvements - Improved performance of ``.replace()`` (:issue:`12745`) - Improved performance of ``PeriodIndex`` (:issue:`14822`) +- Performance regression in indexing with getitem (:issue:`14930`) - Improved performance ``Series`` creation with a datetime index and dictionary data (:issue:`14894`) .. _whatsnew_0192.enhancements.other: diff --git a/pandas/index.pyx b/pandas/index.pyx index a6eb74727a999..a245e85d80f96 100644 --- a/pandas/index.pyx +++ b/pandas/index.pyx @@ -82,20 +82,13 @@ cdef class IndexEngine: cdef: bint unique, monotonic_inc, monotonic_dec - bint initialized, monotonic_check, unique_check + bint need_monotonic_check, need_unique_check def __init__(self, vgetter, n): self.vgetter = vgetter self.over_size_threshold = n >= _SIZE_CUTOFF - - self.initialized = 0 - self.monotonic_check = 0 - self.unique_check = 0 - - self.unique = 0 - self.monotonic_inc = 0 - self.monotonic_dec = 0 + self.clear_mapping() def __contains__(self, object val): self._ensure_mapping_populated() @@ -213,16 +206,20 @@ cdef class IndexEngine: property is_unique: def __get__(self): - if not self.initialized: - self.initialize() + if self.need_unique_check: + self._do_unique_check() - self.unique_check = 1 return self.unique == 1 + cdef inline _do_unique_check(self): + + # this de-facto the same + self._ensure_mapping_populated() + property is_monotonic_increasing: def __get__(self): - if not self.monotonic_check: + if self.need_monotonic_check: self._do_monotonic_check() return self.monotonic_inc == 1 @@ -230,7 +227,7 @@ cdef class IndexEngine: property is_monotonic_decreasing: def __get__(self): - if not self.monotonic_check: + if self.need_monotonic_check: self._do_monotonic_check() return self.monotonic_dec == 1 @@ -246,13 +243,12 @@ cdef class IndexEngine: self.monotonic_dec = 0 is_unique = 0 - self.monotonic_check = 1 + self.need_monotonic_check = 0 # we can only be sure of uniqueness if is_unique=1 if is_unique: - self.initialized = 1 self.unique = 1 - self.unique_check = 1 + self.need_unique_check = 0 cdef _get_index_values(self): return self.vgetter() @@ -266,30 +262,32 @@ cdef class IndexEngine: cdef _check_type(self, object val): hash(val) + property is_mapping_populated: + + def __get__(self): + return self.mapping is not None + cdef inline _ensure_mapping_populated(self): - # need to reset if we have previously - # set the initialized from monotonic checks - if self.unique_check: - self.initialized = 0 - if not self.initialized: - self.initialize() - - cdef initialize(self): - values = self._get_index_values() + # this populates the mapping + # if its not already populated + # also satisfies the need_unique_check - self.mapping = self._make_hash_table(len(values)) - self.mapping.map_locations(values) + if not self.is_mapping_populated: - if len(self.mapping) == len(values): - self.unique = 1 + values = self._get_index_values() + + self.mapping = self._make_hash_table(len(values)) + self.mapping.map_locations(values) + + if len(self.mapping) == len(values): + self.unique = 1 - self.initialized = 1 + self.need_unique_check = 0 def clear_mapping(self): self.mapping = None - self.initialized = 0 - self.monotonic_check = 0 - self.unique_check = 0 + self.need_monotonic_check = 1 + self.need_unique_check = 1 self.unique = 0 self.monotonic_inc = 0 From 73e2829c3c8eb7a31bc2beb17e0735c8a365d1c8 Mon Sep 17 00:00:00 2001 From: gfyoung Date: Wed, 21 Dec 2016 06:28:02 -0500 Subject: [PATCH 44/51] BUG: Properly read Categorical msgpacks (#14918) Patches bug in read_msgpack in which Series categoricals were accidentally being constructed with a non-categorical dtype, resulting in an error. Closes gh-14901. --- doc/source/whatsnew/v0.20.0.txt | 1 + pandas/io/packers.py | 6 +----- pandas/io/tests/test_packers.py | 4 ++++ 3 files changed, 6 insertions(+), 5 deletions(-) diff --git a/doc/source/whatsnew/v0.20.0.txt b/doc/source/whatsnew/v0.20.0.txt index b27737bf7229a..27f8564ba16c2 100644 --- a/doc/source/whatsnew/v0.20.0.txt +++ b/doc/source/whatsnew/v0.20.0.txt @@ -286,6 +286,7 @@ Bug Fixes +- Bug in ``pd.read_msgpack()`` in which ``Series`` categoricals were being improperly processed (:issue:`14901`) diff --git a/pandas/io/packers.py b/pandas/io/packers.py index 1838d9175e597..ab44e46c96b77 100644 --- a/pandas/io/packers.py +++ b/pandas/io/packers.py @@ -593,17 +593,13 @@ def decode(obj): elif typ == u'series': dtype = dtype_for(obj[u'dtype']) pd_dtype = pandas_dtype(dtype) - np_dtype = pandas_dtype(dtype).base index = obj[u'index'] result = globals()[obj[u'klass']](unconvert(obj[u'data'], dtype, obj[u'compress']), index=index, - dtype=np_dtype, + dtype=pd_dtype, name=obj[u'name']) - tz = getattr(pd_dtype, 'tz', None) - if tz: - result = result.dt.tz_localize('UTC').dt.tz_convert(tz) return result elif typ == u'block_manager': diff --git a/pandas/io/tests/test_packers.py b/pandas/io/tests/test_packers.py index 91042775ba19d..63c2ffc629ca6 100644 --- a/pandas/io/tests/test_packers.py +++ b/pandas/io/tests/test_packers.py @@ -363,6 +363,8 @@ def setUp(self): 'F': [Timestamp('20130102', tz='US/Eastern')] * 2 + [Timestamp('20130603', tz='CET')] * 3, 'G': [Timestamp('20130102', tz='US/Eastern')] * 5, + 'H': Categorical([1, 2, 3, 4, 5]), + 'I': Categorical([1, 2, 3, 4, 5], ordered=True), } self.d['float'] = Series(data['A']) @@ -370,6 +372,8 @@ def setUp(self): self.d['mixed'] = Series(data['E']) self.d['dt_tz_mixed'] = Series(data['F']) self.d['dt_tz'] = Series(data['G']) + self.d['cat_ordered'] = Series(data['H']) + self.d['cat_unordered'] = Series(data['I']) def test_basic(self): From f79bc7a9d128187f3a93a3dae84ff03f4f4a62f4 Mon Sep 17 00:00:00 2001 From: Dr-Irv Date: Wed, 21 Dec 2016 11:47:32 -0500 Subject: [PATCH 45/51] DOC: Pandas Cheat Sheet closes #13202 closes #14943 --- doc/cheatsheet/Pandas_Cheat_Sheet.pdf | Bin 0 -> 685314 bytes doc/cheatsheet/Pandas_Cheat_Sheet.pptx | Bin 0 -> 104088 bytes doc/cheatsheet/README.txt | 4 ++++ doc/source/whatsnew/v0.19.2.txt | 2 ++ 4 files changed, 6 insertions(+) create mode 100644 doc/cheatsheet/Pandas_Cheat_Sheet.pdf create mode 100644 doc/cheatsheet/Pandas_Cheat_Sheet.pptx create mode 100644 doc/cheatsheet/README.txt diff --git a/doc/cheatsheet/Pandas_Cheat_Sheet.pdf b/doc/cheatsheet/Pandas_Cheat_Sheet.pdf new file mode 100644 index 0000000000000000000000000000000000000000..a0bff02d45f91e3af754564dcab23afdfdd0a100 GIT binary patch literal 685314 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
  • CN0m00L7rxHDaU zt_whLhF-Ky^;{p2guP2ki%FMEZtSA6NN(F)7y1b@x(s1oP(LH2-QM5P2)Aew6Bnqe z)?KT0E(I<%*UDkx^6}io$1ts1*^$TZ48fW5J$E%-o!e z{qK^FQ0_X1(}SaF(7zxdL1bYG1z9h$?E*0gN#*T)dn7}(?ZhNx6*3N5sL4ic^1`oH z^Fl(%#3Ey2>XMTQ)A!$jp$5&*&pWk>m%hCIp)bl}{DtMo8nQ}OQT_E`>NB%`>>h+H z%p;Vn>$SKVP*ZpXN@!~-4&g1Mi7iH8SDl`mGz$L&U9HyZ7x)9B9(#Lvd5Cm7C@6Xi&_#R~kWOfDR2;ql-}Xu$vQI#*<1+)ys~!6#iV9;buCg*43(N3Imuxq$ z0|Z~dteZJVA!xVCYWt+^Wrx=FMzX-7#Y99T+MzcjtDv%K6yHwaQSJNUscg zE7OpRZ{u94@rlPFG0_zvf>hMVVX}w_G7G73aUtG%25LI{#b&qxC)1VD-IH7aI%OGI z0mS8o=4QQeGTZn+ngcShel3Lw-y@8i(%C2GZwmIC4wGOn85w388y&@;vl>JMxKPoq zd=7o&AGOFPw!PfJ2x2ew(?Ea!yR&V*_Y_8DdDSXk*}PMq>M)Oh2n-6X&h)Qpy1J1E zvY=h4+rF47mVPi-<8rfqMwuh2`a$>FN8syS^ZO`&sAYG+&P$2)dV|?mKwA=-6f7 zIyiE_-5J@h7b<5G@j4<0^>s(S1cmk{)Xv_%EN1ZKOA*swY5b&aj;|tKKscm9xk!o7=}T=VK0 z^v`8Ke*O9twNtIAsJOG!2%%8L#di+!p6cld6NSMy>^4wUJ>0L`411jhq$?@@{>pQS zd9WnaV@DVj6KhpW?GZLTiy*QBIi*kU-@{knn1}{3 ziM57=_=~lVVc1q26XN4%Z*_LEq7hf4WW5_&Z1AqKu4`2X)w}QE5CS_W$fbdcq<&h# zp7j!BWWoEVd$U*qEC|2wiHIUUliew3YHG?L6WoDSD|O%fk(!bMnn^^5bp0L=rEqw7 zvpD>#NNFT3x>~;=9#SQx)SM?J)4TvL=z0T%J;D>a2*ngRKjvpJX++@eqKe?`Rz8yP zY!Vrsn2cq1LRYsVA$L*E3?R?e22u0j=_*pBjQ4@7>(Eq_sKIw6pP9@#5)8gd`5$^;J z%P8WY0nz(x9DH|F^!|MLl`Y+LLBhFws-La?Z(?G2#ZsG_f39@BkycxF?7%?mfqf_K z&MfN<$0Y!g%cd|St?J3Csh-|mv(HKI--Gfbr)A)~H(kOrb8DtS7nkM_e0U(K^tnE( zsqX6Rl!;+Sj35>`<0ZXtQ-a=lfByV=cW*WgouqcOA?}gKldd;*kiE+@_1HI<6Sf1% zh#wik_2Gtpa^RCSYqD?&l&|4?M`TZZ$MD$%MA* z+;_D|<;RnrzWAD-pHJvn)zEO&4%3E!%9oV%+wdT6f;J_&4XP^ia*7d9Z@y+&G3rK` zAaXk3C9uHh31DI>qocpg%nVdEhB0pOaUZ304N@Z*SnB9_{>?5jGE!A-ye}658+bFM z)hNM?(}AJG`7HB`Zq=jG5nNX5TU$v z*9T-oSfDv8%cK{L8!`Y4M^?5E$y>wLc6&tBZdtYK%}9fvE^H#j^~0S&7H)B7Ll*QX zh|bb-KPQL!`3D+0I*-AW9>^}eve6u>zOlA;a$4G8+Zm3ikk?UrPY(j(n$z5LO=~Mm z93w01!Ll^Swt0DYL<+aA@<(AFq$4RwO^r>P2jvaDp`k1CTZ>~lE9*@uS=n4aDHq91 zk)e<5E80Q&U@|c<93@0hWGK46e?L$6JX`d2x^6lwQBEszUvBScC6rmm0y75ipeIjq zsi~<`DhAbGKh!w;+#BY}gCFxJMn{8WPRH}*0|EkItpu|=J|s^geuERMBwRl7*wb+r z$X!JObzpX8JP^^F6T@DafuZdDZ2ov>s&wd+CnMt=#6FX2yR@PL)$q%=E`t25EYx?X zSrT_p`&%#W6=VFdN6!$V-4C|6w*l`bH8m2SoPglh)|S`Vmg=Ip81+mrWN|4WVH_ap ztNXoHM+p)sxtyGw7yCa6iG9c&m@v!(FU8-WWEUV;NQ#@rCML>mQb96i7ZzMQ;aikN zt`0&mxkT6o`7?n01{5XXnPRgP zK<2%=wpLmi_SFD*o~3|Nm%*IzE_g<(si`&klj7mvz%EP2%4EX&Nry=`18Nnc z@PZlKRGsg|!C0;}?7VqZ9Gk9LXB#JBlRq=^sbJt4Ohpao&?8~;@Mvl}3aK$c7Q{m*c^%L2 z{N&8cR!6f3ASb$I>5vi#+tE^ys@{x*k805S_o6H;+D#1&rxb5nTH2u4aB!h;h#2e* zn|-XbjEpGyzG7mK32LP*lCtdV+2Sd#H%>+WHak! zWqS=m6f;QLs?2z9cN3*(lU0MnY4~L^4lxlrWN}kqK8Lh4JBrq+8g^PR2I0w7l z|DFHl@-pgZ&@3dF_0`SpXE;|OA)(QXoM)jAv^P*%p<`lh@~cW!#L%*_1%jTik&(Wu ztDqxbnrT{^ukqQ>pasc7JVl@eWQg1g8Cd8Pi#Bd%&z?Q2Bq7|d73pMdw!|C6v#-PI zc<~NICSL9oP`*$E8Vp+@R?X5|4~}jLH6%xoxN2%n=}2}7iQK=P8JHvUJfu@d$%3f> zh>#@*M`Z%5(gnByAp$}es6sK2k+Y#3bUXN0nE zcaipiY5&UeIl-f{{f^L@qEU`%7%SC8EXGHe_chJULLwsfnb2<0eUfJ~n;?qpPu^a& zx0?qC2gCjdH%AywD@J?=Q7OsGQ&UlCzrociV~5iZZ(rC;7$)su(JAwLb(WccV{d0? zr!pGpeac5i_k$WOfsKZndqnioguES{h=_tLeW^Y@{M`!i?Ooir@7@rN{%@p5XL}-Q zyii+U$4pF3ILowRy(t_M^a?5zyh?VbR&2M4pFWYa)9z#s83KHOiVgnG`>YfuBm0z@ zsdOmXF<3JSKYGgd_7eGcpNNGKgrS(2vR@<9AQxnIAgixO*gZUK14#;?zht>c7qLA@ z=Hcg;*7YV5LvGg<7Dl}$!N;gE0L{&oma%u)1xLO7eDy`euilcO5*VcH|E#Ohp@-bV zMpV|;5*WC9>G|HAd(AB`tIyySH&`dVc+t4l%hK$;Lfs#0mz$ew4!Do95ZoXxX=y~! zHpxz7IZ*5CI~Ai5;5dfk&Mrh&|X%dsOV?_(iJL0 z!+TD8u=5iV#4RlHg3feK0gmx#Ss~>}UQh31(0c}SeSKMiT}pSomXwsoMsIJYqrZ~z zpUA%4zsiVzA}ZwEURbF0sKss3RC-x*9${>DSMs zJoX2v&#Y~S(-A!m85zTwf4qXA2lGGP~@)>AEJEjBGqEqB3<)TYM9N}WZBcYpsiXg2KmvgS}T zFnDc^UO|4neA(!v_ms`W#yJvLX?kYni2F=MvXX+r-i8J zMXar?&?fi>PwS|ug-i|jCWNLBo@@wAa%%1g``P~dAo;kW8o-g56e4-g+TYeAFqM2B z6<{AV+65rUV-o$Aa{}xB_q2R(d-ZB+3=4~FI?Wn}(o3U;ou$K&&`2@uqd zU$E9|tCV(G1AKe9lytjqa7z^5we_B`n%X@YCg#Wp+hab@TSegA5RzF96O!u?i{K(O z)QEemDBz2%tM2OTj}zR+j3#Dg>TM@}KUL>LC3sv=n7HrLgJh22d$=epC@8pB?ds|Z zIJMKC^+8~S{#GZk2?2?2Rjo$`U;H!If~4YNqEG&4pIJVUHNRSuc}}o}_3|NBG}s?4~U&NQ+YOi-C{y;J-qY zot-aDx-^1QLx)57IX}O*vJxCV_3azd&kvQA92e)ApxtNgY0{UF^-)b-y(v90j^+0N z+Y}^CCPv5kv>=PO5Z1=Qfd$m5Lh2z+1OU2O>NGnCbZUVmtv#lIdtF>t3Qmjf;Al|a zWM6CcC&I$6mX^b9_uQh4jE$}#&CSig*@s_YP_)YJn0Y=!d4%#CF!(_|bG$#s6Ev!*LlCJLVqB=+T zJdZEU&7Igccv`JBGZ&Vo7S_^HVR{N-g$#CgDx`kpdv*%_Il&0}4(+jm$L7PNs!F%* ztffUoTZ*`L$4W4J8wYPI?Ni_CWHMgJkCI97KKct3N6CecCO6~{tF7hHn*m+LG+|$Y zmZzxEP(=ib_hHgaRxe*hEmBTVh5{Zg0!^#SM*ngL-#n99dnUmrQN zh^SJMW#YLrX$unxdM$CJ$QtTveEbcoQ|Ut9{bOUtfGC{)A^P*&;9yLY&~L(McN^$E z>yJzih;mU*4mvxs2_k`v(IU~!I>sg%I=Z^{bX|>mCo49Bh)W(uyChNSXL9mSJ-m&1 z1d8x$nu2^~$(O`B#o^yW@FBVIKb3@gYARo4@Wxg7-yAqWcDR(ggbF)LRYe^jcATh(A`<E}BR_T1Ns99OR zbk%>YsBj*obYN^Yz5D58cgj|}jU%K9;@fh^F9`jjud?9NZE*@zg)JOvosKLckgcfb zN=xU=>c>*NH+6H1iHjRqXhJqS$5+k}x|>jbgi82vzL9p1uEa(SR05$xzmwxRan zlCz|LjE!Y`loHAeipcnPl9e+q>NwW zJI}TU!Z1G>1KKR`_5k1VurvBu+&EWdUEX{v5R}4Uezv;mQ=9!rT<+mcUF~704IMjU zFYVEhk+JPO%yNo~)#yN&+Pb3LZ;7$6miP8ZiHM}hStF6DbzoF( z82Br6ZeTLdNeTjhC#dvk{JtPsY)6%HL zXW5Rzx6>)>f?Rcl7q7NpeYZvK6odcCA{+%tN=e~+`JPTp;8TnFLL>SuB0yr5(@Q$d z49zRQD154w@+sWp=HePm?Luu`CkGUaZ5(t;0GA9Ds}~mO%FHC7YG}G&ZvFt&VN8+& zMHY!b4wpP0s6G692psQC0Itsd{e5tMzaHe1)$k<4)9w3sJaG-Ij;JKSrXCTUhRl@a zSzuu~$F#k+aj2;tw6x^?*5A0Zt$P%62nflAN>leok_%*l%|u?(hJZ-$F(JX_d}j(Y zVr-wfLW2OBViND-l98Pr8{M>UwP5M)K9oQG`gG40Aa8`mS;a3987R2q5M)1sjBR!7uUYDNNchH@OS`L>C}`I@MPxq^u)VizuU^*ro)|?S$=d15kg85N{nT}AkLS} z_PnmY{Jg#OiBjD`s)Pc?prxWx1uW``heemLQM^dQ`NT1bI^wZ zIh*x{ULcOWU`=;HNl8h4y^c`;k(jVpe9Ry-QK~=WIrJh>bm03?et}R(uwgma|~$ z_4En~3sD0z9DaIWkT*-o$c%JbXvU$4nQ)?2SJ;q=TyH%=L_`GKsOk(*<^ej6VVz@o zb~e@F3S$>S^f|xBo_&xM!S4EMPq;tk&8*B=u4IL>OxMTsbe8zf_Q;@M4CzVIx;3t^ zx*5e}e)@DJ?s2bkhn0l|?Lv_!T<{30OFe+qbqW8AM9tEUD+V z9F4mRHM%N5=Oa=h{w8*Foyx zRk&^5#V<2p>7;@kT&k+7V2_Z0na&#tsi_(pBA%OKRE*Mh){5FUtgRt zr%PV#yX*=MMLD@|^{*x%U*Pc2$r{C8`?8_}$PORh|K;Ku6VJ~p5SC$a=;;bOqlm5eJYSt9e@4?y{6a6Nv3Iki)0Vpoc-p7ur16L*|E}mUjxEYR4a#@!p zk)M_AeSKD3PtTr(Xr!h#zAHxHl~s2^K}?)x*!25_6IVSXFk? zE9%L)egY&tb!}cU?x<&$Q9HoJ_-!hSOrq`wxba`$Ff1B_*bZMg}>WpG!(` ztUmEGi-Fc8pic%;$h|{JVVeP*7?9=P2KDZOy_fS8`FaoZofO_U!f8)e9i7J>FX-q> z-(YSwL+^8V9n9$^sHq*_k`|*>nC@tt$HXYSvX;f78YHy0x8DPK-;tz(LQG*H{e>*v zo>SXh_z(CuQEGKqj})^%e1MCt!Cc;sz?KIZG553-^ywtJ@+ix=n%5w@8lKqgsH@^8 zd^7eHHQHKQJKNhFx)q?Ls;;cGEi`kxxw&x-lS@IlBeBWnKk#cY1D^0N)PoNVkuz{1%O2n}AISZ%4OaZeW^a~gQLh!rHZECD`f zX1-R`5P=F~29v?WxU^`Ib>$UQmtxj)Zz9Kn(17^1Dq3B{Lx#F|8p%h!<7JJ{bUb z!G>2VDk`$ta2l*`6l{AoFOZZpdkfhAK6G&*4-eN`_eTllNuiqoNXF>sDA*+m@-vVt z}}LRR5*Oyfxvlgk2#F%Jt1`rRP#Acyk}RkgK0 zCMVATyGC4G9B?+9EfVnU0bMWeIjU~ifW61je1ngLCl9QHoI%Bw5zldlJDX~xh=@qh zEWL7uj=p}Ky8Mfpni}tMu?}GS&3;!nf$sv7wMx?iHptRwdcg*hk1{Sa zd*kXiwY9Z@)WgDXwe6}sBwfHAMOx3;I4;D&#zrjpv8Er`p?r69af%Utscr@4u=m@|O~~~Z+I@(O2WZ^+{@z=mU=C0odj{fLc0mE?v2IcXEb|HYO#b*Wp7=C)ln4;rW*SaCiHMwnQ26`>?cOY@k7WOHLs`k@xu~N-Jo+&i%3i zt*;Ns$^YWxrNqaJ|CHDUEaJHg8BUc7Kz?FSW?}hUUCrg#9SN2T9uZNVeYHFOiR{+* zqPuf){Yrq_oUK2kcn?7TAG+RSJUl6Vns;F1?%cI-Br3>WYl1OvecpDCjbS4&QLerQ zY+jFShwA0SLuF+dIj~_F@QsDN^8q?RLjxFpBrQ{3dovt+SKHrrK|31cy=Uv1hK4M& z5xCIumS?_Uo^flJ6l=q=E^Dw2oV={>Tk@!|bzSzpS|g9mTzsYRP1^e!yJyEoWkDhz zORLWi5U}}yJ~7SJ-Ou{1z|uunhUs-{=Ey}=>!$ZF4sP!AK6=oJp85Hco{kP|$$y3n zwp>BiaOrI%L8m)rsFf}l06n%5L7}0crKP2|^=SZ}BqLMo+OV5*0Q=%jkB>RflV9Xh z^C@;o`_@!eUh$9I`FeYsHu4Dy<_3c!6n_5HmstgX4xmJjkE?b4w5dnRF-MMs5@BFs zdU|*SEJHC4wzl~A`B#D_I{{6d$A9lva;qi4K)dA^a(S!DbICbWvuAT_K z(LMeO(8afGENYHlO9G%6Orw+(e3vL2Apt>WS63w<+YQLYfczd<4bcblon*ZBeZqK*YT`JHrF| za}63@2=MTa*UYF7=+=?o;8hhA2G`eV5MS2l$;J4Ko0yo`*)h=~l^YrxuW|BJfeo;& ztwwx=H=s1EtFG>D%|4l5ScrT37R)}N`M`f&req8Pq@mQCo`+OqIG8do+oopj(3J{q zMeX1@r6gce93CE`qN2{KZNT(cRLkVr0v@7BGDF3w# zhKI-XpNce#GYgXU-7qU1Mn^~EHeFhq;NePupuE`krLV8=%^O6C;iHavh6+xW!}ay< zrKLbu*F>f4`S{iCZSPmFsFF}qQd2E~_S4b=%x8tnuiFaHOGlYsyK?jJTsP-tX9p*} z4u;1(eaxcFN61XWOfWWzPT=n0F>ZRrg#2I=QPD^mj?~w80Sz=fJV~%}gG|QY`;bTm z`ulNu&i$RkCs~IOQ^+Gt#|b>&RW%342a$`ngQgxz+Xkd9QN-)@xZ-4_;XGuH;gkd+ zII4dg@!flus8!qFee8GF-;I;K$ngX503#|n{S4q-zqS$jbl|8=C~}S3x;`1 zm*&|VX@dogOpx^1tAq$It9LhkrL|%vs9jWe{e7rzD7`edmN86`--M%-rKJ%*7^?&7pS7e~fE$eVyS|=XKjsx!2cJu$Q}S zy-SFe=D++XgaI$pVg&vDyI^8_eVT)YCV&rEoP?w#$Rj6T*2I5-e-1_m`tEOlKaFo? zrUa=07Fri^tW3Vz`S0KN)0@=CPDg||{0ubz{SF0ga5CQCI~3I2&D^}5E!h-o9qriE zEY02YDLFV<*}3>A*;#qm+1a@$`FUCSz@NOV{0|4^NT>@5v1wDXi-@qvP;#+}gTMZq zej{$~X6xk0rp~6R_Wa?O!N$$aS%8hr+0@a()RooQ+rre%l-0?_n(Zki_^i5{i@Uj- zimA)PK{tQSt@-W-ruo4d2Ulc|L(8z(#1qruL}_AmezPZw~CpuMf5HH*28rKy{%jisd< ztFwjGe;w4Ha{&Jt6cG4-nsOfAKgSXMJ>|SyJgj^VQ_juvznJoeF*&=~I+|O$IXOBx zyV*L}`j|ef&YuzfS4sbD4*5q?u<-v#s$uJ9Z^`hKl1<#*&Bn=v;kkFCEfd+*UY|QTQL;8a&03t#w=mKE>?qM%Nx^$BGU?+! zpUKx+0w3*Ur6tGXJXWFSHrqBE0(v6Xvv28S*&uFb$8T+G{dC#^09TF zJE5B=>>QPZ079-7WY}*Ve#NJQUZ5wLpUIj2o>E1A8))|0$3iS1(<+{VHJ#Rb#5K&5s`chwC;}t;=5O&41Cv0tCQlcgks##>(&ZPPDaz`zH7}J)%O@c5s zCj@4E>}AMso+LN2dRgHKxw9#Q4y%C*d+{5qx2QQby=n9+GWpIwl#URi6kbrrdw#@Z znWXw48g>hK*kDb%wuBO{}m>x)E&;eOR|72>T~!V(n5PM(R z`PF7pJB-f6?ueLX-|9T8C#p}a!s1|fU2-O}uO!~fbhzaFd~T1(B1!pJSkE!b zIy}3EXC6kc07~7!QCFc_RGvvHUBHX8*oA6C-DTm^YhbBkNvOir70`IZG^4FOihBU> z7=8f%;xLRnd9iG@jZ9U)9P&6x8QYiyHHFdzw+S4e&v=( z5vf6}({|ORVu62Jn(!stwMcF6Q=tzLD~~>OjZlRa8I+I=46$iL43XFII;5oklI0SWD# zU%%d|6|N{Eh2kBZ-EGYGadk3b3iYn-dK(buhUJ$MA(vNCA+O$)+nRa6%E-<3xCnK9y zkhcjVa4oP18}K3*wTxgfE>tnA)oNGclc6Gw!hmL`IJ$yi#Qn;LO>xw}6(4L05~s50 z*^P<9K(OET2ZhdPeSF5dV%r!{xe~q;TcYp?`prf$dh@0z9@bYnZB3QP+pjCbV|0WU z?pirrO_iAGw(*Ew4I2U}gNYHxq9`9G*1o1_$&hCDMY1fmo|TUl*C0LFscv5Y!i-t^ zPeig93+2yT8jLiZ@Osug)~14V^bEXlyY)0bEd1nXv%F>#j2hRW2d*2L*c$k_R&z%B zT2_3s>Q5UZ!bfnClr^~Su^2-UpN_S*Vxvr*UCe)xFUuSf&5Ttyu=bg%5?swpu}Di5 z=9yUhusdAJwEO)iwLWvP^%H|loM;Z|_hU)?F@nL59vm=U8S(6ef<^|`(o?r+gObxzY;2OOyp*B*wqo#o;39@;lxe>~TJ(DB$;9sRh*Vcx zXDh;m1u607QPd`~?-)2x22uGcpP8wzQO2QOv(=d=^&NpUdWBYtgK^h_I_! zpT~j#Wpc!NkW~iw)E}#S2df1+vqrEVp+1Yb&~+x#!R}_VYukJkOiOlDExlpP;$5iY z+-9W3Oz6Lp?pH6fk;V&?lI_Kd;~iMbsWQw8v{-cIYMyXjO|rM7m;m8(%rLpTf1;+5 z8RaEY>^`3lM<{2XLee0%QpAU2v?_AI>cTsNn_GsmBUYA^^41O z#s9I|2DOF#RyAQAR$iel!HP?k85Vpc$!fw!*Y``uc73e1GBhO(i9`QBYIw{6iUHw3 zB$sJesHBM@GZGXP6?;F^UaqqzGLHm;-Ol|z)YVE6Ql8~jSV7s)ZW=v?EZ(*@)RRf0 zrsHU-m=r}PP)}POojH)|PUbxn74>HjY!^ndqBv?1otGuxYP67rFjFr>U{L00#jJ*h z(Uizg?`B4nR~;*}RkwO87PBFw&J>@HQ0tC;w5M^F zK^$X~TZx+OVcH{I5kmE}HecIVNu-W7RT_whP8)-JL^4WZ7b+D59W?CEHj!S({G(w{ zHAxvk;iF<$S+00!&yl$T0m8BzBWCT`0v-y@C?j0j1jMEdgSS!alFr97*YRnd5QU7lNf0O8mXOImWsTh>+oU7&vs! z^8nYcc5AwB=xSMHAy85y*cs!BO3I(SDa(0BPO|$R_RPzATU}vx8Pi6$GTmWIQ^Zo9 z#Pwy_<0ZfCu_#I?C%o(QJl$aXc#xO`J{`>Q1U{{kiugbG1U|jZ@rb-Wvh;wRGzGl8 z^@#Z2MoJ9d_wY@bygyyMpF5MkzYLJRT^(KoLOxCQ5Fc+Q@_+=+e}m|I#8|5duhJG` zb-Q|T*OHuj-cMCFUx6k}TU^qnW6PvBBH6urkbP<4#rEQs60=u7i%;agR#7p1Dt40n zZJc)F7MxhT8Q=&tq6oIq!=JP!=?-}AxCr1p){g{fsA@p^moz**CY@fBpIwvtSD^;7 zuU7p|KTq@vlr7u-RX^8(YiC96Q!n%@;fM_lCx9Vv<nfyAe=xri3fKXByB(5Ez zvf-fo&E|$9A!uGwg1?txgunE`gq8YpWHUte_E$JtewuUo>UoQ=(L%Sa$#H~e6~ZP7 z&ujRvvv@2QZ26zd!*j3Pk`B46N^?4yY~LV$Du^j{?A%>M6bJZ?0<-%r^H*qkSIHdj z`J{X&&D=(Oz1Klc{@Ry3X_XgbqYBhHu#@Xox}!V8_)hgKX^c*`KBUD(meH?E;-egm z(WEm{UTKCRLFpLc4y2!!6285nlXI!opK5Qw9n-CtkPOSGv!{U!zEvB|pPn1|$4^0@QQ_#>;JwxEirs;q-p_+5`d1_ie-k1;>&3d;v?w z@m_Utjm?n?s!REbJ-*#fY^d~upOk_lI*Gpor(Ts{MneFq}}`JMq&{F5EUgCAe)x_;YPKfs7C8lTr6p> zgY?hkspW!VU&H#nt3L{dw;()gN+@>zK)?C;CHKJB88dFK?cOE_;I8Mnv@$Zf_Uzug z)Z>R)+;#D>xSNrrX-UE-ab1Jf=8^2sO>4#2t90E+^U84aN5K-@^y~%Coa~jsu^%}d znrg?l?)Z7bH|w6DDas`VAEoELOAw0Bx+Z1%l9BQL7q-@%YH|Q!4#i3hY~YN?`{Zk589{DQ=3FZwRDH71Z#^*=JRXslNXGas;!_HXGvjo-Sr6xBF56j}Bl z6OEt#5HFP5vqNmq714T*a^P;OrtuOe7zbAmaSLF05};QFn70?}@}EUj3lM1lEDC#t zM;4{_J$}3DddVJSq*(;}e>;AnowkEBcO-<$2tSSbup!$?T#;ml!e6z$ct&~kxe4G0 zi1u;oqL~(2e2p7PZK+fd&htD#F9bah7lM*-3qie@g%0epDDN-H# zFvhrx;BPwL7 zB4znCTQ8N4wa!+TCA|TRNHBMpMLZOIYE~ru`TYKpO)_=X8UFe#CITRP;f`uskZ{NE zY@<86zBSL~eZUwhjFWK3_tEwPOD+)_$5X*c;jPS7<^07L!Kx~trq#Q*H)?{zY9xdE zs##i~y#UU#jTV}&l}vf}0DaE{F(L?n3p};=s!#Md=-zF3`Rc`3d(p6HbzwkL_R6OBoU}c2N!h;8m zsb>vvO>Z1ve}`!8bY|e?|D%__$cV|otnk}R?@A8`5!Ap4$H=i;zek+@SaPOn8mJ<6 z z3uZ6st9*)8y!(}VtQ8fy?Hy;_2gl^qZ@nkFP-N^>?V%>FT`4 zJBHP(?n2YVg-wN|&qmHoiI(F{YR=g2*i3c3Zv@ zU+~jeM2+lUB!#^JS|%YsyI(m&L7KN<>Jg~tv~Rx{t&{z}ZO#0%^aNRXA};gj4lhNv zcflslY+6hgWIK!CeHU2pGt#_<4qm7^_^dkFLMlI#XWz~I^Rcj(d7QKCU=?lfNSVt7 zci~0VRAe`LV#oSaB1EPo@z;UvY_`?iwNSRF?t#t{XB7|p{H6hz=jH@@4VdR`#baHs z@OX%Q_v?q`bIofo`w^%P#<{-)-j)9%DC~{34=}|^sX{{_Sr?{QEke+>j_{roV7z8n zed_MpI_kC2L;W{uTzFhO*gsvamz{&80#rK@Xr@S8`<@gu_7(Um09|o2A59mrGjmCH zD;_b#0>>v?BL9Fj_T)rF2p#v?(y43WTWosVdsp`)#DiTSnDlM^MpQ-OIi7PIZb9tt;%Ur-z6WU*Ht@#f;vo z#yfz6whpdjqu|7I{7Ek~JM5}rr#;}n%FVV@=k0Ccx?utsU-c`^HE{Ga83fnp8C26< zNx1@Kv{N-~0uUjpHP0Cq)xQoZMAgqd!dubwVw~(R37#-=o&LA<`SQ^?U18lpga_k0 zsF6i{C0aeqjTWzf2obg{!vw#mp}pom(-&p4+X3J8+nC3J*sR+#l#{z8&k8LUg;Ej5^gjRtKM^i{^ z3xT1&jI}0EQJ-wOyNzDsp^SQ{s8&^WZCB+EUU%BM9aVTO?qc_TLus!}RiD-VWYWb( z05#BO7e5Mn-?q>-GG#>ZtyH(4F=D)$gQ;b_E$;Zb0!+R(ld8@BT}yRI5Z7=?*t3iA zJ6;_Tj51CdUQ<)fQ%@FH7EYf#y7SncbB#%Rfp;3p?d}jJxI>q!rU0!Os>#s16VgVO z(^UDO!6TtW1siS;r^#Z;ql3u0rl^sHV{ zX7nVc1S!v}cSxiI(0ig#IN>#iH1GlKFy6N)UXLV82$*2)Xz66HM8nq7e6U)50K1e* zm3K|7cb&&;mmdOP0R$Suiv+kozU8*+LFPG225zVe2N?SJO=+}V?=JwK(*QaUA~iey z#);3J^>;q;pa=gQ@ZLq|;MJk$XUDQV7xj1@DJcH z2A}~1jxJqtq}?B`mF7O>L?Vm;u9X+=z%V` zI0$%M^<9@gw$Imlk$k6Fk-di_W?%&aMGk4PwO|Bf$FyR7Q?M~oWsm=mvq`MTw9hU? z8uESdJ4uu2dQ#M(!v{RlYh3D8>(dCYYNaimE)e7c9y0nwT%9@n50qlPh{-ei24QNytr6GPzQG<;dr8!J<-!4LDLIQ+4ll9a89N4oQuVv%xGe`k$Bg&ZYDuoR}eU#D@{r($CHghR!nOxD? zdg4zI)0Cp<_bP<>kb>J!8`+!|&1%&v^wG#rm6EKzIq7XG`n|o1D%>g-IVl6NZ$GGv z#m4&~gN`S;R9T116>z*G=4E@edU1nf$rcB0Kk5=x$0^X0hQ9mhn^OHx1hipPXRjwnKd$dHA{r35iLNSX~>quBbhp8@(q#xidjg`xje-`tmLXb(v0CAsy>fRaoo#vn;FEPlfhS~DjH$K9GFwO5HHJwNo8Angn z7NnAb2boTI6u@EOPki*xNy8l=2{w|3I<&kG&`+XXt*}KOq_7}x_ztH!X%#>7dXkWeS%`ZfL_rvyqv@ABY$>Jo*XzdmDBLCg8A&2o$ljL)$W^NwD}n zJs0R?rTDAD;X%;3A>WZ_k|tO)-xRsmqwzBfCo>2QeXtj0$`K>w;vqnJDhnq!Y1eNy%W zHv0vt`d$!WuyX`)?{<*+2lPw<+KDo(yS~;>jV;}Rnr5U#j&vXi9Jpt6@*&~IE9SYx zMn3{~Mm!=zyeCl-(VBEQGwrQSQF5(t?x9kgr@AwFGv(-F9+wu~og zbQcZB((jx92HjT~Up6F~lzGiY6_@skvSCGP;mWC=i}t%_ zdK2E!B#N%^ELPFjf>b_i<}N&0%l0`NN5=S=idLU81Wx=Tld)ZoxPT6rcCo zQb(YhVmW9iwj%Atkxrdu092&vJsK8$n8w1giZDta#D;{Tp*@HgOXXz?EJ#Zq^zMIT zjOMPMh{2S}5r(bK?EALjF*_9OmnjxwhO24p%9GOX{juo}N7@oU9d)?y7RWn8?<*yo zh6{f}tXbo98Ge_XnDHnKi| z=I|kh=}^}d>?d=_I)amztwTH54x%k<nJ{IYHTo}z~n=xeN%CcCpY~L<0Fc) zAw|l>k|2+GByJ7!vv)X|JJ`ItGzkug;fG}?ut^S4oy!{W#-hNZn#;;=;^9l}e%hcI zyJ~J?U%)X>+Uc6K-zgOwm!$kK7oiP0FoXi`i7tw&7?y6^=w@+zCrC4js=!jMR{7IA z3=+Wv4*JmXJ{L38Gue=EYo~=%e>i#d46ML4yS~`*xVmj&9!Vk}`#0o+gvQNoMwn)_ z*6C)}ewa}nK7P92i(5@rbYmsfC22F?Fywy4-l5BR#}mb0=4~T9BAJO7kr)=yD+RbT zi5?Yv@`w2m&NSU>791M} zkwVACVff8sZV*xMfMKUe9`n5Sl#Y}YcTfg3|~jDmc?ucW?lx6Lg~k^?Xv&ha~K zlx@;*Cv?6E1(H1c4FfG{!YVnQ%AY$_6@xiR^gGY?gbn|Pq|cP$-QxQG`+HOftker5 z@?)4w_i>Dh4>1#5mW@7okHm9~#j3~|(b_ES5pmWm9|-53DtZg64FLwwS#;X=v4&{V zH`}Y)&hp>*h%?Y&-mID6rU?zD^cbMOAuBpyVE9*kJeu|BB*CLHVG<=WiWaiL@^RCT zzg)piz>2DDi|b|G>-~}ReQoCA{m&tQq(csHFabDV1RPXC9-;-lzP`U9 z?Gg^OY#MfTxlgvYbq9hfWYqancvkz02m2Gy`cZY3AF<6!nHY)Mm#X|q44OL9_B<;9 z+XS%l(9F;WkQtDdLE}MQy$ixaR=omS1b`j(X?z!d7{mImQilt=Ro}6@d~i1ImG8b3 zq~h;yUoZA^1$z^s9LR-|1ZxN@3+7S`<}w>J4q?}86~wv4E=u5nPlnRk4W+)mHIJhF zKW@0ZZ4FOP6Q5+;RQ&NAe*|o~6~zmNrk;+g9w&or2lN-6wlaX7p49_mnKV}o;V!F! zIDD(hWH>7cZWr#?yUqZg=X{g8)n85@DS@A+_MSx@1)|MXrnR1_)B8?CPgivqy>CDlNkGl?QusSEiV_CQCnlts%aCUyzu zX!1W)kd+8N{`pE|ta~A>y2`dc3*AKQqC;v3tcxe?uKTqBsYB&;2QFGZD{sQ`z zY*ORRH`A=dd7-j0De%c4F|_m-9P?(6&|&zC=RlvKH#$6p+LsrDFQKIbm)-dvfCr*v zSStwmTtO=9eGU9LONQ@1q^G8pUkuz|43H?)z<2k)66sE7nk{?OR`FyZ7Z{EO&p!?c z)SgQ{<;fh4nD2|k?~5U_^TaM*q=wR+7c^TZ|0#c{jaP_`7q}@t2@!<+b+&yH$?xYu zz7JdMJN_b&OD?_G(Sm|N{0Ys?zJ@?1??qz4Q`CG%IAC+AO^ec9*Q3e%abn>6s>L&b zqXB;<5b1&~TOecj$Hb_cKk|qO$`aEdmQ#c8>(}Wo_crc`JjY!DDzz3sRb^?`Y%fNH zhM&17aLwlx_Pp~esG51o4__HD@vQlYbsts_`S3Sf@)Z*s0!hX}-s-MAoo?)F+pE^q zG!4ALl;8A-be>@828gH5dW@lckv`LY+?vo;7)6*G?8}mT65vgNu!(3$#mtQkZBVs_ zvw0h~S03he&A9?B7aZ`u5xGPok4 z4aXzzI8ZIdqz~CDf3#1J?E1#@j57C3zK>+tKvyCe!Up)cGz-;*I}hbCi{jNW7wiWR z#J31cX|(1SxT>2#opK9mIMfxnMwqIPZ%{pW@yT^WUjqyLe7rxn#_-yff!#shp|r0( zgjZ@X$@_U?7doedX!4OS8|YU{lD8re+S8h&Tw?x|7Lp4ndK9F?RxH&-9|NT#{xG5c z^_MI~zt6)Srfz~JiGBJVs_#EKHRjFsk}gz zx>8Osak5*9H`AHFRmsnbWc3C$r0nPZ1jV9QQ47sJ$VD=ZUh%IrixiiXe#*@JEG ztnC`53XI8-(cklr=6;OV2*t=ZJ)$oE)t^MnTqQUg%Gu4n6=WA{$!njGhT|>9Z$99@ z+ruqH9nds|9?zqiXY~X%)VXr=Oyzo^9{ih-!-mCwN;VMA20X{24%|XGTwQQRLG!HE zssd%woFe7Kilv_a^kp)>;Wh1v2~=A2Sgq)c>zDJZDuhkgtHBkkhV;9)s+p}cmPk3P zVrf6C)a!~1J+j97(-$XctiVl&J4;Vh@MHDPXgTwju%?VT9o6q!T|u)F4o(ez!i7H% z?h5yJPzXVk@J-ke?4+1C$weH{GzoO2NB#ztDY@GGZbr@R|x|I&JNAXw!lO2g@(d+Tmgv>dhJ`Y+C zHb+guBS7X{$_MHz$+Y9+G6ugyZ48lhT%QMKXa89g0JtNLUS!B*%kae5|)<%7$2Buf# zib5ztTunoBu`mYdCceBUn|sLB1DQ{FAjDUzDuX6 zrE94W*}YC2@{`?hUJz~QUR^T8<-`ab4rIL$2Eb+F5M*hlg*T5%T4k7pUEd8pkpjw(< za6uz0*l(1l9|GI-!RJ4)=;IEn1J5^tIY%VZ2EPuuLkL1#`NQ+)(dWy_ZEIVqlu^V& z!6?ChqXyZ19}o}hFGecdRlixkGvV#}A%fppNHq|5-*hFJ9i43nlo8{>X&%X)iRS$l zqixU-h&nvk_gwIK7mEetErU@jeO6v>6tonF2 z#Z>5#PBd}Mv+`*5p+B6(gz#g-I0k2M)JJ;m?B_b~e@3DBcFi5u3}GU@=L~+P-66!| zplycCiZ1u6DFck(hAcX9MSP8U-faioZ8(xthfMHi%-u1rm63Otetet5XjYz{H@j`W z)#iN V4VqL#S-KEg}CiXoSlXRPEn<3d6k9v9iU^0c{&)9G%654hm5W`>kDNk~y zy~uW5&7;S=(af{r&+!)rwkbcpU9QF6fc+x85dcxu;X=7zS)hv=TLLj3XeqeH(}snEaZ7QJlopGYUMuB*AOu_<(lb~kYIk8 zP+jYhoNlGWZ6nV<(Y%o0Cz}D>-FZZR-=cPD#9PD%F?~RqWXYE z_59xUn|YN^>1egNp|EA!Zr>7nE0?U;nHodE8E%tcYh2fH6rnqp=?eVoL4`53@WuxH zMIMtz&G)?cYmaW@_Lo>EwSW3 z!34Wu4-XL#gc zzC!zO&wV-Iv%1>TQk?$urar|hVDb908U2)BjvHuklRmkF3US{FYb2uJ4VI==*M%il z=DK-Px|RCX!@hA7cCGMXva9DYmItES&a&LMJA~;f7%1{qmU_5n@p``7hs1@W7?qPf^^)kJXpL<3-Z>`&X&R#D_CGBw#0RYs@-|i6#ulGP>FX&C z+LSSawDLCj_U(+qdR<<5gzOF9N}Pl!$DJ<+wE zH2Nj@`ZLsn2AVu>HRE&AO%QN(lmFOy41H!|689SDm(DQzzrIjsW99xI<^_KZPySQ0 zo}2sMiuK$ae^u-qz@d*>r2mFKmb9{Pwgg+KSUK5v*pjhx{C}faRAn1E8@6CXTtM%M z@KcrJ+OJ%(^cHYI(Ajo?wou5gji@sBK(y+hQ%_$x`+LJ4ZSI%l&Ihr43Oh{1X zOWi0pqc>}|*QjHYir2_1JrcIh8YwOxbVQ_VIIcpgV@*88u^w`vTJ&_HB2nBO2w84*^Cv9R;s*D%=-RQ7dNoWI{Ro49UuDs;We^{qh$vMG)> zG8-uIO&IfU@I_u$0=0)7*zWkoKrEiXg#+XJrJXfGWIci|b~*R~6T~i^kxpXwWAym^ z8)JO;VqUp#Y%;TQmZsPm=Uu^CitDk+vgRkLr#o$dpY8IiM8?<4Z>!|aK^}w)Sr2km z&J`EhpEsoz!9j8{314$hZ`Qpka2xb8jjNfpYZiMpyEb0HUXn&iZ%=m4@2+z?NNbiz zb$|iHYCMTgz{anaPP1+AulJh)9KM+nZmyT+0N45(SplEoJmJ}?yWe@ysu@nCO|}`z zR|!OrH5^|&)E<*P_me$ulReMmwz4GBx->d95`(>RXNdCa%Lq`XI+T2M}3$?y0{i&OjjbLIXnL*TdJ-*ut23%eYov&(cH z5(IzwT9ktFi|ZC~oJQi~m2Z@v_#HCVjfdCIkBsvv>RiJGf8Dk6kmNlE)hn+ol+rRp z?C6q?+U%bTn_fE@BE4*E1e~{3&Y7Rj6LJNM5Ctg|(W*<(OLpb>%Dqr&I^3~y(R}|* zxVrk^de-VNVOGsr|CWyh9DH%vu|}V-*=|02@F)7?I|66Z zb70L<*?=}B{G-h4Meeq5!KOy|$5ZB6e>O`|+u;E|N0gW0r#=|`m+zQDkW!>X{w{*W z<-SnfUpkC?)*Q~YS$LLC0W2a);|V$}%+5DN(v-7EPbKdj5cO2=GH90tqIK5;y}GT}yb};z&Nh?EK`d z^e20Zt8m~$AVT*?LFxzDKS{j;!Ol>?4+#h_VU{dM^3y2=lwv#~#$h?7jHBOM#sk7I zHG0*;T#saWwWgEd1N!u)(`W+(Lkn3T1I28_jWHk4Z$2FFTs)8~pslyQ6Hs#`4Vq0`{|ZcB+21lK*ba4@E001tUd(1z{0J- zf+50tiiM|kGo5e(xNT`D6-UM!9Th3#RkRg$(mM*}pyb2QnAJhQ+T=rJ1v0iaE2C9~jH$?B$qZSqBiY>L?q97SD z78rl58`a(-^a~h4L~pE})}&%YUaXz^+Kc`|gJm!Ba@?H?&A=%^PzO3q$zyny0DDHd zJjqW`$2VvC=jy!-dEs(UN6coE&r~;qtLjQ1HL2#U0$+>UmDoOO)u4jb{jL?~TW{4j zG*2t8yDgo*nvWvbFZAtILxA1QSQr+}X(K6T>=*m%i#jjCmVE&${#I@m$F1MJO|H7& z%-*52u+yLh^b%~fQkUj7-vj5BC3K|poA1MusBIk_;OrFI#eQqPw>%lBe@hU3X_!sO z%hf{^xy6Fsyg%1$d?iljZH3iIg=mZvzBi>2lb=|<}< zgw;ugXp8~F5*_0Bx#vs()5{x_7yW!WOY7~3)ya!!Oq}<|f_(U*-t)Ts5}U#56mSK% z9NF_(_@(VnED!hU?EO4Y*`#xV?ZWTTeRRNtT)A`OQqHSJ%YWj$iQXBk-F5I@Az^^? zzwgu7*#C2%W zqNPqD9yAi~Co%{QJNRuZ^z5eBbl7`)*UH4-gdSysR0_xm>%e3?qi9F0VQeu3Zhd zOu6N|%ft|4q!5_`2TT)Vt|)xZ5WgUVo4j3*bM05VGP)4a8!^d1Ht~+!BU-D6nh=ak zlKBzCP8ol4zQdtHR93=n?dtGqH~XtU^kD^A{Q^1~+MRlcGM3eK?dk%YtUdz~S1Yst z5RL5+nwZ%+zZbin{ch=l9t49Zv>MhIJ)+u9g(?Y8BjqM_3s%3ch5777?j3M1wY%!n zQPWnSu0EgIcQg>s3VK1`5Dh#(Ehb2>Zf4{YK)IMbzcg~M@<-Mix^f8za%|xKc67Yc zAYG3F-uWS+U+03Iaqee*U{LKY9ePGBU7rzrzM_RNU=N}|lUz?;GqhG}DN;6g;KI`+ zo6SqP&m8jJEI+4~xJPr+3M_h~wq8gz0UwZFprjRU9H6d?+#ucZ40v^FQm3=_gm{?R z=0g%^n$p`lA~Y+Unv#;g_F9NI?Ypz}=*8eORhstmMQmdc0k4tA%~q^8e;!Wc2%s@0 z!7IP*7IIOkKa#AlK!CiTu`jE|al+}6TC?{5unNHPZ;430kOL2GQkf#OY<6{wk>uX# z^;&ZZ&q#d|x^S-ER_Z^{ib5hz4`Ez0h{Gq%=>X=UkfB9?@##)|LsAW5j?guYmK7ZT z2;M!>jwwRN(K%g4t*JgzzRDP_27lx8d89e>9@&8y^NwU@6feS+poy5UqIfRyV-$>P5HHN7!kSo&F1!XhORxfZX&>hx zg<@cEM?b}&c`cc8r1{{-%miIT>Q*F%Q1wAKT8Ui9{U{Ezh(nG{mpO!vmnQk5sv#6tl!96G zp@lB20>)=L=1BcPe%z3xI6kscYYA3 zw0FJygSS{Lp||<>+io%MFd5{=kQtOtK@8}=7>NVY%R#NtJ888Dm-I0@18Mp9TLi6$ zt{jH(517kw4;q7Bg=hgGt>HV`%OT!OL#L({hs4X$b)?l2og_~f&Z2^_JpH#(BB6xn z&LM;tfv6%9FEDF+K7>vY0Ll%h9?{OU9Y+_W9hPlvpg}FMlf(=5%STtZp}g9G>rZRS zm#E9pt+6{b+n$30W*LVltw;g!-aJFTTgrpJ+fIY;5x#;o1O6^7JMXG5C~J}4B0HaJ z2?Iipezd}QQl6JQK(q?g^oQ2MU6Ol4T$*{KUt$dQ^g;-RwW5)Tt)W3jC93-&-}x8^ zkC=(U(E-Q*_&zZ0kUtRbn8g5lFE9Y% z68RZhXfAk{eBQ8^KHfN&iGPT8kfH)3DE|oV0JajNSo$#}8LvCxS^5CzCO^EfjK%%J zcTBddfPgJ6-k1l1p`~rDK_1#}gc_fOUIVPn2p;srzMQCwUW0txEu)x=KDNPKtj$O- z43VIF!N4%IZQdQ3Kf*f*F@fP|LcoE|Ey}^f?GHP0F@RnZ43Y3eAz+`4%g0OihYy!X zF(&;sQ6_zd`69hbe_(d#Vm5m-qBi@N@@=*+To5k>Vm1eOqC|RIqC)@V9pdAKTwn-c z0dJ18N%!aA-pK)P>wNxCoA0C#H+JvR0Aq|l$B+P$zqbGk;nzs_^SK@ouw%+|nTMPA z7hxgbNU4e-IL?5$|I_??nF<0_#}fps>i2LqZp90c$=WIi?W#fPRr!H%(?!0OV7ts;mpTi^!Dlg8GxpN@>4{ zMi7*TSux5&)SVBB?`#wq3#jl-Z@$P){#_Bg2!$sr6UN<*0!D<(f%CFj0>t!0FxqXpmgnQt3{4}Ixo1iy3 zEbQ`ufw&#PJIN&vpI!W8fYnW%+!=sQ6tbOlb|h@qS`91!BBmHkiN#ApoG`cD3kM9X zD6VwGvaDg87PzSs4)Dp_qDZWh<~buvArw{tQW0B(ZKKMq4~RoP44%&M5AY*5y;r)3 z8X9<+j0^i9OUWmb6h%X%#QJ62wJvZM+R1K2MW>xMTP^>*)GXyiunB9G8 zIFi|?__v^0cAo?%!t(b^Ix;>=CE?z2zB9TOx!L&05fnfe;q6<36%(a>Ndhw%#lNRc zT>;sxHJP8j!+@9cq)+<^BLi{FCu@clQnKl@ZU4x6^Op5bAL$;Cy)zL6#v{dzv&s5( z>GCcB)UKM$Q~!E$n(C>cky*d4ms9k@km-!}0MuXp4v!o(cz7sJ<3`b8W-O*Ax#Yr# z=!6DD#*ZvCz6bvJ+fCc;H9K_Zy8gDd!J7ITW{~@9L#E8WIg<_Ai!1U-Mw_O(fS_l~Ua=SL{9da{JTbp%^Dn&`gvke_ynnI6lA9&hD<2`mT zQwC#ed;rQzvR%Psh7}4H$#wd4zu(CD*Mnpy!CkwsVhC*f^^UW1)QAj&eP;|Qr;5DK z3YXn`d>Pa_a5w6^LD)9+a-gcvml`tq=+nlxa!@%DchiWlI|2?#CdW-pjW`^}b{WyC z>#yjcX({QQsZ2=lu@XVOA{8;;0w3zw>c`dBzC8Vl19c@18|x^a6ci)}VVGMd$k;KN z>(=nEW1r#<8p#f0=6IPtmRe<|9EFL~PRQbpDTX{hs;97urccxi-!zr{An5b|_TzAx zGee$(JX20_kS2`X-@Sb6)2(<`M`uS{O=UOMDcEj+o-J)TlzrArB?&f#K(TFHDM6^% zkDw6YN2kLW39KeLZQ8TChFz9#dbuW6-{gxyxCl;~(K{9`BeSzCLTP`h@6 z9BI9RFz#LL)Yh~{{6Z-ZssqMdF)3)3zaTW?sd4L*Mv9|eQ%=)Dlw(*)n@y(tI>#dE zl1(vMQU{J!#{xC<2OO=7Pz9kbU+dfS^u?&E@C;4oJ1d@Af2$`Pv5C7|N1Qc*L!IXh zC9Jw1und#3EzD)glI2QP1~7GmNI&h+YSq63#mR@*>vGg1&wjAi6$hkkY3KaN$$r*e z*fkxxZ8H;7+1Y4SV0soD*_vf9bXIGkn=!IvU09aiy_Xc<49SPH)(g`sy09$1mT>S3tkhA8Wf}>ST}w-epX6mT zIP)g{0H+vUbibG>svCb4TlgO-q>0RRqtr22>q}&xq}=hj`8qF@I_75AFh515e`o9~ zlp6gp^D-EB58;k26Wl7)Bj4@5%wSkeYOGN`5w)Dn`sWH;^^+v1 z99NVnH{Ck26))a9R`nIqjg&7h={S8Hdp>z~fX?55O)22GJ*(4yCbGKSU`Fvqbz*B} zGWeX0K);a3U1%?C?8O3bgMYt;(zr8bZ^1|MK?mO`dt+ZG#ffp`oZdKjU*CB1=ZoRAxgQ zDx5%OwKy7@PTb}|7R($Cs7-oJhd)@Pj*P#>`zgZjAV?m;U-_lxGUYRCy=~l5rHF%H zef6|%i_rue{-gqvLRQI_PYwl7$!C%AaICyBl%s6_W=6!!HzFD-)@wR!+Si+6m2SFc zLM`0zH3lOFDO3GdziMP5i3Cf;I-YUwA39iUqGSzZJPd@zTO4rGH06!jhL5no!x|{L z#UsM|$_5gQKjpYeAHww5JOS^2N>-^s>=*T*pUWjd@fMbT+z3dHwRL z;wC-y%f?kt(8e;3(c%N8S=`{SlX-qeoKbU_rUE7ksY*S^#VN{b-PqsXt0=!Xgtv>Y z_Bolh)Ugp48ynTEixSyKdJ-OM-P?O51$^n@_U2hB-zXOnU9)ewgK<-J^tmaxb99sR zmn3x1JmLI5jC})eCr{gLY}>YNY;4<3Hnwfswl=ntjcq%>WRq-c>*oKy_tUNVs%}m7 zOwUX|PxnmqbahQX=Nv6*A(av~>mzFVEFQDaG7+u1^#Yflt<>J^yeS`9+Y`B2pwewe z;D~i*?e{pYdE4=Q>JwK( zO>cxHk?j#OM|FfxpQ92GdId~Dub|dPp2E)e-bCE)ctsGdFB34IgNg0$B!u^glp~r& zAH|&%_2XDc_+-s8BWX7qdRU#AytJb9lZr4)|9Vn;$w&FoicOaMj6_qDQA$Nqlb-jX z&Y~29RyIv2;-ZdfU^9M44`XEZi36a*`42jP4CXWOMFN1rD4EXt>+uI;v1KyjnKm=;9Rk+nCXTU2bv$k>wW6$SE`SkG;g*OpTiTTYDv5Hh%*Qwx-+_7VSZ*!#gM$-1E#GfKqP9ln)l%w_0AIA0 zPLsL;jiG=NtK}qHk&R#BE>n6br#P)+IzJBB0>#m_4syIh2@>i~RmxGK+YzRu+<`%V zV!x&TKvzM9e;en&rN_qzF9a!Us%lzX4qaMbm*UaOtv$@0)YA+hOLHsj;OWxMr78p) z1c}zt(9qV_(57t9Y&35R=x+qqaNp{on#h98Q12ibSDp9*CwUPu{8I-qutWR#k#XG4 z31@rl6ZnL}{F&4P5%BeU7NHY;(2e?p8`e{cUxPLI-G0#b8DgeWqitZ9>E2iq;lqQ+ z4>@X&p(2QO&y5ARS2T_#MKt&sjezI2AKHJ|1-?B3@{JwT{T1}u+c-$f0g(?#F#MSR zO^DjBKJv|*xB55FRe(Woz=M78=$;t^RuD0cvLW77IK2ZSY-JH99mYWe3cx<}Al7e4a=iV#5eF6XwRA zyayh_{sV8f06E_{(N!bJ=7poDn-_stWRoGwqXV-OegNq;&*KqflEfvY#8`PuUgiW` z{oS)!9zPP8<(fYHk_cq$I(&M+csok#fNMRhwLgpi1>FRa{7AwLS@@qM^L-*tBmOH^ zlMHBCjHZ-n(<@^_BZGt6XB|ERqxhhDg$AmA&9Ok4YdF;)oSy-1)h{?p(+nx^`seE= z*L*7-0o6qGrnDWo=M;!ZvzdJ69N&}zZpx`%?7Pm!!ZSTM=}ugf6N>UDx8R3lQzXHVq-;rt};L`6BpV`T0Qo z1D*h=OA=U-B+#ZLI ze9iH$MSIM$%^J^o&9>yVDeByNe+_?qMhh@w?a%oo&2z94q0&{fDL4Pdt_P|M^|;rA zh@FdJEyI_P#-nYBPw%HVKg3wF7Tf~j?3ZuH_x9r4`0IO(bUrxm4>Eeqjnvn0>)O+c%1T7@^31(IL4#c1y}G0#YE6@yMbOBYz+9hVhp1=8B32 zU4g1sWu@YNZ=`pN)61zz%7)V=0j|C&zSyh>qHBztED>9#H{`6ncq>~L0~0*mNkxjQ zE9v~lG+(&$BR$H%W`<@`DC;v&S5TjFBADfbIul@Pz2D^ro@ZV(rA8ueJB&H>;7T_lqKGbn=d*QRS(qOyb8nqbg_1)y&c>R?nlK}BvXk0R5Ws)R?H`ud2If+V?r7fI8v6J%l)P2 zd|Q=l1ONwDR4u`MC)$*itu(pG%HX8tq~xJd#+KG(R?kQpVqxKouV@)JnS?D%i<4Qw zb+VY68qZXce-u!3J^+}Qsj0zM)z}LhVxQ(_X7e}kaoR&juk;@=Kiz38diGrhB1HrM zFW5#ZIy4Z^cN!`-&2QrKG^$9rfKJ)Sgn04R^SG#QuHnD< z9Q4t-3>NH%E;){=!dcs8V9n^BG9PBY~~1;)7oh`<=r+81yl9SG#1yz!*Zx&RU*4g zIG@2+1X_kI;$d;n(L^c)Io!luTUITt^|J`Akyp3sg*%Oo?1YevnhO>;GA{%don!e{ z{wOapml*nLqsiILZQ_2TO;&y!oY@xOxmp(U4`*E4Kn+^T!Li6%$YRKMB&}lS5sFjM zM96hu8Y4qwd%(2O)W({mcN~LEpt7OlaY$x|?b3#DsUs6$sSL)RnjYDjKmdBj zGG+zq`%To1LjHAI5}stkU!2^s60+Tvgaj<3(HN>8@6Uz+$L+oGgQVNJ2>Ja!;cZH5 zE2Vxd%J{mra}? zz_G@uP}j?33Zubaw9lEWsb@Nz8Ra`XnhwrKYd0OMci~|H6*N|;sE`UaJw|hWtFFPb zhcRv1DijW!@iHha5e3!4^l{`OK!jojXb+=0~AyTx6%<;c&;9=pvWT5ShS| z$+9BNT;HFiZp{Siy2^b5zQY2taDUc>{B#%io z#=i&ocxyS1l$=;Yr0X$L+f$XfT*Ep~PxNE@ZzO2BfcyXThFrCmn||$`PO)lDvV}L zl4u9HP}T{|`g@+q7r|uZ3e(hIKV3ig8%IB8J#+uJ=X#wXI%8S2gh)^>+`(I(}h7)JS% zL*q?jve=aFV2Z?{4FocQ!M3J!pcJDL46IH0WgxP$Bwi9CN7_MJRrFU~PD(mdnK>-y67zQKU5b;}oUwgkv3YmZh>DS29-iByj`T{=ISnTC748Ro2`6Gm)* z@x^<5MBps-s6(=hGBq}Qg+(j0itLg}OOV1T!b3LD!U;w0Y2n6&$=Po|1sd9ang_~t zp=W8T4x3?|RHdA>;SW@!|F|HnPHYjEvolG#cH|&Hj5_d$-X)%zaO1$>$07od`C|l+jUdZP#Ae%nqT*o}^%Nu4`}Yt=GkBk-Ct1;6qu*xy2y32XzQU?p=xOB>dfK) zqHlJA;pjhXW?$d5nOPPdjcQsUtG2bXw87Z0;TI0ZuhL#$IBDcns!ek%oWFEgXVPCj zv^lY{vP65~WyM_6aBJDf8B8_v$kwxQcZ*^-w>Zi$VsHsS-S{oOOY&e?3+yEcwQ)@| zm0w_=*8POJFFzDUE*ByH)7akZsXo35lIh&!sp$)}be}QR(7{NP@iPk=Dn-LbIzYU7 zJdmD?T7xwWrk#_qUyJ%j>oYD>0w}f<4dEmPaXkJ3_r86$p#z`^L0eha%t^6%enm7+ zwp%4exz(6&L7Z}Wow?OyORjXH#C7ck8`H(eQo$G{tyxiDNg1<7!zX-G+`AKJlE-jZ zkSH0*`X&*m(mI)M%Un5*Wn={>bzjs3^)1KzM)!leu|brX zRMrWrF>TQnypw#=Cix`)uhk5LK>B7Qy&AS-+B5C$MJclurET{4&W(>HC5W^7-6TDa z79DAJhB%?F_iEUDjLoxwR`ody9p67F9b~=es=*6fF2I{Um*AvU*CbDn#$~}CHY{?Kcnu+IU65v~uE={+3eY}|Gd%sm zyW%?R#8DEioFVALpj{@OY18E!k6rRVif~`-bwSw7sc>xA=HNNNFsdR|m@TW6=h?aN z+nB!36w7VI$gT*vaM^Jg*T!wok@DX;?kUb=IIDw|(J`}JRo-2ceWRH6X^7uR{8_$% z)lh_CrDNQ4;?hm-ZJ%t>s~T<^j&Rx``b}@6lVJ1fknQZO#Dvq>oAfb_LFZXpHacxT z;eoq|yI)YV45kI#fj47ZcO+RxGH1`QE{xS1a_s=Megn6R-ig%6ntq=c_jK?OL>(T}5j$R`{j=-(tl zxs=V4vm|S;UhTGcX}t<<>WJ*UExVKTw97*RpVnYK`MNJ(yZ^My0*0Q;M=D>T-lJ7g zjNH=TW+i;7)rghSBNV3;>tx^6wQM_zdyuUz=7;)O8 zRdd{=f%QJuh>bcle|UQj-wSRNx)Mhm{>{?d$mU%K z#p%{LeCdOD9A}|cv0c6JHof_9_VG6WLT7JoFQ**g(c{BNd7ZDtqAKl&ZkL%yNJ(DI zQd?TwmlaP|ufY7-hXfaILR;?45W_FWhR-9wr=-)1cH3&Q^ef@|rZ@deK74MK1nDDl z^y9}=V$=L$B#?Femi*b{qxgoH6hYTVGqc0Mi3PCzbgm0LCck}hH-@BlPm6%x-e^p3 zn}DT!lyl2l%yvXuFY9Q7$c}>K+Yj8_<ZUfOU^NFgUFK4 z2n;r}_Au%DuVGCd?5DVw_RHgg2?1;q)}!IR0i-`wDAf_395QK! zRF?w7do?Y(m&Yf*HxFa__Ke!4v9B$x$0^N}&EpF0Dpl5rzTxh6YYlZlx^{%if>+XS zChD43J=Ke*1U?CXocv5XzqKleU&XV3Z(q}RsZhPd{JG0EBG~nuX_E}*o zx1(;|mAwBZkvmNE_C`H6tLRIde=P{8!=0@PeYjITfSXiyC&9P9coZeFCb&Ot__&=c zG|6`^y1}n5iRGv9rPL`j#d}@4Fgm_kRwZ8YUEKD{G-5mMxQ$b)@Sg6xiBdkGFm%W+ zq^ji2ej&teR1EF-hUo2#LzkbZ>bCTzxW6TF;GU?+HQN78c*3Qm@`p{WUp(&Bh!Xb# zL8|b#d;r{N7hI|6Eftr>XBjP6?o|0w>Lv1oul^8f)#BBIuKL4GmG)un`ZK*}BEsIf zs7a|YE^V=TP^@N9{0u$J9cHITBid);ZsQ=6r+(b)XJJnY8^1Otz5v0PIK5ppUwJ9U z%E9stBRQ%36Z}DX$>HeE~Vz0&@ly;k$iRnECA-W%SxZ8*vN|jM3 zU z+50s0KRHAs-72^>3zIIH_z;i0#1ylF986UNMA~ycy$c~S3-R+`$rn)1MMPQ1%*dB++bvT!YcC|LO zFxB2h7@WuIbM}v6j$->JII>2m)}$GzNW2=h*Bk52%)08w)|XFEjyCkHd2_0oOs14b zf+@vjjY%H5#Vf9)$BxK&CjS9Edw-p;pca{WMvY-;X``8~ikFqxT;Vsb-n~EdUfr!u zaUbV7`yYSy_FdU?KRFkZ8+-zWvcxk?Bydg=v#?F`&k+k56|Ux7@PT{=zQDPlqWB_sj{J#-qZ zTZFfl-s79<_Y<$KDUXry8yz}AUh2Q!8f2qU*&87~u529xph~HKaM-Dsb=*<#=%^}U zgN3iNI!SQ2#CR=*zA_=B%Oso0_xkH;I{0hwHiqVsw-#56Qj`*_ajrRFc>$)F#uf{+5LGY8+@AlfN6c7AHIdCg3F z-|RveBQS1Bq<2fG2mS%Tb;bLPp=^}M|LQu*|D7wQ}K z;l3J4#CXh$3|)fOOnoXTw_mqwY;NZ2X>GX<=93qz)XT3QElH?h&%Ns=tPwXVl|fiI zaN8!XLc*7k0YB(M)p^8P2#(4GqA#p(dk>FPk=9rtGu8!^VXl!pU5Y|c{3dV9WJ%Y( zePW6XOoJxhE6P{w)NJkB`KM@osGUm2mwNwp&QwKEd?Lb6nBMAj{COc|X#dM~`N=U{ zkXh+#!UJC05|$vmIe`D-Wt;&gpBFz=9h;)!@PbL9NZY3gppP0)bAm)pB+Gr)1Xr1g zqCQNh0&)T`h&P15&P_~&4xxm?0(#zpAW}kcDGlI(z9vHH)qv@dh?I091xE(PP^1>t zEkI@h%0BTI+v5S!o26Q%VwGIVVFuI1NdPq!V1x^;#(d|s1=YP*BLh?e-QJ;Lu?7^m z7Xciw(3HMlG1f$z9vsy6eBbp!dRk&0%+{xSM(rZ|;@FM4M(y=vc+n_83_W`k$W={L z%2BJDJ&+avor+*0wLgW)FdJ{SDtb*wi~op9L5JJ-SE!$rJliClGx+jdEVM>XTXD%T znv*bNdiRx7)J7_KuRkweM2@29;S&tgExiy20>nT|>|w@0atbitnkPVhhV@~|TUrwy z|6Ry^@L;d_B85g`x(zu0MI3?c%Ww6d$!(>E+3$nG=OftY zW*UVI9-;vs{B*{Z3oHs3B)J0|C{QxTz8caG6!4m*W&#YSj@`8KPAGY=Ag&Em^AgQe z#%@ANl4KZ)4s(7Nhc+I)BYcVdWRSYKYH)~z(%=4L+qoScvvWw_3$ z1YS|xHOc+**ERb4&4&+_27lRbj@B5A-v;=*OA_j|^!1!nYBVs8rKFlAW+1)$_K6w{95FhL1Zij6TS*juO=JY(3t>GZyMklg^k@eJ{k*L5*ggn00y7=v-|U)!5)S^JHd zYNa#Fq&PNzrzl9@=XU-TgaMQQ`9pi|`TSgs8H*`E&lcnlADmU_9sr7g$`3aTcCUal zqaz{CPSk$xIO+FWJ?PorTv=UNogTgqkavDTnXva<)4oj#euq!X?EQehryS3H_%~o5 z0)N^5+WAK(0*~R42sT0E=E`Mgtda31S!{}+)ytE6VpBRqm!VyjGuX*>5wdn_Hm*Ub zA*cPsnf5aNI%P^R_39uzYtGx0S3kG_R2?#NEyBp*`oHO5spstaczd6v!Ga7gg~!vC z+|%Ibn5cwJS-ca-m;FUx+R2_7tTIq?vW<6OonmQg`*EkPEg&rm-kJ^JndYt`*yEP@ zP-Kg)6pg8&Nr127)xET#z7|&e%@>vce~ewa~9Q430m4L#yFheu1x0=r4sHiN%khJD^w z;T<=g^hQ5qnivkqJTcis9!Z3fq5?}32^V!0rWQ& z3j#zdj1`3G`dGu%{G2Vt+`$xJoU0`%={Qx)+$%on^qF;g)>WuA(wj9ySSMq!W}4fZ zz+dF3Jg73|aNU`-)iWU=Iw{l9Y4JXa@UY2z){T00S^2~(f3)7cc~@Z}B9t^R{>kME z>vAX>uVeEqASRJCiIO;84nTO6(hB0zo0#TIFERl$p%Zb}$nbaSf87hYr~}hN^oj%B z_{clT{+`=`!6U|)onrN^k0vOYYB~oOPZ^o^a_YprE3Q%C8qng)j7{z^*4y|eIVIa< zrav6#)d#^Zsf+fUOm;U)!Oe2ub9-#F%%6`_TNZ=IM{=Uf^I9!;QZQXL#Op$c4B7#S z2`FLQG2^*{lwafm!;s>TH6d1+hPjyRYkp89PqZOM>vKG>CP3tV)CbV0qXT`5F0%bS zFNaIYr^&dS%Ld{;>+3;2znX%2%pU$^j-ipQnV&jN^`oo{Zd~9+E0VOW`5R@_6-vr4 zS?!T#S$TZEU}TexLG!lK9lLuE|B2DWP(Fs|cQk!@X+clT85l@jZfAr11UawoMotUqZMMg!gzMnAH z8%`G$+d)*-hEo)dt8E7EX!$yWU@sZ1Zx_cQkI`k$eRR`sL~%WI6M?=VJ2M`j(8^IP zM|V@hOihe2j|vVEQD)XEWiJu`ds86pQ2eQ$YcKM*XGF6msFL6bYT zBPF$s+@!8I{nEj$BG~SS?4vM4lP4^VK`IzgLLZV1+FvNbix)oZiO=NdeupW()9&Y@ zWs|9$taa#wj)|Sx=sju}M3{4RgFEKe4{qvuacQ5MP0NeR5&L0E-03$O=(T%+8j8v?3^kcf&*4lnR>OF|$6V z7t>d2TK6?dE3Huy^i>}d7at6czMA|j?F3K#3y^d2VO7QEur61hIsuu*R}ZS*!Lj;o zJwpv@c-U0{9(oarl8G|{?m;lPa?*isS-#cWl)NnRJ?$IqHS$9}#IQAsLPCnGocN%T zdDkx_N|gJjH%@^}nQYrW*!m=3bty(O=Qq0jB;Z5Vi9 zwSA5Cv=$4l7%5h|2-Tf(;0GlneR<-S2XX`z{Ru6`$Bpi$65Tve!9X7z7yiak7mX^A zLi(*EN$&pn@Csnz23WaeC;#@IWypZTpgL|u5v${GGZZ+h zE>rqv8`7@(pAWrAj^uZ^z0ZACGa@VstOIH8%uA`&=2?)zdOsa3h|;eO;Tp8WzE;m4 zOMaP9qYeY>Z@=K3gnhTQe{I8FxuFPYoPA9nR%2=WCRZT`d0X7nr?5W8AnEg7q>-W7 zckT(&S9>PdDp3^vz4L=J$o+4;5lIe+QNcHENgjGst&NT+jIsoVG}K5k|1rD}@@@C{ z(L-j3QiJXeqcbM&QHrkAOmNrRB=0Ll4Bb185fZ+`RaCG}{Ni`ea?79o?mtfc0@H?% zKgASgRZn8|iXh$LBlF$Z!w>1dH6sN!T6e^TI!+#-f3r7_;;kGg3AEfLX}NEIO0Phk z3!P_<8hi78D0Q4beF4_0YP-^QoDVPa7HC?nj!f7y;>YoxNddB9Dtvh;In8Z8lqj@r zrTsHTpnRS0K__g2Uw-o7p^<2*sEcb->3Ee*t7IUIy4)^rWrg1Sk)5=BKJv+Dz`+Vj zW&PdGTWztdZuEDLw=Y|k(35%#5~DVL*F4c6Eg)2iO?6qqhE$4j^)jyD>tkHf60(Nx|H2zLkyAo3IO zm}wnsD@{~QW~!IhIIa$@qt#bg4*0yCJR?NN0iLP5l|T1Kj&W_wMi4!1&wC2txn|Ai zw&N@3O>xJ%2!exv()IEwT!tLcZaelPKOiO+a+LK_h264*$W(I6%-POG{*)K+&Q2QV zaQfde%AGM(^*q(qw%-wipR(SrM=1}z%4d2b;@w}I50LLC)xkvfDSk$Tc*Bm1n9`PM zmO{gQ0Y5-QF#j)5Cf0w@O8-J6=@7B7{G%@T-#1of7NURBe_Uhv7r=>~iSt|O?SH2K zDDnRuIhZ(z*g2Sq*uSAq-_Ug;wr}M=Huit=oZpH0|9WO)VI|_?WFzAE=MLw$1?xX` zvVTW-uyKAT?tc{L*twaBxWB#qzcqaOor(3k)g0fp|Gv(`_Ky`C z7ZcGxIWA__f0ttYcWEXfR(5tGR&H)0R<`eF`p3_Aot$j!|7zzyK3KUq|0j&=U+w1+KWz1 zCn_R}fzN{3uUa5V@j->Po5!=}lv#PX>UrF;{@w|A&j9;D!2yw6lL(nu>K(5Ac}PtxSW`kYT+>k3 z)fRMTov2*RzFwV-DvF&Cge-U93 z(6S9tAfK_ju%)^W_r1C`4Uxd=DYTfRJ{hcZvPLipS_a;P$=>5`e=cgsczJlxS8v&W zE=YSh4|KK$nvgrc(ddw7?-sFYZ=1dST6|F&3gj#>Oym#7w<2x5W+B+^2#6_2 zlpx+9Y(M`zUC`h{q|#eCxVlGB8-89j+y+7l0NbQ4L|hYCE<3ow(H|rOTHrE5r21{ppr07c5G#7)>LCo|j}-I{rj#Tq!~-R= zoFg0uV$yQPw1l z4T&tLRjDwV{@wk&zW1If>I1eyRaAJ3=AYGM{nhkok+&1yi1zldHSMj3onh>S% zoX8+ZjllS0-g5MT|L1420K`KZF3G!1!ejJiJovKzRvD0bB;#PpV%m1V(-IK!D#A>@ zlqh6%(k0L+_2(tmy#CyWw}B>stF$+G3$h=NuZ|h`)1C_rb3|V6}XkpCyF_8g6-=k4az{j)D~mC)V^a1Sww#BYCz4AH7w3EDgXk z@)}30!03LTiiL0`PSrZ>6*Yu0yx9UF%Sbgo7)78UMA}}iKRUsSX3Khd?*Pv!%yAkyoARt8n77=XvXhd8)?hD5ss ztTf=5F_1QIQBse&h&hO6DX{W^{6K|v>*j=Q=*JafI$Dq4ihMcfTLGDTjdc2f6lvyZ z!Q1v#74(L)Hrn?@<+G2P{~RK^2K2>cvhI1kfjv1jce9HM{Ey?AXL*4 zbt#IrQ2QO0EUz}N9XYI!L99loMr4|+>LxYs;aPsyo+1VX%@C<|@MnMIEGd7vz(Ee( zxo3qq{+sm%3@;JtCIxg&0y!N>(;PzQ;;JKjo!UQF(D`Yi(#yaK+$L}|3pJkQtqDY);!VmoJ`*h5Cvh>I|<{UH9@)}<%=L8D2GNK*iD3c%w+)HcGl39_w^ zHp5+jR~Km|o@Lr%S}e%#yrKEUP znJSnjW&$k(p(*2cP)6J^6RC_5yA4eC$War<$_#@!{<)PKeOKQ0j9Y!rIrbx-cU})k zWYQ3VG>jDWi`1twkc^2sM;dxPjbh`~VQ-({i#?i&{`I?<3Gio+q72SUWNDwQ?oPg2 z0Rf8lkbjgxbolJw<3C!-IT^fj=ZUaJ^Oj+b(yGq}X#&WYQ@JRa`I+li^!w{-2UVVr z^6PlJ+nka(hi6xgPk}W)Blnia^0^Cp^{cCLziKkM3cY-m+b5zL4$Vr*hfQq6iX~$4 zn7iu@H9zNMt;M~f$f@UZkTB6Ps$my?sR4ibNr#fbz%5Kp9mZ08FY8ikO`)S>^V!=8 zi!1_(6fcI9-S)fYl!lUOuoM8=O|lr>g(mQqk!v!!xRGUlynt!PGlb}s!waUQo(6X$WM zT*^>2naDJ@yD+9M&dfnlo(OY?-m5#@<{2(&EYq6F(w5Mw6cFeYY88q+pRA;Fd>!wV zJ-%TcWG}0|@5xhF-9zRzn=|X+MLCt-tCt}U^H7(0 zF(ol>KD{sL8g^1netvj-~bQYxWHMCfsM5OxKyE;5EJO zt>P`1V>e}6douy&J~IDgk-2DipO!g8n$hSE4>F9u4jq5!4CeO}DIgbv+i)KDEBjS~ z-wnlOX)5=`NbI$h3*+r0C|@{57Q9DFB%NLnuS-QlzA`HESrKBb?tn|PCd|_ju=a?` zVP=8&cjN`-14joInOm=qC$#|dD9P6|V%Y(9rlLXz5esR?$NK0BW@2%CkGV$88oeCwQ|vw`srih}Ug$Ys_Nr!kh_@ zCbV*oct$0A_*SIi5I$IT)Sy%we!cF;xbS&Lbxqm0+NQ_W)MoFmm4Y(W)VjBWQKYb8 zaJrBiXPTr#&$_MCIM8z5#zb1QmrG^bq@SI+uLG%%l_uFF+)Z!8nP&H`judq05M|F; zqs~zzPE%~Q?~#a24X>H@rynnbdFIB#zaIrb=}NyF%bOFx%lGqjMng--s+i^J zovUU?cl1PTMvvA0aTDCaq6;!|c+Ol}|2gu_)S3c%AJbYirkB;Zed#6f?&qr@!e`gw ztW?gG18nK>NSicb)YG7gJO3RCU(^v94|ky@4ipbrt;Em< z*hI!#dG*;-A&IAHnI)8lE(UyFBGM5~kQl(h8t42pDR&4STC9s8~eH0=}EW0Osmv6+}&QS6?Oym59=-{ar)7T{Mbi` z()Q8_iR1du*o`r4exUzAVKu@yC0PQkNXj5a2n2~hUF4TV4R43pN68;KH($D_DDq~+ znI1pv`XgFh=_A|3g#t5#Y={|73Y!Q%W;EvWN70mk1=CWTg6JTTqFy9x%zha5Sq)Fj zECV;NRg@X`R0*6r^>`d#D3wT7HcWX*K}ihHm1Tu^l4OZi$zGU0zzb}dFg!1S;I3XG z%vMfwGo(fC?|cZo?AidBG(aMK9%+^SebP);OLwl9)SjCunM@E!0D zaj%@SZoWDe9z@-30+D+(JD8?r62_GAahj-4Ovxmk6T zTjK4h4zK`oD|b{Qe1P}>e8?HJHS}uY8T-<^_5gc`{J?U^^3op70L_5(Kx&8}Qmw)~tLlohHI!2;EJrD5`#y3JK zOj8uekj(f|K@mf#iadf$1C1Wi5aJ|^U6`UMOhpkxyapu}G9RK8k{E&<0tgY-P$e!3 zV2Vjlz>*##{e$8JwH`u;P2w!3#hflBPD>n|ATLP@M_huU3^fi0OFWLw4U#Cy)J5_V zChs7IATg9YFB(CL1q~rgC!`QTEQ(qLl^6mg%=LgI&L5J*9D*b}ha3bI2u3d?qKK** z0(5(#a7|jAR6ryNmPmwz1#HU1Sr|Vj^Bn1r;}COA3NQ#E{A0KNbQ`m##6m#qBk`Pe z4G&-fSPuw7^M{Cp)Ik}b^b+~VKgYbjh0_kiJo5rnG{Eeb9-#py8lu4aqys`4qR{&y z8lu$upaX9qPrArv5$<}(hY{{j_NbrYwYwzUQZt{@GYCkZ!XCjnADJ6H@*c6*G)95| z^nuBxOLC_V5&$^P`(4O!MW0{?Nfh#1ML%I>v4!Q*Y(i5{NIA3uavs?^@i_&bP_297 znVr)ISI3Ujn$Vg&zU@E#YN;lr;qDs#QK4Q7H-Wge=W1x&! zy<=d6SiN(gjHI@tQBZN3wqoM2wPtKk$js3IQhf-2NjAb8;{kiAr$V8MawRk7Yi}sYh zg0pxhq!Zymdv4lx6>4da1liM?XAC=MFQ4<)YOGy*k_^jHW_=Mv_y?ZB)Sska3K z8KX1kWyR{>T^{Mb`a4q+(?IC~mOK?18d4bYEwl)t(9Z`MUMpp!XGdXGE0mO+=8MXKo7o4Pl~%@zK{>Lx@mod zy`isYr^yxGitfb%fnJmh!}t~3HsE4jnY0=9FQsTXGnd6nD?>?F3s zIs@x^=VX{KiFBp8X3=Bfg>AkEkx;Y$eH0=3uOWn@U%GIHs04KZN(8Dh1WlNwUs$rJ zMT#r~8YV~-2^u7D9v`~ZJHc*AU}=`Q-oEG){Q>CIKymlS2kYrsMO|TURNzi%r?PBR zmvZySN1)b0ZH1;$pU))B+ieuWo0$&J`Dq+7z8Zc}r$~HziHXc;7yg6{ZQ45HdgBxW zJ**BzMVdNY>-X7Ot^O1nrbhGT*`}ba-~vNf%WB)KmBEsq${R4-v#s6kPH&ywx!YAs zXftLEmBGB9Zx>S7AxLu*kzJg<24ouJub)kfTMOpt8@C%F$PycC{TvjgEe%<%BOJii zw$?JT)W==6^(^z@IB^z`(TIvlNh+eMl?jjdv9QPlk_C76f}tDDZ7+NK&g zbu2crt79LrS1cb-bjsFeTjU!QwpoUE3|-e|`(Kl59^Bs2yu5Q;Rs<|%YJ7`agM2|Y zs%q38Z*+d0A5^11PSB%2X2Ec*XxlNO-W^<{g2g;9Tj?6{*`zGRhN%b7S#ka3vO&@@ zK^%pde4wK;_ng|mVuoS_(JMMAS{1jC*}cCxn8WEN(Hw(m1@9y9VbToR zlj|3r+bD!965d{mKB+WjpJAxw$7HebX%upmujeD)V~UR3Dl4O z`-dsTNWckFkznn#8wP;}gTVMRq73@)wFkv~_2rA>Jk`Vdy3AA4s$418cdM%0ebrjG zAm0g92~3k!b{FQtk{#@kzBYzqjan_xuzi~H!WjSxr!5N_rz*F`b@Mbu`8FTCW+}1l z>%e2^_ozTGI|zGvANo^kDb9ceOF!`<+GD&ZG(c@(hNyc)IL@tOVc-$_;x8!dT(=^} z-IhzoM5fPs-2}G9Z6ERZ)A{>X8<3r8ZxtrOR)i1ho`4<}yGiH!8HArZ@O=&LwGLGJ zK_9On?0Ep?9<~ScC&(@{I@^G>2aZ4>BS42M?x}_l)}n##;oNWWz^3F1F$%l@{V6Ev zi?Qm`-WJ)-N_RA;xd_p(NvHy)Gi>@7Q_-yP#|UMmxG)@Ph-d&2O$9X!m|`1?<_~&@a108P9Qk2SGltc%rM& z>2Lff5Tfy?QOqalHP*(M@QcKJBlM;C*~ibrmUdg(PiJAwc0*j7QTF0)&Q*ACBTBxw zt^zE&#TAJ(#_c zVA)fF;Y0V)0cevTL?KfU&kO_)lC$jjbep7Z&dU@3<@9EGoo+O44%C4K91 z-LH<4M4I*eEZ}c9CsCMxxc^vU;a{bb$iFu@`NsGJW|t-oHi9FqXudmXn~<#lvn#_- zSU!9NqZ01EB#nLA=W4-^%<^u?PiTWdr57)(-u}Bkyj(#qSMyF-&gI$)t?vO}pWuQ6 z%)0&g1@1q-Ww4X<{|>T`K*CWlA-~F($ZMLVW&}~+$lh51%MP>2PJ$fn*4*+|if$XA z_((?{v6%rkl81ygGVw8zYN16NdGT?=PmS$s^2uN+Vr&~251_Ehm`dd}LUowA_-}Gm zBXbwn(M%dg-%R-D)1oe})5XJ^4Qdi=voPfczW_AT$eXaN3@N6K)HRk-W@@Vw> z?w8d0-~jdGAB^sfyWfN&L%G#?JweFOV4Sr}p;HjqXo~<4v8p%kw7pMp<`rK_o+E*w z#%+lod%o9+Yy=F$eA=7cD}5W}PpyTT4pMMXs+k%a}pxxpCN8Plib#`NT{=*;QUqW0(H zc3ib@AB);IeHtaRvhfL8KX?o~c;Z*|m6e^A){qntL2H&Q#`^_|<^+o+e;A{Miu5y! z@luyY8Bvg(TWHis=k&!)lC*}QY1X_jrG~9l>dd2aN0cWAE1zYLvzD2OL&6nefKJP# z-oQ|`q>LP5mM#qrSBs)LBJ{c5cW^JR0g&=>R~jJ=3gAv}Y~zG=J7Uz~;cDPNb4<77 z@}I(~W0LX3ds}w4Ut+gs-ii3KZVS-W=0)*b9)GR3`PJk6VtUewdeU%mJ%uc@CnvK9 z_h(2U?oWN!FY}U>-GEzKGRG%ah6d;5=f-0|!ucLIiY(76n9ad_gNL3-O8J(OX|2mA z^gS4#krB_z7T^b;9v_+|Pc@5wYsMBZnNPJh?Lbcv zzhJx$;0Dw0`GxHE0vv z+{fUtDIo@nJ|xx>Ya9}zF{hb}+V7v&_Q3q1@hK+%s5Jh2?R=N*#a$KxanM3hdKyB7 z4S2%F2sc6iM0w^I)y=H7fWTV4JUu=CzLHIGVka;<iIV{XA8HxdN)C7+)fS5~+PmYU>YB*&94P7Y}_k1xXd1Y{a8q-M3F2i5~`*NLAlDbyPCHOV+rLiOm?V zWO&>YFTc=k;U-&z)&NF>UrG?G_KVVJ*?2#l8k0}3b0E}xcqgVqL!*`5?t|N~hEkqv zARDjjW>dG@5^AI6qZDW8nO_=@*}mXHIbgQn-_C9SJ{lM&@8_mBk~l#%#;Ad<2?$gx zYMolC#EW!uda^ot2*#??{iU=) zkqAZbHpOaNY-~^z|FsQB4%#iOhdjRh`N*Si;D~JS>c*XXM9PBGu}MxUk+{V@6DDn5yBS z?{44N+ciBh-V&Qj`&C+wPaK)B-}{-ENxLPT__|Ou@^Ff+8jiA9tg+UJo@>4+?4;;%p(37L1#{({UTfi@M<-Pso zO*?S^(uYAf+Pq0=xz?CtNzOHB`(ial+QV97t|d9gs9~RK4Y|pd9HTZ-rBf-DcoEdS zN4;t3Id7^jiM{Jhd(O;yjA;y1dSe=nM}Qgvf+mH_6AI@)hd6O;vCRGaw6~q9eDHDB zKM8&-*5eVS>fIWj;Tg1+-HHaqg~n991`n%Sy~8^GwK_VL)?0ZIo=+p;EgG9mt`~NXUu{5&Lct)W%G-8`Sw3k64SdOd1v? zu>@^gYC%$$J~{ftwvY_RKh*}SLP*52E4I!g72eBQD1(Q;F972LD!uZq_Yl23{QyR50sGD^>j-NvO z1h?`Znt8VhzY7ZS5wtK3kD$U6_f%#u1>5!OU3w!-fwfqY%@Gmdr-nDwC`RU525eWU zTc=M7Z8hhnr9}5V6+1jqkR-Lb?-)_Bc6{$t6@84Tq-!!WwZ@^zeaUHcbu}sFx0MMqR6319p}~7lfExD~ zifBa=gyJW0|C3ml@GL%w8S$!u=o8Nq=i-f5XO5!x8-C*{CZFa>>?|7$IP<+Pn(~9# zfCo}Vbj@8~tiSc6TdI(^ulwlM>b^s!>J^PmSJcFt#;<7N6mGe@uWQ=GdyZ|n^SE>R zgnNG2Ip=}JV=9;3JN5jBmK0T7dLMt<#9bufy&MavaGB?6BT>0qSO>vi5T3CGKyZ>g zNPJgI+on`%%-#L3aV%}SExcCaeE^U@u=sBAJcIp5?YvVqpZugC4SWO@ORsox#e6ND zv6}1@mTj$Dw75RKuP3X#I<@uUB71(UxN^aR3rF@f_uoI)W@h?Dj-Ii6W~pO{y00=} zl-)D$YMggIl)?s@_ja8%I90VS`;k*7N}L{9l8$Ry|&qGk)ynZQTY0` z(-vPF={-rj(~)1~4)n+$3a1tepR`HbJL_``z&wE{DWJCnZvm{$A-dI)p z8;9o%$uVf8Md2ygwjqYLVx%`BBfD9K zO*2NXNUe*IH&F!tf%=I%gr6p9!SuMV>)~5Ye)jK?Uj(hcjn@AON!r6+&# zi=tAzcKj8OHJ2=OjEGT7__!aKThmgR^*_XY33OanndVz-dGFP}@B6ELFR4^oOOjnx zDphIq5-+m6NM7T3i5)wRNu0&bLK8w3nk|QPfPwBg-C#?$6&ylC+%Q1W%>;J>83=I5 zIhinc4ulLeiB+C^->WK>);JD5bLt$`({ribz5n|C-~I1(smUBGZ{NMW99w<#iyI=F zhdR|l62pZOnvUf*r-Rv`COSB=dtxAlKCtt1yHZ-4(-@D~0!G^5bLaw{Y^W<9jCHI% zGCcN)v4~V}RZDd)qs3=r%np;rld=T)f4?0_odK1@Z-G@ik*YHby_Nt_+%8^yCpd83w3N(S9WM;KbN&XvlnN)gv z)2-kaLFIKZX2>L?X)}fY2K^l&u{DQd8Jm=N7yAuPnN!hFT#Ji)^%faP$}D<3b?qgc zMb2Fld)$64iPIX@H3$Avm0m&;621DG5C6GbCm~5~&;$7n3h2F)2m!tOkpA;}otI%H zGuZG&9SiQzEP#>Eo<~@ZB>?Jlc~%So`=oL=xf|i}I*hQKs35-J?0|cZ#pl>T??QHv z;Mu_-Ez-87<1J>I=&tPSAR#*#j;n+;Iv`NEJCpu4zfl1oI`%2lGw$+fNL(nByf7mL zAWfhRIPuTQRTO~|LPo)SrBZ@B|&Q<2aFSG9d%D%$GTqP^`~ z3JHhQ&Ek)(IL_5xe}F#ucq>w;DV?IMIeQ zAsy%Ri1!lq6NEvuXw$Uaf?Awhx8hE0231~&#=GKJJT!yuJ1g9Sbj@BFyUP8j@_3#F zb?kCf9R6{!C0W?ibo5(i3gw6Y`ABdy-(qG+kwnC}TSqdTTf3dUzRAv1xy8!}DFOav zf6QXm%T_(~(t{7Z@@St_XEnzY7FJK0?56m}yGtAIAN3k629eeeEfQ#vXa!n?44fBo zZ(riLw|gM>hQ`iGCrmSF{4B|9sS55^WX@WLpZfR5DsONaXnpkMM~js|ISNO%?%Q|E z;WCRkpZf8AZM?9v_kQ=`-0=;G*=?cqr+{3cJ%zzYLP!V4ncZ_yY**P;h}bxTN-xM+ zlw-9}#W~3Y@D9aULEUl=fq}hTC&ZQ^vNQ{ctS}Ve?04Znu~u+N5a37UUUaocDkccA zR8+Zy-Vbh(+e{uE#gAF6Wz8nHj(QVZn2a8+xKa`8JTMxb0ojNGqjw?6vn0S$PhT|C zv@3i>%S$eL_4S$`=+c`$Qj*r4)Mue zz@7nS+=VI;5^zEl?x}ZtL$qxgil-cRX+FFqDvXc=qL1JzME1{A|x zK?QjrDe^FP1+b`%;th*JKU3LVyT;$DbEs#~6SeE=*wIJ8*fogiIpC>JPgC+qZj>kl zf1X9-K_6jk{G%ln_-NbQ1M#=T5@-<;@%8J79(?Z;7*6rNkv^^8BSpG*~HZ-6yMy?yyy}_ zt1ek_aU4ahIR0~xWPSdWT_LQzv`BV7q0$y(eJPuS5X&W%-=b*|BgDCR;Uc*N{c}YK zZJnFr{}l69FRql(bBs(xkic6+a*at@dA4Gf>6KE1k22W1V4ixo4^{;&K`5C7rk*)V zaPfqvmORiO7m-KUyDH^u#p>sWXJgRS;JL(PIs$^j3pEK}yG-eQRf&=>f{4(96sAL( zuopPphOF2riBjRPGX+xp?yLfFHcf=JG;U!hEW71Zk#fL>GeTvi12X-3$N@nh)JWA- z^Zim(4G(ny*3pnJ(x#Y)jhQK|@)M$^%N{n%@XBi#xXZFp6BS{<9?nK=%+H8lN^HSa z?>~A&b4C-t_CtjXfIt!6eC^-rchC7la%aXjdl}0FT3xb`zvgG%K&ov>0`V0jD!;5J%V_D{V%t_=lceJBDH?DmDb1uAo7@)*oU6==XA;>bB+zd20o0oQzmy zQCBt(K3;GQjSRWbf37WKfZVtiM9tG6YC=xL3)zsba%{-gAR7Wgq->`P+6}p9QEps; z%OFnYANkS!_x{V7)qUXoZ`+l{&6kOh3R1n`|tr@r!MTzH<9s&MT7^Cc>g2U&-CGyWp+-As$f$4113z z+kGnRjqy*8$0{#0N>w1FQ-gcgr3U~~uADbUx{&Ia-vVP!f;`mo90(}?Fddf%6)CtS zmTgnO@N5n$063g#Ytv=G;Lk&|;ho}YeaV>$$~kI_!eVt4F^+p zDPERZJW)@vHa&n>)=YkKcdM~!AY}-6obt7lsPY{J+unS~ZON{HMkS<3oS@{)Z+sb6 zS-Gb^-EXmOXW>A9^TvFWoU(>HygxHrupgOYE_LO9t34^`AHCOqiwA%u^&`X2AwAg1 z^K6PuNiA?QFCvXyLSg3z1t6m;177;h8I(S6=_P|Z^$_Ur23BPi7t;V$ixb>%&m=9V?xzP4R|GZa~uOUQ*Jjtglq9q1T}Ig)Or zzjy71wLN~cZQx_;qjG~qDbv`rHlLm{J56$1$n1=J9lm6KM^Ev{P(Z3N$fY``!RSzn zbVi-r?A1DBtkavwZvzrB0bAG#Y{8D$&LRXz$x~VxA)i6hQ>F=uGuT?G4zW>#c3txd z@vRE^b(rqFaf{@-NCGt?5#gAK0SV$eE#Ye~*0t2Z_o2WZ5-)iE1HiX^AYug(_w$Gy zI|)2ni=8@8v6J#i)0|s(Ep+R-j8JvxhPdSGJofd&`~UG+2V+Ti;DU%XGZ=}K(`MQl zWBpMJjXrbq^S8DpcYf|(Y;P@J%zkxrP1R0CLND8TWI1h*q;fB zB^3%MR3bVkS5r7BW|jD7Tz)m|6_H*09WIfpXhNv*yZGu~Fb>Aoj;xzk_m9r6`=8D# zK-oVTnB&3Zf&iPJGGkC<`)5C?(lYa=uaI4v#okw_X@a0t@>v|a zrU0TK)d3Fsv%r@B2arV)S^GTV#=eLc5g!yp!jMcD!3&YXz2kbgO7v`2jxa3CgeO@> zWt&trq9{W&8Px+7a$3xAYy3Pp*UXs_Ozo`Ar$~c%g4QBo#$7e*JLv+|}=Ol~~?o@Z{LGgbo zD`sqydVz9MP_xtMY=)a3Y)7km)Y4{JO*>{u<+4hmZcj(jHVOHC{M)3&k_?J%Y_83mRF9T7Zl1#*Z~*x2DJ{m+lUpSX)}nPl+qyU(Aumn!|X+P%1ZwF+xQ*$ zYcNlu-YP#R)`2v+X&Ui*k=7Y(bylvxb?6^;sBVTyq1RGq3hw+7!;XejD$*U8LG@YF zube3UG3O_oSk^h@-0H+-PMZ^B2&a><%v}FfR?5iGl0`2^%a->dMM%+S#o(8YH?vHc zK=je-0!@%#C>|RdALAD4gOI2>1SE8sD_(hi?*H##xU~c5A}r8SwY3rIDA`m+U)4JV z7pH}MCe*@$6~99r421oP^e5KkkFAe&+&O)0y~5ia>)KID%4r2Hpv<`~2io>LwKeqT ztsU!{4f(F74H27EE)>e8`L-TU->rp#+xy+kfv$ks>@-V_tj^}PxU4Gw+B2J9SGtpq zmTYqhqMy63zfB}kD(}sZ6<~LA`CFb$OER1v2s)BFFBkO&Y_Z5NOq#>4Uwl-~RimwW*(cc|=;Y>ln zw)(emD=(CcCSA2<%8JSvvq=ZfOdZYa9f?bw&A!S{SLG8!JAo$`0E%+puOdygRjhMn z#QOqvgzKoYA+~zgr5kSlR27MDq6H)lOp&J1ay-P%J_PrWX2s=dXI!w}T6Z~7ZLRxA zUo@}Bu7O@I*uLACEGJX_ zEv!V$2#IePU3!_$VU%Y-HhtvGi>ErJdaG8ZcNtov!0i6^@xpCIkBzlaCT@KJNJ>bM z$C0DR?NhtPhxfwJ5lasv<{4~!%Ih6hzkrP+B7j7XAmd07wPfi7`P6^3cKtCiQCNEk zOtysN(Oj0=SVqjavm}L!xaG5Wk%L4qSopwO_?%I@K4^ znmv>NS1aVs#Oioemc=GFkfn&gNs+dtZyhK3?A`}f%bik_zWMfZC(;{x0t)<=Y*+j4 zkMEfM1;v+w6gt~oY_jBfXTM&%Lp+S3hCs#^Y4ggoE>mmNXfyIUuzIYtG3YS5bTX|& z&uQ!Qw~l8>(vS^x-@YzRQjAi;Ye;YvXy_Pn-_*K+>;|YI8=KW0c>%HI5y*Ffd7z`}&MCP-|QAuK(~y{^%Gjtb$r=Lz>at`M$EEM3x|| zn9~weT2)hg2{D^^Q(jltQjE<<(9j&oBM_n}$mUmROVZ~{Ih2CRs|(a*V&~MfZO?~L z6Dk&}9dWLOM=q_rhejC20m^oWR3zxD72iTt1+whTsOs7^bO)p4zKWJPRh6Gs!fFez zKk`-b5OOziavC|dXAqykHcuDQgHiz1$Fp>@BRL3O$JFe`8SF@wI#&Ag$ohARCky+b zo+glSG&gm)oCNiqZA#ivFvAV*;d1W`YCbEx_W_m>sW z)#_pgV5BN@SS@KA)I`(@Cw6{PykXs<*9^MU?$7O-czitaT_{(z>cvQ#+OAg$1(b-O z74}HRTDq;^oKUHu$aknb8IP;QtI@f|B&L?jov~H%1@Wvg`epZ?2Fk@R7`j8y7Ar(^+X5I2pfS%%@PkR^$PZ_$I%iu^+1u$p8ndCu6+snw-MY_)C=DZ?*dj z^y(qe97&PkN2Nwr@2&YX5MSw(HzeQHA?@glrf%cwmWNScSmsqWZE4t9e1>$ zzp3Tm+0?2+d}OkzW$$Q0=1lvb)QUiA7XT&=A}JKFcAu(Lju1QxDwqNVJdm3M52-?! zDfA)%@t;nDmJvcuV5K2qD}g;je1pIU!W^C9n@8b$)($=seUmNf|Aa{8QcQtM#d-!U zi}m0G;=g3g)$AI)0x;jzD*PKev}G)Kb;}s!f__nLNzID?pFWxcO9Gc;S(gF7dz(2e z3GoYl_w27tZDZX%6MZom2y8e;h$O8WkMtayI^NcK$KUTg_{E*EckxZ*v3%5kq3=aP znXzuCN~aPk9R{sUE0gMViuM!V{MfN?pU(9heP)Y&@15?B(I|*QhU@QPp8;8<9XV9h ziB^u7V3LmoJQPR~Q_XoJJ2SUYz;+=UE7(i&Laq5G0WbZBvg3Xf+KuLn2ppTJN6162l_WXyeT4)Neo_Kr-tiq3yuMaOd`jT!_$F)#vO&? z$WWUPg7@iRjV7~m27qlES=E`L4jtS~koy2cp59hmm$O2F74wl+Fz2jzRUuV!7v!ZQ z056{fa2Z0MF0MR;Y$OETmy;aw0f9QhG4u_KVhtEtAoy@n(p8h^GMHO%EV%<I4ROC4q+oaN>Vj`OkJ0_B z5{7spZEFS?eRXIlj82>p2t-0$>1p>btBUf*hc|@@p;*j_#UNU*4Cr}niC!R2AWGyJ z9C7eX@Xz) zNmk(zmt!-0>n&H~@~T~+2y_{RX+E?GIF_{rzUi%=qBX)9g}+)%rM5T4fTG^-@N=3? zhx8Hx6`A6`diAya?qta2V)c^a+8Q$9Kr${85o zixQbosduPb6X@#;6p0xIH$B9uT_m9wseMPykhaq@$khNtdPD$R8dtDw{I2^|)%$q43i?0<-H%L6 zCzI((HH@1Zt=3)|3V44w4c;!4^SzTQgB(SNZ0*fAIAk)Vmue%$*{5QO*Iw@C|c|aEg$U?H{fc7 zY^msWBOJkBAt^Tw+iA{VfiO z#L?pSr|lBe3OS{8WKbLSS!p4O(Q<)IW7agq(DzuD_@O6hlSphyk2_(PO6`gFQ!B}f zPdXxsmTFzbn3oWcAOt$xyu<|koWxEd_e~ECg^xoyO^3!pw*v6+`~@lmUK#F0-jkcd zFkgs!J2J-$RjEypWbYB^NjvhJ3%9_FzFgRzfoY?+kSx^%T2C90{2Hr?wMMY~E9X1P zMohS(j8_mhu|yhKtOG&6#E}m8(+;WBk@g4D4xodo7gVM{z~)!8Rg*V3)ESsvfQmFx z@0^M(>gE{wKI^?<6)j`lQt6_+vxElu9Fzb#=m2uZ^r}_S&I05s*B}~fDBziTW(p?0=-}&Us%K8!7YV>QfDDh61W*_iRnXfwWYRdPHKpD zT&$Z-T&+jC`OQi^kEL0HCcB9oh2IWy2}%jocDTZ2lPDm66{Q*4lHgb};T%hb(<0g( z3TozOs>EVw-_aVVW-9U^j8ND9umo?#&{BZq7ZPM2K4n$2)SbY`K8-y69C8}FaQ>6y z<8AxeVLU1XgIW()b+z5v_QWNixd#v$W-RTU+BWbiP(WQ-1{o<89-zrb`tF8@!dj*e z=l2zM!HZjR?a=~MATv_vDK(Wm1w|c7)Sa%Ys|qLP(iKqO{Die!Guln(q@`VPE*&ng z7tx(iqyD5rC8)esb4H+1%EN2)hEtMfen#T+V1`$?k$&Pm)hRt685!cgU)iyifPiz3#X&&lM{pY`sVc$~v;f~ZhTN7FkB-Ko zHXF^$WNS3qz8{vm=Z=lX;Ei0i{V*q_>7DuU!X|i8%Eesm9L~-anoA85oAZsj*m#@` zgr`t`C;{HI3kX{3(2EjN?!She0|?$&+5Qy`d5N->)6VZeT?rYa@w3??LnL%5PVk`pKE|hE<=qd zYhB+fO1Y6;tI7ETNq+Pn7O`oiJBGdeE~yBIJtF!a^3<|6|C< zr#m~11CX#h@7=sva;p^LG~=N0&ikR)7@6ejzKa9{8{<|90Yfx|t zHYXbOv9i}>p{{waY0!1Pyy@Z1VTn|#_gTy?6$pd^xu-p_c6k#(aKu!30)H0&3DSuS zAmb=f-7_{QiwW@-S20<9v54D>Xz|xSU{F1SGCvqat)r-Z6dnD;%NkUtK@p8ygUK|S ztu6Rp+6w`DsOR|}4Cz68UT!JMHlcES(@Rev{lY`G>8*e?Qp9eb5~ z8AAie#ekwDpjniQJKw}$#WEgt1io^A1{+6rA$Mw?17xj8cs zQ{!7>5q*ba;Lg#YMk;Y@EgnpSdwRFD_Z(f9aA!9(Ioi_+oo+DNw$1C>-Zya9+At*! zRsK>KG6XZWRfGCKdUjnnhLI|l-6~I{bZnGcfdiKC68;*}0dT?ixrB9S2HP@?NTo;) zE+a{N7G$KQFVQ(6Rl!47 zYmBZUnQZJ$@+{RI+ca-i3Z|?3=;Ecd?mPeK*0w#PO$xYdBVdF~s4&^vx~AFW>F!?b zt*y5C^0|VaHu!8dzn)sO-WELgg{>i4sg}rfHjS0l2$edeHZh!8=S3UEqjL(GG{Y)QqJ7~OT9uKL=wop+Ad=nps7Sa4e-L0HDGAm zbzRPiv*DsU$B}T{u@BrvYrcOP9&B(!AD?$R#3E{^-W*hAf$&#q@k`~N$HLU!t6a?r z^jTvcP>m78kbT$RLq9|HH4nPzgOF_ zvvr!{p1b^xokdTYd%(%sRaNtsfaX)kw%Y9DVBSuI0Y9~f3%f8C4r{rpN}5HqPMY-f znRAM|F1bpH+g=;x8b4t8qnG+r;~xAKH}CNE4SuOw-++qswS`lG1&JdL3KAOw3X=EH z2q;LF>d%-{`O-y1O|D@68l{Brp3hS996uK{3f0WD367bj zYIm1Z{0b_V8(4J=0x^hLL&)D(cbfxP4xpgbn&69?PA}}_OCa(FuR7OXY&^@Z4Aj$I z?97E*`obkcqu}Qb&&Y85U*WNKz<58(cYT2GF6YdeYAbFH&x;u|+(2ZZ6|N>vcylvH zv;r|HoXzgY=DLehM!(G-&{4%FhSImJPAGik{(kR<6aDtOI59~%D=Q5|Ytn>#ra9RsNw4a!{>)1Drv~--fc-Qf7+}=`|)g(r{T0qj&#@BRa z)-)T@w+}!6P_gIknL7@D>%n68-81+092klC2M^@Id)Pm40QSpPo+1!1$HsnHM>AFH zmp#2wzigj;@T2z2e!y2W_RB7z{^j~*0a)1L?e1u|*X_XI=hkJt{R5*>ZY};jg}*mp zh{Jx_t*Q9xkOsYa?AvDwGF!w}*<3%(=Z%_C?D2K@)#Wqij%D_Y#AR?*_VwPr#PCku zW3WqHANg%nk6~qS>4-s$GRj6pDO`e6uqTFwr<9?iSt=VWvNDamPgCNLl;BK$9QN8= zuKEh~fgfMc8nTpgaMBTAmk5!B5~&SVr6v#tF0#NiT%9c~W{K6Vr%3|C``r;E1?vxY zduaB`V&^!J=w@ZOP)soz{;a&Wv3J1S`;fQh&SZ(y&tzGZ1=*8`ppiGzAc;_KDbiUO z0n+v~hI1#W$lB3%c=D5pJ5A+Hc#=vHl>HL4glJJYp?#-j5%3H({y3E}ZhO}FSWpg^ zTE^xb)snUU=RWKvPH@5A$?Se~G_k1=(=vpJ5!1o!+Gb~ySMBL250^VUi7gMV2@GaK zDiML>LPjKJGyO4V!Y*e!2ZskcS=3rOGT@cz^qO$U;?f8WR-@GDGg^aovon<4*p=N^ z3NT8IOs28vOir~>qt{4{F10OSH#-1iaQK-(>d| z*T0i1pO(SSZA0N<$OniyK7b<>lXH9M;Aur1S9awx@aJe0Zn)vQE8l?8p}O@$uzd3* zwosy)6*bV%BD)M3Kz;!eh-A(Pq+ar_JxUEp%f!1?-i*i9>em{~Vq8Q+HIy3Fu(A@H z*4~;{J7ora)1J@o-0}F<=u&im*{P98>x4k9xpGxlt6`h%;TB`czl8oeR@Q#+o`Q!Y z)V*x>wvk9j`4sP^7ZnOgn;&t(Rk?FINw^l4!;n^U6)ck4 z4GGk*t`LWfvsoeU9UwBl%q6wtY~pf4Q9G?Nd=uZnXZgjQvn#0&dz4nXs$9-Kz7uxu zLKX(L%|fx$0`f#Cs#+lQ75EcQR-~Ogj!Yn1&X06=Cnl1dcMO=>1d?!q*Z-yMOW@n6 z?)>My(Tp@Rx<<$77~S_R`H*b+h-Ev8oy2w=J0Z^DK*&KL39;i40%^Ds{!q#hV1ZJO z@NY|(qd;OiL4g#qOQ74*^nwrFwtv`mxBXLS!?vZAEyVJ^Hs)3%3o$J=oHGv*Hv4PGyG_hly-LWoPr-1kT>5fud3`fRrObk)#R4E>I zx|H#P_r7LEvPv%TdBVh>oM>Do7g^`;-rX1I2;zJd1w+fdVZj!%s4CK5q{w?=dj)~c zPfhaVbk3g?mr^n3$q=jzLVg0diOES!U)g-B2L`}n$c&Ohzm#z=(Os58JlaaMj3!&P zI6@h9IHDSyc0s12t)1E^W~|0^rvcG>%-_vOvEP={XK)S2Vu~s*DTp@}D=YtfcH;du z;+~2O?x-LTtMi?gKt9je$L1zO+<1O66uC?x`!#~%K{Q(&j~$Kn3}8+ZRBb97dJ*a9 za-yfRwX?IcaX^jdKAP^-VHxswubmFRN=$aTS_-_L!ZGiu1A-7pw=JWHE$c4d zd->iiIGs1g-rRA0=dRB7pmiN4{FcrRO!$FrvN2_rdTM&ydP|5@@aryR&RbchLxmK0c`9F0{!QB{k z{GCA!Lw;H=aixgFgeejEjFL0G=+nC+MNFYzkT7Muh$&Q68B^#dkd$3UTr%pMw^Z6> zx~%##^<{&Dm#Imy2eU<672aza^^5&@t4Y1FyR&OvXH{o?eRL@y;>GuO%CNW@OV&+M z*rctdVj_yP-qJ!RrM;%lzg(XIufR7e5qoMcv3dz|nx#Di z^=J6$xlVMo zprBYN1rXq}iU^`G`4KsWW*wWVH>h)N5#7 z3y6D5_M^?NOT=Q@NFKK5IJ>r9t(B1t4cewWjOJ81Qro(yW|20g{C3(E zsGwBETk17h@gAjhH&<27^J-=HLU@ZzG$o;fVJ7~4nyz*?$Ks4^7L!$}#AL-p*02-XxYC`B(O{Wz zA?~>iQ8`K6Sfug^!UJz1%!Cg{a!kUEUWAEL=HdFB)MSMexFq5Aa%>(R&8dkT7hdG$ zc>5xLI+RwyU6`z9?VI?RjYQvaNm6m{-^21GlmahgiJo=(idqO2l@M-J09!*UUgy-v z9(`1%w%0~twPwJ4_!|aTvsJOQLrooem{eNh!C2Y^xVLH%>ro`5VnK7^C050dlv?1y zv*1CUMNN~miY>eWA_^t4VbvBxVXIWhvv3bNj%ec}Hk2w;1BOu(RxuCT#(h@SYRs%9ITyH(-SxD!4p@``Lk%|ZnB6Vb^1Uc2m-YgbrZ0MDH!B% z|2C$#JCrg*`IRaoRXD9OXOq!tn_B);@+7T~)kU+SqHxM0$hBr3L}`nfto8bh3Q}n? zO*{$LTX}^-@LSN#77zq{k3304iAPFNcUI#ET8#$qG_rz^A9EVe3)fNj&M4#O%T5(9 znJJb|%~Zn)`)H0@QjDG<7d$$nxB`Keecd2h>Zy5`PU6j7kmGN5)H^ddk?FM ziQ}T3WHd_9Q#hqJQAn3Sx7whR%M=JZ$H7I6mZLARhs}&HoY2`t8xLivG_D&%Yi-6V zgVScyPE05SeAXxfPryx-gNP&lb>67l*pLTLj}tgoBoCg-=`}8wXuLIo7;HE${?sczfPV_XmLrZrrO|#~RE7Tl! zvN}QAzBSi*NvrdPw5Q6c3VB>r7WgZ*N~sBWLMG(fS1pViMWfTm>Wq9UVzM{{OS-TA zRt0a-*&Q|;n%!zNyXR>o5g_V_+ELb-dLA6c0cUVL#}j%dtByVG8MbU!kJKEdc9k5< z;!e|<@|>m)!pv5CMZT4n!so_fbQC`C&aG{9)TUyBFNHfxu|mLR_X~>1ikjBdS<9=8 z$#1jO_#A16=r?oZ2c08*F;4KB(+K1hoSf9sEKQQ=ufp42cdBpeLPsWQaYgU*`7DuI z#L@NeJJ3qmh!l|?H52|kIF?hh#)p4|>vn!qGfX~;biqlyuN(_KF5e~XE6=FdDODq# zT8xT-8eLowX;RQiQVP#N_O`p?y+iH#NYF2E#WG6@m8;5LKd-6Dn+YfxMh3{V&cbs> z+gESz-Q68Ps#?SGCY{=5*3ed6cW>_!lUrqS;T_Nhv=$H09735iQ9a67(s(ThA`ZrL zTHd+c!jPeF3&YhoiKnWTZEHen5_P+QQC?gMd10|HV2xx%M_okpM9Xuz z1xbycND!?@63B)%-yJ8aIM=Rt#ho#veHp=^a_Tc?NM7=|D#?BPezb2|rO{arT1yzK(au+kxSw`R$NXaSMt>aA^ zdW~A6Rt++O-){Gtm^L-KZMD=ctFu&FSsGF&4Hgx}Ds*;J(h&)}3zx__9B<*|;C^>F z;z(rr>+Ny{%Zs>vuNnLqUO`!jCZda2L+okgh-Kg_M2OIVg9!5%fIEmPq8S{_vGQn@ zTwWC={oQD(MhS5_MmLvVc3*Z!XxTl+&O0>;Ihi@EJgJ0Ar7L%5W_aa6*Y2qmL#EJ~ zx6Wi+O0`3aZi!Zkuu6r1J~a;}b50rz`XfI#4Th#mckl`|*Tga2+}e6mM6F=$)|=8x z)7DVW6+K;B7r5d<(e8Ix9R9Yob@m$J1gCx{7BV^vY%FMW8dzt*d$EH8Y$+$ zPUGo}5@dl-PQ-wZAX&BB5Ql`K*0dApbGt1du+wmwZ0xHM;D1bUN3uTS^AsL0-&X>u z$K#u~B8%mADdPAj!XTW5;W~lry#GW)C&1xnS?7ORv_sO6-#VuZ;?&^kDpM>RjIqeV z2-4Bj$fy#nxp=arH9kEmXi%`ohLf|3=hER&O>H<-rr({2ezim+;@B$iB(6`2s3;I# z@Ep>_EchKZLUDG(kZn6(reukb#X6-Gs)?L~ignXj4syL9z&jb_k~tBKQ~!51DQ}@T z!DqLJ%&by>%{Ns{dGtyJuoQkf2R&;Pt|H9gB_ZH4tO~p9@8=6xwZv??1tKBY* z8zko>C9usN$28TZzpF$o8IQ1bA(1~K>iTs;&X zF;&p3RMawgrkIZK3G6rf9xrim2V5xU5y*JP7_ecM42CS#&hqm6!`A94{`4kOp49qu z=LKdspD@|!$ze%5geyYZ0!2x4AYir?XOi@$He{Omt4%XzP=`kR*f}GX z#tMln(u*h1SoKIVdQK1qa18I}BO8TbEr&G2-ftAGtn(EbmCx9QN2Y0P`BgprSN8bA zeS7|BYlZb*U+McJD0^mT|2tGjWLTU+7t*hMoe8; z;#Y$Y;PYri*aEB@b*5NMK%-;<8VDnsN;+i}HUh;V?G=?qplNO+a0VMs(ePX&u;s#L zOC*4Nk`iAi^iEUCo7~u(TT^e9j6gBtaikHYu@SgvWLb>it^6PHRu)cTD|7$C|f zQpsi8IF{GZ~=~{Q@JC zD|9Y2$|l4M6dGjns{jx={RhsnLkj+BK{Ym|0}-mIoHyxMFtS&gP}YbMqfHz_z3 zXLIUJDw$HNv>D7+qY!G9EU6RV73vUCO~l3suQP~OM61_u&K~^}V5%^xidH#(23}F9%$|V$l8bU`m0I0`1r_7Zuo~U&w7M-$ijpJP zwA(!@Moz8Ya2DH3yAUJEWazJ5*qZv4->0NB7Kw*Wz(*(pvR~sz7;n)Ow_{Y{y$l&1 zG7Y&#rws9_!b@|Q;T2&(VMY`XKH^E4T{=Z#b6rzkwTUrFD9?l=mO2OGf5{9l+uhkz z$~Uh+3wkiuljyI)PwVP^9c{0lUWS*1ZSXm2BV=@zsC+JH7jElHi;&r65CI!D~UCD!*KSG`Z` z(W8?%>m@Or0rOj_0ErH~7J6kKE;O+qk%uC+t~hTClZDwHA@C`lk%0DumBAi57$lxK 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

    F9*G<;lShip!dJdL(uTKaiZpoY}sQH0Y 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%0Ayg=8IUA-A+CHhx49h2fP7azMVHN3W=QZ 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

    wW8e`@nE< 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 ~siN}c-|DF+EA`ZkH89Ur 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 z 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

    Ad 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%0AA2vO#z=GSm7Z>23cDZSZ-)A%%0> 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 I|Ec-^0_>nXyZ`_I literal 0 HcmV?d00001 diff --git a/doc/cheatsheet/Pandas_Cheat_Sheet.pptx b/doc/cheatsheet/Pandas_Cheat_Sheet.pptx new file mode 100644 index 0000000000000000000000000000000000000000..399edf84e7d1c13577201777c6c89b114d6393fd GIT binary patch literal 104088 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

    c@ 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 z sIcJ0a4Ch>yzSvJaFP-3bPWsPY>wS4-AZS1!M&P9nR3()D2*9uZ0p*Q$*8l(j literal 0 HcmV?d00001 diff --git a/doc/cheatsheet/README.txt b/doc/cheatsheet/README.txt new file mode 100644 index 0000000000000..e2f6ec042e9cc --- /dev/null +++ b/doc/cheatsheet/README.txt @@ -0,0 +1,4 @@ +The Pandas Cheat Sheet was created using Microsoft Powerpoint 2013. +To create the PDF version, within Powerpoint, simply do a "Save As" +and pick "PDF' as the format. + diff --git a/doc/source/whatsnew/v0.19.2.txt b/doc/source/whatsnew/v0.19.2.txt index ef40faf5457e7..e9af6ee2a921a 100644 --- a/doc/source/whatsnew/v0.19.2.txt +++ b/doc/source/whatsnew/v0.19.2.txt @@ -10,6 +10,8 @@ We recommend that all users upgrade to this version. Highlights include: - Compatibility with Python 3.6 +- Added a `Pandas Cheat Sheet `__. (:issue:`13202`). + .. contents:: What's new in v0.19.2 :local: From a06e32a9742d51a6e0e76f9119c9f9cbcecb64f9 Mon Sep 17 00:00:00 2001 From: John Owens Date: Thu, 15 Dec 2016 15:53:11 -0800 Subject: [PATCH 46/51] added 'separator' argument to json_normalize --- pandas/io/json.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/pandas/io/json.py b/pandas/io/json.py index 0a6b8af179e12..fa123d5783958 100644 --- a/pandas/io/json.py +++ b/pandas/io/json.py @@ -24,8 +24,8 @@ def to_json(path_or_buf, obj, orient=None, date_format='epoch', default_handler=None, lines=False): if lines and orient != 'records': - raise ValueError( - "'lines' keyword only valid when 'orient' is records") + raise ValueError( + "'lines' keyword only valid when 'orient' is records") if isinstance(obj, Series): s = SeriesWriter( @@ -726,8 +726,8 @@ def nested_to_record(ds, prefix="", level=0): def json_normalize(data, record_path=None, meta=None, meta_prefix=None, record_prefix=None, + separator='.', errors='raise'): - """ "Normalize" semi-structured JSON data into a flat table @@ -744,6 +744,9 @@ def json_normalize(data, record_path=None, meta=None, If True, prefix records with dotted (?) path, e.g. foo.bar.field if path to records is ['foo', 'bar'] meta_prefix : string, default None + separator : string, default '.' + Nested records will generate names separated by separator, + e.g., for separator='.', { 'foo' : { 'bar' : 0 } } -> foo.bar errors : {'raise', 'ignore'}, default 'raise' * ignore : will ignore KeyError if keys listed in meta are not always present @@ -828,7 +831,7 @@ def _pull_field(js, spec): lengths = [] meta_vals = defaultdict(list) - meta_keys = ['.'.join(val) for val in meta] + meta_keys = [separator.join(val) for val in meta] def _recursive_extract(data, path, seen_meta, level=0): if len(path) > 1: From dcc463265c856a3c7ef4b74025c3274f96f035fa Mon Sep 17 00:00:00 2001 From: John Owens Date: Thu, 15 Dec 2016 16:21:34 -0800 Subject: [PATCH 47/51] test for json_normalize argument 'separator' --- pandas/io/tests/json/test_json_norm.py | 30 ++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/pandas/io/tests/json/test_json_norm.py b/pandas/io/tests/json/test_json_norm.py index 36110898448ea..9935550024915 100644 --- a/pandas/io/tests/json/test_json_norm.py +++ b/pandas/io/tests/json/test_json_norm.py @@ -133,6 +133,36 @@ def test_shallow_nested(self): expected = DataFrame(ex_data, columns=result.columns) tm.assert_frame_equal(result, expected) + def test_shallow_nested_with_separator(self): + data = [{'state': 'Florida', + 'shortname': 'FL', + 'info': { + 'governor': 'Rick Scott' + }, + 'counties': [{'name': 'Dade', 'population': 12345}, + {'name': 'Broward', 'population': 40000}, + {'name': 'Palm Beach', 'population': 60000}]}, + {'state': 'Ohio', + 'shortname': 'OH', + 'info': { + 'governor': 'John Kasich' + }, + 'counties': [{'name': 'Summit', 'population': 1234}, + {'name': 'Cuyahoga', 'population': 1337}]}] + + result = json_normalize(data, 'counties', + ['state', 'shortname', + ['info', 'governor']], + separator='_') + ex_data = {'name': ['Dade', 'Broward', 'Palm Beach', 'Summit', + 'Cuyahoga'], + 'state': ['Florida'] * 3 + ['Ohio'] * 2, + 'shortname': ['FL', 'FL', 'FL', 'OH', 'OH'], + 'info_governor': ['Rick Scott'] * 3 + ['John Kasich'] * 2, + 'population': [12345, 40000, 60000, 1234, 1337]} + expected = DataFrame(ex_data, columns=result.columns) + tm.assert_frame_equal(result, expected) + def test_meta_name_conflict(self): data = [{'foo': 'hello', 'bar': 'there', From 236331478944b6a8738e402960ad8125cee2cdea Mon Sep 17 00:00:00 2001 From: John Owens Date: Thu, 15 Dec 2016 16:22:09 -0800 Subject: [PATCH 48/51] added new enhancement: json_normalize now takes 'separator' as an optional argument --- doc/source/whatsnew/v0.20.0.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/doc/source/whatsnew/v0.20.0.txt b/doc/source/whatsnew/v0.20.0.txt index 27f8564ba16c2..fc1e9bb906905 100644 --- a/doc/source/whatsnew/v0.20.0.txt +++ b/doc/source/whatsnew/v0.20.0.txt @@ -107,6 +107,7 @@ Other enhancements - ``pd.DataFrame.plot`` now prints a title above each subplot if ``suplots=True`` and ``title`` is a list of strings (:issue:`14753`) - ``pd.Series.interpolate`` now supports timedelta as an index type with ``method='time'`` (:issue:`6424`) - ``pandas.io.json.json_normalize()`` gained the option ``errors='ignore'|'raise'``; the default is ``errors='raise'`` which is backward compatible. (:issue:`14583`) +- ``pandas.io.json.json_normalize()`` gained the option ``separator=string``; the default is ``separator='.'`` which is backward compatible. (:issue:`14883`) - ``.select_dtypes()`` now allows the string 'datetimetz' to generically select datetimes with tz (:issue:`14910`) From 8e0faa8b8981f42627ca15e0b89e6ca775e88e25 Mon Sep 17 00:00:00 2001 From: John Owens Date: Thu, 15 Dec 2016 19:46:37 -0800 Subject: [PATCH 49/51] rename json_normalize arg separator to sep, simpler test, add version tag --- pandas/io/json.py | 13 ++++++---- pandas/io/tests/json/test_json_norm.py | 36 +++++++------------------- 2 files changed, 17 insertions(+), 32 deletions(-) diff --git a/pandas/io/json.py b/pandas/io/json.py index fa123d5783958..e7823ef9e9c09 100644 --- a/pandas/io/json.py +++ b/pandas/io/json.py @@ -726,8 +726,8 @@ def nested_to_record(ds, prefix="", level=0): def json_normalize(data, record_path=None, meta=None, meta_prefix=None, record_prefix=None, - separator='.', - errors='raise'): + errors='raise', + sep='.'): """ "Normalize" semi-structured JSON data into a flat table @@ -744,9 +744,6 @@ def json_normalize(data, record_path=None, meta=None, If True, prefix records with dotted (?) path, e.g. foo.bar.field if path to records is ['foo', 'bar'] meta_prefix : string, default None - separator : string, default '.' - Nested records will generate names separated by separator, - e.g., for separator='.', { 'foo' : { 'bar' : 0 } } -> foo.bar errors : {'raise', 'ignore'}, default 'raise' * ignore : will ignore KeyError if keys listed in meta are not always present @@ -755,6 +752,12 @@ def json_normalize(data, record_path=None, meta=None, .. versionadded:: 0.20.0 + sep : string, default '.' + Nested records will generate names separated by sep (separator), + e.g., for sep='.', { 'foo' : { 'bar' : 0 } } -> foo.bar + + .. versionadded:: 0.20.0 + Returns ------- frame : DataFrame diff --git a/pandas/io/tests/json/test_json_norm.py b/pandas/io/tests/json/test_json_norm.py index 9935550024915..e65d252ab24d1 100644 --- a/pandas/io/tests/json/test_json_norm.py +++ b/pandas/io/tests/json/test_json_norm.py @@ -133,34 +133,16 @@ def test_shallow_nested(self): expected = DataFrame(ex_data, columns=result.columns) tm.assert_frame_equal(result, expected) - def test_shallow_nested_with_separator(self): - data = [{'state': 'Florida', - 'shortname': 'FL', - 'info': { - 'governor': 'Rick Scott' - }, - 'counties': [{'name': 'Dade', 'population': 12345}, - {'name': 'Broward', 'population': 40000}, - {'name': 'Palm Beach', 'population': 60000}]}, - {'state': 'Ohio', - 'shortname': 'OH', - 'info': { - 'governor': 'John Kasich' - }, - 'counties': [{'name': 'Summit', 'population': 1234}, - {'name': 'Cuyahoga', 'population': 1337}]}] + def test_simple_normalize_with_default_separator(self): + result = json_normalize({"A": {"A": 1, "B": 2}}) + expected = pd.DataFrame([[1, 2]], columns={"A.A", "A.B"}) + assert_frame_equal(result, expected) + tm.assert_frame_equal(result, expected) - result = json_normalize(data, 'counties', - ['state', 'shortname', - ['info', 'governor']], - separator='_') - ex_data = {'name': ['Dade', 'Broward', 'Palm Beach', 'Summit', - 'Cuyahoga'], - 'state': ['Florida'] * 3 + ['Ohio'] * 2, - 'shortname': ['FL', 'FL', 'FL', 'OH', 'OH'], - 'info_governor': ['Rick Scott'] * 3 + ['John Kasich'] * 2, - 'population': [12345, 40000, 60000, 1234, 1337]} - expected = DataFrame(ex_data, columns=result.columns) + def test_simple_normalize_with_user_specified_separator(self): + result = json_normalize({"A": {"A": 1, "B": 2}}, sep='_') + expected = pd.DataFrame([[1, 2]], columns={"A_A", "A_B"}) + assert_frame_equal(result, expected) tm.assert_frame_equal(result, expected) def test_meta_name_conflict(self): From 521720dc04f065b7c0d3425a5a59fa46e34acc22 Mon Sep 17 00:00:00 2001 From: John Owens Date: Wed, 21 Dec 2016 15:32:59 -0800 Subject: [PATCH 50/51] json_normalize's separator is now sep, also does a check for string_types --- doc/source/whatsnew/v0.20.0.txt | 2 +- pandas/io/json.py | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/doc/source/whatsnew/v0.20.0.txt b/doc/source/whatsnew/v0.20.0.txt index fc1e9bb906905..2a3c83708b6f3 100644 --- a/doc/source/whatsnew/v0.20.0.txt +++ b/doc/source/whatsnew/v0.20.0.txt @@ -107,7 +107,7 @@ Other enhancements - ``pd.DataFrame.plot`` now prints a title above each subplot if ``suplots=True`` and ``title`` is a list of strings (:issue:`14753`) - ``pd.Series.interpolate`` now supports timedelta as an index type with ``method='time'`` (:issue:`6424`) - ``pandas.io.json.json_normalize()`` gained the option ``errors='ignore'|'raise'``; the default is ``errors='raise'`` which is backward compatible. (:issue:`14583`) -- ``pandas.io.json.json_normalize()`` gained the option ``separator=string``; the default is ``separator='.'`` which is backward compatible. (:issue:`14883`) +- ``pandas.io.json.json_normalize()`` gained ``sep`` option that accepts ``str``, default is ".", which is backward compatible. (:issue:`14883`) - ``.select_dtypes()`` now allows the string 'datetimetz' to generically select datetimes with tz (:issue:`14910`) diff --git a/pandas/io/json.py b/pandas/io/json.py index e7823ef9e9c09..009792cf00716 100644 --- a/pandas/io/json.py +++ b/pandas/io/json.py @@ -834,7 +834,9 @@ def _pull_field(js, spec): lengths = [] meta_vals = defaultdict(list) - meta_keys = [separator.join(val) for val in meta] + if not isinstance(sep, compat.string_types): + sep = str(sep) + meta_keys = [sep.join(val) for val in meta] def _recursive_extract(data, path, seen_meta, level=0): if len(path) > 1: From 74c4285671125dcbc61fabedc86bb6c5f4100a78 Mon Sep 17 00:00:00 2001 From: John Owens Date: Wed, 21 Dec 2016 15:33:33 -0800 Subject: [PATCH 51/51] simpler and better tests for json_normalize with separator (default, user-specified, user-specified-with-unicode) --- pandas/io/tests/json/test_json_norm.py | 27 ++++++++++++++------------ 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/pandas/io/tests/json/test_json_norm.py b/pandas/io/tests/json/test_json_norm.py index e65d252ab24d1..d94c389c026ad 100644 --- a/pandas/io/tests/json/test_json_norm.py +++ b/pandas/io/tests/json/test_json_norm.py @@ -63,6 +63,21 @@ def test_simple_normalize(self): tm.assert_frame_equal(result, expected) + def test_simple_normalize_with_default_separator(self): + result = json_normalize({'A': {'A': 1, 'B': 2}}) + expected = DataFrame([[1, 2]], columns={'A.A', 'A.B'}) + tm.assert_frame_equal(result, expected) + + def test_simple_normalize_with_user_specified_separator(self): + result = json_normalize({'A': {'A': 1, 'B': 2}}, sep='_') + expected = DataFrame([[1, 2]], columns={'A_A', 'A_B'}) + tm.assert_frame_equal(result, expected) + + def test_simple_normalize_with_user_specified_unicode_separator(self): + result = json_normalize({'A': {'A': 1, 'B': 2}}, sep=u'\u03c3') + expected = DataFrame([[1, 2]], columns={u'A\u03c3A', u'A\u03c3B'}) + tm.assert_frame_equal(result, expected) + def test_more_deeply_nested(self): data = [{'country': 'USA', 'states': [{'name': 'California', @@ -133,18 +148,6 @@ def test_shallow_nested(self): expected = DataFrame(ex_data, columns=result.columns) tm.assert_frame_equal(result, expected) - def test_simple_normalize_with_default_separator(self): - result = json_normalize({"A": {"A": 1, "B": 2}}) - expected = pd.DataFrame([[1, 2]], columns={"A.A", "A.B"}) - assert_frame_equal(result, expected) - tm.assert_frame_equal(result, expected) - - def test_simple_normalize_with_user_specified_separator(self): - result = json_normalize({"A": {"A": 1, "B": 2}}, sep='_') - expected = pd.DataFrame([[1, 2]], columns={"A_A", "A_B"}) - assert_frame_equal(result, expected) - tm.assert_frame_equal(result, expected) - def test_meta_name_conflict(self): data = [{'foo': 'hello', 'bar': 'there',