def loaddata(path): """Load the specified JSON fixtures. If preceded by a deployment target, the fixture data will be loaded onto that target. Otherwise they will be loaded into the local datastore. Arguments: :path -- The path to the fixture data to load Usage: # Load data locally fab loaddata:groups/fixtures/test_groups.json # Load data onto staging fab staging loaddata:groups/fixtures/test_groups.json """ import fixtures # Are we loading the fixtures remotely or locally? if hasattr(env, 'gae'): utils.prep_remote_shell() else: utils.prep_local_shell() # Actually load the fixtures (tweak the logging so their info shows up) logging.getLogger().setLevel(logging.INFO) fixtures.load_fixtures(path)
def dumpjson(kinds): """Dumps data from the local or remote datastore in JSON format. Arguments: :kinds -- A comma-separated list of kinds to dump, specified as `path.to.module.ModelName ` """ import fixtures if hasattr(env, 'gae'): utils.prep_remote_shell() else: utils.prep_local_shell() for kind in kinds.split(','): print fixtures.serialize_entities(kind)
def shell(cmd=None, path='/remote_api'): """Launches an interactive shell for this app. If preceded by a deployment target (e.g. production or staging), a remote_api shell on the given target is started. Otherwise, a local shell is started. Uses enhanced ipython or bpython shells, if available, falling back on the normal Python shell. Optional arguments: :cmd -- A string of valid Python code to be executed on the shell. The shell will exit after the code is executed. :path -- The path to the remote_api handler on the deployment target. Defaults to '/remote_api'. Usage: # A local shell fab shell # A remote_api shell on production fab production shell # Run a command directly on production fab production shell:cmd="memcache.flush_all()" """ # Import the modules we want to make available by default from google.appengine.api import urlfetch from google.appengine.api import memcache from google.appengine.ext import deferred from google.appengine.ext import db # Build a dict usable as locals() from the modules we want to use modname = lambda m: m.__name__.rpartition('.')[-1] mods = [db, deferred, memcache, sys, urlfetch] mods = dict((modname(m), m) for m in mods) # The banner for either kind of shell banner = 'Python %s\n\nImported modules: %s\n' % ( sys.version, ', '.join(sorted(mods))) # Are we running a remote shell? if hasattr(env, 'gae'): # Add more info to the banner loc = '%s%s' % (env.gae.host, path) banner = '\nApp Engine remote_api shell\n%s\n\n%s' % (loc, banner) # Actually prepare the remote shell utils.prep_remote_shell(path=path) # Otherwise, we're starting a local shell else: utils.prep_local_shell() # Define the kinds of shells we're going to try to run def ipython_shell(): import IPython shell = IPython.Shell.IPShell(argv=[], user_ns=mods) shell.mainloop(banner=banner) def bpython_shell(): from bpython import cli cli.main(args=[], banner=banner, locals_=mods) def plain_shell(): sys.ps1 = '>>> ' sys.ps2 = '... ' code.interact(banner=banner, locals=mods) # If we have a command to run, run it. if cmd: print 'Running remote command: %s' % cmd exec cmd in mods # Otherwise, start an interactive shell else: try: ipython_shell() except ImportError: try: bpython_shell() except ImportError: plain_shell()