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
|
%global _empty_manifest_terminate_build 0
Name: python-Flask-SQLAlchemy-Caching
Version: 1.0.4
Release: 1
Summary: CachingQuery implementation to Flask using Flask-SQLAlchemy and Flask-Caching
License: MIT
URL: http://www.github.com/bbelyeu/Flask-SQLAlchemy-Caching
Source0: https://mirrors.nju.edu.cn/pypi/web/packages/da/3d/20339dbe72c9acacd0191dfaf8af9e29aaf153fa8759a3a7ddaaaae9b03b/Flask-SQLAlchemy-Caching-1.0.4.tar.gz
BuildArch: noarch
%description
This is a fork of [iurisilvio's Flask-SQLAlchemy-Cache](https://github.com/iurisilvio/Flask-SQLAlchemy-Cache)
A CachingQuery implementation to Flask using Flask-SQLAlchemy and Flask-Caching.
To start using caching queries, you just have to replace Flask-SQLAlchemy `Model.query_class`.
```python
from flask_sqlalchemy import SQLAlchemy
from flask_sqlalchemy_caching import CachingQuery
from flask_caching import Cache
db = SQLAlchemy(app, query_class=CachingQuery)
cache = Cache(app)
```
After that, you can just make queries to a model `YourModel`:
```python
from flask_sqlalchemy_caching import FromCache
# cache is a Flask-Caching instance imported for your app init
YourModel.query.options(FromCache(cache)).get()
```
You also have `RelationshipCache` to enable lazy loading relationships from
cache.
```python
from sqlalchemy.orm import lazyload
from flask_sqlalchemy_caching import RelationshipCache
rc = RelationshipCache(YourModel.some_relationship, cache)
obj = YourModel.query.options(lazyload(YourModel.some_relationship), rc).get()
# make the query and cache the results for future queries
print(obj.some_relationship)
```
If there is a column in your table that is much more dynamic and you want to exclude it from
being cached, try using a deferred query like:
```python
YourModel.query.options(defer('crazy_column')).options(FromCache(cache)).get()
```
Take a look at [Dogpile Caching example][] to more details about how
`CachingQuery` works. Most changes to their were made just to integrate it
with Flask, Flask-SQLAlchemy and Flask-Caching instead of Dogpile.
[Dogpile Caching example]: http://docs.sqlalchemy.org/en/latest/orm/examples.html?highlight=dogpile#module-examples.dogpile_caching
%package -n python3-Flask-SQLAlchemy-Caching
Summary: CachingQuery implementation to Flask using Flask-SQLAlchemy and Flask-Caching
Provides: python-Flask-SQLAlchemy-Caching
BuildRequires: python3-devel
BuildRequires: python3-setuptools
BuildRequires: python3-pip
%description -n python3-Flask-SQLAlchemy-Caching
This is a fork of [iurisilvio's Flask-SQLAlchemy-Cache](https://github.com/iurisilvio/Flask-SQLAlchemy-Cache)
A CachingQuery implementation to Flask using Flask-SQLAlchemy and Flask-Caching.
To start using caching queries, you just have to replace Flask-SQLAlchemy `Model.query_class`.
```python
from flask_sqlalchemy import SQLAlchemy
from flask_sqlalchemy_caching import CachingQuery
from flask_caching import Cache
db = SQLAlchemy(app, query_class=CachingQuery)
cache = Cache(app)
```
After that, you can just make queries to a model `YourModel`:
```python
from flask_sqlalchemy_caching import FromCache
# cache is a Flask-Caching instance imported for your app init
YourModel.query.options(FromCache(cache)).get()
```
You also have `RelationshipCache` to enable lazy loading relationships from
cache.
```python
from sqlalchemy.orm import lazyload
from flask_sqlalchemy_caching import RelationshipCache
rc = RelationshipCache(YourModel.some_relationship, cache)
obj = YourModel.query.options(lazyload(YourModel.some_relationship), rc).get()
# make the query and cache the results for future queries
print(obj.some_relationship)
```
If there is a column in your table that is much more dynamic and you want to exclude it from
being cached, try using a deferred query like:
```python
YourModel.query.options(defer('crazy_column')).options(FromCache(cache)).get()
```
Take a look at [Dogpile Caching example][] to more details about how
`CachingQuery` works. Most changes to their were made just to integrate it
with Flask, Flask-SQLAlchemy and Flask-Caching instead of Dogpile.
[Dogpile Caching example]: http://docs.sqlalchemy.org/en/latest/orm/examples.html?highlight=dogpile#module-examples.dogpile_caching
%package help
Summary: Development documents and examples for Flask-SQLAlchemy-Caching
Provides: python3-Flask-SQLAlchemy-Caching-doc
%description help
This is a fork of [iurisilvio's Flask-SQLAlchemy-Cache](https://github.com/iurisilvio/Flask-SQLAlchemy-Cache)
A CachingQuery implementation to Flask using Flask-SQLAlchemy and Flask-Caching.
To start using caching queries, you just have to replace Flask-SQLAlchemy `Model.query_class`.
```python
from flask_sqlalchemy import SQLAlchemy
from flask_sqlalchemy_caching import CachingQuery
from flask_caching import Cache
db = SQLAlchemy(app, query_class=CachingQuery)
cache = Cache(app)
```
After that, you can just make queries to a model `YourModel`:
```python
from flask_sqlalchemy_caching import FromCache
# cache is a Flask-Caching instance imported for your app init
YourModel.query.options(FromCache(cache)).get()
```
You also have `RelationshipCache` to enable lazy loading relationships from
cache.
```python
from sqlalchemy.orm import lazyload
from flask_sqlalchemy_caching import RelationshipCache
rc = RelationshipCache(YourModel.some_relationship, cache)
obj = YourModel.query.options(lazyload(YourModel.some_relationship), rc).get()
# make the query and cache the results for future queries
print(obj.some_relationship)
```
If there is a column in your table that is much more dynamic and you want to exclude it from
being cached, try using a deferred query like:
```python
YourModel.query.options(defer('crazy_column')).options(FromCache(cache)).get()
```
Take a look at [Dogpile Caching example][] to more details about how
`CachingQuery` works. Most changes to their were made just to integrate it
with Flask, Flask-SQLAlchemy and Flask-Caching instead of Dogpile.
[Dogpile Caching example]: http://docs.sqlalchemy.org/en/latest/orm/examples.html?highlight=dogpile#module-examples.dogpile_caching
%prep
%autosetup -n Flask-SQLAlchemy-Caching-1.0.4
%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-Flask-SQLAlchemy-Caching -f filelist.lst
%dir %{python3_sitelib}/*
%files help -f doclist.lst
%{_docdir}/*
%changelog
* Tue May 30 2023 Python_Bot <Python_Bot@openeuler.org> - 1.0.4-1
- Package Spec generated
|
