automatic import of python-alexlib

1 files changed, 303 insertions, 0 deletions

diff --git a/python-alexlib.spec b/python-alexlib.spec
new file mode 100644
index 0000000..10d3283
--- /dev/null
+++ b/python-alexlib.spec
@@ -0,0 +1,303 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-alexlib
+Version:	1.9.0
+Release:	1
+Summary:	Making Python even more convenient by extending list and dict and pathlib and more.
+License:	Apache 2.0
+URL:		https://github.com/thisismygitrepo/alexlib
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/f5/d0/4ae9f0b3695b3c0b12e0b3de78dfd0e48dcc4155fb5d324ef42ce830c5f4/alexlib-1.9.0.tar.gz
+BuildArch:	noarch
+
+
+%description
+
+# Welcome to alexlib
+
+Fill your life with one-liners, take your code to artistic level of brevity and readability while simultaneously being more productive by typing less boilerplate lines of code that are needless to say.
+
+This package extends many native Python classes to equip you with an uneasy-to-tame power. The major classes extended are:
+
+ * `list` is  extended to `List`
+    * Forget that `for` loops exist, because with this class, `for` loops are implicitly used to apply a function to all items.
+      Inevitably while programming, one will encounter objects of the same type and you will be struggling to get a tough grab on them.  `List` is a powerful structure that put at your disposal a grip, so tough, that the objects you have at hand start behaving like one object. Behaviour is ala-JavaScript implementation of ``forEach`` method of Arrays.
+
+  * `dict` is  extended to `Struct`.
+    * Combines the power of dot notation like classes and key access like dictionaries.
+
+   * `pathlib.Path` is  extended to `P`
+        * `P` objects are incredibly powerful for parsing paths, *no* more than one line of code is required to do **any** operation. Take a shufti at this:
+        ```
+     path = tb.P("dataset/type1/meta/images/file3.ext")
+     >> path[0]  # allows indexing!
+        P("dataset")
+     >> path[-1]  # nifty!
+        P("file3.ext")
+     >> path[2:-1]  # even slicing!
+        P("meta/images/file3.ext")
+     ```
+     This and much more, is only on top of the indespensible `pathlib.Path` functionalities.
+
+   * Additionally, the package provides many other new classes, e.g. `Read` and `Save`. Together with `P`, they provide comprehensible support for file management. Life cannot get easier with those. Every class inherits attributes that allow saving and loading in one line.
+
+
+Furthermore, those classes are inextricably connected. For example, globbing a path `P` object returns a `List` object. You can move back and forth between `List` and `Struct` and `DataFrame` with one method, and so on.
+
+
+# Install
+In the commandline:
+`pip install alexlib`.
+
+Being a thin extension on top of almost pure Python, you need to worry **not** about your venv, the package is not aggressive in requirements, it installs itself peacefully, never interfere with your other packages. If you do not have `numpy`, `matplotlib` and `pandas`, it simply throws `ImportError` at runtime, that's it.
+
+[comment]: # (The package is not fussy about versions either. It can though at runtime, install packages on the fly, e.g. `dill` and `tqdm` which are very lightweight libraries.)
+
+# Getting Started
+That's as easy as taking candy from a baby; whenever you start a Python file, preface it with following in order to unleash the library:
+
+```
+import alexlib.toolbox as tb
+```
+
+
+# A Taste of Power
+Suppose you want to know how many lines of code in your repository. The procedure is to glob all `.py` files recursively, read string code, split each one of them by lines, count the lines, add up everything from all strings of code.
+
+
+To achieve this, all you need is an eminently readable one-liner.
+```
+tb.P.cwd().search("*.py", r=True).read_text().split('\n').apply(len).to_numpy().sum()
+```
+
+How does this make perfect sense?
+* `search` returns `List` of `P` path objects
+* `read_text` is a `P` method, but it is being run against `List` object. Behind the scenes, **responsible black magic** fails to find such a method in `List` and realizes it is a method of items inside the list, so it runs it against them and thus read all files and containerize them in another `List` object and returns it.
+* A similar story applies to `split` which is a method of strings in Python.
+* Next, `apply` is a method of `List`. Sure enough, it lives up to its apt name and applies the passed function `len` to all items in the list and returns another `List` object that contains the results.
+* `.to_numpy()` converts `List` to `numpy` array, then `.sum` is a method of `numpy`, which gives the final result.
+
+Methods naming convention like `apply` and `to_numpy` are inspired from the popular `pandas` library, resulting in almost non-existing learning curve.
+
+# Friendly interactive tutorial.
+Please refer to [Here](<https://github.com/thisismygitrepo/alexlib/blob/master/tutorial.ipynb>) on the main git repo.
+
+# Full docs:
+Click [Here](<https://alexlib.readthedocs.io/en/latest/>)
+
+# Author
+Alex Al-Saffar. [email](mailto:programmer@usa.com)
+
+
+
+
+%package -n python3-alexlib
+Summary:	Making Python even more convenient by extending list and dict and pathlib and more.
+Provides:	python-alexlib
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-alexlib
+
+# Welcome to alexlib
+
+Fill your life with one-liners, take your code to artistic level of brevity and readability while simultaneously being more productive by typing less boilerplate lines of code that are needless to say.
+
+This package extends many native Python classes to equip you with an uneasy-to-tame power. The major classes extended are:
+
+ * `list` is  extended to `List`
+    * Forget that `for` loops exist, because with this class, `for` loops are implicitly used to apply a function to all items.
+      Inevitably while programming, one will encounter objects of the same type and you will be struggling to get a tough grab on them.  `List` is a powerful structure that put at your disposal a grip, so tough, that the objects you have at hand start behaving like one object. Behaviour is ala-JavaScript implementation of ``forEach`` method of Arrays.
+
+  * `dict` is  extended to `Struct`.
+    * Combines the power of dot notation like classes and key access like dictionaries.
+
+   * `pathlib.Path` is  extended to `P`
+        * `P` objects are incredibly powerful for parsing paths, *no* more than one line of code is required to do **any** operation. Take a shufti at this:
+        ```
+     path = tb.P("dataset/type1/meta/images/file3.ext")
+     >> path[0]  # allows indexing!
+        P("dataset")
+     >> path[-1]  # nifty!
+        P("file3.ext")
+     >> path[2:-1]  # even slicing!
+        P("meta/images/file3.ext")
+     ```
+     This and much more, is only on top of the indespensible `pathlib.Path` functionalities.
+
+   * Additionally, the package provides many other new classes, e.g. `Read` and `Save`. Together with `P`, they provide comprehensible support for file management. Life cannot get easier with those. Every class inherits attributes that allow saving and loading in one line.
+
+
+Furthermore, those classes are inextricably connected. For example, globbing a path `P` object returns a `List` object. You can move back and forth between `List` and `Struct` and `DataFrame` with one method, and so on.
+
+
+# Install
+In the commandline:
+`pip install alexlib`.
+
+Being a thin extension on top of almost pure Python, you need to worry **not** about your venv, the package is not aggressive in requirements, it installs itself peacefully, never interfere with your other packages. If you do not have `numpy`, `matplotlib` and `pandas`, it simply throws `ImportError` at runtime, that's it.
+
+[comment]: # (The package is not fussy about versions either. It can though at runtime, install packages on the fly, e.g. `dill` and `tqdm` which are very lightweight libraries.)
+
+# Getting Started
+That's as easy as taking candy from a baby; whenever you start a Python file, preface it with following in order to unleash the library:
+
+```
+import alexlib.toolbox as tb
+```
+
+
+# A Taste of Power
+Suppose you want to know how many lines of code in your repository. The procedure is to glob all `.py` files recursively, read string code, split each one of them by lines, count the lines, add up everything from all strings of code.
+
+
+To achieve this, all you need is an eminently readable one-liner.
+```
+tb.P.cwd().search("*.py", r=True).read_text().split('\n').apply(len).to_numpy().sum()
+```
+
+How does this make perfect sense?
+* `search` returns `List` of `P` path objects
+* `read_text` is a `P` method, but it is being run against `List` object. Behind the scenes, **responsible black magic** fails to find such a method in `List` and realizes it is a method of items inside the list, so it runs it against them and thus read all files and containerize them in another `List` object and returns it.
+* A similar story applies to `split` which is a method of strings in Python.
+* Next, `apply` is a method of `List`. Sure enough, it lives up to its apt name and applies the passed function `len` to all items in the list and returns another `List` object that contains the results.
+* `.to_numpy()` converts `List` to `numpy` array, then `.sum` is a method of `numpy`, which gives the final result.
+
+Methods naming convention like `apply` and `to_numpy` are inspired from the popular `pandas` library, resulting in almost non-existing learning curve.
+
+# Friendly interactive tutorial.
+Please refer to [Here](<https://github.com/thisismygitrepo/alexlib/blob/master/tutorial.ipynb>) on the main git repo.
+
+# Full docs:
+Click [Here](<https://alexlib.readthedocs.io/en/latest/>)
+
+# Author
+Alex Al-Saffar. [email](mailto:programmer@usa.com)
+
+
+
+
+%package help
+Summary:	Development documents and examples for alexlib
+Provides:	python3-alexlib-doc
+%description help
+
+# Welcome to alexlib
+
+Fill your life with one-liners, take your code to artistic level of brevity and readability while simultaneously being more productive by typing less boilerplate lines of code that are needless to say.
+
+This package extends many native Python classes to equip you with an uneasy-to-tame power. The major classes extended are:
+
+ * `list` is  extended to `List`
+    * Forget that `for` loops exist, because with this class, `for` loops are implicitly used to apply a function to all items.
+      Inevitably while programming, one will encounter objects of the same type and you will be struggling to get a tough grab on them.  `List` is a powerful structure that put at your disposal a grip, so tough, that the objects you have at hand start behaving like one object. Behaviour is ala-JavaScript implementation of ``forEach`` method of Arrays.
+
+  * `dict` is  extended to `Struct`.
+    * Combines the power of dot notation like classes and key access like dictionaries.
+
+   * `pathlib.Path` is  extended to `P`
+        * `P` objects are incredibly powerful for parsing paths, *no* more than one line of code is required to do **any** operation. Take a shufti at this:
+        ```
+     path = tb.P("dataset/type1/meta/images/file3.ext")
+     >> path[0]  # allows indexing!
+        P("dataset")
+     >> path[-1]  # nifty!
+        P("file3.ext")
+     >> path[2:-1]  # even slicing!
+        P("meta/images/file3.ext")
+     ```
+     This and much more, is only on top of the indespensible `pathlib.Path` functionalities.
+
+   * Additionally, the package provides many other new classes, e.g. `Read` and `Save`. Together with `P`, they provide comprehensible support for file management. Life cannot get easier with those. Every class inherits attributes that allow saving and loading in one line.
+
+
+Furthermore, those classes are inextricably connected. For example, globbing a path `P` object returns a `List` object. You can move back and forth between `List` and `Struct` and `DataFrame` with one method, and so on.
+
+
+# Install
+In the commandline:
+`pip install alexlib`.
+
+Being a thin extension on top of almost pure Python, you need to worry **not** about your venv, the package is not aggressive in requirements, it installs itself peacefully, never interfere with your other packages. If you do not have `numpy`, `matplotlib` and `pandas`, it simply throws `ImportError` at runtime, that's it.
+
+[comment]: # (The package is not fussy about versions either. It can though at runtime, install packages on the fly, e.g. `dill` and `tqdm` which are very lightweight libraries.)
+
+# Getting Started
+That's as easy as taking candy from a baby; whenever you start a Python file, preface it with following in order to unleash the library:
+
+```
+import alexlib.toolbox as tb
+```
+
+
+# A Taste of Power
+Suppose you want to know how many lines of code in your repository. The procedure is to glob all `.py` files recursively, read string code, split each one of them by lines, count the lines, add up everything from all strings of code.
+
+
+To achieve this, all you need is an eminently readable one-liner.
+```
+tb.P.cwd().search("*.py", r=True).read_text().split('\n').apply(len).to_numpy().sum()
+```
+
+How does this make perfect sense?
+* `search` returns `List` of `P` path objects
+* `read_text` is a `P` method, but it is being run against `List` object. Behind the scenes, **responsible black magic** fails to find such a method in `List` and realizes it is a method of items inside the list, so it runs it against them and thus read all files and containerize them in another `List` object and returns it.
+* A similar story applies to `split` which is a method of strings in Python.
+* Next, `apply` is a method of `List`. Sure enough, it lives up to its apt name and applies the passed function `len` to all items in the list and returns another `List` object that contains the results.
+* `.to_numpy()` converts `List` to `numpy` array, then `.sum` is a method of `numpy`, which gives the final result.
+
+Methods naming convention like `apply` and `to_numpy` are inspired from the popular `pandas` library, resulting in almost non-existing learning curve.
+
+# Friendly interactive tutorial.
+Please refer to [Here](<https://github.com/thisismygitrepo/alexlib/blob/master/tutorial.ipynb>) on the main git repo.
+
+# Full docs:
+Click [Here](<https://alexlib.readthedocs.io/en/latest/>)
+
+# Author
+Alex Al-Saffar. [email](mailto:programmer@usa.com)
+
+
+
+
+%prep
+%autosetup -n alexlib-1.9.0
+
+%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-alexlib -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Thu May 18 2023 Python_Bot <Python_Bot@openeuler.org> - 1.9.0-1
+- Package Spec generated