summaryrefslogtreecommitdiff
path: root/python-pymongoose.spec
diff options
context:
space:
mode:
Diffstat (limited to 'python-pymongoose.spec')
-rw-r--r--python-pymongoose.spec955
1 files changed, 955 insertions, 0 deletions
diff --git a/python-pymongoose.spec b/python-pymongoose.spec
new file mode 100644
index 0000000..67f1ed8
--- /dev/null
+++ b/python-pymongoose.spec
@@ -0,0 +1,955 @@
+%global _empty_manifest_terminate_build 0
+Name: python-pymongoose
+Version: 1.3.7
+Release: 1
+Summary: A pymongo helper with methods and classes
+License: MIT License
+URL: https://github.com/djcharles26/pymongoose
+Source0: https://mirrors.nju.edu.cn/pypi/web/packages/e4/56/2be0e9bc993c2a74ae16400b58db234a86e99553c753754a14ebf44227ed/pymongoose-1.3.7.tar.gz
+BuildArch: noarch
+
+Requires: python3-pymongo
+
+%description
+# Pymongoose
+
+This is a pymongo helper package, that let you make more complicated actions with your collections.
+It gives you the possibility to populate between packages without needs of creating an aggregation by yourself.
+Gives you the basic actions such as find, update and delete, with more simplicity.
+
+Pymongoose came with a Schema class that let you work with more efficiency and organization
+
+# First Steps
+
+```bash
+pip install pymongoose pymongo
+```
+
+## Create a model:
+
+models/role.py
+
+```python
+import datetime
+from pymongoose import methods
+from pymongoose.mongo_types import Types, Schema, MongoException, MongoError
+from bson import json_util
+from bson.objectid import ObjectId
+
+
+class Role(Schema):
+ schema_name = "roles" # Name of the schema that mongo uses
+
+ # Attributes
+ id = None
+ name = None
+ action = None
+
+ def __init__(self, **kwargs):
+ self.schema = {
+ "name": {
+ "type": Types.String,
+ "required": True
+ },
+ "actions": [{
+ "type": Types.String,
+ "required": True
+ }]
+ }
+
+ super().__init__(self.schema_name, self.schema, kwargs)
+
+
+ def __str__(self):
+ return f"Role: {self.name}, Actions: {self.action}"
+```
+
+**Is higly recommended to follow this model for any schema**
+
+## Mongo Configuration
+This mongo configuration is required for pymongoose to work correctly
+
+db.py:
+```python
+ import os, traceback
+ import signal
+ from pymongo import MongoClient
+ from pymongoose.methods import set_schemas, get_cursor_length
+ from models.role import Role
+
+ MONGO_URI = os.environ.get("MONGO_URI")
+
+ mongo_db = None
+
+ def mongo_init ():
+ global mongo_db
+
+ client = MongoClient(MONGO_URI)
+ db = client.test
+ try:
+ # Now schemas can be set in two ways
+
+ #-> In a dict mode
+ schemas = {
+ "roles": Role(empty=True).schema
+ }
+ set_schemas(db, schemas)
+
+ #-> Or in a list mode
+
+ set_schemas_from_list (db, [Role (empty=True)])
+
+
+ print("MongoDB Connected!")
+ except:
+ traceback.print_exc()
+ print("Error initializing database")
+ exit(1)
+
+ if __name__ == "__main__":
+ mongo_init()
+```
+
+## Examples:
+- For more model examples check examples/
+
+### Insert function:
+
+```python
+user = User(
+ name="TestA",
+ password="test",
+ role=role.id
+)
+id = user.save()
+```
+user.save() will throw an exception if a field marked as required in schema is **None**.
+
+### Find function:
+```python
+users = User.find({})
+for user in users:
+ user = User.parse(user)
+```
+This will return a cursor of elements, which can be parsed into User model for a better management.
+
+### Find one function:
+```python
+user = User.find({}, one=True)
+# OR
+user = User.find_one ({})
+```
+This will return a User element with fields obtained by database, if you prefer a json just add
+```python
+parse = False
+```
+At last of the **find** statement.
+
+### Find by id function:
+```python
+# this Function will search for "_id" field
+# so id must be a hex24 string or ObjectId
+user = User.find_by_id(id)
+# for a complete user
+user = User.find_by_id(id, select={"name": 1, "username": 1})
+# For a custom user
+```
+This will return a User element with fields obtained by database, if you prefer a json just add
+```python
+parse = False
+```
+At last of the **find** statement.
+
+### Populate a search:
+```python
+user = User.find_by_id(id, populate=[
+ {
+ "path": "role",
+ "select": ["name", "actions"],
+ "options": ["actions"]
+ }
+])
+# For an extensive populate
+# or
+user = User.find_by_id(id, populate=["role"])
+# For a simple populate
+```
+This will return a User element with fields obtained by database
+
+
+Populate is a really useful tool when we work with difficult or complex models, with pymongoose you wont need to create an extensive aggregation to lookup for elements.
+
+Populate works with simple ids like:
+```python
+schema = {
+ "name": {
+ "type": Types.String,
+ "required": True
+ },
+ "role": { # <- Simple field
+ "type": Types.ObjectId,
+ "ref": "roles"
+ }
+}
+```
+lists:
+```python
+schema = {
+ "name": {
+ "type": Types.String,
+ "required": True
+ },
+ "logs": [{ # <- List field
+ "type": Types.ObjectId,
+ "ref": "logs"
+ }]
+}
+```
+and complex models
+
+```python
+schema = {
+ "name": {
+ "type": Types.String,
+ "required": True
+ },
+ "friends": [{
+ "friend": {
+ "type": Types.ObjectId, # <- Complex list field
+ "ref": "friends"
+ },
+ "frequent": {
+ "type": Types.Boolean,
+ "default": False
+ }
+ }]
+}
+```
+
+Pymongoose can recursively populate fields like this:
+```python
+ #menu schema:
+ menu_schema = {
+ # ...
+ "items":[
+ {
+ "type":Types.ObjectId,
+ "ref":"items"
+ }
+ ],
+ # ...
+ }
+
+ #item schema:
+ item_schema: {
+ # ...
+ "drink":{
+ "type":Types.ObjectId,
+ "ref":"drinks"
+ },
+ "dish":{
+ "type":Types.ObjectId,
+ "ref":"dishes"
+ }
+ # ...
+ }
+
+ #Populate
+
+ menus = Menu.find({}, populate=[{
+ "path": "items",
+ "options": ["dish", "drink"]
+ }])
+
+ for menu in menus:
+ print(menu)
+```
+This will return a CursorCommand element
+
+In this example all menus populate each item of their array, at same time element dish and drink are populated, returning a complete array of populated menus with populated items.
+
+## Parsed finds:
+**pymongoose** has the ability to parse the return cursor as different types:
+Available types are
+ - IF **AS_DEFAULT(0)**, will return cursor if one == False, else a dict if parse == False
+ - IF **AS_DICT(1)**, will return a list of dicts if one == False, else as serializable dict
+ - IF **AS_STRING(2)**, will return a parsed list of dicts as str if one == False, else as a str parsed serializable dict
+
+*Note: In case you don't need a serializable dict, left cursor **AS_DEFAULT**
+
+
+## Update item:
+```python
+count = User.update({},
+ {
+ "$set": {
+ "password": "0"
+ }
+ }, many=True
+ ) #many is set to False by default
+```
+
+## Delete item:
+```python
+count = User.delete({}, many=True) #many is set to False by default
+```
+
+# Note:
+If you are working with vscode I have already created a model snippet to save you a lots of time:
+https://github.com/Djcharles26/pymongoose/blob/master/pymongoose-snippets.json
+
+For using this you must copy them to your python snippets:
+
+1. CTRL + SHIFT + P
+2. Configure User snippets
+3. python.json
+4. Copy snippets in blob
+5. Paste them in your user python.json
+
+
+%package -n python3-pymongoose
+Summary: A pymongo helper with methods and classes
+Provides: python-pymongoose
+BuildRequires: python3-devel
+BuildRequires: python3-setuptools
+BuildRequires: python3-pip
+%description -n python3-pymongoose
+# Pymongoose
+
+This is a pymongo helper package, that let you make more complicated actions with your collections.
+It gives you the possibility to populate between packages without needs of creating an aggregation by yourself.
+Gives you the basic actions such as find, update and delete, with more simplicity.
+
+Pymongoose came with a Schema class that let you work with more efficiency and organization
+
+# First Steps
+
+```bash
+pip install pymongoose pymongo
+```
+
+## Create a model:
+
+models/role.py
+
+```python
+import datetime
+from pymongoose import methods
+from pymongoose.mongo_types import Types, Schema, MongoException, MongoError
+from bson import json_util
+from bson.objectid import ObjectId
+
+
+class Role(Schema):
+ schema_name = "roles" # Name of the schema that mongo uses
+
+ # Attributes
+ id = None
+ name = None
+ action = None
+
+ def __init__(self, **kwargs):
+ self.schema = {
+ "name": {
+ "type": Types.String,
+ "required": True
+ },
+ "actions": [{
+ "type": Types.String,
+ "required": True
+ }]
+ }
+
+ super().__init__(self.schema_name, self.schema, kwargs)
+
+
+ def __str__(self):
+ return f"Role: {self.name}, Actions: {self.action}"
+```
+
+**Is higly recommended to follow this model for any schema**
+
+## Mongo Configuration
+This mongo configuration is required for pymongoose to work correctly
+
+db.py:
+```python
+ import os, traceback
+ import signal
+ from pymongo import MongoClient
+ from pymongoose.methods import set_schemas, get_cursor_length
+ from models.role import Role
+
+ MONGO_URI = os.environ.get("MONGO_URI")
+
+ mongo_db = None
+
+ def mongo_init ():
+ global mongo_db
+
+ client = MongoClient(MONGO_URI)
+ db = client.test
+ try:
+ # Now schemas can be set in two ways
+
+ #-> In a dict mode
+ schemas = {
+ "roles": Role(empty=True).schema
+ }
+ set_schemas(db, schemas)
+
+ #-> Or in a list mode
+
+ set_schemas_from_list (db, [Role (empty=True)])
+
+
+ print("MongoDB Connected!")
+ except:
+ traceback.print_exc()
+ print("Error initializing database")
+ exit(1)
+
+ if __name__ == "__main__":
+ mongo_init()
+```
+
+## Examples:
+- For more model examples check examples/
+
+### Insert function:
+
+```python
+user = User(
+ name="TestA",
+ password="test",
+ role=role.id
+)
+id = user.save()
+```
+user.save() will throw an exception if a field marked as required in schema is **None**.
+
+### Find function:
+```python
+users = User.find({})
+for user in users:
+ user = User.parse(user)
+```
+This will return a cursor of elements, which can be parsed into User model for a better management.
+
+### Find one function:
+```python
+user = User.find({}, one=True)
+# OR
+user = User.find_one ({})
+```
+This will return a User element with fields obtained by database, if you prefer a json just add
+```python
+parse = False
+```
+At last of the **find** statement.
+
+### Find by id function:
+```python
+# this Function will search for "_id" field
+# so id must be a hex24 string or ObjectId
+user = User.find_by_id(id)
+# for a complete user
+user = User.find_by_id(id, select={"name": 1, "username": 1})
+# For a custom user
+```
+This will return a User element with fields obtained by database, if you prefer a json just add
+```python
+parse = False
+```
+At last of the **find** statement.
+
+### Populate a search:
+```python
+user = User.find_by_id(id, populate=[
+ {
+ "path": "role",
+ "select": ["name", "actions"],
+ "options": ["actions"]
+ }
+])
+# For an extensive populate
+# or
+user = User.find_by_id(id, populate=["role"])
+# For a simple populate
+```
+This will return a User element with fields obtained by database
+
+
+Populate is a really useful tool when we work with difficult or complex models, with pymongoose you wont need to create an extensive aggregation to lookup for elements.
+
+Populate works with simple ids like:
+```python
+schema = {
+ "name": {
+ "type": Types.String,
+ "required": True
+ },
+ "role": { # <- Simple field
+ "type": Types.ObjectId,
+ "ref": "roles"
+ }
+}
+```
+lists:
+```python
+schema = {
+ "name": {
+ "type": Types.String,
+ "required": True
+ },
+ "logs": [{ # <- List field
+ "type": Types.ObjectId,
+ "ref": "logs"
+ }]
+}
+```
+and complex models
+
+```python
+schema = {
+ "name": {
+ "type": Types.String,
+ "required": True
+ },
+ "friends": [{
+ "friend": {
+ "type": Types.ObjectId, # <- Complex list field
+ "ref": "friends"
+ },
+ "frequent": {
+ "type": Types.Boolean,
+ "default": False
+ }
+ }]
+}
+```
+
+Pymongoose can recursively populate fields like this:
+```python
+ #menu schema:
+ menu_schema = {
+ # ...
+ "items":[
+ {
+ "type":Types.ObjectId,
+ "ref":"items"
+ }
+ ],
+ # ...
+ }
+
+ #item schema:
+ item_schema: {
+ # ...
+ "drink":{
+ "type":Types.ObjectId,
+ "ref":"drinks"
+ },
+ "dish":{
+ "type":Types.ObjectId,
+ "ref":"dishes"
+ }
+ # ...
+ }
+
+ #Populate
+
+ menus = Menu.find({}, populate=[{
+ "path": "items",
+ "options": ["dish", "drink"]
+ }])
+
+ for menu in menus:
+ print(menu)
+```
+This will return a CursorCommand element
+
+In this example all menus populate each item of their array, at same time element dish and drink are populated, returning a complete array of populated menus with populated items.
+
+## Parsed finds:
+**pymongoose** has the ability to parse the return cursor as different types:
+Available types are
+ - IF **AS_DEFAULT(0)**, will return cursor if one == False, else a dict if parse == False
+ - IF **AS_DICT(1)**, will return a list of dicts if one == False, else as serializable dict
+ - IF **AS_STRING(2)**, will return a parsed list of dicts as str if one == False, else as a str parsed serializable dict
+
+*Note: In case you don't need a serializable dict, left cursor **AS_DEFAULT**
+
+
+## Update item:
+```python
+count = User.update({},
+ {
+ "$set": {
+ "password": "0"
+ }
+ }, many=True
+ ) #many is set to False by default
+```
+
+## Delete item:
+```python
+count = User.delete({}, many=True) #many is set to False by default
+```
+
+# Note:
+If you are working with vscode I have already created a model snippet to save you a lots of time:
+https://github.com/Djcharles26/pymongoose/blob/master/pymongoose-snippets.json
+
+For using this you must copy them to your python snippets:
+
+1. CTRL + SHIFT + P
+2. Configure User snippets
+3. python.json
+4. Copy snippets in blob
+5. Paste them in your user python.json
+
+
+%package help
+Summary: Development documents and examples for pymongoose
+Provides: python3-pymongoose-doc
+%description help
+# Pymongoose
+
+This is a pymongo helper package, that let you make more complicated actions with your collections.
+It gives you the possibility to populate between packages without needs of creating an aggregation by yourself.
+Gives you the basic actions such as find, update and delete, with more simplicity.
+
+Pymongoose came with a Schema class that let you work with more efficiency and organization
+
+# First Steps
+
+```bash
+pip install pymongoose pymongo
+```
+
+## Create a model:
+
+models/role.py
+
+```python
+import datetime
+from pymongoose import methods
+from pymongoose.mongo_types import Types, Schema, MongoException, MongoError
+from bson import json_util
+from bson.objectid import ObjectId
+
+
+class Role(Schema):
+ schema_name = "roles" # Name of the schema that mongo uses
+
+ # Attributes
+ id = None
+ name = None
+ action = None
+
+ def __init__(self, **kwargs):
+ self.schema = {
+ "name": {
+ "type": Types.String,
+ "required": True
+ },
+ "actions": [{
+ "type": Types.String,
+ "required": True
+ }]
+ }
+
+ super().__init__(self.schema_name, self.schema, kwargs)
+
+
+ def __str__(self):
+ return f"Role: {self.name}, Actions: {self.action}"
+```
+
+**Is higly recommended to follow this model for any schema**
+
+## Mongo Configuration
+This mongo configuration is required for pymongoose to work correctly
+
+db.py:
+```python
+ import os, traceback
+ import signal
+ from pymongo import MongoClient
+ from pymongoose.methods import set_schemas, get_cursor_length
+ from models.role import Role
+
+ MONGO_URI = os.environ.get("MONGO_URI")
+
+ mongo_db = None
+
+ def mongo_init ():
+ global mongo_db
+
+ client = MongoClient(MONGO_URI)
+ db = client.test
+ try:
+ # Now schemas can be set in two ways
+
+ #-> In a dict mode
+ schemas = {
+ "roles": Role(empty=True).schema
+ }
+ set_schemas(db, schemas)
+
+ #-> Or in a list mode
+
+ set_schemas_from_list (db, [Role (empty=True)])
+
+
+ print("MongoDB Connected!")
+ except:
+ traceback.print_exc()
+ print("Error initializing database")
+ exit(1)
+
+ if __name__ == "__main__":
+ mongo_init()
+```
+
+## Examples:
+- For more model examples check examples/
+
+### Insert function:
+
+```python
+user = User(
+ name="TestA",
+ password="test",
+ role=role.id
+)
+id = user.save()
+```
+user.save() will throw an exception if a field marked as required in schema is **None**.
+
+### Find function:
+```python
+users = User.find({})
+for user in users:
+ user = User.parse(user)
+```
+This will return a cursor of elements, which can be parsed into User model for a better management.
+
+### Find one function:
+```python
+user = User.find({}, one=True)
+# OR
+user = User.find_one ({})
+```
+This will return a User element with fields obtained by database, if you prefer a json just add
+```python
+parse = False
+```
+At last of the **find** statement.
+
+### Find by id function:
+```python
+# this Function will search for "_id" field
+# so id must be a hex24 string or ObjectId
+user = User.find_by_id(id)
+# for a complete user
+user = User.find_by_id(id, select={"name": 1, "username": 1})
+# For a custom user
+```
+This will return a User element with fields obtained by database, if you prefer a json just add
+```python
+parse = False
+```
+At last of the **find** statement.
+
+### Populate a search:
+```python
+user = User.find_by_id(id, populate=[
+ {
+ "path": "role",
+ "select": ["name", "actions"],
+ "options": ["actions"]
+ }
+])
+# For an extensive populate
+# or
+user = User.find_by_id(id, populate=["role"])
+# For a simple populate
+```
+This will return a User element with fields obtained by database
+
+
+Populate is a really useful tool when we work with difficult or complex models, with pymongoose you wont need to create an extensive aggregation to lookup for elements.
+
+Populate works with simple ids like:
+```python
+schema = {
+ "name": {
+ "type": Types.String,
+ "required": True
+ },
+ "role": { # <- Simple field
+ "type": Types.ObjectId,
+ "ref": "roles"
+ }
+}
+```
+lists:
+```python
+schema = {
+ "name": {
+ "type": Types.String,
+ "required": True
+ },
+ "logs": [{ # <- List field
+ "type": Types.ObjectId,
+ "ref": "logs"
+ }]
+}
+```
+and complex models
+
+```python
+schema = {
+ "name": {
+ "type": Types.String,
+ "required": True
+ },
+ "friends": [{
+ "friend": {
+ "type": Types.ObjectId, # <- Complex list field
+ "ref": "friends"
+ },
+ "frequent": {
+ "type": Types.Boolean,
+ "default": False
+ }
+ }]
+}
+```
+
+Pymongoose can recursively populate fields like this:
+```python
+ #menu schema:
+ menu_schema = {
+ # ...
+ "items":[
+ {
+ "type":Types.ObjectId,
+ "ref":"items"
+ }
+ ],
+ # ...
+ }
+
+ #item schema:
+ item_schema: {
+ # ...
+ "drink":{
+ "type":Types.ObjectId,
+ "ref":"drinks"
+ },
+ "dish":{
+ "type":Types.ObjectId,
+ "ref":"dishes"
+ }
+ # ...
+ }
+
+ #Populate
+
+ menus = Menu.find({}, populate=[{
+ "path": "items",
+ "options": ["dish", "drink"]
+ }])
+
+ for menu in menus:
+ print(menu)
+```
+This will return a CursorCommand element
+
+In this example all menus populate each item of their array, at same time element dish and drink are populated, returning a complete array of populated menus with populated items.
+
+## Parsed finds:
+**pymongoose** has the ability to parse the return cursor as different types:
+Available types are
+ - IF **AS_DEFAULT(0)**, will return cursor if one == False, else a dict if parse == False
+ - IF **AS_DICT(1)**, will return a list of dicts if one == False, else as serializable dict
+ - IF **AS_STRING(2)**, will return a parsed list of dicts as str if one == False, else as a str parsed serializable dict
+
+*Note: In case you don't need a serializable dict, left cursor **AS_DEFAULT**
+
+
+## Update item:
+```python
+count = User.update({},
+ {
+ "$set": {
+ "password": "0"
+ }
+ }, many=True
+ ) #many is set to False by default
+```
+
+## Delete item:
+```python
+count = User.delete({}, many=True) #many is set to False by default
+```
+
+# Note:
+If you are working with vscode I have already created a model snippet to save you a lots of time:
+https://github.com/Djcharles26/pymongoose/blob/master/pymongoose-snippets.json
+
+For using this you must copy them to your python snippets:
+
+1. CTRL + SHIFT + P
+2. Configure User snippets
+3. python.json
+4. Copy snippets in blob
+5. Paste them in your user python.json
+
+
+%prep
+%autosetup -n pymongoose-1.3.7
+
+%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-pymongoose -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Mon May 15 2023 Python_Bot <Python_Bot@openeuler.org> - 1.3.7-1
+- Package Spec generated
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-17 12:59:30 +0000