The Marrow Mongo Document Mapper
  • Introduction
  • Installation
  • Contributing
  • Guide
    • Introduction
    • Modelling
    • Management
    • Interaction
    • Fields
    • Indexes
    • Trait Mix-Ins
    • Plugin Namespaces
  • Reference
    • Decimal
    • Field
    • Index
    • Fields
      • Alias
      • Array
      • Binary
      • Boolean
      • Date
      • Double
      • Embed
      • Integer
      • Link
      • Long
      • Mapping
      • Markdown
      • Number
      • ObjectId
      • Path
      • Period
      • Plugin
      • Reference
      • Regex
      • Set
      • String
      • TTL
      • Timestamp
    • Parametric
      • F (Filter)
      • P (Project)
      • S (Sort)
      • U (Update)
    • Query
      • Ops
      • Q
    • Traits
      • Collection
      • Derived
      • Expires
      • Heirarchical
      • Identified
      • Localized
      • Lockable
      • Published
      • Stateful
      • Queryable
    • Utilities
      • Capped Collections
      • Geospatial
      • Logging
  • End Matter
    • Colophon
    • License
    • History
Powered by GitBook
On this page
  • Overview
  • Plugin Package Namespaces
  • Declarative document modeling.
  • Refined, Pythonic data access object interactions.
  • Collection and index metadata, and creation shortcuts.
  • Filter construction through rich comparison.
  • Parametric filter, projection, sort, and update document construction.
  • Advanced GeoJSON support.
  • Code Quality
  • Guaranteed to be fully tested before any release.
  • Extensively documented, with a > 1:1 code to comment ratio.
  • A considered road map.
  • MIT Licensed
  • Code Metrics

Was this helpful?

Edit on Git

Introduction

NextInstallation

Last updated 6 years ago

Was this helpful?

Marrow Mongo is a collection of small, focused utilities written to enhance use of the without the overhead, glacial update cycle, complexity, and head-space requirements of stateful active mapper patterns. This project grew out of the need (both personal and commercial) to find a viable, simple, well-tested alternative to existing ODMs. We believe that Marrow Mongo hits the Goldilocks zone for a supportive MongoDB experience in Python without getting in the way, offering elegant and Pythonic approaches to document storage modelling, access, and interaction.

This is a living document, evolving as the framework evolves. You can always within the to review previous versions of these instructions. (Try using the "edit this page" link in the upper right if viewing this document on the .)

Overview

Plugin Package Namespaces

Explicit is better than implicit, with fields, traits, and document classes registered as entry_point plugins and made accessible through the standard import mechanism.

from marrow.mongo import Document, Index
from marrow.mongo.field import String
from marrow.mongo.trait import Queryable

Declarative document modeling.

Instantiate field objects and associate them with custom Document sub-classes to model your data declaratively.

class Television(Document):
    model = String()

Refined, Pythonic data access object interactions.

Utilize Document instances as attribute access mutable mappings with value typecasting, directly usable with PyMongo APIs. Attention is paid to matching Python language expectations, such as allowing instantiation using positional arguments. Values are always stored in the PyMongo-preferred MongoDB native format, and cast on attribute access as needed.

tv = Television('D50u-D1')
assert tv.model == \
    tv[~Television.model] == \
    tv['model'] == \
    'D50u-D1'

Collection and index metadata, and creation shortcuts.

Keep information about your data model with your data model and standardize access.

class Television(Queryable):
    __collection__ = 'tv'

    model = String()
    brand = String()

    _model = Index('model')

collection = Television.create_collection(database)
Television('D50u-D1').insert_one()

Filter construction through rich comparison.

Construct filter documents through comparison of (or method calls on) field instances accessed as class attributes.

exact = Television.model == 'D50u-D1'
prefix = Television.model.re(r'^D50\w')

tv_a = Television.find_one(exact)
tv_b = Television.find_one(prefix)

assert tv_a.model == tv_b.model == 'D50u-D1'
assert tv_a['_id'] == tv_b['_id']

Parametric filter, projection, sort, and update document construction.

Many Python active record object relational mappers (ORMs) and object document mappers (ODMs) provide a short-hand involving the transformation of named parameters into database concepts.

filter_doc = F(Television, model__ne='XY-zzy')
update_doc = U(Television, set__brand='Vizio')

tv = Television.find_one(model='D50u-D1')

assert tv.brand == 'Vizio'

Advanced GeoJSON support.

position = Point(longitude, latitude)
collection.find(Battleship.location.near(position))

Code Quality

Guaranteed to be fully tested before any release.

Extensively documented, with a > 1:1 code to comment ratio.

Every developer has run into those objects that fail to produce sensible or useful programmers' representation, generate meaningless exception messages, or fail to provide introspective help. With more documentation in the code than code, you won't find that problem here. Code should be self-descriptive and obvious; we feel comments and docstrings are integral to this.

A considered road map.

MIT Licensed

You are effectively free to deal in this software however you choose, without commercial hinderance.

Code Metrics

marrow.mongo as of a889491

Value

Total Lines

2,976

SLoC

1,479

Logical Lines

840

Tests

305

Functions

57

Classes

41

Modules

23

Average Complexity

2.5

Complexity 95th %

6

Maximum Complexity

17

# > 15 Complexity

1

Bytecode Size

71 KiB

Marrow Mongo comes with batteries included, having extensive support for querying, constructing, and manipulating GeoJSON data.

We utilize continuous integration, with test coverage reporting provided by . We also monitor requirements for security concerns and deprecation using . Extensive static analysis through , proactive use of tools such as with such as the infosec analyzer , and various linting tools help to keep code maintainable and secure.

Changes to the library demand to ensure feature creep and organic growth are kept in check. Where possible, solutions involving objects passed to standard PyMongo functions and methods are preferred to solutions involving wrapping, proxying, or middleware. All but minor changes are isolated in to aid in code review.

The is highly permissive, allowing commercial and non-commercial use, reproduction, modification, republication, redistribtution, sublicensing, and sale of the software (and associated documentation) or its components. The license notice must be included in the reproduced work, and any warranty or liability on behalf of the or waived.

Learn more about interacting with documents.
Learn more about indexing.
Learn more about querying documents.
Learn more about the parametric helpers.
GeoJSON
Learn more about working with geospatial data.
Travis
Codecov.io
Requires.io
Landscape.io
pre-commit
plugins
OpenStack Bandit
meditation
pull requests
MIT License
Marrow Open Source Collective
project contributors
PyMongo native MongoDB driver
browse any point in time
source repository
official site
Learn more about plugin registration and discovery.
Learn more about constructing documents.
Latest version.
Latest tag.
Subscribe to project activity on Github.
Star this project on Github.
Fork this project on Github.
Release build status.
Release test coverage.
Release code health.
Status of release dependencies.