bottle-sqlite-0.1.3/0000755000175000001440000000000012730533135015121 5ustar avelinousers00000000000000bottle-sqlite-0.1.3/bottle_sqlite.py0000755000175000001440000001114112730515020020337 0ustar avelinousers00000000000000''' Bottle-sqlite is a plugin that integrates SQLite3 with your Bottle application. It automatically connects to a database at the beginning of a request, passes the database handle to the route callback and closes the connection afterwards. To automatically detect routes that need a database connection, the plugin searches for route callbacks that require a `db` keyword argument (configurable) and skips routes that do not. This removes any overhead for routes that don't need a database connection. Usage Example:: import bottle from bottle.ext import sqlite app = bottle.Bottle() plugin = sqlite.Plugin(dbfile='/tmp/test.db') app.install(plugin) @app.route('/show/:item') def show(item, db): row = db.execute('SELECT * from items where name=?', item).fetchone() if row: return template('showitem', page=row) return HTTPError(404, "Page not found") ''' __author__ = "Marcel Hellkamp" __version__ = '0.1.3' __license__ = 'MIT' ### CUT HERE (see setup.py) import sqlite3 import inspect import bottle # PluginError is defined to bottle >= 0.10 if not hasattr(bottle, 'PluginError'): class PluginError(bottle.BottleException): pass bottle.PluginError = PluginError class SQLitePlugin(object): ''' This plugin passes an sqlite3 database handle to route callbacks that accept a `db` keyword argument. If a callback does not expect such a parameter, no connection is made. You can override the database settings on a per-route basis. ''' name = 'sqlite' api = 2 ''' python3 moves unicode to str ''' try: unicode except NameError: unicode = str def __init__(self, dbfile=':memory:', autocommit=True, dictrows=True, keyword='db', text_factory=unicode): self.dbfile = dbfile self.autocommit = autocommit self.dictrows = dictrows self.keyword = keyword self.text_factory = text_factory def setup(self, app): ''' Make sure that other installed plugins don't affect the same keyword argument.''' for other in app.plugins: if not isinstance(other, SQLitePlugin): continue if other.keyword == self.keyword: raise PluginError("Found another sqlite plugin with " "conflicting settings (non-unique keyword).") elif other.name == self.name: self.name += '_%s' % self.keyword def apply(self, callback, route): # hack to support bottle v0.9.x if bottle.__version__.startswith('0.9'): config = route['config'] _callback = route['callback'] else: config = route.config _callback = route.callback # Override global configuration with route-specific values. if "sqlite" in config: # support for configuration before `ConfigDict` namespaces g = lambda key, default: config.get('sqlite', {}).get(key, default) else: g = lambda key, default: config.get('sqlite.' + key, default) dbfile = g('dbfile', self.dbfile) autocommit = g('autocommit', self.autocommit) dictrows = g('dictrows', self.dictrows) keyword = g('keyword', self.keyword) text_factory = g('keyword', self.text_factory) # Test if the original callback accepts a 'db' keyword. # Ignore it if it does not need a database handle. argspec = inspect.getargspec(_callback) if keyword not in argspec.args: return callback def wrapper(*args, **kwargs): # Connect to the database db = sqlite3.connect(dbfile) # set text factory db.text_factory = text_factory # This enables column access by name: row['column_name'] if dictrows: db.row_factory = sqlite3.Row # Add the connection handle as a keyword argument. kwargs[keyword] = db try: rv = callback(*args, **kwargs) if autocommit: db.commit() except sqlite3.IntegrityError as e: db.rollback() raise bottle.HTTPError(500, "Database Error", e) except bottle.HTTPError as e: raise except bottle.HTTPResponse as e: if autocommit: db.commit() raise finally: db.close() return rv # Replace the route callback with the wrapped one. return wrapper Plugin = SQLitePlugin bottle-sqlite-0.1.3/setup.py0000644000175000001440000000261312730515020016626 0ustar avelinousers00000000000000#!/usr/bin/env python import sys import os from distutils.core import setup try: from distutils.command.build_py import build_py_2to3 as build_py except ImportError: from distutils.command.build_py import build_py # This ugly hack executes the first few lines of the module file to look up some # common variables. We cannot just import the module because it depends on other # modules that might not be installed yet. filename = os.path.join(os.path.dirname(__file__), 'bottle_sqlite.py') source = open(filename).read().split('### CUT HERE')[0] exec(source) setup( name = 'bottle-sqlite', version = __version__, url = 'http://bottlepy.org/docs/dev/plugins/sqlite.html', description = 'SQLite3 integration for Bottle.', long_description = __doc__, author = 'Marcel Hellkamp', author_email = 'marc@gsites.de', license = __license__, platforms = 'any', py_modules = [ 'bottle_sqlite' ], requires = [ 'bottle (>=0.9)' ], classifiers = [ 'Environment :: Web Environment', 'Intended Audience :: Developers', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Topic :: Internet :: WWW/HTTP :: Dynamic Content', 'Topic :: Software Development :: Libraries :: Python Modules' ], cmdclass = {'build_py': build_py} ) bottle-sqlite-0.1.3/PKG-INFO0000644000175000001440000000334712730533135016225 0ustar avelinousers00000000000000Metadata-Version: 1.1 Name: bottle-sqlite Version: 0.1.3 Summary: SQLite3 integration for Bottle. Home-page: http://bottlepy.org/docs/dev/plugins/sqlite.html Author: Marcel Hellkamp Author-email: marc@gsites.de License: MIT Description: Bottle-sqlite is a plugin that integrates SQLite3 with your Bottle application. It automatically connects to a database at the beginning of a request, passes the database handle to the route callback and closes the connection afterwards. To automatically detect routes that need a database connection, the plugin searches for route callbacks that require a `db` keyword argument (configurable) and skips routes that do not. This removes any overhead for routes that don't need a database connection. Usage Example:: import bottle from bottle.ext import sqlite app = bottle.Bottle() plugin = sqlite.Plugin(dbfile='/tmp/test.db') app.install(plugin) @app.route('/show/:item') def show(item, db): row = db.execute('SELECT * from items where name=?', item).fetchone() if row: return template('showitem', page=row) return HTTPError(404, "Page not found") Platform: any Classifier: Environment :: Web Environment Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content Classifier: Topic :: Software Development :: Libraries :: Python Modules Requires: bottle (>=0.9)