From b8e6c2f9db7fbc98eb31d688b1525e13934ce4d9 Mon Sep 17 00:00:00 2001 From: CoprDistGit Date: Tue, 20 Jun 2023 04:58:49 +0000 Subject: automatic import of python-pygasus --- python-pygasus.spec | 590 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 590 insertions(+) create mode 100644 python-pygasus.spec (limited to 'python-pygasus.spec') diff --git a/python-pygasus.spec b/python-pygasus.spec new file mode 100644 index 0000000..0a7671d --- /dev/null +++ b/python-pygasus.spec @@ -0,0 +1,590 @@ +%global _empty_manifest_terminate_build 0 +Name: python-pygasus +Version: 0.10.4 +Release: 1 +Summary: A lightweight ORM built on top of Pydantic +License: BSD-3-Clause +URL: https://github.com/talismud/pygasus +Source0: https://mirrors.aliyun.com/pypi/web/packages/0e/dd/1d87faed889517ea3c89982758c50dfa68d3f7c1d7d34bcc69627b9bed32/pygasus-0.10.4.tar.gz +BuildArch: noarch + +Requires: python3-alembic +Requires: python3-email-validator +Requires: python3-pydantic +Requires: python3-SQLAlchemy +Requires: python3-typing-compat + +%description +# pygasus + +A lightweight Sqlite ORM built on top of Pydantic. + +## Installation + +The easiest way to install Pygasus is to use `pip`, preferably inside a virtual environment: + + pip install pygasus + +`pygasus` supports Python 3.7, 3.8, 3.9 and 3.10. + +## Getting started + +Pygasus allows you to create your models using type annotations. This model will then be converted to something that can be stored (in a database): + +```python +from pygasus import Model + +class User(Model): + + """An user.""" + + id: int + name: str + age: int + height: float +``` + +You then need to add this model to Pygasus: + +```python +from pygasus.storage import SQLStorageEngine + +# The default storage engine is SQLAlchemy, connected to Sqlite3. +storage = SQLStorageEngine("test.sql") +# ... you can also just create the database in memory for testing: +storage = SQLStorageEngine(memory=True) + +# Then you need to add your models. +storage.bind_models({User}) + +# You can call `bind_models` without any argument, but in this case, +# make sure to import your `User` class (and your other models) +# before you do that. + +# Create a new user. +user = User.repository.create(name="Vincent", age=33, height=5.7) +# Notice that we don't specify the `id`. This field will be set by +# the storage engine Pygasus uses. + +# At this point, our new user has been created, stored and returned. +print(user.id) # 1 +print(user.name) # Vincent +user.age = 21 # Well, why not? +# This will call an immediate update in the storage. + +# Of course we can also query a model: +queried = User.repository.get(id=1) + +# Due to caching, the queried user will be identical (in terms of reference). +print(user is queried) # True + +# You can control the cache to remove this behavior. +``` + +This should show you some basic concepts. To learn more, head over to the documentation. + +## Contributing + +If you wish to develop Pygasus, all you need is: + +- Docker: getting a working Docker engine isn't that complicated on Linux, Windows or Mac OS. +- Make: getting Make is more complicated, but it's not exactly required. If you're on Windows, don't despair. You might rely on Bash itself, it's available (and easy to access if you have WSL installed). + +Pygasus relies on Docker images to make sure it remains usable on the supported Python versions: the idea is that each version will run in a diffferent Docker container, built on a different image. This process is automated, and you don't really need to understand it to use it, but it might be worth diving into the scripts (see the `scripts` directory). + +### Initializes the images + +Once you have cloned the `pygasus` repository, you must create the images for the required Python versions. This is not exactly mandatory, as other scripts will make sure the images exist (and will build them if necessary), but this might make things easier, particularly in case of errors. + +Pygasus supports four Python versions: 3.7, 3.8, 3.9 and 3.10. You can initialize them all at once, though it will take time: + + make init + +Get yourself a cup of coffee and stare at the process: each image is downloaded and built in turn. Additional packages are installed. Pygasus will install additional dependencies, then install Poetry and let it handle other Python dependencies, so that each image uses the same versions in dependencies. + +If you wish to build images individually: + + make init version=3.7 + +This will build the image only for Python 3.7 (called pygasus-3.7). Running each build one at a time makes it easier to spot errors. + +On the other hand, only panics if a build actually fails: it's not that uncommon to see warnings and even errors during the build process, but most of the time, this can be ignored... unless the build itself fails (you will be warned if that happens, don't worry). + +> Curious? Try to look at the images in Docker: `docker images` . You should see the four `pygasus-VERSION` images along with the `python-VERSION-slim` build (this is the image on which Pygasus images are built). + +Don't have Make? If you have Bash, you can still run the command: + + bash scripts/init.sh + +Initializing isn't a "fire and forget" command. Should Pygasus dependencies change or critical security bugs be fixed in Python images, it is recommended to run `make init` once more. + +### Testing + +Now that you have your Pygasus images, you can run the test suite in all versions at once: + + make test + +This will run the test suite in every Python version and display the result on the screen. This might take a little while, but you should see the progress. Obviously, if a test fails in a supported Python version, this is a big deal and something to fix for the next commit. It is recommended to run `make test` before committing anything. + +Don't have Make? No worries: + + bash scripts/test.sh + +You can also run the test suite in a specific version, though this is less useful: + + make test version=3.9 + +### Linter + +Pygasus uses black and flake8 as linters. If you have written some code, make sure it's properly formatted before committing: + + make check-style + +This won't do any modification in your code, this will merely display the errors (if any). Fix them before committing! + +It's also possible to format your code using black: + + make format + +This will actually edit your files in a proper format. However, notice that flake8 isn't involved. Sometimes, it sees potential errors black will ignore, so make sure `make check-style` is completely empty before committing. + +You don't have Make? No worries: + + bash scripts/check_style.sh + bash scripts/format.sh + +### Debugging + +When coding, it can help to actually see what Pygasus does when you execute a line of code. It is possible to start a shell inside of the container where Pygasus is installed. You can then access to `pdb` to debug or run some arbitrary code: + + make shell + +If no version is specified, run in the first version (that is, 3.7). It is assumed that it might be harder to break compatibility that way. You can specify a version though: + + make shell version=3.10 + +Once connected to the container, you can execute commands (including `poetry`, `python` and such). + +Don't have Make? No worries: + + bash scripts/shell.sh + +### Cleaning up + +The started containers using the previous commands will not be maintained: once you exit them, they will go away. However, images are kept. Although this usually doesn't pose many problems, these images are heavy. You can remove images without tags (usually, Pygasus images have got only one tag). + + make clean + +This shouldn't be necessary. Keep an eye on the output of the `docker images` command to see if Docker keeps images it shouldn't. + +### Updating images + +It bears reminding, once built, Pygasus images aren't changed. If a major security bug is fixed and a new Python image is pushed to Docker hub, you won't have it. If Pygasus dependencies change, you might run into errors. + +At any point, you can force-update the Pygasus images: + + make init + +This will pull the Python image from Docker and rebuild the Pygasus image even if you already have one. + + +%package -n python3-pygasus +Summary: A lightweight ORM built on top of Pydantic +Provides: python-pygasus +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-pygasus +# pygasus + +A lightweight Sqlite ORM built on top of Pydantic. + +## Installation + +The easiest way to install Pygasus is to use `pip`, preferably inside a virtual environment: + + pip install pygasus + +`pygasus` supports Python 3.7, 3.8, 3.9 and 3.10. + +## Getting started + +Pygasus allows you to create your models using type annotations. This model will then be converted to something that can be stored (in a database): + +```python +from pygasus import Model + +class User(Model): + + """An user.""" + + id: int + name: str + age: int + height: float +``` + +You then need to add this model to Pygasus: + +```python +from pygasus.storage import SQLStorageEngine + +# The default storage engine is SQLAlchemy, connected to Sqlite3. +storage = SQLStorageEngine("test.sql") +# ... you can also just create the database in memory for testing: +storage = SQLStorageEngine(memory=True) + +# Then you need to add your models. +storage.bind_models({User}) + +# You can call `bind_models` without any argument, but in this case, +# make sure to import your `User` class (and your other models) +# before you do that. + +# Create a new user. +user = User.repository.create(name="Vincent", age=33, height=5.7) +# Notice that we don't specify the `id`. This field will be set by +# the storage engine Pygasus uses. + +# At this point, our new user has been created, stored and returned. +print(user.id) # 1 +print(user.name) # Vincent +user.age = 21 # Well, why not? +# This will call an immediate update in the storage. + +# Of course we can also query a model: +queried = User.repository.get(id=1) + +# Due to caching, the queried user will be identical (in terms of reference). +print(user is queried) # True + +# You can control the cache to remove this behavior. +``` + +This should show you some basic concepts. To learn more, head over to the documentation. + +## Contributing + +If you wish to develop Pygasus, all you need is: + +- Docker: getting a working Docker engine isn't that complicated on Linux, Windows or Mac OS. +- Make: getting Make is more complicated, but it's not exactly required. If you're on Windows, don't despair. You might rely on Bash itself, it's available (and easy to access if you have WSL installed). + +Pygasus relies on Docker images to make sure it remains usable on the supported Python versions: the idea is that each version will run in a diffferent Docker container, built on a different image. This process is automated, and you don't really need to understand it to use it, but it might be worth diving into the scripts (see the `scripts` directory). + +### Initializes the images + +Once you have cloned the `pygasus` repository, you must create the images for the required Python versions. This is not exactly mandatory, as other scripts will make sure the images exist (and will build them if necessary), but this might make things easier, particularly in case of errors. + +Pygasus supports four Python versions: 3.7, 3.8, 3.9 and 3.10. You can initialize them all at once, though it will take time: + + make init + +Get yourself a cup of coffee and stare at the process: each image is downloaded and built in turn. Additional packages are installed. Pygasus will install additional dependencies, then install Poetry and let it handle other Python dependencies, so that each image uses the same versions in dependencies. + +If you wish to build images individually: + + make init version=3.7 + +This will build the image only for Python 3.7 (called pygasus-3.7). Running each build one at a time makes it easier to spot errors. + +On the other hand, only panics if a build actually fails: it's not that uncommon to see warnings and even errors during the build process, but most of the time, this can be ignored... unless the build itself fails (you will be warned if that happens, don't worry). + +> Curious? Try to look at the images in Docker: `docker images` . You should see the four `pygasus-VERSION` images along with the `python-VERSION-slim` build (this is the image on which Pygasus images are built). + +Don't have Make? If you have Bash, you can still run the command: + + bash scripts/init.sh + +Initializing isn't a "fire and forget" command. Should Pygasus dependencies change or critical security bugs be fixed in Python images, it is recommended to run `make init` once more. + +### Testing + +Now that you have your Pygasus images, you can run the test suite in all versions at once: + + make test + +This will run the test suite in every Python version and display the result on the screen. This might take a little while, but you should see the progress. Obviously, if a test fails in a supported Python version, this is a big deal and something to fix for the next commit. It is recommended to run `make test` before committing anything. + +Don't have Make? No worries: + + bash scripts/test.sh + +You can also run the test suite in a specific version, though this is less useful: + + make test version=3.9 + +### Linter + +Pygasus uses black and flake8 as linters. If you have written some code, make sure it's properly formatted before committing: + + make check-style + +This won't do any modification in your code, this will merely display the errors (if any). Fix them before committing! + +It's also possible to format your code using black: + + make format + +This will actually edit your files in a proper format. However, notice that flake8 isn't involved. Sometimes, it sees potential errors black will ignore, so make sure `make check-style` is completely empty before committing. + +You don't have Make? No worries: + + bash scripts/check_style.sh + bash scripts/format.sh + +### Debugging + +When coding, it can help to actually see what Pygasus does when you execute a line of code. It is possible to start a shell inside of the container where Pygasus is installed. You can then access to `pdb` to debug or run some arbitrary code: + + make shell + +If no version is specified, run in the first version (that is, 3.7). It is assumed that it might be harder to break compatibility that way. You can specify a version though: + + make shell version=3.10 + +Once connected to the container, you can execute commands (including `poetry`, `python` and such). + +Don't have Make? No worries: + + bash scripts/shell.sh + +### Cleaning up + +The started containers using the previous commands will not be maintained: once you exit them, they will go away. However, images are kept. Although this usually doesn't pose many problems, these images are heavy. You can remove images without tags (usually, Pygasus images have got only one tag). + + make clean + +This shouldn't be necessary. Keep an eye on the output of the `docker images` command to see if Docker keeps images it shouldn't. + +### Updating images + +It bears reminding, once built, Pygasus images aren't changed. If a major security bug is fixed and a new Python image is pushed to Docker hub, you won't have it. If Pygasus dependencies change, you might run into errors. + +At any point, you can force-update the Pygasus images: + + make init + +This will pull the Python image from Docker and rebuild the Pygasus image even if you already have one. + + +%package help +Summary: Development documents and examples for pygasus +Provides: python3-pygasus-doc +%description help +# pygasus + +A lightweight Sqlite ORM built on top of Pydantic. + +## Installation + +The easiest way to install Pygasus is to use `pip`, preferably inside a virtual environment: + + pip install pygasus + +`pygasus` supports Python 3.7, 3.8, 3.9 and 3.10. + +## Getting started + +Pygasus allows you to create your models using type annotations. This model will then be converted to something that can be stored (in a database): + +```python +from pygasus import Model + +class User(Model): + + """An user.""" + + id: int + name: str + age: int + height: float +``` + +You then need to add this model to Pygasus: + +```python +from pygasus.storage import SQLStorageEngine + +# The default storage engine is SQLAlchemy, connected to Sqlite3. +storage = SQLStorageEngine("test.sql") +# ... you can also just create the database in memory for testing: +storage = SQLStorageEngine(memory=True) + +# Then you need to add your models. +storage.bind_models({User}) + +# You can call `bind_models` without any argument, but in this case, +# make sure to import your `User` class (and your other models) +# before you do that. + +# Create a new user. +user = User.repository.create(name="Vincent", age=33, height=5.7) +# Notice that we don't specify the `id`. This field will be set by +# the storage engine Pygasus uses. + +# At this point, our new user has been created, stored and returned. +print(user.id) # 1 +print(user.name) # Vincent +user.age = 21 # Well, why not? +# This will call an immediate update in the storage. + +# Of course we can also query a model: +queried = User.repository.get(id=1) + +# Due to caching, the queried user will be identical (in terms of reference). +print(user is queried) # True + +# You can control the cache to remove this behavior. +``` + +This should show you some basic concepts. To learn more, head over to the documentation. + +## Contributing + +If you wish to develop Pygasus, all you need is: + +- Docker: getting a working Docker engine isn't that complicated on Linux, Windows or Mac OS. +- Make: getting Make is more complicated, but it's not exactly required. If you're on Windows, don't despair. You might rely on Bash itself, it's available (and easy to access if you have WSL installed). + +Pygasus relies on Docker images to make sure it remains usable on the supported Python versions: the idea is that each version will run in a diffferent Docker container, built on a different image. This process is automated, and you don't really need to understand it to use it, but it might be worth diving into the scripts (see the `scripts` directory). + +### Initializes the images + +Once you have cloned the `pygasus` repository, you must create the images for the required Python versions. This is not exactly mandatory, as other scripts will make sure the images exist (and will build them if necessary), but this might make things easier, particularly in case of errors. + +Pygasus supports four Python versions: 3.7, 3.8, 3.9 and 3.10. You can initialize them all at once, though it will take time: + + make init + +Get yourself a cup of coffee and stare at the process: each image is downloaded and built in turn. Additional packages are installed. Pygasus will install additional dependencies, then install Poetry and let it handle other Python dependencies, so that each image uses the same versions in dependencies. + +If you wish to build images individually: + + make init version=3.7 + +This will build the image only for Python 3.7 (called pygasus-3.7). Running each build one at a time makes it easier to spot errors. + +On the other hand, only panics if a build actually fails: it's not that uncommon to see warnings and even errors during the build process, but most of the time, this can be ignored... unless the build itself fails (you will be warned if that happens, don't worry). + +> Curious? Try to look at the images in Docker: `docker images` . You should see the four `pygasus-VERSION` images along with the `python-VERSION-slim` build (this is the image on which Pygasus images are built). + +Don't have Make? If you have Bash, you can still run the command: + + bash scripts/init.sh + +Initializing isn't a "fire and forget" command. Should Pygasus dependencies change or critical security bugs be fixed in Python images, it is recommended to run `make init` once more. + +### Testing + +Now that you have your Pygasus images, you can run the test suite in all versions at once: + + make test + +This will run the test suite in every Python version and display the result on the screen. This might take a little while, but you should see the progress. Obviously, if a test fails in a supported Python version, this is a big deal and something to fix for the next commit. It is recommended to run `make test` before committing anything. + +Don't have Make? No worries: + + bash scripts/test.sh + +You can also run the test suite in a specific version, though this is less useful: + + make test version=3.9 + +### Linter + +Pygasus uses black and flake8 as linters. If you have written some code, make sure it's properly formatted before committing: + + make check-style + +This won't do any modification in your code, this will merely display the errors (if any). Fix them before committing! + +It's also possible to format your code using black: + + make format + +This will actually edit your files in a proper format. However, notice that flake8 isn't involved. Sometimes, it sees potential errors black will ignore, so make sure `make check-style` is completely empty before committing. + +You don't have Make? No worries: + + bash scripts/check_style.sh + bash scripts/format.sh + +### Debugging + +When coding, it can help to actually see what Pygasus does when you execute a line of code. It is possible to start a shell inside of the container where Pygasus is installed. You can then access to `pdb` to debug or run some arbitrary code: + + make shell + +If no version is specified, run in the first version (that is, 3.7). It is assumed that it might be harder to break compatibility that way. You can specify a version though: + + make shell version=3.10 + +Once connected to the container, you can execute commands (including `poetry`, `python` and such). + +Don't have Make? No worries: + + bash scripts/shell.sh + +### Cleaning up + +The started containers using the previous commands will not be maintained: once you exit them, they will go away. However, images are kept. Although this usually doesn't pose many problems, these images are heavy. You can remove images without tags (usually, Pygasus images have got only one tag). + + make clean + +This shouldn't be necessary. Keep an eye on the output of the `docker images` command to see if Docker keeps images it shouldn't. + +### Updating images + +It bears reminding, once built, Pygasus images aren't changed. If a major security bug is fixed and a new Python image is pushed to Docker hub, you won't have it. If Pygasus dependencies change, you might run into errors. + +At any point, you can force-update the Pygasus images: + + make init + +This will pull the Python image from Docker and rebuild the Pygasus image even if you already have one. + + +%prep +%autosetup -n pygasus-0.10.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-pygasus -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Tue Jun 20 2023 Python_Bot - 0.10.4-1 +- Package Spec generated -- cgit v1.2.3