velocity-python 0.0.1__tar.gz

velocity-python-0.0.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2000-2023 Paul Perez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

velocity-python-0.0.1/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.1
+Name: velocity-python
+Version: 0.0.1
+Summary: A rapid application development library for interfacing with data storage
+Author-email: Paul Perez <pperez@codeclubs.org>
+Project-URL: Homepage, https://codeclubs.org/projects/velocity
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: psycopg2-binary
+Requires-Dist: python-tds
+Requires-Dist: mysql-connector-python
+Requires-Dist: openpyxl
+Requires-Dist: boto3
+Requires-Dist: jinja2
+Requires-Dist: xlrd
+
+# Velocity.DB
+
+This project's goal is to simplify database management by abstracting complex (and many times database engine specific) functions to Python methods. This project is still in its infancy and is not yet ready for production use. If you would like to contribute to this project, please feel free to fork it and submit a pull request. This documentation is severely out of date and not yet complete, but will be updated as the project progresses.
+
+This project currently supports the following database engines:
+
+<b>PostgreSQL</b><br/>
+<b>Microsoft SQL Server</b><br/>
+<b>SQLite</b><br/>
+<b>MySQL</b><br/>
+
+[The source for this project is available here][src].
+
+<b>Prerequisites:</b><br/>
+The following packages must be installed prior to using Velocity.DB:<br/>
+`psycopg2` - For PostgreSQL<br/>
+`pytds` - For Microsoft SQL Server<br/>
+`sqlite3` - For SQLite 3<br/>
+`mysqlclient` - MySQL<br/>
+You will also need the MySQL Connector for your operating system before you install `mysqlclient`. You can download it <a href='https://dev.mysql.com/downloads/connector/c/'>here.</a>
+
+<b>For Windows Users:</b><br/>
+If you're using Windows, after you install the MySQL Connector you will need the Visual C++ Compiler for Python 2.7, you can download it <a href='https://www.microsoft.com/en-us/download/details.aspx?id=44266'>here.</a> After both dependencies are installed you can install `mysqlclient` without issue.
+
+Optionally if you only want to support a single database engine or do not want to install dependencies for engines you won't be using, download the source code for velocity.db and comment out the engines you wont be using in the `python-db/velocity/db/__init_.py` file on the following lines:
+
+<pre>
+# Import for PostgreSQL Support
+import servers.postgres
+postgres = servers.postgres.initialize()
+<br/># Import for Microsoft SQL Server Support
+import servers.sqlserver
+sqlserver = servers.sqlserver.initialize
+<br/># Import for SQLite 3 Support
+import servers.sqlite
+sqlite = servers.sqlite.initialize
+<br/># Import for MySQL Support
+import servers.mysql
+mysql = servers.mysql.initialize</pre>
+
+If you setup your project this way, make sure to install velocity.db using: `python setup.py develop` in case you want to revert your changes.
+
+----
+
+# Using Velocity.DB
+
+<b>Warning: Not all database engines are alike, and some datatypes in certain engines will be specific to the engine. This tutorial assumes you have basic knowledge of your database engine and it's specific datatypes.</b>
+
+To setup Velocity.DB with your server, define your server variable like so:
+
+<b>PostgreSQL:</b>
+<pre>
+import velocity.db
+<br/>server = velocity.db.postgres({
+	'database':'db-name',
+	'host': 'server',
+	'user':'username',
+	'password':'password',
+})
+</pre>
+<b>Microsoft SQL Server:</b>
+<pre>
+import velocity.db
+<br/>server = velocity.db.sqlserver({
+	'database': 'db-name',
+	'server': 'server',
+	'user':'username',
+	'password':'password',
+	'use_mars': True, # To enable Multiple Active Result Sets (disabled by default)
+})
+</pre>
+<b>SQLite:</b>
+<pre>
+import velocity.db
+<br/>server = velocity.db.sqlserver({
+	'database': 'db-name' # Use ':memory:' for an in memory database
+})
+</pre>
+<b>MySQL:</b>
+<pre>
+import velocity.db
+<br/>server = velocity.db.mysql({
+	'db':'db-name',
+	'host':'server',
+	'user':'username',
+	'passwd':'password',
+})
+</pre>
+<br>
+<b>Basic SQL Functions:</b><br/>
+Since the SQL ANSI standard holds all SQL compliant databases to the CRUD standard (Create, Read, Update, Delete) we will cover how to accomplish all of those functions using Velocity.DB.<br/>
+<br/><b>The <code>@server.transaction</code> Decorator:</b><br/>
+All SQL transactions have to live in their own functions so that in case some part of the function fails, the transaction will not commit. In order to signify a method as a transaction, use the <code>@server.transaction</code> decorator. Any function using this decorator will not commit any changes to the database unless the function successfully completes without error. This also passes the argument <code>tx</code> to your method which allows you to access the transaction object within your method.<br/>
+<br/><b>Creating a Table:</b>
+<pre>
+@server.transaction
+def create_new_table(self, tx):
+	t = tx.table('new_table')
+    t.create()
+</pre>
+Once the function is complete the transaction will commit and you will have a new table in your database titled 'new_table'.<br>
+If you would like to create a new row and add a column, you could do so using the following syntax:
+<pre>
+@server.transaction
+def add_column(self,tx):
+	# We will be using the same table we made in the above method.
+	t = tx.table('new_table')
+    # Creates a new row with a primary key of 1 (sys_id by default)
+    r = t.row(1)
+    r['new_column'] = 'Value to be placed in the first row of the new column'
+</pre>
+<br/><b>Reading Data from a Table:</b>
+<br/>Now let's say you already have a table with data named 'people', and you want to read the 'firstname' column of your table on the third row and return that field. You would accomplish this in Velocity.DB like so:
+<pre>
+@server.transaction
+def read_third_firstname(self, tx):
+	t = tx.table('people')
+    r = t.row(3)
+    return r['firstname']
+</pre>
+The above method will return the value of the 'firstname' column in row 3 of the table. The table object is iterable so if you would like to return the values of each field in the 'firstname' column you could do so like this:
+<pre>
+@server.transaction
+def read_all_firstnames(self,tx):
+	t = tx.table('people')
+    name_list = []
+    for r in t:
+    	name_list.append(r['firstname'])
+    return name_list
+</pre>
+<b>Updating a Preexisting Table:</b><br/>
+If you already have a table that you would like to update the data within, you can update data fields using the same syntax that you would use to create the field. This example will be working on a table named 'people' with columns: 'firstname' and 'lastname' with information filled out for 3 rows. Let's assume that the person on row 2 just got married and their last name has changed so we need to update it within the database.
+<pre>
+@server.transaction
+def update_lastname(self, tx):
+	t = tx.table('people')
+    r = t.row(2)
+    r['lastname'] = 'Newname'
+</pre>
+Notice the syntax is the same as if we were creating a new column. This syntax will attempt to insert the data, and if the column doesn't exist then it will create it. It will also see if the data is already populated, and if so it will issue a UPDATE command to the database instead.<br/>
+<br/><b>Deleting Data and Dropping Tables:</b><br/>
+To delete data from an existing table you may want to only delete a specific row. We will use the same 'people' database, let's go ahead and delete the person that was occupying row 3.
+<pre>
+@server.transaction
+def delete_person(self, tx):
+	t = tx.table('people')
+    r = t.row(3)
+    r.delete()
+</pre>
+It's as simple as that! But what if instead you were wanting to drop the whole table? <b>Warning: Executing the following code will drop the table from the database, if you are testing on your own database make sure you have a backup first.</b>
+<pre>
+@server.transaction
+def drop_table(self, tx):
+	t = tx.table('people')
+    t.drop()
+</pre>
+Keep in mind this will use the "IF EXISTS" SQL statement so if you accidentally misspell a table name, your program will not hang and no tables will be dropped.<br/>
+<br/>Congratulations, you now know how to use basic CRUD functionality with Velocity.DB. Velocity.DB has many advanced features as well, so if you'd like to see how some of those methods are used check out the <code>python-db/velocity/tests/db/unit_tests.py</code> file for examples.
+
+[src]: https://github.com/

