Marguerite

Marguerite provides a declarative, consistent accessor to data layer.

Dependencies

Python 2.7 or later
Werkzeug 0.12.7 or later

Installation

$ pip install Marguerite

Usage

Example

Install requests as an example.

$ pip install requests

define data layer accessor, and writen access structure ```python from marguerite import AbstractStructure, AbstractAccessor, Order from marguerite.accessors import bind

class Accessor(AbstractAccessor): def prepare(self, name, value): order = self.structure.get_order(name) return bind(order, value)

def create(self, name, value):
    order = self.prepare(name, value)
    return requests.post(order).json()

def get(self, name, value={}):
    order = self.prepare(name, value)
    return requests.get(order).json()

class UserStructure(AbstractStructure): accessor = Accessor

orders = Order(
    user = "https://example.com/users/:id",
    create = "https://example.com/users/:id?=username=:username"
)

```

get data layer accessor object ```python from marguerite import Marguerite

marguerite = Marguerite() accessor = marguerite.get_accessor(“path.to.UserStructure”) ```

fetch data ```python # execute get logic result = accessor.get(“user”, { “id”: 1 }) print(result) # {“id”: 1, “username”: “john”…}

execute post logic

result = accessor.create(“create”, { “id”: 2, “username”: “marguerite” }) print(result) # {“status”: “success”, {“result”: {“id”: 2, “username”: “marguerite”…}}} ```

SQLAlchemy

$ pip install SQLAlchemy MySQL-python

create database

mysql> create database marguerite;
Query OK, 1 row affected (0.00 sec)

define database structure ```python from marguerite import Order from marguerite.accessors.sql import SQLAlchemyAccessor from marguerite.structures.sql import SQLAlchemyStructure

class User(SQLAlchemyStructure): struct = { “id”: int(), “name”: str(), “email”: str(), }

orders = Order(
    create_table = """
        CREATE TABLE IF NOT EXISTS __table__(
          id int(11) unsigned NOT NULL AUTO_INCREMENT,
          name varchar(255) NOT NULL DEFAULT '',
          PRIMARY KEY (id)
        ) ENGINE=InnoDB CHARSET=utf8;
    """,

    drop_table = """
        DROP TABLE IF EXISTS __table__
    """,

    insert = """
        INSERT INTO
            __table__(name)
        VALUES
            (:name)
    """,

    select = """
        SELECT
            *
        FROM
            __table__
        WHERE
            id = :id
    """,

    find = """
        SELECT
            *
        FROM
            __table__
        WHERE
            id in (:id1, :id2)
    """
)

```

get database accessor object ```python from marguerite import Marguerite

engine = create_engine(“mysql+mysqldb://root:@localhost:3309/marguerite”)

marguerite = Marguerite(engine) accessor = marguerite.get_accessor(“path.to.User”) ```

create table
```
accessor.execute("create_table")
```

check also

mysql> use marguerite
Database changed
mysql> show tables;
+----------------------+
| Tables_in_marguerite |
+----------------------+
| user                 |
+----------------------+

fetch data ```python # insert record at user table accessor.execute(“insert”, {“name”: “john”})

get record

row = accessor.get(“select”, { “id”: 1 }) print(row) # {“id”: 1, “name”: “john”, “email”: “”}

find records

rows = accessor.find(“find”, { “id1”: 1, “id2”: 2 }) print(rows) # [{“id”: 1, “name”: “john”, “email”: “”}] ```

LICENSE

Apache License 2.0

Metadata

Release files for Marguerite 1.0.2

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for Marguerite 1.0.2
File	Size	Uploaded
Marguerite-1.0.2.tar.gz	6.0 kB	Apr 18, 2017	Details

Release files / Marguerite-1.0.2.tar.gz

Download URL	Marguerite-1.0.2.tar.gz
Size	6.0 kB
Tags	Source
SHA-256 checksum How to use checksums	`c815fb90d7d5c5c122fcc0352da30e3cc82c0f70bff2121b474cee792c8c6ef2`
BLAKE2b-256 checksum How to use checksums	`ab38b3756fb428e5634bb4608f7463263bce5eb81b244cb7d5f96d8cbb6abf2c`
Upload date	Apr 18, 2017
Uploaded using Trusted Publishing? What is trusted publishing?	No