1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
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.aliyun.com/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 Jun 08 2023 Python_Bot <Python_Bot@openeuler.org> - 1.9.0-1
- Package Spec generated
|