velocity-python-0.0.1/README.md

@@ -0,0 +1,160 @@
+# Velocity.DB
+
+This project's goal is to simplify database management by abstracting complex (and many times database engine specific) functions to Python methods. This project is still in its infancy and is not yet ready for production use. If you would like to contribute to this project, please feel free to fork it and submit a pull request. This documentation is severely out of date and not yet complete, but will be updated as the project progresses.
+
+This project currently supports the following database engines:
+
+<b>PostgreSQL</b><br/>
+<b>Microsoft SQL Server</b><br/>
+<b>SQLite</b><br/>
+<b>MySQL</b><br/>
+
+[The source for this project is available here][src].
+
+<b>Prerequisites:</b><br/>
+The following packages must be installed prior to using Velocity.DB:<br/>
+`psycopg2` - For PostgreSQL<br/>
+`pytds` - For Microsoft SQL Server<br/>
+`sqlite3` - For SQLite 3<br/>
+`mysqlclient` - MySQL<br/>
+You will also need the MySQL Connector for your operating system before you install `mysqlclient`. You can download it <a href='https://dev.mysql.com/downloads/connector/c/'>here.</a>
+
+<b>For Windows Users:</b><br/>
+If you're using Windows, after you install the MySQL Connector you will need the Visual C++ Compiler for Python 2.7, you can download it <a href='https://www.microsoft.com/en-us/download/details.aspx?id=44266'>here.</a> After both dependencies are installed you can install `mysqlclient` without issue.
+
+Optionally if you only want to support a single database engine or do not want to install dependencies for engines you won't be using, download the source code for velocity.db and comment out the engines you wont be using in the `python-db/velocity/db/__init_.py` file on the following lines:
+
+<pre>
+# Import for PostgreSQL Support
+import servers.postgres
+postgres = servers.postgres.initialize()
+<br/># Import for Microsoft SQL Server Support
+import servers.sqlserver
+sqlserver = servers.sqlserver.initialize
+<br/># Import for SQLite 3 Support
+import servers.sqlite
+sqlite = servers.sqlite.initialize
+<br/># Import for MySQL Support
+import servers.mysql
+mysql = servers.mysql.initialize</pre>
+
+If you setup your project this way, make sure to install velocity.db using: `python setup.py develop` in case you want to revert your changes.
+
+----
+
+# Using Velocity.DB
+
+<b>Warning: Not all database engines are alike, and some datatypes in certain engines will be specific to the engine. This tutorial assumes you have basic knowledge of your database engine and it's specific datatypes.</b>
+
+To setup Velocity.DB with your server, define your server variable like so:
+
+<b>PostgreSQL:</b>
+<pre>
+import velocity.db
+<br/>server = velocity.db.postgres({
+	'database':'db-name',
+	'host': 'server',
+	'user':'username',
+	'password':'password',
+})
+</pre>
+<b>Microsoft SQL Server:</b>
+<pre>
+import velocity.db
+<br/>server = velocity.db.sqlserver({
+	'database': 'db-name',
+	'server': 'server',
+	'user':'username',
+	'password':'password',
+	'use_mars': True, # To enable Multiple Active Result Sets (disabled by default)
+})
+</pre>
+<b>SQLite:</b>
+<pre>
+import velocity.db
+<br/>server = velocity.db.sqlserver({
+	'database': 'db-name' # Use ':memory:' for an in memory database
+})
+</pre>
+<b>MySQL:</b>
+<pre>
+import velocity.db
+<br/>server = velocity.db.mysql({
+	'db':'db-name',
+	'host':'server',
+	'user':'username',
+	'passwd':'password',
+})
+</pre>
+<br>
+<b>Basic SQL Functions:</b><br/>
+Since the SQL ANSI standard holds all SQL compliant databases to the CRUD standard (Create, Read, Update, Delete) we will cover how to accomplish all of those functions using Velocity.DB.<br/>
+<br/><b>The <code>@server.transaction</code> Decorator:</b><br/>
+All SQL transactions have to live in their own functions so that in case some part of the function fails, the transaction will not commit. In order to signify a method as a transaction, use the <code>@server.transaction</code> decorator. Any function using this decorator will not commit any changes to the database unless the function successfully completes without error. This also passes the argument <code>tx</code> to your method which allows you to access the transaction object within your method.<br/>
+<br/><b>Creating a Table:</b>
+<pre>
+@server.transaction
+def create_new_table(self, tx):
+	t = tx.table('new_table')
+    t.create()
+</pre>
+Once the function is complete the transaction will commit and you will have a new table in your database titled 'new_table'.<br>
+If you would like to create a new row and add a column, you could do so using the following syntax:
+<pre>
+@server.transaction
+def add_column(self,tx):
+	# We will be using the same table we made in the above method.
+	t = tx.table('new_table')
+    # Creates a new row with a primary key of 1 (sys_id by default)
+    r = t.row(1)
+    r['new_column'] = 'Value to be placed in the first row of the new column'
+</pre>
+<br/><b>Reading Data from a Table:</b>
+<br/>Now let's say you already have a table with data named 'people', and you want to read the 'firstname' column of your table on the third row and return that field. You would accomplish this in Velocity.DB like so:
+<pre>
+@server.transaction
+def read_third_firstname(self, tx):
+	t = tx.table('people')
+    r = t.row(3)
+    return r['firstname']
+</pre>
+The above method will return the value of the 'firstname' column in row 3 of the table. The table object is iterable so if you would like to return the values of each field in the 'firstname' column you could do so like this:
+<pre>
+@server.transaction
+def read_all_firstnames(self,tx):
+	t = tx.table('people')
+    name_list = []
+    for r in t:
+    	name_list.append(r['firstname'])
+    return name_list
+</pre>
+<b>Updating a Preexisting Table:</b><br/>
+If you already have a table that you would like to update the data within, you can update data fields using the same syntax that you would use to create the field. This example will be working on a table named 'people' with columns: 'firstname' and 'lastname' with information filled out for 3 rows. Let's assume that the person on row 2 just got married and their last name has changed so we need to update it within the database.
+<pre>
+@server.transaction
+def update_lastname(self, tx):
+	t = tx.table('people')
+    r = t.row(2)
+    r['lastname'] = 'Newname'
+</pre>
+Notice the syntax is the same as if we were creating a new column. This syntax will attempt to insert the data, and if the column doesn't exist then it will create it. It will also see if the data is already populated, and if so it will issue a UPDATE command to the database instead.<br/>
+<br/><b>Deleting Data and Dropping Tables:</b><br/>
+To delete data from an existing table you may want to only delete a specific row. We will use the same 'people' database, let's go ahead and delete the person that was occupying row 3.
+<pre>
+@server.transaction
+def delete_person(self, tx):
+	t = tx.table('people')
+    r = t.row(3)
+    r.delete()
+</pre>
+It's as simple as that! But what if instead you were wanting to drop the whole table? <b>Warning: Executing the following code will drop the table from the database, if you are testing on your own database make sure you have a backup first.</b>
+<pre>
+@server.transaction
+def drop_table(self, tx):
+	t = tx.table('people')
+    t.drop()
+</pre>
+Keep in mind this will use the "IF EXISTS" SQL statement so if you accidentally misspell a table name, your program will not hang and no tables will be dropped.<br/>
+<br/>Congratulations, you now know how to use basic CRUD functionality with Velocity.DB. Velocity.DB has many advanced features as well, so if you'd like to see how some of those methods are used check out the <code>python-db/velocity/tests/db/unit_tests.py</code> file for examples.
+
+[src]: https://github.com/

