diff options
Diffstat (limited to 'python-pandas-ply.spec')
| -rw-r--r-- | python-pandas-ply.spec | 150 |
1 files changed, 150 insertions, 0 deletions
diff --git a/python-pandas-ply.spec b/python-pandas-ply.spec new file mode 100644 index 0000000..edb72cd --- /dev/null +++ b/python-pandas-ply.spec @@ -0,0 +1,150 @@ +%global _empty_manifest_terminate_build 0 +Name: python-pandas-ply +Version: 0.2.1 +Release: 1 +Summary: functional data manipulation for pandas +License: Apache License 2.0 +URL: https://github.com/coursera/pandas-ply +Source0: https://mirrors.aliyun.com/pypi/web/packages/8d/6b/434ef2f9c96e10ba6f75a1f82a85cf46ac98199f581627c9e732504a62f3/pandas-ply-0.2.1.tar.gz +BuildArch: noarch + + +%description +**pandas-ply** is a thin layer which makes it easier to manipulate data with `pandas <http://pandas.pydata.org/>`_. In particular, it provides elegant, functional, chainable syntax in cases where **pandas** would require mutation, saved intermediate values, or other awkward constructions. In this way, it aims to move **pandas** closer to the "grammar of data manipulation" provided by the `dplyr <http://cran.r-project.org/web/packages/dplyr/index.html>`_ package for R. +For example, take the **dplyr** code below: + flights %>% + group_by(year, month, day) %>% + summarise( + arr = mean(arr_delay, na.rm = TRUE), + dep = mean(dep_delay, na.rm = TRUE) + ) %>% + filter(arr > 30 & dep > 30) +The most common way to express this in **pandas** is probably: + grouped_flights = flights.groupby(['year', 'month', 'day']) + output = pd.DataFrame() + output['arr'] = grouped_flights.arr_delay.mean() + output['dep'] = grouped_flights.dep_delay.mean() + filtered_output = output[(output.arr > 30) & (output.dep > 30)] +**pandas-ply** lets you instead write: + (flights + .groupby(['year', 'month', 'day']) + .ply_select( + arr = X.arr_delay.mean(), + dep = X.dep_delay.mean()) + .ply_where(X.arr > 30, X.dep > 30)) +In our opinion, this **pandas-ply** code is cleaner, more expressive, more readable, more concise, and less error-prone than the original **pandas** code. +Explanatory notes on the **pandas-ply** code sample above: +* **pandas-ply**'s methods (like ``ply_select`` and ``ply_where`` above) are attached directly to **pandas** objects and can be used immediately, without any wrapping or redirection. They start with a ``ply_`` prefix to distinguish them from built-in **pandas** methods. +* **pandas-ply**'s methods are named for (and modelled after) SQL's operators. (But keep in mind that these operators will not always appear in the same order as they do in a SQL statement: ``SELECT a FROM b WHERE c GROUP BY d`` probably maps to ``b.ply_where(c).groupby(d).ply_select(a)``.) +* **pandas-ply** includes a simple system for building "symbolic expressions" to provide as arguments to its methods. ``X`` above is an instance of ``ply.symbolic.Symbol``. Operations on this symbol produce larger compound symbolic expressions. When ``pandas-ply`` receives a symbolic expression as an argument, it converts it into a function. So, for instance, ``X.arr > 30`` in the above code could have instead been provided as ``lambda x: x.arr > 30``. Use of symbolic expressions allows the ``lambda x:`` to be left off, resulting in less cluttered code. + +%package -n python3-pandas-ply +Summary: functional data manipulation for pandas +Provides: python-pandas-ply +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-pandas-ply +**pandas-ply** is a thin layer which makes it easier to manipulate data with `pandas <http://pandas.pydata.org/>`_. In particular, it provides elegant, functional, chainable syntax in cases where **pandas** would require mutation, saved intermediate values, or other awkward constructions. In this way, it aims to move **pandas** closer to the "grammar of data manipulation" provided by the `dplyr <http://cran.r-project.org/web/packages/dplyr/index.html>`_ package for R. +For example, take the **dplyr** code below: + flights %>% + group_by(year, month, day) %>% + summarise( + arr = mean(arr_delay, na.rm = TRUE), + dep = mean(dep_delay, na.rm = TRUE) + ) %>% + filter(arr > 30 & dep > 30) +The most common way to express this in **pandas** is probably: + grouped_flights = flights.groupby(['year', 'month', 'day']) + output = pd.DataFrame() + output['arr'] = grouped_flights.arr_delay.mean() + output['dep'] = grouped_flights.dep_delay.mean() + filtered_output = output[(output.arr > 30) & (output.dep > 30)] +**pandas-ply** lets you instead write: + (flights + .groupby(['year', 'month', 'day']) + .ply_select( + arr = X.arr_delay.mean(), + dep = X.dep_delay.mean()) + .ply_where(X.arr > 30, X.dep > 30)) +In our opinion, this **pandas-ply** code is cleaner, more expressive, more readable, more concise, and less error-prone than the original **pandas** code. +Explanatory notes on the **pandas-ply** code sample above: +* **pandas-ply**'s methods (like ``ply_select`` and ``ply_where`` above) are attached directly to **pandas** objects and can be used immediately, without any wrapping or redirection. They start with a ``ply_`` prefix to distinguish them from built-in **pandas** methods. +* **pandas-ply**'s methods are named for (and modelled after) SQL's operators. (But keep in mind that these operators will not always appear in the same order as they do in a SQL statement: ``SELECT a FROM b WHERE c GROUP BY d`` probably maps to ``b.ply_where(c).groupby(d).ply_select(a)``.) +* **pandas-ply** includes a simple system for building "symbolic expressions" to provide as arguments to its methods. ``X`` above is an instance of ``ply.symbolic.Symbol``. Operations on this symbol produce larger compound symbolic expressions. When ``pandas-ply`` receives a symbolic expression as an argument, it converts it into a function. So, for instance, ``X.arr > 30`` in the above code could have instead been provided as ``lambda x: x.arr > 30``. Use of symbolic expressions allows the ``lambda x:`` to be left off, resulting in less cluttered code. + +%package help +Summary: Development documents and examples for pandas-ply +Provides: python3-pandas-ply-doc +%description help +**pandas-ply** is a thin layer which makes it easier to manipulate data with `pandas <http://pandas.pydata.org/>`_. In particular, it provides elegant, functional, chainable syntax in cases where **pandas** would require mutation, saved intermediate values, or other awkward constructions. In this way, it aims to move **pandas** closer to the "grammar of data manipulation" provided by the `dplyr <http://cran.r-project.org/web/packages/dplyr/index.html>`_ package for R. +For example, take the **dplyr** code below: + flights %>% + group_by(year, month, day) %>% + summarise( + arr = mean(arr_delay, na.rm = TRUE), + dep = mean(dep_delay, na.rm = TRUE) + ) %>% + filter(arr > 30 & dep > 30) +The most common way to express this in **pandas** is probably: + grouped_flights = flights.groupby(['year', 'month', 'day']) + output = pd.DataFrame() + output['arr'] = grouped_flights.arr_delay.mean() + output['dep'] = grouped_flights.dep_delay.mean() + filtered_output = output[(output.arr > 30) & (output.dep > 30)] +**pandas-ply** lets you instead write: + (flights + .groupby(['year', 'month', 'day']) + .ply_select( + arr = X.arr_delay.mean(), + dep = X.dep_delay.mean()) + .ply_where(X.arr > 30, X.dep > 30)) +In our opinion, this **pandas-ply** code is cleaner, more expressive, more readable, more concise, and less error-prone than the original **pandas** code. +Explanatory notes on the **pandas-ply** code sample above: +* **pandas-ply**'s methods (like ``ply_select`` and ``ply_where`` above) are attached directly to **pandas** objects and can be used immediately, without any wrapping or redirection. They start with a ``ply_`` prefix to distinguish them from built-in **pandas** methods. +* **pandas-ply**'s methods are named for (and modelled after) SQL's operators. (But keep in mind that these operators will not always appear in the same order as they do in a SQL statement: ``SELECT a FROM b WHERE c GROUP BY d`` probably maps to ``b.ply_where(c).groupby(d).ply_select(a)``.) +* **pandas-ply** includes a simple system for building "symbolic expressions" to provide as arguments to its methods. ``X`` above is an instance of ``ply.symbolic.Symbol``. Operations on this symbol produce larger compound symbolic expressions. When ``pandas-ply`` receives a symbolic expression as an argument, it converts it into a function. So, for instance, ``X.arr > 30`` in the above code could have instead been provided as ``lambda x: x.arr > 30``. Use of symbolic expressions allows the ``lambda x:`` to be left off, resulting in less cluttered code. + +%prep +%autosetup -n pandas-ply-0.2.1 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "\"/%h/%f\"\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "\"/%h/%f\"\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "\"/%h/%f\"\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "\"/%h/%f\"\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "\"/%h/%f.gz\"\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-pandas-ply -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Tue Jun 20 2023 Python_Bot <Python_Bot@openeuler.org> - 0.2.1-1 +- Package Spec generated |