Skip to main content

A MongoDB aggregation generator for Mongoengine

Project description

Aggify

Aggify is a Python library to generate MongoDB aggregation pipelines

Package version Downloads Supported Python versions Coverage License Contributors Telegram

Aggify

Aggify is a Python library for generating MongoDB aggregation pipelines, designed to work seamlessly with Mongoengine. This library simplifies the process of constructing complex MongoDB queries and aggregations using an intuitive and organized interface.

Features

  • Programmatically build MongoDB aggregation pipelines.
  • Filter, project, group, and perform various aggregation operations with ease.
  • Supports querying nested documents and relationships defined using Mongoengine.
  • Encapsulates aggregation stages for a more organized and maintainable codebase.
  • Designed to simplify the process of constructing complex MongoDB queries.

TODO

Installation

You can install Aggify using pip:

pip install aggify

Sample Usage

Here's a code snippet that demonstrates how to use Aggify to construct a MongoDB aggregation pipeline:

from mongoengine import Document, fields

class AccountDocument(Document):
    username = fields.StringField()
    display_name = fields.StringField()
    phone = fields.StringField()
    is_verified = fields.BooleanField()
    disabled_at = fields.LongField()
    deleted_at = fields.LongField()
    banned_at = fields.LongField()

class FollowAccountEdge(Document):
    start = fields.ReferenceField("AccountDocument")
    end = fields.ReferenceField("AccountDocument")
    accepted = fields.BooleanField()
    meta = {
        "collection": "edge.follow.account",
    }

class BlockEdge(Document):
    start = fields.ObjectIdField()
    end = fields.ObjectIdField()
    meta = {
        "collection": "edge.block",
    }

Aggify query:

from models import *
from aggify import Aggify, F, Q
from bson import ObjectId

aggify = Aggify(AccountDocument)

pipelines = list(
    (
        aggify.filter(
            phone__in=[],
            id__ne=ObjectId(),
            disabled_at=None,
            banned_at=None,
            deleted_at=None,
            network_id=ObjectId(),
        )
        .lookup(
            FollowAccountEdge,
            let=["id"],
            query=[Q(start__exact=ObjectId()) & Q(end__exact="id")],
            as_name="followed",
        )
        .lookup(
            BlockEdge,
            let=["id"],
            as_name="blocked",
            query=[
                (Q(start__exact=ObjectId()) & Q(end__exact="id"))
                | (Q(end__exact=ObjectId()) & Q(start__exact="id"))
            ],
        )
        .filter(followed=[], blocked=[])
        .group("username")
        .annotate(annotate_name="phone", accumulator="first", f=F("phone") + 10)
        .redact(
            value1="phone",
            condition="==",
            value2="132",
            then_value="keep",
            else_value="prune",
        )
        .project(username=0)[5:10]
        .out(coll="account")
    )
)

Mongoengine equivalent query:

[
    {
        "$match": {
            "phone": {"$in": []},
            "_id": {"$ne": ObjectId("65486eae04cce43c5469e0f1")},
            "disabled_at": None,
            "banned_at": None,
            "deleted_at": None,
            "network_id": ObjectId("65486eae04cce43c5469e0f2"),
        }
    },
    {
        "$lookup": {
            "from": "edge.follow.account",
            "let": {"id": "$_id"},
            "pipeline": [
                {
                    "$match": {
                        "$expr": {
                            "$and": [
                                {
                                    "$eq": [
                                        "$start",
                                        ObjectId("65486eae04cce43c5469e0f3"),
                                    ]
                                },
                                {"$eq": ["$end", "$$id"]},
                            ]
                        }
                    }
                }
            ],
            "as": "followed",
        }
    },
    {
        "$lookup": {
            "from": "edge.block",
            "let": {"id": "$_id"},
            "pipeline": [
                {
                    "$match": {
                        "$expr": {
                            "$or": [
                                {
                                    "$and": [
                                        {
                                            "$eq": [
                                                "$start",
                                                ObjectId("65486eae04cce43c5469e0f4"),
                                            ]
                                        },
                                        {"$eq": ["$end", "$$id"]},
                                    ]
                                },
                                {
                                    "$and": [
                                        {
                                            "$eq": [
                                                "$end",
                                                ObjectId("65486eae04cce43c5469e0f5"),
                                            ]
                                        },
                                        {"$eq": ["$start", "$$id"]},
                                    ]
                                },
                            ]
                        }
                    }
                }
            ],
            "as": "blocked",
        }
    },
    {"$match": {"followed": [], "blocked": []}},
    {"$group": {"_id": "$username", "phone": {"$first": {"$add": ["$phone", 10]}}}},
    {
        "$redact": {
            "$cond": {
                "if": {"$eq": ["phone", "132"]},
                "then": "$$KEEP",
                "else": "$$PRUNE",
            }
        }
    },
    {"$project": {"username": 0}},
    {"$skip": 5},
    {"$limit": 5},
    {"$out": "account"},
]

In the sample usage above, you can see how Aggify simplifies the construction of MongoDB aggregation pipelines by allowing you to chain filters, lookups, and other operations to build complex queries. For more details and examples, please refer to the documentation and codebase.

Project details


Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

aggify-0.3.9.tar.gz (18.0 kB view details)

Uploaded Source

Built Distribution

aggify-0.3.9-py3-none-any.whl (18.3 kB view details)

Uploaded Python 3

File details

Details for the file aggify-0.3.9.tar.gz.

File metadata

  • Download URL: aggify-0.3.9.tar.gz
  • Upload date:
  • Size: 18.0 kB
  • Tags: Source
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/5.0.0 CPython/3.9.19

File hashes

Hashes for aggify-0.3.9.tar.gz
Algorithm Hash digest
SHA256 a697476f0ecc54f21a3a228683b14cb1d600e6d78677971598f2aea13cb89cf1
MD5 d34e627773726e4f50a8e09f5579d3dd
BLAKE2b-256 19e83eff4d78c01670d539a7efd4e2617d2a30ebfa66c1ae839936cf75a24d25

See more details on using hashes here.

File details

Details for the file aggify-0.3.9-py3-none-any.whl.

File metadata

  • Download URL: aggify-0.3.9-py3-none-any.whl
  • Upload date:
  • Size: 18.3 kB
  • Tags: Python 3
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/5.0.0 CPython/3.9.19

File hashes

Hashes for aggify-0.3.9-py3-none-any.whl
Algorithm Hash digest
SHA256 403383b7dccf497ce39e84fc0d9b0faec5dc572a0d2c2c5c98b796fb94bd5365
MD5 f60b10f11ded0ca3effba2c8abb546d9
BLAKE2b-256 ab64d269ac000bf28dabe52b9b285c7dbf09a14e94fcd39bf15f6c34b72a6207

See more details on using hashes here.

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page