velocity-python-0.0.1/pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "velocity-python"
+version = "0.0.1"
+authors = [
+  { name="Paul Perez", email="pperez@codeclubs.org" },
+]
+description = "A rapid application development library for interfacing with data storage"
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+  'requests',
+  'psycopg2-binary',
+  'python-tds',
+  'mysql-connector-python',
+  'openpyxl',
+  'boto3',
+  'jinja2',
+  'xlrd',
+  
+]
+[project.urls]
+Homepage = "https://codeclubs.org/projects/velocity"

velocity-python-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

velocity-python-0.0.1/src/velocity/__init__.py

@@ -0,0 +1,3 @@
+from . import aws
+from . import db
+from . import misc  

velocity-python-0.0.1/src/velocity/aws/__init__.py

@@ -0,0 +1,24 @@
+import os
+import requests
+
+from velocity.aws.handlers import LambdaHandler
+from velocity.aws.handlers import SqsHandler
+
+DEBUG = (os.environ.get('ENV') != 'production') \
+     or (os.environ.get('DEBUG') == 'Y')
+
+# This is helpful for running HTTPS clients on lambda.
+if os.path.exists('/opt/python/ca-certificates.crt'):
+    os.environ["REQUESTS_CA_BUNDLE"] = '/opt/python/ca-certificates.crt'
+
+
+class AWS(object):
+    # Get AWS EC2 Instance ID. Must run this from the EC2 instance itself to get the ID
+    @staticmethod
+    def instance_id(cls):
+        response = requests.get(
+            'http://169.254.169.254/latest/meta-data/instance-id')
+        instance_id = response.text
+        return instance_id
+
+

velocity-python-0.0.1/src/velocity/aws/handlers/__init__.py

@@ -0,0 +1,2 @@
+from velocity.aws.handlers.lambda_handler import LambdaHandler
+from velocity.aws.handlers.sqs_handler import SqsHandler

velocity-python-0.0.1/src/velocity/aws/handlers/lambda_handler.py

@@ -0,0 +1,123 @@
+from velocity.misc.format import to_json
+import json
+import pprint
+import traceback
+
+class LambdaHandler:
+    def __init__(self, event, context):
+        self.event = event
+        self.context = context
+        self.serve_action_default = True
+
+        requestContext = event.get('requestContext', {})
+        identity = requestContext.get('identity', {})
+        headers = event.get('headers', {})
+        self.session = {
+            'authentication_provider':
+            identity.get('cognitoAuthenticationProvider'),
+            'authentication_type':
+            identity.get('cognitoAuthenticationType'),
+            'cognito_user':
+            identity.get('user'),
+            'is_desktop':
+            headers.get('CloudFront-Is-Desktop-Viewer') == 'true',
+            'is_mobile':
+            headers.get('CloudFront-Is-Mobile-Viewer') == 'true',
+            'is_smart_tv':
+            headers.get('CloudFront-Is-SmartTV-Viewer') == 'true',
+            'is_tablet':
+            headers.get('CloudFront-Is-Tablet-Viewer') == 'true',
+            'origin':
+            headers.get('origin'),
+            'path':
+            event.get('path'),
+            'referer':
+            headers.get('Referer'),
+            'source_ip':
+            identity.get('sourceIp'),
+            'user_agent':
+            identity.get('userAgent'),
+        }
+        if self.session.get('is_mobile'):
+            self.session['device_type'] = 'mobile'
+        elif self.session.get('is_desktop'):
+            self.session['device_type'] = 'desktop'
+        elif self.session.get('is_tablet'):
+            self.session['device_type'] = 'tablet'
+        elif self.session.get('is_smart_tv'):
+            self.session['device_type'] = 'smart_tv'
+        else:
+            self.session['device_type'] = 'unknown'
+
+    def serve(self, tx):
+        response = {
+            'statusCode': 200,
+            'body': '{}',
+            'headers': {
+                'Content-Type': 'application/json',
+                "Access-Control-Allow-Origin": "*",
+            },
+        }
+        try:
+            postdata = {}
+            if self.event.get('body'):
+                postdata = json.loads(self.event.get('body'))
+            req_params = self.event.get('queryStringParameters') or {}
+            if hasattr(self, 'beforeAction'):
+                self.beforeAction(args=req_params,
+                                  postdata=postdata,
+                                  response=response)
+            actions = []
+            action = postdata.get('action', req_params.get('action'))
+            if action:
+                actions.append(
+                    f"on action {action.replace('-', ' ').replace('_', ' ')}".
+                    title().replace(' ', ''))
+            if self.serve_action_default:
+                actions.append('OnActionDefault')
+            for action in actions:
+                if hasattr(self, action):
+                    getattr(self, action)(args=req_params,
+                                          postdata=postdata,
+                                          response=response)
+                    break
+            if hasattr(self, 'afterAction'):
+                self.afterAction(args=req_params,
+                                 postdata=postdata,
+                                 response=response)
+
+        except Exception as e:
+            response = {
+                'statusCode':
+                500,
+                'body':
+                to_json({
+                    'type': 'Unhandled Exception',
+                    'error_message': str(e),
+                    'user_message': 'Oops! An unhandled error occurred.',
+                    'traceback': traceback.format_exc() if DEBUG else None
+                }),
+                'headers': {
+                    'Content-Type': 'application/json',
+                    'Access-Control-Allow-Origin': '*'
+                }
+            }
+            if hasattr(self, 'onError'):
+                self.onError(args=req_params,
+                             postdata=postdata,
+                             response=response,
+                             exc=e,
+                             tb=traceback.format_exc())
+
+        return response
+
+    def OnActionDefault(self, tx, args, postdata, response):
+        response['body'] = to_json({'event': self.event, 'postdata': postdata})
+
+    def onError(self, tx, args, postdata, response, exc, tb):
+        pprint.pprint({
+            'message': 'Unhandled Exception',
+            'exception': str(exc),
+            'traceback': traceback.format_exc()
+        })
+

velocity-python-0.0.1/src/velocity/aws/handlers/sqs_handler.py

@@ -0,0 +1,48 @@
+from velocity.misc.format import to_json
+import json
+import traceback
+
+class SqsHandler:
+    def __init__(self, event, context):
+        self.event = event
+        self.context = context
+        self.serve_action_default = True
+
+    def serve(self, tx):
+        records = self.event.get('Records', [])
+        print(f"Handling batch of {len(records)} records from SQS")
+        for record in records:
+            print(f"Start MessageId {record.get('messageId')}")
+            attrs = record.get('attributes')
+            try:
+                postdata = {}
+                if record.get('body'):
+                    postdata = json.loads(record.get('body'))
+                if hasattr(self, 'beforeAction'):
+                    self.beforeAction(attrs=attrs, postdata=postdata)
+                actions = []
+                action = postdata.get('action')
+                if action:
+                    actions.append(
+                        f"on action {action.replace('-', ' ').replace('_', ' ')}"
+                        .title().replace(' ', ''))
+                if self.serve_action_default:
+                    actions.append('OnActionDefault')
+                for action in actions:
+                    if hasattr(self, action):
+                        getattr(self, action)(attrs=attrs, postdata=postdata)
+                        break
+                if hasattr(self, 'afterAction'):
+                    self.afterAction(attrs=attrs, postdata=postdata)
+            except Exception as e:
+                if hasattr(self, 'onError'):
+                    self.onError(attrs=attrs,
+                                 postdata=postdata,
+                                 exc=e,
+                                 tb=traceback.format_exc())
+
+    def OnActionDefault(self, tx, attrs, postdata):
+        print(
+            "Action handler not found. Calling default action `SqsHandler.OnActionDefault` with the following parameters for tx, attrs, and postdata:"
+        )
+        print({'tx': tx, 'attrs': attrs, 'postdata': postdata})

velocity-python-0.0.1/src/velocity/db/__init__.py

@@ -0,0 +1,5 @@
+from velocity.db.core import exceptions
+from velocity.db.servers import postgres
+from velocity.db.servers import mysql
+from velocity.db.servers import sqlite
+from velocity.db.servers import sqlserver