Datasets:

0n1xus

/

codexglue

like 5

<s> """<STR_LIT>""" <EOL> from bootstrap import Bootstrap <EOL> from fund import InstantPaymentNotificationHandler <EOL> from fund import ThankYouHandler <EOL> from view import * <EOL> mapping = [ ( <EOL> r'<STR_LIT:/>' , <EOL> Index <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> InstantPaymentNotificationHandler <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> ThankYouHandler <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> About <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Guide <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Download <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Standards <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Community <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> News <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Support <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Contact <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Press <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Terms <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Library <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Library <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Library <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Users <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> User <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Design <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Design <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Design <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Design <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Design <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> RedirectSuccess <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> RedirectError <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> RedirectAfterDelete <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Moderate <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Bootstrap <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> ActivityScreen <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> TxnList <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Base64Blob <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> Base64Blob <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> MessageStrings <EOL> ) , ( <EOL> r'<STR_LIT>' , <EOL> NotFound <EOL> ) <EOL> ] </s>

<s> import msgpack <EOL> import gevent . pool <EOL> import gevent . queue <EOL> import gevent . event <EOL> import gevent . local <EOL> import gevent . lock <EOL> import logging <EOL> import sys <EOL> import gevent_zmq as zmq <EOL> from . exceptions import TimeoutExpired <EOL> from . context import Context <EOL> from . channel_base import ChannelBase <EOL> if sys . version_info < ( <NUM_LIT:2> , <NUM_LIT:7> ) : <EOL> def get_pyzmq_frame_buffer ( frame ) : <EOL> return frame . buffer [ : ] <EOL> else : <EOL> def get_pyzmq_frame_buffer ( frame ) : <EOL> return frame . buffer <EOL> logger = logging . getLogger ( __name__ ) <EOL> class SequentialSender ( object ) : <EOL> def __init__ ( self , socket ) : <EOL> self . _socket = socket <EOL> def _send ( self , parts ) : <EOL> e = None <EOL> for i in xrange ( len ( parts ) - <NUM_LIT:1> ) : <EOL> try : <EOL> self . _socket . send ( parts [ i ] , copy = False , flags = zmq . SNDMORE ) <EOL> except ( gevent . GreenletExit , gevent . Timeout ) as e : <EOL> if i == <NUM_LIT:0> : <EOL> raise <EOL> self . _socket . send ( parts [ i ] , copy = False , flags = zmq . SNDMORE ) <EOL> try : <EOL> self . _socket . send ( parts [ - <NUM_LIT:1> ] , copy = False ) <EOL> except ( gevent . GreenletExit , gevent . Timeout ) as e : <EOL> self . _socket . send ( parts [ - <NUM_LIT:1> ] , copy = False ) <EOL> if e : <EOL> raise e <EOL> def __call__ ( self , parts , timeout = None ) : <EOL> if timeout : <EOL> with gevent . Timeout ( timeout ) : <EOL> self . _send ( parts ) <EOL> else : <EOL> self . _send ( parts ) <EOL> class SequentialReceiver ( object ) : <EOL> def __init__ ( self , socket ) : <EOL> self . _socket = socket <EOL> def _recv ( self ) : <EOL> e = None <EOL> parts = [ ] <EOL> while True : <EOL> try : <EOL> part = self . _socket . recv ( copy = False ) <EOL> except ( gevent . GreenletExit , gevent . Timeout ) as e : <EOL> if len ( parts ) == <NUM_LIT:0> : <EOL> raise <EOL> part = self . _socket . recv ( copy = False ) <EOL> parts . append ( part ) <EOL> if not part . more : <EOL> break <EOL> if e : <EOL> raise e <EOL> return parts <EOL> def __call__ ( self , timeout = None ) : <EOL> if timeout : <EOL> with gevent . Timeout ( timeout ) : <EOL> return self . _recv ( ) <EOL> else : <EOL> return self . _recv ( ) <EOL> class Sender ( SequentialSender ) : <EOL> def __init__ ( self , socket ) : <EOL> self . _socket = socket <EOL> self . _send_queue = gevent . queue . Channel ( ) <EOL> self . _send_task = gevent . spawn ( self . _sender ) <EOL> def close ( self ) : <EOL> if self . _send_task : <EOL> self . _send_task . kill ( ) <EOL> def _sender ( self ) : <EOL> for parts in self . _send_queue : <EOL> super ( Sender , self ) . _send ( parts ) <EOL> def __call__ ( self , parts , timeout = None ) : <EOL> try : <EOL> self . _send_queue . put ( parts , timeout = timeout ) <EOL> except gevent . queue . Full : <EOL> raise TimeoutExpired ( timeout ) <EOL> class Receiver ( SequentialReceiver ) : <EOL> def __init__ ( self , socket ) : <EOL> self . _socket = socket <EOL> self . _recv_queue = gevent . queue . Channel ( ) <EOL> self . _recv_task = gevent . spawn ( self . _recver ) <EOL> def close ( self ) : <EOL> if self . _recv_task : <EOL> self . _recv_task . kill ( ) <EOL> self . _recv_queue = None <EOL> def _recver ( self ) : <EOL> while True : <EOL> parts = super ( Receiver , self ) . _recv ( ) <EOL> self . _recv_queue . put ( parts ) <EOL> def __call__ ( self , timeout = None ) : <EOL> try : <EOL> return self . _recv_queue . get ( timeout = timeout ) <EOL> except gevent . queue . Empty : <EOL> raise TimeoutExpired ( timeout ) <EOL> class Event ( object ) : <EOL> __slots__ = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> def __init__ ( self , name , args , context , header = None ) : <EOL> self . _name = name <EOL> self . _args = args <EOL> if header is None : <EOL> self . _header = { '<STR_LIT>' : context . new_msgid ( ) , '<STR_LIT:v>' : <NUM_LIT:3> } <EOL> else : <EOL> self . _header = header <EOL> self . _identity = None <EOL> @ property <EOL> def header ( self ) : <EOL> return self . _header <EOL> @ property <EOL> def name ( self ) : <EOL> return self . _name <EOL> @ name . setter <EOL> def name ( self , v ) : <EOL> self . _name = v <EOL> @ property <EOL> def args ( self ) : <EOL> return self . _args <EOL> @ property <EOL> def identity ( self ) : <EOL> return self . _identity <EOL> @ identity . setter <EOL> def identity ( self , v ) : <EOL> self . _identity = v <EOL> def pack ( self ) : <EOL> return msgpack . Packer ( use_bin_type = True ) . pack ( ( self . _header , self . _name , self . _args ) ) <EOL> @ staticmethod <EOL> def unpack ( blob ) : <EOL> unpacker = msgpack . Unpacker ( encoding = '<STR_LIT:utf-8>' ) <EOL> unpacker . feed ( blob ) <EOL> unpacked_msg = unpacker . unpack ( ) <EOL> try : <EOL> ( header , name , args ) = unpacked_msg <EOL> except Exception as e : <EOL> raise Exception ( '<STR_LIT>' . format ( <EOL> unpacked_msg , e ) ) <EOL> if not isinstance ( header , dict ) : <EOL> header = { } <EOL> return Event ( name , args , None , header ) <EOL> def __str__ ( self , ignore_args = False ) : <EOL> if ignore_args : <EOL> args = '<STR_LIT>' <EOL> else : <EOL> args = self . _args <EOL> try : <EOL> args = '<STR_LIT>' . format ( str ( self . unpack ( self . _args ) ) ) <EOL> except Exception : <EOL> pass <EOL> if self . _identity : <EOL> identity = '<STR_LIT:U+002CU+0020>' . join ( repr ( x . bytes ) for x in self . _identity ) <EOL> return '<STR_LIT>' . format ( identity , self . _name , <EOL> self . _header , args ) <EOL> return '<STR_LIT>' . format ( self . _name , self . _header , args ) <EOL> class Events ( ChannelBase ) : <EOL> def __init__ ( self , zmq_socket_type , context = None ) : <EOL> self . _debug = False <EOL> self . _zmq_socket_type = zmq_socket_type <EOL> self . _context = context or Context . get_instance ( ) <EOL> self . _socket = self . _context . socket ( zmq_socket_type ) <EOL> if zmq_socket_type in ( zmq . PUSH , zmq . PUB , zmq . DEALER , zmq . ROUTER ) : <EOL> self . _send = Sender ( self . _socket ) <EOL> elif zmq_socket_type in ( zmq . REQ , zmq . REP ) : <EOL> self . _send = SequentialSender ( self . _socket ) <EOL> else : <EOL> self . _send = None <EOL> if zmq_socket_type in ( zmq . PULL , zmq . SUB , zmq . DEALER , zmq . ROUTER ) : <EOL> self . _recv = Receiver ( self . _socket ) <EOL> elif zmq_socket_type in ( zmq . REQ , zmq . REP ) : <EOL> self . _recv = SequentialReceiver ( self . _socket ) <EOL> else : <EOL> self . _recv = None <EOL> @ property <EOL> def recv_is_supported ( self ) : <EOL> return self . _recv is not None <EOL> @ property <EOL> def emit_is_supported ( self ) : <EOL> return self . _send is not None <EOL> def __del__ ( self ) : <EOL> try : <EOL> if not self . _socket . closed : <EOL> self . close ( ) <EOL> except ( AttributeError , TypeError ) : <EOL> pass <EOL> def close ( self ) : <EOL> try : <EOL> self . _send . close ( ) <EOL> except AttributeError : <EOL> pass <EOL> try : <EOL> self . _recv . close ( ) <EOL> except AttributeError : <EOL> pass <EOL> self . _socket . close ( ) <EOL> @ property <EOL> def debug ( self ) : <EOL> return self . _debug <EOL> @ debug . setter <EOL> def debug ( self , v ) : <EOL> if v != self . _debug : <EOL> self . _debug = v <EOL> if self . _debug : <EOL> logger . debug ( '<STR_LIT>' ) <EOL> else : <EOL> logger . debug ( '<STR_LIT>' ) <EOL> def _resolve_endpoint ( self , endpoint , resolve = True ) : <EOL> if resolve : <EOL> endpoint = self . _context . hook_resolve_endpoint ( endpoint ) <EOL> if isinstance ( endpoint , ( tuple , list ) ) : <EOL> r = [ ] <EOL> for sub_endpoint in endpoint : <EOL> r . extend ( self . _resolve_endpoint ( sub_endpoint , resolve ) ) <EOL> return r <EOL> return [ endpoint ] <EOL> def connect ( self , endpoint , resolve = True ) : <EOL> r = [ ] <EOL> for endpoint_ in self . _resolve_endpoint ( endpoint , resolve ) : <EOL> r . append ( self . _socket . connect ( endpoint_ ) ) <EOL> logger . debug ( '<STR_LIT>' , endpoint_ , r [ - <NUM_LIT:1> ] ) <EOL> return r <EOL> def bind ( self , endpoint , resolve = True ) : <EOL> r = [ ] <EOL> for endpoint_ in self . _resolve_endpoint ( endpoint , resolve ) : <EOL> r . append ( self . _socket . bind ( endpoint_ ) ) <EOL> logger . debug ( '<STR_LIT>' , endpoint_ , r [ - <NUM_LIT:1> ] ) <EOL> return r <EOL> def disconnect ( self , endpoint , resolve = True ) : <EOL> r = [ ] <EOL> for endpoint_ in self . _resolve_endpoint ( endpoint , resolve ) : <EOL> r . append ( self . _socket . disconnect ( endpoint_ ) ) <EOL> logging . debug ( '<STR_LIT>' , endpoint_ , r [ - <NUM_LIT:1> ] ) <EOL> return r <EOL> def new_event ( self , name , args , xheader = None ) : <EOL> event = Event ( name , args , context = self . _context ) <EOL> if xheader : <EOL> event . header . update ( xheader ) <EOL> return event <EOL> def emit_event ( self , event , timeout = None ) : <EOL> if self . _debug : <EOL> logger . debug ( '<STR_LIT>' , event ) <EOL> if event . identity : <EOL> parts = list ( event . identity or list ( ) ) <EOL> parts . extend ( [ '<STR_LIT>' , event . pack ( ) ] ) <EOL> elif self . _zmq_socket_type in ( zmq . DEALER , zmq . ROUTER ) : <EOL> parts = ( '<STR_LIT>' , event . pack ( ) ) <EOL> else : <EOL> parts = ( event . pack ( ) , ) <EOL> self . _send ( parts , timeout ) <EOL> def recv ( self , timeout = None ) : <EOL> parts = self . _recv ( timeout = timeout ) <EOL> if len ( parts ) > <NUM_LIT:2> : <EOL> identity = parts [ <NUM_LIT:0> : - <NUM_LIT:2> ] <EOL> blob = parts [ - <NUM_LIT:1> ] <EOL> elif len ( parts ) == <NUM_LIT:2> : <EOL> identity = parts [ <NUM_LIT:0> : - <NUM_LIT:1> ] <EOL> blob = parts [ - <NUM_LIT:1> ] <EOL> else : <EOL> identity = None <EOL> blob = parts [ <NUM_LIT:0> ] <EOL> event = Event . unpack ( get_pyzmq_frame_buffer ( blob ) ) <EOL> event . identity = identity <EOL> if self . _debug : <EOL> logger . debug ( '<STR_LIT>' , event ) <EOL> return event <EOL> def setsockopt ( self , * args ) : <EOL> return self . _socket . setsockopt ( * args ) <EOL> @ property <EOL> def context ( self ) : <EOL> return self . _context </s>

<s> """<STR_LIT>""" <EOL> import os <EOL> import sys <EOL> if __name__ == "<STR_LIT:__main__>" : <EOL> os . environ . setdefault ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> from django . core . management import execute_from_command_line <EOL> execute_from_command_line ( sys . argv ) </s>

<s> """<STR_LIT>""" <EOL> import os <EOL> cwd = os . path . dirname ( __file__ ) <EOL> __version__ = open ( os . path . join ( cwd , '<STR_LIT>' , '<STR_LIT>' ) , '<STR_LIT:r>' ) . read ( ) . strip ( ) <EOL> try : <EOL> from setuptools import setup , find_packages <EOL> except ImportError : <EOL> from ez_setup import use_setuptools <EOL> use_setuptools ( ) <EOL> from setuptools import setup , find_packages <EOL> setup ( <EOL> name = '<STR_LIT>' , <EOL> description = '<STR_LIT>' , <EOL> long_description = open ( '<STR_LIT>' ) . read ( ) , <EOL> version = __version__ , <EOL> author = '<STR_LIT>' , <EOL> author_email = '<STR_LIT>' , <EOL> url = '<STR_LIT>' , <EOL> packages = find_packages ( exclude = [ '<STR_LIT>' ] ) , <EOL> install_requires = open ( '<STR_LIT>' ) . readlines ( ) , <EOL> package_data = { '<STR_LIT>' : [ '<STR_LIT>' ] } , <EOL> include_package_data = True , <EOL> extras_require = { <EOL> '<STR_LIT>' : open ( '<STR_LIT>' ) . readlines ( ) , <EOL> } , <EOL> entry_points = { <EOL> '<STR_LIT>' : [ '<STR_LIT>' , ] , <EOL> } , <EOL> license = '<STR_LIT>' <EOL> ) </s>

<s> import os <EOL> import sys <EOL> if __name__ == "<STR_LIT:__main__>" : <EOL> os . environ . setdefault ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> from django . core . management import execute_from_command_line <EOL> execute_from_command_line ( sys . argv ) </s>

<s> from __future__ import unicode_literals <EOL> from django . db import models , migrations <EOL> class Migration ( migrations . Migration ) : <EOL> dependencies = [ <EOL> ] <EOL> operations = [ <EOL> migrations . CreateModel ( <EOL> name = '<STR_LIT>' , <EOL> fields = [ <EOL> ( '<STR_LIT:id>' , models . AutoField ( verbose_name = '<STR_LIT>' , serialize = False , auto_created = True , primary_key = True ) ) , <EOL> ( '<STR_LIT:name>' , models . CharField ( help_text = b'<STR_LIT>' , max_length = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT:image>' , models . ImageField ( help_text = b'<STR_LIT>' , null = True , upload_to = b'<STR_LIT>' , blank = True ) ) , <EOL> ] , <EOL> options = { <EOL> '<STR_LIT>' : ( '<STR_LIT:name>' , ) , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> } , <EOL> bases = ( models . Model , ) , <EOL> ) , <EOL> ] </s>

<s> import twitter <EOL> from django . contrib import messages <EOL> from django . contrib . auth . decorators import user_passes_test <EOL> from django . db import transaction <EOL> from django . shortcuts import redirect , render <EOL> from twobuntu . news . forms import AddItemForm <EOL> @ user_passes_test ( lambda u : u . is_staff ) <EOL> def add ( request ) : <EOL> """<STR_LIT>""" <EOL> if request . method == '<STR_LIT:POST>' : <EOL> form = AddItemForm ( data = request . POST ) <EOL> if form . is_valid ( ) : <EOL> item = form . save ( commit = False ) <EOL> item . reporter = request . user <EOL> try : <EOL> with transaction . atomic ( ) : <EOL> item . save ( ) <EOL> except twitter . TwitterError as e : <EOL> messages . error ( request , "<STR_LIT>" % e . message [ <NUM_LIT:0> ] [ '<STR_LIT:message>' ] ) <EOL> else : <EOL> messages . info ( request , "<STR_LIT>" ) <EOL> return redirect ( '<STR_LIT>' ) <EOL> else : <EOL> form = AddItemForm ( ) <EOL> return render ( request , '<STR_LIT>' , { <EOL> '<STR_LIT:title>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : form , <EOL> '<STR_LIT:description>' : "<STR_LIT>" , <EOL> '<STR_LIT:action>' : '<STR_LIT>' , <EOL> } ) </s>

<s> """<STR_LIT>""" <EOL> __all__ = ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> class DjangoWSGIException ( Exception ) : <EOL> """<STR_LIT>""" <EOL> pass <EOL> class ApplicationCallError ( DjangoWSGIException ) : <EOL> """<STR_LIT>""" <EOL> pass </s>

<s> import boto <EOL> import boto . s3 . connection <EOL> from django . conf import settings <EOL> import logging <EOL> log = logging . getLogger ( __name__ ) <EOL> def get_s3_connection ( ) : <EOL> if settings . S3_ACCESS_KEY and settings . S3_SECRET_KEY and settings . S3_HOST : <EOL> log . debug ( '<STR_LIT>' . <EOL> format ( settings . S3_HOST , settings . S3_SECURE_CONNECTION ) ) <EOL> return boto . connect_s3 ( <EOL> aws_access_key_id = settings . S3_ACCESS_KEY , <EOL> aws_secret_access_key = settings . S3_SECRET_KEY , <EOL> host = settings . S3_HOST , <EOL> is_secure = settings . S3_SECURE_CONNECTION , <EOL> calling_format = boto . s3 . connection . OrdinaryCallingFormat ( ) ) <EOL> return None <EOL> def get_or_create_bucket ( s3_connection ) : <EOL> bucket = s3_connection . get_bucket ( settings . S3_BUCKET_NAME ) <EOL> if bucket is None : <EOL> bucket = s3_connection . create_bucket ( settings . S3_BUCKET_NAME ) <EOL> return bucket </s>

<s> from django . db import models <EOL> import datetime <EOL> from common . models import Project <EOL> class Stage ( models . Model ) : <EOL> name = models . CharField ( max_length = <NUM_LIT> ) <EOL> project = models . ForeignKey ( Project ) <EOL> text = models . TextField ( default = '<STR_LIT>' , blank = True ) <EOL> link = models . URLField ( default = None , blank = True , null = True ) <EOL> state = models . CharField ( max_length = <NUM_LIT> , default = '<STR_LIT:info>' , blank = True ) <EOL> weight = models . IntegerField ( default = <NUM_LIT:0> ) <EOL> updated = models . DateTimeField ( default = datetime . datetime . now ( ) ) <EOL> def save ( self , * args , ** kwargs ) : <EOL> self . updated = datetime . datetime . now ( ) <EOL> return super ( Stage , self ) . save ( * args , ** kwargs ) <EOL> def __str__ ( self ) : <EOL> return self . name </s>

<s> from __future__ import unicode_literals <EOL> from django . db import models , migrations <EOL> class Migration ( migrations . Migration ) : <EOL> dependencies = [ <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ] <EOL> operations = [ <EOL> migrations . AddField ( <EOL> model_name = '<STR_LIT>' , <EOL> name = '<STR_LIT>' , <EOL> field = models . TextField ( default = b'<STR_LIT>' , max_length = <NUM_LIT> , verbose_name = '<STR_LIT>' , blank = True ) , <EOL> preserve_default = True , <EOL> ) , <EOL> migrations . AddField ( <EOL> model_name = '<STR_LIT>' , <EOL> name = '<STR_LIT>' , <EOL> field = models . BooleanField ( default = False , verbose_name = '<STR_LIT>' ) , <EOL> preserve_default = True , <EOL> ) , <EOL> ] </s>

<s> import gevent <EOL> from gevent import monkey <EOL> monkey . patch_all ( ) <EOL> import time <EOL> import smtplib <EOL> TEST_MAIL = """<STR_LIT>""" <EOL> def timeit ( func ) : <EOL> def wrap ( num , port , * args , ** kwargs ) : <EOL> max_rqs = <NUM_LIT:0> <EOL> for _ in xrange ( <NUM_LIT:3> ) : <EOL> conns = [ smtplib . SMTP ( port = port ) for x in xrange ( num ) ] <EOL> map ( lambda x : x . connect ( '<STR_LIT:127.0.0.1>' , port ) , conns ) <EOL> start_at = time . time ( ) <EOL> func ( num , conns , ** kwargs ) <EOL> interval = time . time ( ) - start_at <EOL> for con in conns : <EOL> try : <EOL> con . quit ( ) <EOL> con . close ( ) <EOL> except Exception : <EOL> pass <EOL> gevent . sleep ( <NUM_LIT:3> ) <EOL> rqs = num / interval <EOL> max_rqs = max ( rqs , max_rqs ) <EOL> return max_rqs <EOL> return wrap <EOL> @ timeit <EOL> def helo ( num , conns ) : <EOL> tasks = [ gevent . spawn ( x . helo ) for x in conns ] <EOL> gevent . joinall ( tasks ) <EOL> @ timeit <EOL> def send ( num , conns ) : <EOL> tasks = [ gevent . spawn ( x . sendmail , '<STR_LIT>' , [ '<STR_LIT>' ] , TEST_MAIL ) for x in conns ] <EOL> gevent . joinall ( tasks ) <EOL> def main ( port , num ) : <EOL> print "<STR_LIT>" % ( num , helo ( num , port ) , send ( num , port ) ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> import sys <EOL> try : <EOL> main ( int ( sys . argv [ <NUM_LIT:1> ] ) , int ( sys . argv [ <NUM_LIT:2> ] ) ) <EOL> except IndexError : <EOL> print '<STR_LIT>' </s>

<s> import sys <EOL> import json <EOL> if sys . version_info < ( <NUM_LIT:3> , ) : <EOL> def b ( x ) : <EOL> return x <EOL> def s ( x ) : <EOL> return x <EOL> else : <EOL> def b ( x ) : <EOL> return bytes ( x , '<STR_LIT:utf-8>' ) <EOL> def s ( x ) : <EOL> return x . decode ( '<STR_LIT:utf-8>' ) <EOL> def parse_payload ( payload ) : <EOL> if not isinstance ( payload , str ) : <EOL> payload = '<STR_LIT:U+0020>' . join ( payload ) <EOL> try : <EOL> json . loads ( payload ) <EOL> except ValueError : <EOL> kv = payload . split ( '<STR_LIT:U+0020>' , <NUM_LIT:1> ) <EOL> if len ( kv ) > <NUM_LIT:1> : <EOL> payload = '<STR_LIT>' % ( kv [ <NUM_LIT:0> ] , kv [ <NUM_LIT:1> ] ) <EOL> else : <EOL> payload = '<STR_LIT:%s>' % kv [ <NUM_LIT:0> ] <EOL> return payload <EOL> def requires_elements ( xs , dictionary ) : <EOL> missing_values = [ ] <EOL> for x in xs : <EOL> if x not in dictionary : <EOL> missing_values . append ( x ) <EOL> if missing_values : <EOL> err_msg = '<STR_LIT:U+002CU+0020>' . join ( missing_values ) <EOL> raise KeyError ( '<STR_LIT>' % ( err_msg ) ) </s>

<s> from flask_resty import Api , GenericModelView <EOL> from marshmallow import fields , Schema <EOL> import pytest <EOL> from sqlalchemy import Column , Integer , String <EOL> import helpers <EOL> @ pytest . yield_fixture <EOL> def models ( db ) : <EOL> class Widget ( db . Model ) : <EOL> __tablename__ = '<STR_LIT>' <EOL> id_1 = Column ( Integer , primary_key = True ) <EOL> id_2 = Column ( Integer , primary_key = True ) <EOL> name = Column ( String , nullable = False ) <EOL> db . create_all ( ) <EOL> yield { <EOL> '<STR_LIT>' : Widget , <EOL> } <EOL> db . drop_all ( ) <EOL> @ pytest . fixture <EOL> def schemas ( ) : <EOL> class WidgetSchema ( Schema ) : <EOL> id_1 = fields . Integer ( as_string = True ) <EOL> id_2 = fields . Integer ( as_string = True ) <EOL> name = fields . String ( required = True ) <EOL> return { <EOL> '<STR_LIT>' : WidgetSchema ( ) , <EOL> } <EOL> @ pytest . fixture ( autouse = True ) <EOL> def routes ( app , models , schemas ) : <EOL> class WidgetViewBase ( GenericModelView ) : <EOL> model = models [ '<STR_LIT>' ] <EOL> schema = schemas [ '<STR_LIT>' ] <EOL> id_fields = ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> class WidgetListView ( WidgetViewBase ) : <EOL> def get ( self ) : <EOL> return self . list ( ) <EOL> def post ( self ) : <EOL> return self . create ( allow_client_id = True ) <EOL> class WidgetView ( WidgetViewBase ) : <EOL> def get ( self , id_1 , id_2 ) : <EOL> return self . retrieve ( ( id_1 , id_2 ) ) <EOL> def patch ( self , id_1 , id_2 ) : <EOL> return self . update ( ( id_1 , id_2 ) , partial = True ) <EOL> def delete ( self , id_1 , id_2 ) : <EOL> return self . destroy ( ( id_1 , id_2 ) ) <EOL> api = Api ( app ) <EOL> api . add_resource ( <EOL> '<STR_LIT>' , WidgetListView , WidgetView , <EOL> id_rule = '<STR_LIT>' , <EOL> ) <EOL> @ pytest . fixture ( autouse = True ) <EOL> def data ( db , models ) : <EOL> db . session . add_all ( ( <EOL> models [ '<STR_LIT>' ] ( id_1 = <NUM_LIT:1> , id_2 = <NUM_LIT:2> , name = "<STR_LIT>" ) , <EOL> models [ '<STR_LIT>' ] ( id_1 = <NUM_LIT:1> , id_2 = <NUM_LIT:3> , name = "<STR_LIT>" ) , <EOL> models [ '<STR_LIT>' ] ( id_1 = <NUM_LIT:4> , id_2 = <NUM_LIT:5> , name = "<STR_LIT>" ) , <EOL> ) ) <EOL> db . session . commit ( ) <EOL> def test_list ( client ) : <EOL> response = client . get ( '<STR_LIT>' ) <EOL> assert response . status_code == <NUM_LIT:200> <EOL> assert helpers . get_data ( response ) == [ <EOL> { <EOL> '<STR_LIT>' : '<STR_LIT:1>' , <EOL> '<STR_LIT>' : '<STR_LIT:2>' , <EOL> '<STR_LIT:name>' : "<STR_LIT>" , <EOL> } , <EOL> { <EOL> '<STR_LIT>' : '<STR_LIT:1>' , <EOL> '<STR_LIT>' : '<STR_LIT:3>' , <EOL> '<STR_LIT:name>' : "<STR_LIT>" , <EOL> } , <EOL> { <EOL> '<STR_LIT>' : '<STR_LIT:4>' , <EOL> '<STR_LIT>' : '<STR_LIT:5>' , <EOL> '<STR_LIT:name>' : "<STR_LIT>" , <EOL> } , <EOL> ] <EOL> def test_retrieve ( client ) : <EOL> response = client . get ( '<STR_LIT>' ) <EOL> assert response . status_code == <NUM_LIT:200> <EOL> assert helpers . get_data ( response ) == { <EOL> '<STR_LIT>' : '<STR_LIT:1>' , <EOL> '<STR_LIT>' : '<STR_LIT:2>' , <EOL> '<STR_LIT:name>' : "<STR_LIT>" , <EOL> } <EOL> def test_create ( client ) : <EOL> response = helpers . request ( <EOL> client , <EOL> '<STR_LIT:POST>' , '<STR_LIT>' , <EOL> { <EOL> '<STR_LIT>' : '<STR_LIT:4>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT:name>' : "<STR_LIT>" , <EOL> } , <EOL> ) <EOL> assert response . status_code == <NUM_LIT> <EOL> assert response . headers [ '<STR_LIT>' ] == '<STR_LIT>' <EOL> assert helpers . get_data ( response ) == { <EOL> '<STR_LIT>' : '<STR_LIT:4>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT:name>' : "<STR_LIT>" , <EOL> } <EOL> def test_update ( client ) : <EOL> update_response = helpers . request ( <EOL> client , <EOL> '<STR_LIT>' , '<STR_LIT>' , <EOL> { <EOL> '<STR_LIT>' : '<STR_LIT:1>' , <EOL> '<STR_LIT>' : '<STR_LIT:2>' , <EOL> '<STR_LIT:name>' : "<STR_LIT>" , <EOL> } , <EOL> ) <EOL> assert update_response . status_code == <NUM_LIT> <EOL> retrieve_response = client . get ( '<STR_LIT>' ) <EOL> assert retrieve_response . status_code == <NUM_LIT:200> <EOL> assert helpers . get_data ( retrieve_response ) == { <EOL> '<STR_LIT>' : '<STR_LIT:1>' , <EOL> '<STR_LIT>' : '<STR_LIT:2>' , <EOL> '<STR_LIT:name>' : "<STR_LIT>" , <EOL> } <EOL> def test_destroy ( client ) : <EOL> destroy_response = client . delete ( '<STR_LIT>' ) <EOL> assert destroy_response . status_code == <NUM_LIT> <EOL> retrieve_response = client . get ( '<STR_LIT>' ) <EOL> assert retrieve_response . status_code == <NUM_LIT> </s>

<s> from . dogpile import Dogpile </s>

<s> """<STR_LIT>""" <EOL> import pygame <EOL> from pygame . locals import * <EOL> import time <EOL> import datetime <EOL> import sys <EOL> import os <EOL> import glob <EOL> import subprocess <EOL> os . environ [ "<STR_LIT>" ] = "<STR_LIT>" <EOL> os . environ [ "<STR_LIT>" ] = "<STR_LIT>" <EOL> os . environ [ "<STR_LIT>" ] = "<STR_LIT>" <EOL> white = ( <NUM_LIT:255> , <NUM_LIT:255> , <NUM_LIT:255> ) <EOL> red = ( <NUM_LIT:255> , <NUM_LIT:0> , <NUM_LIT:0> ) <EOL> green = ( <NUM_LIT:0> , <NUM_LIT:255> , <NUM_LIT:0> ) <EOL> blue = ( <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:255> ) <EOL> black = ( <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> ) <EOL> cyan = ( <NUM_LIT:50> , <NUM_LIT:255> , <NUM_LIT:255> ) <EOL> magenta = ( <NUM_LIT:255> , <NUM_LIT:0> , <NUM_LIT:255> ) <EOL> yellow = ( <NUM_LIT:255> , <NUM_LIT:255> , <NUM_LIT:0> ) <EOL> orange = ( <NUM_LIT:255> , <NUM_LIT> , <NUM_LIT:0> ) <EOL> width = <NUM_LIT> <EOL> height = <NUM_LIT> <EOL> size = ( width , height ) <EOL> screen = pygame . display . set_mode ( size ) <EOL> pygame . init ( ) <EOL> pygame . mouse . set_visible ( False ) <EOL> font = pygame . font . Font ( None , <NUM_LIT> ) <EOL> screensaver_timer = <NUM_LIT:5> <EOL> screensaver = False <EOL> menu = <NUM_LIT:1> <EOL> skin_number = <NUM_LIT:1> <EOL> max_skins = <NUM_LIT:8> <EOL> font_color = cyan <EOL> skin1 = pygame . image . load ( "<STR_LIT>" ) <EOL> skin2 = pygame . image . load ( "<STR_LIT>" ) <EOL> skin = skin1 <EOL> screen . blit ( skin , ( <NUM_LIT:0> , <NUM_LIT:0> ) ) <EOL> subprocess . call ( '<STR_LIT>' , shell = True ) <EOL> reboot_label = font . render ( "<STR_LIT>" , <NUM_LIT:1> , ( font_color ) ) <EOL> poweroff_label = font . render ( "<STR_LIT>" , <NUM_LIT:1> , ( font_color ) ) <EOL> song_title = "<STR_LIT:U+0020>" <EOL> playlist = "<STR_LIT:U+0020>" <EOL> def reboot ( ) : <EOL> screen . fill ( black ) <EOL> screen . blit ( reboot_label , ( <NUM_LIT:10> , <NUM_LIT:100> ) ) <EOL> pygame . display . flip ( ) <EOL> time . sleep ( <NUM_LIT:5> ) <EOL> subprocess . call ( '<STR_LIT>' , shell = True ) <EOL> subprocess . call ( '<STR_LIT>' , shell = True ) <EOL> def poweroff ( ) : <EOL> screen . fill ( black ) <EOL> screen . blit ( poweroff_label , ( <NUM_LIT:10> , <NUM_LIT:100> ) ) <EOL> pygame . display . flip ( ) <EOL> time . sleep ( <NUM_LIT:5> ) <EOL> subprocess . call ( '<STR_LIT>' , shell = True ) <EOL> subprocess . call ( '<STR_LIT>' , shell = True ) <EOL> def favorite ( ) : <EOL> print song_title <EOL> f = open ( '<STR_LIT>' , '<STR_LIT:a>' ) <EOL> f . write ( '<STR_LIT:->' + song_title + '<STR_LIT:\n>' ) <EOL> f . close ( ) <EOL> def on_touch ( ) : <EOL> if <NUM_LIT> <= pos [ <NUM_LIT:0> ] <= <NUM_LIT> and <NUM_LIT> <= pos [ <NUM_LIT:1> ] <= <NUM_LIT> : <EOL> button ( <NUM_LIT:1> ) <EOL> if <NUM_LIT> <= pos [ <NUM_LIT:0> ] <= <NUM_LIT> and <NUM_LIT> <= pos [ <NUM_LIT:1> ] <= <NUM_LIT> : <EOL> button ( <NUM_LIT:2> ) <EOL> if <NUM_LIT> <= pos [ <NUM_LIT:0> ] <= <NUM_LIT> and <NUM_LIT> <= pos [ <NUM_LIT:1> ] <= <NUM_LIT> : <EOL> button ( <NUM_LIT:3> ) <EOL> if <NUM_LIT> <= pos [ <NUM_LIT:0> ] <= <NUM_LIT> and <NUM_LIT> <= pos [ <NUM_LIT:1> ] <= <NUM_LIT> : <EOL> button ( <NUM_LIT:4> ) <EOL> if <NUM_LIT> <= pos [ <NUM_LIT:0> ] <= <NUM_LIT> and <NUM_LIT> <= pos [ <NUM_LIT:1> ] <= <NUM_LIT> : <EOL> button ( <NUM_LIT:5> ) <EOL> if <NUM_LIT> <= pos [ <NUM_LIT:0> ] <= <NUM_LIT> and <NUM_LIT> <= pos [ <NUM_LIT:1> ] <= <NUM_LIT> : <EOL> button ( <NUM_LIT:6> ) <EOL> if <NUM_LIT> <= pos [ <NUM_LIT:0> ] <= <NUM_LIT> and <NUM_LIT> <= pos [ <NUM_LIT:1> ] <= <NUM_LIT> : <EOL> button ( <NUM_LIT:7> ) <EOL> if <NUM_LIT> <= pos [ <NUM_LIT:0> ] <= <NUM_LIT> and <NUM_LIT> <= pos [ <NUM_LIT:1> ] <= <NUM_LIT> : <EOL> button ( <NUM_LIT:8> ) <EOL> def button ( number ) : <EOL> global menu <EOL> if menu == <NUM_LIT:1> : <EOL> if number == <NUM_LIT:1> : <EOL> subprocess . call ( '<STR_LIT>' , shell = True ) <EOL> if number == <NUM_LIT:2> : <EOL> subprocess . call ( '<STR_LIT>' , shell = True ) <EOL> if number == <NUM_LIT:3> : <EOL> subprocess . call ( '<STR_LIT>' , shell = True ) <EOL> if number == <NUM_LIT:4> : <EOL> subprocess . call ( '<STR_LIT>' , shell = True ) <EOL> if number == <NUM_LIT:5> : <EOL> subprocess . call ( '<STR_LIT>' , shell = True ) <EOL> if number == <NUM_LIT:6> : <EOL> subprocess . call ( '<STR_LIT>' , shell = True ) <EOL> if number == <NUM_LIT:7> : <EOL> subprocess . call ( '<STR_LIT>' , shell = True ) <EOL> if number == <NUM_LIT:8> : <EOL> menu = <NUM_LIT:2> <EOL> update_screen ( ) <EOL> return <EOL> if menu == <NUM_LIT:2> : <EOL> if number == <NUM_LIT:1> : <EOL> favorite ( ) <EOL> if number == <NUM_LIT:2> : <EOL> global skin_number <EOL> skin_number = skin_number + <NUM_LIT:1> <EOL> update_screen ( ) <EOL> if number == <NUM_LIT:3> : <EOL> pygame . quit ( ) <EOL> sys . exit ( ) <EOL> if number == <NUM_LIT:4> : <EOL> subprocess . call ( '<STR_LIT>' , shell = True ) <EOL> pygame . quit ( ) <EOL> sys . exit ( ) <EOL> if number == <NUM_LIT:5> : <EOL> print "<STR_LIT>" <EOL> poweroff ( ) <EOL> if number == <NUM_LIT:6> : <EOL> print "<STR_LIT>" <EOL> reboot ( ) <EOL> if number == <NUM_LIT:7> : <EOL> update_screen ( ) <EOL> if number == <NUM_LIT:8> : <EOL> menu = <NUM_LIT:1> <EOL> update_screen ( ) <EOL> return <EOL> def update_screen ( ) : <EOL> global skin_number <EOL> if skin_number == <NUM_LIT:9> : <EOL> skin_number = <NUM_LIT:1> <EOL> if skin_number == <NUM_LIT:1> : <EOL> skin1 = pygame . image . load ( "<STR_LIT>" ) <EOL> skin2 = pygame . image . load ( "<STR_LIT>" ) <EOL> font_color = cyan <EOL> if skin_number == <NUM_LIT:2> : <EOL> skin1 = pygame . image . load ( "<STR_LIT>" ) <EOL> skin2 = pygame . image . load ( "<STR_LIT>" ) <EOL> font_color = blue <EOL> if skin_number == <NUM_LIT:3> : <EOL> skin1 = pygame . image . load ( "<STR_LIT>" ) <EOL> skin2 = pygame . image . load ( "<STR_LIT>" ) <EOL> font_color = green <EOL> if skin_number == <NUM_LIT:4> : <EOL> skin1 = pygame . image . load ( "<STR_LIT>" ) <EOL> skin2 = pygame . image . load ( "<STR_LIT>" ) <EOL> font_color = magenta <EOL> if skin_number == <NUM_LIT:5> : <EOL> skin1 = pygame . image . load ( "<STR_LIT>" ) <EOL> skin2 = pygame . image . load ( "<STR_LIT>" ) <EOL> font_color = orange <EOL> if skin_number == <NUM_LIT:6> : <EOL> skin1 = pygame . image . load ( "<STR_LIT>" ) <EOL> skin2 = pygame . image . load ( "<STR_LIT>" ) <EOL> font_color = red <EOL> if skin_number == <NUM_LIT:7> : <EOL> skin1 = pygame . image . load ( "<STR_LIT>" ) <EOL> skin2 = pygame . image . load ( "<STR_LIT>" ) <EOL> font_color = white <EOL> if skin_number == <NUM_LIT:8> : <EOL> skin1 = pygame . image . load ( "<STR_LIT>" ) <EOL> skin2 = pygame . image . load ( "<STR_LIT>" ) <EOL> font_color = yellow <EOL> global menu <EOL> if screensaver == False : <EOL> current_time = datetime . datetime . now ( ) . strftime ( '<STR_LIT>' ) <EOL> time_label = font . render ( current_time , <NUM_LIT:1> , ( font_color ) ) <EOL> if menu == <NUM_LIT:1> : <EOL> skin = skin1 <EOL> screen . blit ( skin , ( <NUM_LIT:0> , <NUM_LIT:0> ) ) <EOL> lines = subprocess . check_output ( '<STR_LIT>' , shell = True ) . split ( "<STR_LIT::>" ) <EOL> if len ( lines ) == <NUM_LIT:1> : <EOL> line1 = lines [ <NUM_LIT:0> ] <EOL> line1 = line1 [ : - <NUM_LIT:1> ] <EOL> station_label = font . render ( "<STR_LIT>" , <NUM_LIT:1> , ( font_color ) ) <EOL> else : <EOL> line1 = lines [ <NUM_LIT:0> ] <EOL> line2 = lines [ <NUM_LIT:1> ] <EOL> line1 = line1 [ : <NUM_LIT:30> ] <EOL> station_label = font . render ( '<STR_LIT>' + line1 + '<STR_LIT:.>' , <NUM_LIT:1> , ( font_color ) ) <EOL> lines = subprocess . check_output ( '<STR_LIT>' , shell = True ) . split ( "<STR_LIT:\n>" ) <EOL> line1 = lines [ <NUM_LIT:0> ] <EOL> if line1 . startswith ( "<STR_LIT>" ) : <EOL> title_label = font . render ( "<STR_LIT>" , <NUM_LIT:1> , ( font_color ) ) <EOL> else : <EOL> line1 = lines [ <NUM_LIT:0> ] <EOL> line2 = lines [ <NUM_LIT:1> ] <EOL> global song_title <EOL> song_title = line1 <EOL> line1 = line1 [ : <NUM_LIT:30> ] <EOL> title_label = font . render ( line1 + '<STR_LIT:.>' , <NUM_LIT:1> , ( font_color ) ) <EOL> title = font . render ( "<STR_LIT>" , <NUM_LIT:1> , ( font_color ) ) <EOL> screen . blit ( skin , ( <NUM_LIT:0> , <NUM_LIT:0> ) ) <EOL> screen . blit ( station_label , ( <NUM_LIT> , <NUM_LIT:15> ) ) <EOL> screen . blit ( title , ( <NUM_LIT> , <NUM_LIT> ) ) <EOL> screen . blit ( title_label , ( <NUM_LIT> , <NUM_LIT> ) ) <EOL> screen . blit ( time_label , ( <NUM_LIT> , <NUM_LIT> ) ) <EOL> lines = subprocess . check_output ( '<STR_LIT>' , shell = True ) . split ( "<STR_LIT:\n>" ) <EOL> line1 = lines [ <NUM_LIT:0> ] <EOL> volume_label = font . render ( line1 , <NUM_LIT:1> , ( font_color ) ) <EOL> screen . blit ( volume_label , ( <NUM_LIT> , <NUM_LIT> ) ) <EOL> pygame . display . flip ( ) <EOL> if menu == <NUM_LIT:2> : <EOL> skin = skin2 <EOL> screen . blit ( skin , ( <NUM_LIT:0> , <NUM_LIT:0> ) ) <EOL> ip = subprocess . check_output ( '<STR_LIT>' , shell = True ) . strip ( ) <EOL> ip_label = font . render ( '<STR_LIT>' + ip , <NUM_LIT:1> , ( font_color ) ) <EOL> screen . blit ( ip_label , ( <NUM_LIT> , <NUM_LIT:15> ) ) <EOL> cpu_temp = subprocess . check_output ( '<STR_LIT>' , shell = True ) . strip ( ) <EOL> temp = font . render ( '<STR_LIT>' + cpu_temp , <NUM_LIT:1> , ( font_color ) ) <EOL> screen . blit ( temp , ( <NUM_LIT> , <NUM_LIT> ) ) <EOL> screen . blit ( time_label , ( <NUM_LIT> , <NUM_LIT> ) ) <EOL> pygame . display . flip ( ) <EOL> if screensaver == True : <EOL> screen . fill ( white ) <EOL> pygame . display . flip ( ) <EOL> minutes = <NUM_LIT:0> <EOL> pygame . time . set_timer ( USEREVENT + <NUM_LIT:1> , <NUM_LIT> ) <EOL> subprocess . call ( '<STR_LIT>' , shell = True ) <EOL> update_screen ( ) <EOL> running = True <EOL> while running : <EOL> for event in pygame . event . get ( ) : <EOL> if event . type == USEREVENT + <NUM_LIT:1> : <EOL> minutes += <NUM_LIT:1> <EOL> if event . type == pygame . QUIT : <EOL> print "<STR_LIT>" <EOL> pygame . quit ( ) <EOL> sys . exit ( ) <EOL> if event . type == pygame . KEYDOWN : <EOL> if event . key == K_ESCAPE : <EOL> print "<STR_LIT>" <EOL> pygame . quit ( ) <EOL> sys . exit ( ) <EOL> if event . type == pygame . MOUSEBUTTONDOWN and screensaver == True : <EOL> minutes = <NUM_LIT:0> <EOL> subprocess . call ( '<STR_LIT>' , shell = True ) <EOL> screensaver = False <EOL> update_screen ( ) <EOL> break <EOL> if event . type == pygame . MOUSEBUTTONDOWN and screensaver == False : <EOL> pos = ( pygame . mouse . get_pos ( ) [ <NUM_LIT:0> ] , pygame . mouse . get_pos ( ) [ <NUM_LIT:1> ] ) <EOL> minutes = <NUM_LIT:0> <EOL> on_touch ( ) <EOL> update_screen ( ) <EOL> if minutes > screensaver_timer : <EOL> screensaver = True <EOL> subprocess . call ( '<STR_LIT>' , shell = True ) <EOL> update_screen ( ) <EOL> update_screen ( ) <EOL> time . sleep ( <NUM_LIT:0.1> ) </s>

<s> '''<STR_LIT>''' <EOL> import memcache <EOL> class MemConnError ( Exception ) : <EOL> """<STR_LIT:U+0020>""" <EOL> def __str__ ( self ) : <EOL> return "<STR_LIT>" <EOL> class MemClient : <EOL> '''<STR_LIT>''' <EOL> def __init__ ( self , timeout = <NUM_LIT:0> ) : <EOL> '''<STR_LIT:U+0020>''' <EOL> self . _hostname = "<STR_LIT>" <EOL> self . _urls = [ ] <EOL> self . connection = None <EOL> def connect ( self , urls , hostname ) : <EOL> '''<STR_LIT>''' <EOL> self . _hostname = hostname <EOL> self . _urls = urls <EOL> self . connection = memcache . Client ( self . _urls , debug = <NUM_LIT:0> ) <EOL> if not self . connection . set ( "<STR_LIT>" , <NUM_LIT:1> ) : <EOL> raise MemConnError ( ) <EOL> def produceKey ( self , keyname ) : <EOL> '''<STR_LIT:U+0020>''' <EOL> if isinstance ( keyname , basestring ) : <EOL> return '<STR_LIT>' . join ( [ self . _hostname , '<STR_LIT::>' , keyname ] ) <EOL> else : <EOL> raise "<STR_LIT>" <EOL> def get ( self , key ) : <EOL> '''<STR_LIT:U+0020>''' <EOL> key = self . produceKey ( key ) <EOL> return self . connection . get ( key ) <EOL> def get_multi ( self , keys ) : <EOL> '''<STR_LIT:U+0020>''' <EOL> keynamelist = [ self . produceKey ( keyname ) for keyname in keys ] <EOL> olddict = self . connection . get_multi ( keynamelist ) <EOL> newdict = dict ( zip ( [ keyname . split ( '<STR_LIT::>' ) [ - <NUM_LIT:1> ] for keyname in olddict . keys ( ) ] , <EOL> olddict . values ( ) ) ) <EOL> return newdict <EOL> def set ( self , keyname , value ) : <EOL> '''<STR_LIT:U+0020>''' <EOL> key = self . produceKey ( keyname ) <EOL> result = self . connection . set ( key , value ) <EOL> if not result : <EOL> self . connect ( self . _urls , self . _hostname ) <EOL> return self . connection . set ( key , value ) <EOL> return result <EOL> def set_multi ( self , mapping ) : <EOL> '''<STR_LIT:U+0020>''' <EOL> newmapping = dict ( zip ( [ self . produceKey ( keyname ) for keyname in mapping . keys ( ) ] , <EOL> mapping . values ( ) ) ) <EOL> result = self . connection . set_multi ( newmapping ) <EOL> if result : <EOL> self . connect ( self . _urls , self . _hostname ) <EOL> return self . connection . set_multi ( newmapping ) <EOL> return result <EOL> def incr ( self , key , delta ) : <EOL> '''<STR_LIT:U+0020>''' <EOL> key = self . produceKey ( key ) <EOL> return self . connection . incr ( key , delta ) <EOL> def delete ( self , key ) : <EOL> '''<STR_LIT:U+0020>''' <EOL> key = self . produceKey ( key ) <EOL> return self . connection . delete ( key ) <EOL> def delete_multi ( self , keys ) : <EOL> """<STR_LIT:U+0020>""" <EOL> keys = [ self . produceKey ( key ) for key in keys ] <EOL> return self . connection . delete_multi ( keys ) <EOL> def flush_all ( self ) : <EOL> '''<STR_LIT:U+0020>''' <EOL> self . connection . flush_all ( ) <EOL> mclient = MemClient ( ) </s>

<s> '''<STR_LIT>''' <EOL> from firefly . dbentrust . dbpool import dbpool <EOL> from firefly . dbentrust . madminanager import MAdminManager <EOL> from firefly . dbentrust import mmode <EOL> from firefly . dbentrust . memclient import mclient <EOL> import time <EOL> if __name__ == "<STR_LIT:__main__>" : <EOL> hostname = "<STR_LIT:localhost>" <EOL> username = '<STR_LIT:root>' <EOL> password = '<STR_LIT>' <EOL> dbname = '<STR_LIT:test>' <EOL> charset = '<STR_LIT:utf8>' <EOL> tablename = "<STR_LIT>" <EOL> aa = { '<STR_LIT:host>' : "<STR_LIT:localhost>" , <EOL> '<STR_LIT:user>' : '<STR_LIT:root>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT:test>' , <EOL> '<STR_LIT:port>' : <NUM_LIT> , <EOL> '<STR_LIT>' : '<STR_LIT:utf8>' } <EOL> dbpool . initPool ( ** aa ) <EOL> mclient . connect ( [ '<STR_LIT>' ] , "<STR_LIT:test>" ) <EOL> mmanager = MAdminManager ( ) <EOL> m1 = mmode . MAdmin ( '<STR_LIT>' , '<STR_LIT:id>' , incrkey = '<STR_LIT:id>' ) <EOL> m1 . insert ( ) <EOL> print m1 . get ( '<STR_LIT>' ) <EOL> m2 = mmode . MAdmin ( '<STR_LIT>' , '<STR_LIT:id>' , incrkey = '<STR_LIT:id>' ) <EOL> print m2 . get ( '<STR_LIT>' ) </s>

<s> """<STR_LIT>""" <EOL> import pexpect <EOL> class connect ( ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , address ) : <EOL> self . address = "<STR_LIT>" <EOL> self . conn = None <EOL> self . connect ( address ) <EOL> def connect ( self , address , adapter = '<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> if self . conn is None : <EOL> self . address = address <EOL> cmd = '<STR_LIT:U+0020>' . join ( [ '<STR_LIT>' , '<STR_LIT>' , address , '<STR_LIT>' , adapter , '<STR_LIT>' ] ) <EOL> self . conn = pexpect . spawn ( cmd ) <EOL> self . conn . expect ( r'<STR_LIT>' , timeout = <NUM_LIT:1> ) <EOL> self . conn . sendline ( '<STR_LIT>' ) <EOL> try : <EOL> self . conn . expect ( r'<STR_LIT>' , timeout = <NUM_LIT:10> ) <EOL> print ( "<STR_LIT>" + address ) <EOL> except pexpect . TIMEOUT : <EOL> raise Exception ( "<STR_LIT>" ) <EOL> else : <EOL> raise Exception ( "<STR_LIT>" ) <EOL> def reconnect ( self ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> self . conn . expect ( r'<STR_LIT>' , timeout = <NUM_LIT:0.1> ) <EOL> self . conn . sendline ( '<STR_LIT>' ) <EOL> try : <EOL> self . conn . expect ( r'<STR_LIT>' , timeout = <NUM_LIT:10> ) <EOL> print ( "<STR_LIT>" + self . address ) <EOL> except pexpect . TIMEOUT : <EOL> print ( "<STR_LIT>" + self . address ) <EOL> return True <EOL> except pexpect . TIMEOUT : <EOL> return False <EOL> def disconnect ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . conn is not None : <EOL> self . conn . sendline ( '<STR_LIT>' ) <EOL> self . conn = None <EOL> print ( "<STR_LIT>" + self . address ) <EOL> def write ( self , handle , value ) : <EOL> """<STR_LIT>""" <EOL> self . send ( '<STR_LIT:U+0020>' . join ( [ '<STR_LIT>' , '<STR_LIT>' + handle , value ] ) ) <EOL> def read ( self , handle ) : <EOL> """<STR_LIT>""" <EOL> self . send ( '<STR_LIT>' + handle , r'<STR_LIT>' , timeout = <NUM_LIT:5> ) <EOL> val = '<STR_LIT:U+0020>' . join ( self . conn . after . decode ( "<STR_LIT:utf-8>" ) . split ( ) [ <NUM_LIT:1> : ] ) <EOL> return val <EOL> def send ( self , cmd , expect = None , timeout = <NUM_LIT:5> ) : <EOL> """<STR_LIT>""" <EOL> self . conn . sendline ( cmd ) <EOL> if expect is not None : <EOL> try : <EOL> self . conn . expect ( expect , timeout ) <EOL> except pexpect . TIMEOUT : <EOL> if self . reconnect ( ) : <EOL> self . conn . sendline ( cmd ) <EOL> else : <EOL> if self . reconnect ( ) : <EOL> self . conn . sendline ( cmd ) </s>

<s> from __future__ import unicode_literals <EOL> from django . db import models , migrations <EOL> import wagtail . wagtailcore . fields <EOL> class Migration ( migrations . Migration ) : <EOL> dependencies = [ <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ] <EOL> operations = [ <EOL> migrations . AlterField ( <EOL> model_name = '<STR_LIT>' , <EOL> name = '<STR_LIT:description>' , <EOL> field = models . CharField ( max_length = <NUM_LIT:255> , help_text = '<STR_LIT>' , verbose_name = '<STR_LIT>' , blank = True ) , <EOL> ) , <EOL> migrations . AlterField ( <EOL> model_name = '<STR_LIT>' , <EOL> name = '<STR_LIT:description>' , <EOL> field = models . CharField ( max_length = <NUM_LIT> , verbose_name = '<STR_LIT>' , blank = True ) , <EOL> ) , <EOL> migrations . AlterField ( <EOL> model_name = '<STR_LIT>' , <EOL> name = '<STR_LIT:name>' , <EOL> field = models . CharField ( max_length = <NUM_LIT> , unique = True , verbose_name = '<STR_LIT>' ) , <EOL> ) , <EOL> migrations . AlterField ( <EOL> model_name = '<STR_LIT>' , <EOL> name = '<STR_LIT>' , <EOL> field = models . ForeignKey ( to = '<STR_LIT>' , related_name = '<STR_LIT>' , null = True , verbose_name = '<STR_LIT>' , blank = True ) , <EOL> ) , <EOL> migrations . AlterField ( <EOL> model_name = '<STR_LIT>' , <EOL> name = '<STR_LIT>' , <EOL> field = wagtail . wagtailcore . fields . RichTextField ( help_text = '<STR_LIT>' , verbose_name = '<STR_LIT>' , blank = True ) , <EOL> ) , <EOL> ] </s>

<s> """<STR_LIT>""" <EOL> print ( __doc__ ) <EOL> import matplotlib . pyplot as plt <EOL> import pyart <EOL> XSAPR_SW_FILE = '<STR_LIT>' <EOL> XSAPR_SE_FILE = '<STR_LIT>' <EOL> radar_sw = pyart . io . read_cfradial ( XSAPR_SW_FILE ) <EOL> radar_se = pyart . io . read_cfradial ( XSAPR_SE_FILE ) <EOL> gatefilter_se = pyart . filters . GateFilter ( radar_se ) <EOL> gatefilter_se . exclude_above ( '<STR_LIT>' , <NUM_LIT:100> ) <EOL> gatefilter_sw = pyart . filters . GateFilter ( radar_sw ) <EOL> gatefilter_sw . exclude_above ( '<STR_LIT>' , <NUM_LIT:100> ) <EOL> grid = pyart . map . grid_from_radars ( <EOL> ( radar_se , radar_sw ) , gatefilters = ( gatefilter_se , gatefilter_sw ) , <EOL> grid_shape = ( <NUM_LIT:1> , <NUM_LIT> , <NUM_LIT> ) , <EOL> grid_limits = ( ( <NUM_LIT:1000> , <NUM_LIT:1000> ) , ( - <NUM_LIT> , <NUM_LIT> ) , ( - <NUM_LIT> , <NUM_LIT> ) ) , <EOL> grid_origin = ( <NUM_LIT> , - <NUM_LIT> ) , <EOL> fields = [ '<STR_LIT>' ] ) <EOL> fig = plt . figure ( ) <EOL> ax = fig . add_subplot ( <NUM_LIT> ) <EOL> ax . imshow ( grid . fields [ '<STR_LIT>' ] [ '<STR_LIT:data>' ] [ <NUM_LIT:0> ] , <EOL> origin = '<STR_LIT>' , extent = ( - <NUM_LIT> , <NUM_LIT> , - <NUM_LIT:50> , <NUM_LIT> ) , vmin = <NUM_LIT:0> , vmax = <NUM_LIT> ) <EOL> plt . show ( ) </s>

<s> """<STR_LIT>""" <EOL> import os <EOL> import tempfile <EOL> import subprocess <EOL> from . . io . cfradial import read_cfradial <EOL> from . . io . common import _test_arguments <EOL> def read_radx ( filename , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> _test_arguments ( kwargs ) <EOL> tmpfile = tempfile . mkstemp ( suffix = '<STR_LIT>' , dir = '<STR_LIT:.>' ) [ <NUM_LIT:1> ] <EOL> head , tail = os . path . split ( tmpfile ) <EOL> try : <EOL> subprocess . check_call ( <EOL> [ '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , head , '<STR_LIT>' , tail , '<STR_LIT>' , filename ] ) <EOL> if not os . path . isfile ( tmpfile ) : <EOL> raise IOError ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> radar = read_cfradial ( tmpfile ) <EOL> finally : <EOL> os . remove ( tmpfile ) <EOL> return radar </s>

<s> """<STR_LIT>""" <EOL> import warnings <EOL> class MissingOptionalDependency ( Exception ) : <EOL> """<STR_LIT>""" <EOL> pass <EOL> class DeprecatedAttribute ( DeprecationWarning ) : <EOL> """<STR_LIT>""" <EOL> pass <EOL> class DeprecatedFunctionName ( DeprecationWarning ) : <EOL> """<STR_LIT>""" <EOL> pass <EOL> def _deprecated_alias ( func , old_name , new_name ) : <EOL> """<STR_LIT>""" <EOL> def wrapper ( * args , ** kwargs ) : <EOL> warnings . warn ( <EOL> ( "<STR_LIT>" + <EOL> "<STR_LIT>" ) . format ( <EOL> old_name , new_name ) , category = DeprecatedFunctionName ) <EOL> return func ( * args , ** kwargs ) <EOL> return wrapper </s>

<s> """<STR_LIT>""" <EOL> import warnings <EOL> import numpy as np <EOL> from . . config import FileMetadata , get_fillvalue <EOL> from . . core . radar import Radar <EOL> from . common import make_time_unit_str , _test_arguments , prepare_for_read <EOL> from . nexrad_level2 import NEXRADLevel2File <EOL> from . . lazydict import LazyLoadDict <EOL> from . nexrad_common import get_nexrad_location <EOL> def read_nexrad_archive ( filename , field_names = None , additional_metadata = None , <EOL> file_field_names = False , exclude_fields = None , <EOL> delay_field_loading = False , station = None , scans = None , <EOL> linear_interp = True , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> _test_arguments ( kwargs ) <EOL> filemetadata = FileMetadata ( '<STR_LIT>' , field_names , <EOL> additional_metadata , file_field_names , <EOL> exclude_fields ) <EOL> nfile = NEXRADLevel2File ( prepare_for_read ( filename ) ) <EOL> scan_info = nfile . scan_info ( scans ) <EOL> time = filemetadata ( '<STR_LIT:time>' ) <EOL> time_start , _time = nfile . get_times ( scans ) <EOL> time [ '<STR_LIT:data>' ] = _time <EOL> time [ '<STR_LIT>' ] = make_time_unit_str ( time_start ) <EOL> _range = filemetadata ( '<STR_LIT>' ) <EOL> first_gate , gate_spacing , last_gate = _find_range_params ( <EOL> scan_info , filemetadata ) <EOL> _range [ '<STR_LIT:data>' ] = np . arange ( first_gate , last_gate , gate_spacing , '<STR_LIT>' ) <EOL> _range [ '<STR_LIT>' ] = float ( first_gate ) <EOL> _range [ '<STR_LIT>' ] = float ( gate_spacing ) <EOL> metadata = filemetadata ( '<STR_LIT>' ) <EOL> metadata [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> scan_type = '<STR_LIT>' <EOL> latitude = filemetadata ( '<STR_LIT>' ) <EOL> longitude = filemetadata ( '<STR_LIT>' ) <EOL> altitude = filemetadata ( '<STR_LIT>' ) <EOL> if nfile . _msg_type == '<STR_LIT:1>' and station is not None : <EOL> lat , lon , alt = get_nexrad_location ( station ) <EOL> else : <EOL> lat , lon , alt = nfile . location ( ) <EOL> latitude [ '<STR_LIT:data>' ] = np . array ( [ lat ] , dtype = '<STR_LIT>' ) <EOL> longitude [ '<STR_LIT:data>' ] = np . array ( [ lon ] , dtype = '<STR_LIT>' ) <EOL> altitude [ '<STR_LIT:data>' ] = np . array ( [ alt ] , dtype = '<STR_LIT>' ) <EOL> sweep_number = filemetadata ( '<STR_LIT>' ) <EOL> sweep_mode = filemetadata ( '<STR_LIT>' ) <EOL> sweep_start_ray_index = filemetadata ( '<STR_LIT>' ) <EOL> sweep_end_ray_index = filemetadata ( '<STR_LIT>' ) <EOL> if scans is None : <EOL> nsweeps = int ( nfile . nscans ) <EOL> else : <EOL> nsweeps = len ( scans ) <EOL> sweep_number [ '<STR_LIT:data>' ] = np . arange ( nsweeps , dtype = '<STR_LIT>' ) <EOL> sweep_mode [ '<STR_LIT:data>' ] = np . array ( <EOL> nsweeps * [ '<STR_LIT>' ] , dtype = '<STR_LIT:S>' ) <EOL> rays_per_scan = [ s [ '<STR_LIT>' ] for s in scan_info ] <EOL> sweep_end_ray_index [ '<STR_LIT:data>' ] = np . cumsum ( rays_per_scan , dtype = '<STR_LIT>' ) - <NUM_LIT:1> <EOL> rays_per_scan . insert ( <NUM_LIT:0> , <NUM_LIT:0> ) <EOL> sweep_start_ray_index [ '<STR_LIT:data>' ] = np . cumsum ( <EOL> rays_per_scan [ : - <NUM_LIT:1> ] , dtype = '<STR_LIT>' ) <EOL> azimuth = filemetadata ( '<STR_LIT>' ) <EOL> elevation = filemetadata ( '<STR_LIT>' ) <EOL> fixed_angle = filemetadata ( '<STR_LIT>' ) <EOL> azimuth [ '<STR_LIT:data>' ] = nfile . get_azimuth_angles ( scans ) <EOL> elevation [ '<STR_LIT:data>' ] = nfile . get_elevation_angles ( scans ) . astype ( '<STR_LIT>' ) <EOL> fixed_angle [ '<STR_LIT:data>' ] = nfile . get_target_angles ( scans ) <EOL> max_ngates = len ( _range [ '<STR_LIT:data>' ] ) <EOL> available_moments = set ( [ m for scan in scan_info for m in scan [ '<STR_LIT>' ] ] ) <EOL> interpolate = _find_scans_to_interp ( <EOL> scan_info , first_gate , gate_spacing , filemetadata ) <EOL> fields = { } <EOL> for moment in available_moments : <EOL> field_name = filemetadata . get_field_name ( moment ) <EOL> if field_name is None : <EOL> continue <EOL> dic = filemetadata ( field_name ) <EOL> dic [ '<STR_LIT>' ] = get_fillvalue ( ) <EOL> if delay_field_loading and moment not in interpolate : <EOL> dic = LazyLoadDict ( dic ) <EOL> data_call = _NEXRADLevel2StagedField ( <EOL> nfile , moment , max_ngates , scans ) <EOL> dic . set_lazy ( '<STR_LIT:data>' , data_call ) <EOL> else : <EOL> mdata = nfile . get_data ( moment , max_ngates , scans = scans ) <EOL> if moment in interpolate : <EOL> interp_scans = interpolate [ moment ] <EOL> warnings . warn ( <EOL> "<STR_LIT>" + <EOL> "<STR_LIT>" % ( interp_scans , moment ) , <EOL> UserWarning ) <EOL> for scan in interp_scans : <EOL> idx = scan_info [ scan ] [ '<STR_LIT>' ] . index ( moment ) <EOL> moment_ngates = scan_info [ scan ] [ '<STR_LIT>' ] [ idx ] <EOL> start = sweep_start_ray_index [ '<STR_LIT:data>' ] [ scan ] <EOL> end = sweep_end_ray_index [ '<STR_LIT:data>' ] [ scan ] <EOL> _interpolate_scan ( mdata , start , end , moment_ngates , <EOL> linear_interp ) <EOL> dic [ '<STR_LIT:data>' ] = mdata <EOL> fields [ field_name ] = dic <EOL> nyquist_velocity = filemetadata ( '<STR_LIT>' ) <EOL> unambiguous_range = filemetadata ( '<STR_LIT>' ) <EOL> nyquist_velocity [ '<STR_LIT:data>' ] = nfile . get_nyquist_vel ( scans ) . astype ( '<STR_LIT>' ) <EOL> unambiguous_range [ '<STR_LIT:data>' ] = ( <EOL> nfile . get_unambigous_range ( scans ) . astype ( '<STR_LIT>' ) ) <EOL> instrument_parameters = { '<STR_LIT>' : unambiguous_range , <EOL> '<STR_LIT>' : nyquist_velocity , } <EOL> nfile . close ( ) <EOL> return Radar ( <EOL> time , _range , fields , metadata , scan_type , <EOL> latitude , longitude , altitude , <EOL> sweep_number , sweep_mode , fixed_angle , sweep_start_ray_index , <EOL> sweep_end_ray_index , <EOL> azimuth , elevation , <EOL> instrument_parameters = instrument_parameters ) <EOL> def _find_range_params ( scan_info , filemetadata ) : <EOL> """<STR_LIT>""" <EOL> min_first_gate = <NUM_LIT> <EOL> min_gate_spacing = <NUM_LIT> <EOL> max_last_gate = <NUM_LIT:0> <EOL> for scan_params in scan_info : <EOL> ngates = scan_params [ '<STR_LIT>' ] [ <NUM_LIT:0> ] <EOL> for i , moment in enumerate ( scan_params [ '<STR_LIT>' ] ) : <EOL> if filemetadata . get_field_name ( moment ) is None : <EOL> continue <EOL> first_gate = scan_params [ '<STR_LIT>' ] [ i ] <EOL> gate_spacing = scan_params [ '<STR_LIT>' ] [ i ] <EOL> last_gate = first_gate + gate_spacing * ( ngates - <NUM_LIT:0.5> ) <EOL> min_first_gate = min ( min_first_gate , first_gate ) <EOL> min_gate_spacing = min ( min_gate_spacing , gate_spacing ) <EOL> max_last_gate = max ( max_last_gate , last_gate ) <EOL> return min_first_gate , min_gate_spacing , max_last_gate <EOL> def _find_scans_to_interp ( scan_info , first_gate , gate_spacing , filemetadata ) : <EOL> """<STR_LIT>""" <EOL> moments = set ( [ m for scan in scan_info for m in scan [ '<STR_LIT>' ] ] ) <EOL> interpolate = dict ( [ ( moment , [ ] ) for moment in moments ] ) <EOL> for scan_num , scan in enumerate ( scan_info ) : <EOL> for moment in moments : <EOL> if moment not in scan [ '<STR_LIT>' ] : <EOL> continue <EOL> if filemetadata . get_field_name ( moment ) is None : <EOL> continue <EOL> index = scan [ '<STR_LIT>' ] . index ( moment ) <EOL> first = scan [ '<STR_LIT>' ] [ index ] <EOL> spacing = scan [ '<STR_LIT>' ] [ index ] <EOL> if first != first_gate or spacing != gate_spacing : <EOL> interpolate [ moment ] . append ( scan_num ) <EOL> assert spacing == gate_spacing * <NUM_LIT:4> <EOL> assert first_gate + <NUM_LIT> * gate_spacing == first <EOL> interpolate = dict ( [ ( k , v ) for k , v in interpolate . items ( ) if len ( v ) != <NUM_LIT:0> ] ) <EOL> return interpolate <EOL> def _interpolate_scan ( mdata , start , end , moment_ngates , linear_interp = True ) : <EOL> """<STR_LIT>""" <EOL> for ray_num in range ( start , end + <NUM_LIT:1> ) : <EOL> ray = mdata [ ray_num ] . copy ( ) <EOL> interp_ngates = <NUM_LIT:4> * moment_ngates <EOL> ray [ : interp_ngates ] = np . repeat ( ray [ : moment_ngates ] , <NUM_LIT:4> ) <EOL> if linear_interp : <EOL> for i in range ( <NUM_LIT:2> , interp_ngates - <NUM_LIT:4> , <NUM_LIT:4> ) : <EOL> gate_val = ray [ i ] <EOL> next_val = ray [ i + <NUM_LIT:4> ] <EOL> if np . ma . is_masked ( gate_val ) or np . ma . is_masked ( next_val ) : <EOL> continue <EOL> delta = ( next_val - gate_val ) / <NUM_LIT> <EOL> ray [ i + <NUM_LIT:0> ] = gate_val + delta * <NUM_LIT:0.5> <EOL> ray [ i + <NUM_LIT:1> ] = gate_val + delta * <NUM_LIT> <EOL> ray [ i + <NUM_LIT:2> ] = gate_val + delta * <NUM_LIT> <EOL> ray [ i + <NUM_LIT:3> ] = gate_val + delta * <NUM_LIT> <EOL> mdata [ ray_num ] = ray [ : ] <EOL> class _NEXRADLevel2StagedField ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , nfile , moment , max_ngates , scans ) : <EOL> """<STR_LIT>""" <EOL> self . nfile = nfile <EOL> self . moment = moment <EOL> self . max_ngates = max_ngates <EOL> self . scans = scans <EOL> def __call__ ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . nfile . get_data ( <EOL> self . moment , self . max_ngates , scans = self . scans ) </s>

<s> """<STR_LIT>""" <EOL> import warnings <EOL> import numpy as np <EOL> from netCDF4 import date2num <EOL> from . . config import FileMetadata , get_fillvalue <EOL> from . . core . radar import Radar <EOL> from . common import make_time_unit_str , _test_arguments , prepare_for_read <EOL> from . uffile import UFFile <EOL> _LIGHT_SPEED = <NUM_LIT> <EOL> _UF_SWEEP_MODES = { <EOL> <NUM_LIT:0> : '<STR_LIT>' , <EOL> <NUM_LIT:1> : '<STR_LIT>' , <EOL> <NUM_LIT:2> : '<STR_LIT>' , <EOL> <NUM_LIT:3> : '<STR_LIT>' , <EOL> <NUM_LIT:4> : '<STR_LIT>' , <EOL> <NUM_LIT:5> : '<STR_LIT:target>' , <EOL> <NUM_LIT:6> : '<STR_LIT>' , <EOL> <NUM_LIT:7> : '<STR_LIT>' , <EOL> } <EOL> _SWEEP_MODE_STR = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT:target>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> } <EOL> def read_uf ( filename , field_names = None , additional_metadata = None , <EOL> file_field_names = False , exclude_fields = None , <EOL> delay_field_loading = False , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> _test_arguments ( kwargs ) <EOL> filemetadata = FileMetadata ( '<STR_LIT>' , field_names , additional_metadata , <EOL> file_field_names , exclude_fields ) <EOL> ufile = UFFile ( prepare_for_read ( filename ) ) <EOL> first_ray = ufile . rays [ <NUM_LIT:0> ] <EOL> dts = ufile . get_datetimes ( ) <EOL> units = make_time_unit_str ( min ( dts ) ) <EOL> time = filemetadata ( '<STR_LIT:time>' ) <EOL> time [ '<STR_LIT>' ] = units <EOL> time [ '<STR_LIT:data>' ] = date2num ( dts , units ) . astype ( '<STR_LIT>' ) <EOL> _range = filemetadata ( '<STR_LIT>' ) <EOL> field_header = first_ray . field_headers [ <NUM_LIT:0> ] <EOL> ngates = field_header [ '<STR_LIT>' ] <EOL> step = field_header [ '<STR_LIT>' ] <EOL> start = ( field_header [ '<STR_LIT>' ] * <NUM_LIT> + <EOL> field_header [ '<STR_LIT>' ] + step / <NUM_LIT> ) <EOL> _range [ '<STR_LIT:data>' ] = np . arange ( ngates , dtype = '<STR_LIT>' ) * step + start <EOL> _range [ '<STR_LIT>' ] = start <EOL> _range [ '<STR_LIT>' ] = step <EOL> latitude = filemetadata ( '<STR_LIT>' ) <EOL> longitude = filemetadata ( '<STR_LIT>' ) <EOL> altitude = filemetadata ( '<STR_LIT>' ) <EOL> lat , lon , height = first_ray . get_location ( ) <EOL> latitude [ '<STR_LIT:data>' ] = np . array ( [ lat ] , dtype = '<STR_LIT>' ) <EOL> longitude [ '<STR_LIT:data>' ] = np . array ( [ lon ] , dtype = '<STR_LIT>' ) <EOL> altitude [ '<STR_LIT:data>' ] = np . array ( [ height ] , dtype = '<STR_LIT>' ) <EOL> metadata = filemetadata ( '<STR_LIT>' ) <EOL> metadata [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> metadata [ '<STR_LIT>' ] = first_ray . mandatory_header [ '<STR_LIT>' ] <EOL> metadata [ '<STR_LIT>' ] = first_ray . mandatory_header [ '<STR_LIT>' ] <EOL> sweep_start_ray_index = filemetadata ( '<STR_LIT>' ) <EOL> sweep_end_ray_index = filemetadata ( '<STR_LIT>' ) <EOL> sweep_start_ray_index [ '<STR_LIT:data>' ] = ufile . first_ray_in_sweep <EOL> sweep_end_ray_index [ '<STR_LIT:data>' ] = ufile . last_ray_in_sweep <EOL> sweep_number = filemetadata ( '<STR_LIT>' ) <EOL> sweep_number [ '<STR_LIT:data>' ] = np . arange ( ufile . nsweeps , dtype = '<STR_LIT>' ) <EOL> scan_type = _UF_SWEEP_MODES [ first_ray . mandatory_header [ '<STR_LIT>' ] ] <EOL> sweep_mode = filemetadata ( '<STR_LIT>' ) <EOL> sweep_mode [ '<STR_LIT:data>' ] = np . array ( <EOL> ufile . nsweeps * [ _SWEEP_MODE_STR [ scan_type ] ] , dtype = '<STR_LIT:S>' ) <EOL> elevation = filemetadata ( '<STR_LIT>' ) <EOL> elevation [ '<STR_LIT:data>' ] = ufile . get_elevations ( ) <EOL> azimuth = filemetadata ( '<STR_LIT>' ) <EOL> azimuth [ '<STR_LIT:data>' ] = ufile . get_azimuths ( ) <EOL> fixed_angle = filemetadata ( '<STR_LIT>' ) <EOL> fixed_angle [ '<STR_LIT:data>' ] = ufile . get_sweep_fixed_angles ( ) <EOL> fields = { } <EOL> for uf_field_number , uf_field_dic in enumerate ( first_ray . field_positions ) : <EOL> uf_field_name = uf_field_dic [ '<STR_LIT>' ] . decode ( '<STR_LIT:ascii>' ) <EOL> field_name = filemetadata . get_field_name ( uf_field_name ) <EOL> if field_name is None : <EOL> continue <EOL> field_dic = filemetadata ( field_name ) <EOL> field_dic [ '<STR_LIT:data>' ] = ufile . get_field_data ( uf_field_number ) <EOL> field_dic [ '<STR_LIT>' ] = get_fillvalue ( ) <EOL> fields [ field_name ] = field_dic <EOL> instrument_parameters = _get_instrument_parameters ( ufile , filemetadata ) <EOL> scan_rate = filemetadata ( '<STR_LIT>' ) <EOL> scan_rate [ '<STR_LIT:data>' ] = ufile . get_sweep_rates ( ) <EOL> ufile . close ( ) <EOL> return Radar ( <EOL> time , _range , fields , metadata , scan_type , <EOL> latitude , longitude , altitude , <EOL> sweep_number , sweep_mode , fixed_angle , sweep_start_ray_index , <EOL> sweep_end_ray_index , <EOL> azimuth , elevation , <EOL> scan_rate = scan_rate , <EOL> instrument_parameters = instrument_parameters ) <EOL> def _get_instrument_parameters ( ufile , filemetadata ) : <EOL> """<STR_LIT>""" <EOL> pulse_width = filemetadata ( '<STR_LIT>' ) <EOL> pulse_width [ '<STR_LIT:data>' ] = ufile . get_pulse_widths ( ) / _LIGHT_SPEED <EOL> first_ray = ufile . rays [ <NUM_LIT:0> ] <EOL> field_header = first_ray . field_headers [ <NUM_LIT:0> ] <EOL> beam_width_h = field_header [ '<STR_LIT>' ] / <NUM_LIT> <EOL> beam_width_v = field_header [ '<STR_LIT>' ] / <NUM_LIT> <EOL> bandwidth = field_header [ '<STR_LIT>' ] / <NUM_LIT> * <NUM_LIT> <EOL> wavelength_cm = field_header [ '<STR_LIT>' ] / <NUM_LIT> <EOL> if wavelength_cm == <NUM_LIT:0> : <EOL> warnings . warn ( '<STR_LIT>' ) <EOL> wavelength_hz = <NUM_LIT> <EOL> else : <EOL> wavelength_hz = _LIGHT_SPEED / ( wavelength_cm / <NUM_LIT> ) <EOL> radar_beam_width_h = filemetadata ( '<STR_LIT>' ) <EOL> radar_beam_width_h [ '<STR_LIT:data>' ] = np . array ( [ beam_width_h ] , dtype = '<STR_LIT>' ) <EOL> radar_beam_width_v = filemetadata ( '<STR_LIT>' ) <EOL> radar_beam_width_v [ '<STR_LIT:data>' ] = np . array ( [ beam_width_v ] , dtype = '<STR_LIT>' ) <EOL> radar_receiver_bandwidth = filemetadata ( '<STR_LIT>' ) <EOL> radar_receiver_bandwidth [ '<STR_LIT:data>' ] = np . array ( [ bandwidth ] , dtype = '<STR_LIT>' ) <EOL> polarization_mode = filemetadata ( '<STR_LIT>' ) <EOL> polarization_mode [ '<STR_LIT:data>' ] = ufile . get_sweep_polarizations ( ) <EOL> frequency = filemetadata ( '<STR_LIT>' ) <EOL> frequency [ '<STR_LIT:data>' ] = np . array ( [ wavelength_hz ] , dtype = '<STR_LIT>' ) <EOL> prt = filemetadata ( '<STR_LIT>' ) <EOL> prt [ '<STR_LIT:data>' ] = ufile . get_prts ( ) / <NUM_LIT> <EOL> instrument_parameters = { <EOL> '<STR_LIT>' : pulse_width , <EOL> '<STR_LIT>' : radar_beam_width_h , <EOL> '<STR_LIT>' : radar_beam_width_v , <EOL> '<STR_LIT>' : radar_receiver_bandwidth , <EOL> '<STR_LIT>' : polarization_mode , <EOL> '<STR_LIT>' : frequency , <EOL> '<STR_LIT>' : prt , <EOL> } <EOL> nyquist_velocity = filemetadata ( '<STR_LIT>' ) <EOL> nyquist_velocity [ '<STR_LIT:data>' ] = ufile . get_nyquists ( ) <EOL> if nyquist_velocity [ '<STR_LIT:data>' ] is not None : <EOL> instrument_parameters [ '<STR_LIT>' ] = nyquist_velocity <EOL> return instrument_parameters </s>

<s> """<STR_LIT>""" <EOL> import pyart <EOL> radar = pyart . io . read_rsl ( '<STR_LIT>' ) <EOL> time_slice = slice ( None , <NUM_LIT> , <NUM_LIT> ) <EOL> range_slice = slice ( None , None , <NUM_LIT:12> ) <EOL> sweep_slice = slice ( None , <NUM_LIT:1> ) <EOL> rf_field = radar . fields [ '<STR_LIT>' ] <EOL> rf_data = rf_field [ '<STR_LIT:data>' ] <EOL> rf_field [ '<STR_LIT:data>' ] = rf_data [ time_slice , range_slice ] <EOL> radar . fields = { '<STR_LIT>' : rf_field } <EOL> radar . nsweeps = <NUM_LIT:1> <EOL> radar . nray = <NUM_LIT> <EOL> radar . ngates = <NUM_LIT> <EOL> radar . range [ '<STR_LIT:data>' ] = radar . range [ '<STR_LIT:data>' ] [ range_slice ] <EOL> radar . time [ '<STR_LIT:data>' ] = radar . time [ '<STR_LIT:data>' ] [ time_slice ] <EOL> radar . azimuth [ '<STR_LIT:data>' ] = radar . azimuth [ '<STR_LIT:data>' ] [ time_slice ] <EOL> radar . elevation [ '<STR_LIT:data>' ] = radar . elevation [ '<STR_LIT:data>' ] [ time_slice ] <EOL> radar . instrument_parameters [ '<STR_LIT>' ] [ '<STR_LIT:data>' ] = radar . instrument_parameters [ '<STR_LIT>' ] [ '<STR_LIT:data>' ] [ time_slice ] <EOL> radar . instrument_parameters [ '<STR_LIT>' ] [ '<STR_LIT:data>' ] = radar . instrument_parameters [ '<STR_LIT>' ] [ '<STR_LIT:data>' ] [ time_slice ] <EOL> radar . instrument_parameters [ '<STR_LIT>' ] [ '<STR_LIT:data>' ] = radar . instrument_parameters [ '<STR_LIT>' ] [ '<STR_LIT:data>' ] [ time_slice ] <EOL> radar . sweep_number [ '<STR_LIT:data>' ] = radar . sweep_number [ '<STR_LIT:data>' ] [ sweep_slice ] <EOL> radar . fixed_angle [ '<STR_LIT:data>' ] = radar . fixed_angle [ '<STR_LIT:data>' ] [ sweep_slice ] <EOL> radar . sweep_start_ray_index [ '<STR_LIT:data>' ] = radar . sweep_start_ray_index [ '<STR_LIT:data>' ] [ sweep_slice ] <EOL> radar . sweep_end_ray_index [ '<STR_LIT:data>' ] = radar . sweep_end_ray_index [ '<STR_LIT:data>' ] [ sweep_slice ] <EOL> radar . sweep_end_ray_index [ '<STR_LIT:data>' ] [ <NUM_LIT:0> ] = <NUM_LIT> <EOL> radar . sweep_mode [ '<STR_LIT:data>' ] = radar . sweep_mode [ '<STR_LIT:data>' ] [ sweep_slice ] <EOL> radar . sweep_number [ '<STR_LIT:data>' ] = radar . sweep_number [ '<STR_LIT:data>' ] [ sweep_slice ] <EOL> radar . instrument_parameters [ '<STR_LIT>' ] [ '<STR_LIT:data>' ] = radar . instrument_parameters [ '<STR_LIT>' ] [ '<STR_LIT:data>' ] [ sweep_slice ] <EOL> radar . metadata = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT:version>' : '<STR_LIT>' , <EOL> '<STR_LIT:title>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : ( '<STR_LIT>' <EOL> '<STR_LIT>' ) , <EOL> '<STR_LIT>' : '<STR_LIT:none>' , <EOL> '<STR_LIT:source>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT:none>' , <EOL> '<STR_LIT>' : '<STR_LIT>' } <EOL> pyart . io . write_cfradial ( '<STR_LIT>' , radar ) </s>

<s> """<STR_LIT>""" <EOL> from __future__ import print_function <EOL> import copy <EOL> import numpy as np <EOL> from netCDF4 import num2date , date2num <EOL> from . import datetime_utils <EOL> def is_vpt ( radar , offset = <NUM_LIT:0.5> ) : <EOL> """<STR_LIT>""" <EOL> elev = radar . elevation [ '<STR_LIT:data>' ] <EOL> return np . all ( ( elev < <NUM_LIT> + offset ) & ( elev > <NUM_LIT> - offset ) ) <EOL> def to_vpt ( radar , single_scan = True ) : <EOL> """<STR_LIT>""" <EOL> if single_scan : <EOL> nsweeps = <NUM_LIT:1> <EOL> radar . azimuth [ '<STR_LIT:data>' ] [ : ] = <NUM_LIT:0.0> <EOL> seri = np . array ( [ radar . nrays - <NUM_LIT:1> ] , dtype = '<STR_LIT>' ) <EOL> radar . sweep_end_ray_index [ '<STR_LIT:data>' ] = seri <EOL> else : <EOL> nsweeps = radar . nrays <EOL> radar . sweep_end_ray_index [ '<STR_LIT:data>' ] = np . arange ( nsweeps , dtype = '<STR_LIT>' ) <EOL> radar . scan_type = '<STR_LIT>' <EOL> radar . nsweeps = nsweeps <EOL> radar . target_scan_rate = None <EOL> radar . elevation [ '<STR_LIT:data>' ] [ : ] = <NUM_LIT> <EOL> radar . sweep_number [ '<STR_LIT:data>' ] = np . arange ( nsweeps , dtype = '<STR_LIT>' ) <EOL> radar . sweep_mode [ '<STR_LIT:data>' ] = np . array ( [ '<STR_LIT>' ] * nsweeps ) <EOL> radar . fixed_angle [ '<STR_LIT:data>' ] = np . ones ( nsweeps , dtype = '<STR_LIT>' ) * <NUM_LIT> <EOL> radar . sweep_start_ray_index [ '<STR_LIT:data>' ] = np . arange ( nsweeps , dtype = '<STR_LIT>' ) <EOL> if radar . instrument_parameters is not None : <EOL> for key in [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] : <EOL> if key in radar . instrument_parameters : <EOL> ip_dic = radar . instrument_parameters [ key ] <EOL> ip_dic [ '<STR_LIT:data>' ] = np . array ( [ ip_dic [ '<STR_LIT:data>' ] [ <NUM_LIT:0> ] ] * nsweeps ) <EOL> return <EOL> def join_radar ( radar1 , radar2 ) : <EOL> """<STR_LIT>""" <EOL> new_radar = copy . deepcopy ( radar1 ) <EOL> new_radar . azimuth [ '<STR_LIT:data>' ] = np . append ( radar1 . azimuth [ '<STR_LIT:data>' ] , <EOL> radar2 . azimuth [ '<STR_LIT:data>' ] ) <EOL> new_radar . elevation [ '<STR_LIT:data>' ] = np . append ( radar1 . elevation [ '<STR_LIT:data>' ] , <EOL> radar2 . elevation [ '<STR_LIT:data>' ] ) <EOL> if len ( radar1 . range [ '<STR_LIT:data>' ] ) >= len ( radar2 . range [ '<STR_LIT:data>' ] ) : <EOL> new_radar . range [ '<STR_LIT:data>' ] = radar1 . range [ '<STR_LIT:data>' ] <EOL> else : <EOL> new_radar . range [ '<STR_LIT:data>' ] = radar2 . range [ '<STR_LIT:data>' ] <EOL> estring = "<STR_LIT>" <EOL> r1dt = num2date ( radar1 . time [ '<STR_LIT:data>' ] , radar1 . time [ '<STR_LIT>' ] ) <EOL> r2dt = num2date ( radar2 . time [ '<STR_LIT:data>' ] , radar2 . time [ '<STR_LIT>' ] ) <EOL> r1num = datetime_utils . datetimes_from_radar ( radar1 , epoch = True ) <EOL> r2num = datetime_utils . datetimes_from_radar ( radar2 , epoch = True ) <EOL> new_radar . time [ '<STR_LIT:data>' ] = np . append ( r1num , r2num ) <EOL> new_radar . time [ '<STR_LIT>' ] = datetime_utils . EPOCH_UNITS <EOL> for var in new_radar . fields . keys ( ) : <EOL> sh1 = radar1 . fields [ var ] [ '<STR_LIT:data>' ] . shape <EOL> sh2 = radar2 . fields [ var ] [ '<STR_LIT:data>' ] . shape <EOL> new_field = np . ma . zeros ( [ sh1 [ <NUM_LIT:0> ] + sh2 [ <NUM_LIT:0> ] , <EOL> max ( [ sh1 [ <NUM_LIT:1> ] , sh2 [ <NUM_LIT:1> ] ] ) ] ) - <NUM_LIT> <EOL> new_field [ <NUM_LIT:0> : sh1 [ <NUM_LIT:0> ] , <NUM_LIT:0> : sh1 [ <NUM_LIT:1> ] ] = radar1 . fields [ var ] [ '<STR_LIT:data>' ] <EOL> new_field [ sh1 [ <NUM_LIT:0> ] : , <NUM_LIT:0> : sh2 [ <NUM_LIT:1> ] ] = radar2 . fields [ var ] [ '<STR_LIT:data>' ] <EOL> new_radar . fields [ var ] [ '<STR_LIT:data>' ] = new_field <EOL> if ( len ( radar1 . latitude [ '<STR_LIT:data>' ] ) == <NUM_LIT:1> & <EOL> len ( radar2 . latitude [ '<STR_LIT:data>' ] ) == <NUM_LIT:1> & <EOL> len ( radar1 . longitude [ '<STR_LIT:data>' ] ) == <NUM_LIT:1> & <EOL> len ( radar2 . longitude [ '<STR_LIT:data>' ] ) == <NUM_LIT:1> & <EOL> len ( radar1 . altitude [ '<STR_LIT:data>' ] ) == <NUM_LIT:1> & <EOL> len ( radar2 . altitude [ '<STR_LIT:data>' ] ) == <NUM_LIT:1> ) : <EOL> lat1 = float ( radar1 . latitude [ '<STR_LIT:data>' ] ) <EOL> lon1 = float ( radar1 . longitude [ '<STR_LIT:data>' ] ) <EOL> alt1 = float ( radar1 . altitude [ '<STR_LIT:data>' ] ) <EOL> lat2 = float ( radar2 . latitude [ '<STR_LIT:data>' ] ) <EOL> lon2 = float ( radar2 . longitude [ '<STR_LIT:data>' ] ) <EOL> alt2 = float ( radar2 . altitude [ '<STR_LIT:data>' ] ) <EOL> if ( lat1 != lat2 ) or ( lon1 != lon2 ) or ( alt1 != alt2 ) : <EOL> ones1 = np . ones ( len ( radar1 . time [ '<STR_LIT:data>' ] ) , dtype = '<STR_LIT>' ) <EOL> ones2 = np . ones ( len ( radar2 . time [ '<STR_LIT:data>' ] ) , dtype = '<STR_LIT>' ) <EOL> new_radar . latitude [ '<STR_LIT:data>' ] = np . append ( ones1 * lat1 , ones2 * lat2 ) <EOL> new_radar . longitude [ '<STR_LIT:data>' ] = np . append ( ones1 * lon1 , ones2 * lon2 ) <EOL> new_radar . latitude [ '<STR_LIT:data>' ] = np . append ( ones1 * alt1 , ones2 * alt2 ) <EOL> else : <EOL> new_radar . latitude [ '<STR_LIT:data>' ] = radar1 . latitude [ '<STR_LIT:data>' ] <EOL> new_radar . longitude [ '<STR_LIT:data>' ] = radar1 . longitude [ '<STR_LIT:data>' ] <EOL> new_radar . altitude [ '<STR_LIT:data>' ] = radar1 . altitude [ '<STR_LIT:data>' ] <EOL> else : <EOL> new_radar . latitude [ '<STR_LIT:data>' ] = np . append ( radar1 . latitude [ '<STR_LIT:data>' ] , <EOL> radar2 . latitude [ '<STR_LIT:data>' ] ) <EOL> new_radar . longitude [ '<STR_LIT:data>' ] = np . append ( radar1 . longitude [ '<STR_LIT:data>' ] , <EOL> radar2 . longitude [ '<STR_LIT:data>' ] ) <EOL> new_radar . altitude [ '<STR_LIT:data>' ] = np . append ( radar1 . altitude [ '<STR_LIT:data>' ] , <EOL> radar2 . altitude [ '<STR_LIT:data>' ] ) <EOL> return new_radar </s>

<s> """<STR_LIT>""" <EOL> reboot_policy = '<STR_LIT>' <EOL> execution_order = '<STR_LIT>' <EOL> retry_on_status = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> max_retries = <NUM_LIT:3> <EOL> device = '<STR_LIT>' <EOL> device_config = dict ( <EOL> ) <EOL> instrumentation = [ <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ] <EOL> result_processors = [ <EOL> '<STR_LIT:status>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ] <EOL> logging = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : True , <EOL> } </s>

<s> import logging <EOL> from wlauto import LinuxDevice , Parameter <EOL> from wlauto . common . gem5 . device import BaseGem5Device <EOL> from wlauto . utils import types <EOL> class Gem5LinuxDevice ( BaseGem5Device , LinuxDevice ) : <EOL> """<STR_LIT>""" <EOL> name = '<STR_LIT>' <EOL> platform = '<STR_LIT>' <EOL> parameters = [ <EOL> Parameter ( '<STR_LIT>' , default = [ ] , override = True ) , <EOL> Parameter ( '<STR_LIT>' , default = [ ] , override = True ) , <EOL> Parameter ( '<STR_LIT:host>' , default = '<STR_LIT:localhost>' , override = True , <EOL> description = '<STR_LIT>' ) , <EOL> Parameter ( '<STR_LIT>' , kind = types . list_of_strs , <EOL> default = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] , <EOL> mandatory = False ) , <EOL> Parameter ( '<STR_LIT>' , kind = types . list_of_strs , <EOL> default = [ '<STR_LIT>' ] , mandatory = False ) , <EOL> ] <EOL> def __init__ ( self , ** kwargs ) : <EOL> self . logger = logging . getLogger ( '<STR_LIT>' ) <EOL> LinuxDevice . __init__ ( self , ** kwargs ) <EOL> BaseGem5Device . __init__ ( self ) <EOL> def login_to_device ( self ) : <EOL> prompt = self . login_prompt + [ self . sckt . UNIQUE_PROMPT ] <EOL> i = self . sckt . expect ( prompt , timeout = <NUM_LIT:10> ) <EOL> if i < len ( prompt ) - <NUM_LIT:1> : <EOL> self . sckt . sendline ( "<STR_LIT:{}>" . format ( self . username ) ) <EOL> password_prompt = self . login_password_prompt + [ r'<STR_LIT>' , self . sckt . UNIQUE_PROMPT ] <EOL> j = self . sckt . expect ( password_prompt , timeout = self . delay ) <EOL> if j < len ( password_prompt ) - <NUM_LIT:2> : <EOL> self . sckt . sendline ( "<STR_LIT:{}>" . format ( self . password ) ) <EOL> self . sckt . expect ( [ r'<STR_LIT>' , self . sckt . UNIQUE_PROMPT ] , timeout = self . delay ) <EOL> def capture_screen ( self , filepath ) : <EOL> if BaseGem5Device . capture_screen ( self , filepath ) : <EOL> return <EOL> self . logger . warning ( "<STR_LIT>" ) <EOL> LinuxDevice . capture_screen ( self , filepath ) <EOL> def initialize ( self , context ) : <EOL> self . resize_shell ( ) <EOL> self . deploy_m5 ( context , force = False ) </s>

<s> """<STR_LIT>""" <EOL> NAME = '<STR_LIT>' <EOL> DESCRIPTION = '<STR_LIT>' <EOL> VERSION = '<STR_LIT>' </s>

<s> import os <EOL> import sqlite3 <EOL> import json <EOL> import uuid <EOL> from datetime import datetime , timedelta <EOL> from contextlib import contextmanager <EOL> from wlauto import ResultProcessor , settings , Parameter <EOL> from wlauto . exceptions import ResultProcessorError <EOL> from wlauto . utils . types import boolean <EOL> SCHEMA_VERSION = '<STR_LIT>' <EOL> SCHEMA = [ <EOL> '''<STR_LIT>''' , <EOL> '''<STR_LIT>''' , <EOL> '''<STR_LIT>''' , <EOL> '''<STR_LIT>''' , <EOL> '''<STR_LIT>''' , <EOL> '''<STR_LIT>''' . format ( SCHEMA_VERSION ) , <EOL> ] <EOL> sqlite3 . register_adapter ( datetime , lambda x : x . isoformat ( ) ) <EOL> sqlite3 . register_adapter ( timedelta , lambda x : x . total_seconds ( ) ) <EOL> sqlite3 . register_adapter ( uuid . UUID , str ) <EOL> class SqliteResultProcessor ( ResultProcessor ) : <EOL> name = '<STR_LIT>' <EOL> description = """<STR_LIT>""" <EOL> name = '<STR_LIT>' <EOL> parameters = [ <EOL> Parameter ( '<STR_LIT>' , default = None , <EOL> global_alias = '<STR_LIT>' , <EOL> description = """<STR_LIT>""" ) , <EOL> Parameter ( '<STR_LIT>' , kind = boolean , default = False , <EOL> global_alias = '<STR_LIT>' , <EOL> description = """<STR_LIT>""" ) , <EOL> ] <EOL> def initialize ( self , context ) : <EOL> self . _last_spec = None <EOL> self . _run_oid = None <EOL> self . _spec_oid = None <EOL> if not os . path . exists ( self . database ) : <EOL> self . _initdb ( ) <EOL> elif self . overwrite : <EOL> os . remove ( self . database ) <EOL> self . _initdb ( ) <EOL> else : <EOL> self . _validate_schema_version ( ) <EOL> self . _update_run ( context . run_info . uuid ) <EOL> def process_iteration_result ( self , result , context ) : <EOL> if self . _last_spec != context . spec : <EOL> self . _update_spec ( context . spec ) <EOL> metrics = [ ( self . _spec_oid , context . current_iteration , m . name , str ( m . value ) , m . units , int ( m . lower_is_better ) ) <EOL> for m in result . metrics ] <EOL> with self . _open_connecton ( ) as conn : <EOL> conn . executemany ( '<STR_LIT>' , metrics ) <EOL> def process_run_result ( self , result , context ) : <EOL> info = context . run_info <EOL> with self . _open_connecton ( ) as conn : <EOL> conn . execute ( '''<STR_LIT>''' , ( info . start_time , info . end_time , info . duration , self . _run_oid ) ) <EOL> def validate ( self ) : <EOL> if not self . database : <EOL> self . database = os . path . join ( settings . output_directory , '<STR_LIT>' ) <EOL> self . database = os . path . expandvars ( os . path . expanduser ( self . database ) ) <EOL> def _initdb ( self ) : <EOL> with self . _open_connecton ( ) as conn : <EOL> for command in SCHEMA : <EOL> conn . execute ( command ) <EOL> def _validate_schema_version ( self ) : <EOL> with self . _open_connecton ( ) as conn : <EOL> try : <EOL> c = conn . execute ( '<STR_LIT>' ) <EOL> found_version = c . fetchone ( ) [ <NUM_LIT:0> ] <EOL> except sqlite3 . OperationalError : <EOL> message = '<STR_LIT>' . format ( self . database ) <EOL> raise ResultProcessorError ( message ) <EOL> if found_version != SCHEMA_VERSION : <EOL> message = '<STR_LIT>' <EOL> raise ResultProcessorError ( message . format ( self . database , found_version , SCHEMA_VERSION ) ) <EOL> def _update_run ( self , run_uuid ) : <EOL> with self . _open_connecton ( ) as conn : <EOL> conn . execute ( '<STR_LIT>' , ( run_uuid , ) ) <EOL> conn . commit ( ) <EOL> c = conn . execute ( '<STR_LIT>' , ( run_uuid , ) ) <EOL> self . _run_oid = c . fetchone ( ) [ <NUM_LIT:0> ] <EOL> def _update_spec ( self , spec ) : <EOL> self . _last_spec = spec <EOL> spec_tuple = ( spec . id , self . _run_oid , spec . number_of_iterations , spec . label , spec . workload_name , <EOL> json . dumps ( spec . boot_parameters ) , json . dumps ( spec . runtime_parameters ) , <EOL> json . dumps ( spec . workload_parameters ) ) <EOL> with self . _open_connecton ( ) as conn : <EOL> conn . execute ( '<STR_LIT>' , spec_tuple ) <EOL> conn . commit ( ) <EOL> c = conn . execute ( '<STR_LIT>' , ( self . _run_oid , spec . id ) ) <EOL> self . _spec_oid = c . fetchone ( ) [ <NUM_LIT:0> ] <EOL> @ contextmanager <EOL> def _open_connecton ( self ) : <EOL> conn = sqlite3 . connect ( self . database ) <EOL> try : <EOL> yield conn <EOL> finally : <EOL> conn . commit ( ) </s>

<s> """<STR_LIT>""" <EOL> import telnetlib <EOL> import socket <EOL> import re <EOL> import time <EOL> import logging <EOL> logger = logging . getLogger ( '<STR_LIT>' ) <EOL> class NetioError ( Exception ) : <EOL> pass <EOL> class KshellConnection ( object ) : <EOL> response_regex = re . compile ( r'<STR_LIT>' ) <EOL> delay = <NUM_LIT:0.5> <EOL> def __init__ ( self , host = '<STR_LIT>' , port = <NUM_LIT> , timeout = None ) : <EOL> """<STR_LIT>""" <EOL> self . host = host <EOL> self . port = port <EOL> self . conn = telnetlib . Telnet ( host , port , timeout ) <EOL> time . sleep ( self . delay ) <EOL> output = self . conn . read_very_eager ( ) <EOL> if '<STR_LIT>' not in output : <EOL> raise NetioError ( '<STR_LIT>' . format ( output ) ) <EOL> def login ( self , user , password ) : <EOL> code , out = self . send_command ( '<STR_LIT>' . format ( user , password ) ) <EOL> if code != <NUM_LIT> : <EOL> raise NetioError ( '<STR_LIT>' . format ( code , out ) ) <EOL> def enable_port ( self , port ) : <EOL> """<STR_LIT>""" <EOL> self . set_port ( port , <NUM_LIT:1> ) <EOL> def disable_port ( self , port ) : <EOL> """<STR_LIT>""" <EOL> self . set_port ( port , <NUM_LIT:0> ) <EOL> def set_port ( self , port , value ) : <EOL> code , out = self . send_command ( '<STR_LIT>' . format ( port , value ) ) <EOL> if code != <NUM_LIT> : <EOL> raise NetioError ( '<STR_LIT>' . format ( value , port , code , out ) ) <EOL> def send_command ( self , command ) : <EOL> try : <EOL> if command . startswith ( '<STR_LIT>' ) : <EOL> parts = command . split ( ) <EOL> parts [ <NUM_LIT:2> ] = '<STR_LIT:*>' * len ( parts [ <NUM_LIT:2> ] ) <EOL> logger . debug ( '<STR_LIT:U+0020>' . join ( parts ) ) <EOL> else : <EOL> logger . debug ( command ) <EOL> self . conn . write ( '<STR_LIT>' . format ( command ) ) <EOL> time . sleep ( self . delay ) <EOL> out = self . conn . read_very_eager ( ) <EOL> match = self . response_regex . search ( out ) <EOL> if not match : <EOL> raise NetioError ( '<STR_LIT>' . format ( out . strip ( ) ) ) <EOL> logger . debug ( '<STR_LIT>' . format ( match . group ( <NUM_LIT:1> ) , match . group ( <NUM_LIT:2> ) ) ) <EOL> return int ( match . group ( <NUM_LIT:1> ) ) , match . group ( <NUM_LIT:2> ) <EOL> except socket . error as err : <EOL> try : <EOL> time . sleep ( self . delay ) <EOL> out = self . conn . read_very_eager ( ) <EOL> if out . startswith ( '<STR_LIT>' ) : <EOL> raise NetioError ( '<STR_LIT>' ) <EOL> except EOFError : <EOL> pass <EOL> raise err <EOL> def close ( self ) : <EOL> self . conn . close ( ) </s>

<s> import os <EOL> import time <EOL> from wlauto import settings , Workload , Executable , Parameter <EOL> from wlauto . exceptions import ConfigError , WorkloadError <EOL> from wlauto . utils . types import boolean <EOL> TXT_RESULT_NAME = '<STR_LIT>' <EOL> RESULT_INTERPRETATION = { <EOL> '<STR_LIT:T>' : '<STR_LIT>' , <EOL> '<STR_LIT:P>' : '<STR_LIT>' , <EOL> '<STR_LIT:C>' : '<STR_LIT>' , <EOL> } <EOL> class Cyclictest ( Workload ) : <EOL> name = '<STR_LIT>' <EOL> description = """<STR_LIT>""" <EOL> parameters = [ <EOL> Parameter ( '<STR_LIT>' , allowed_values = [ '<STR_LIT>' , '<STR_LIT>' ] , default = '<STR_LIT>' , <EOL> description = ( '<STR_LIT>' ) ) , <EOL> Parameter ( '<STR_LIT>' , kind = int , default = <NUM_LIT:30> , <EOL> description = ( '<STR_LIT>' ) ) , <EOL> Parameter ( '<STR_LIT>' , kind = boolean , default = True , <EOL> description = ( '<STR_LIT>' ) ) , <EOL> Parameter ( '<STR_LIT>' , kind = int , default = <NUM_LIT:8> , <EOL> description = ( '<STR_LIT>' ) ) , <EOL> Parameter ( '<STR_LIT>' , kind = int , default = <NUM_LIT> , <EOL> description = ( '<STR_LIT>' ) ) , <EOL> Parameter ( '<STR_LIT>' , kind = str , default = "<STR_LIT>" , <EOL> description = ( '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) ) , <EOL> Parameter ( '<STR_LIT>' , kind = boolean , default = True , <EOL> description = ( '<STR_LIT>' ) ) , <EOL> Parameter ( '<STR_LIT>' , kind = boolean , default = True , <EOL> description = ( '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) ) , <EOL> ] <EOL> def setup ( self , context ) : <EOL> self . cyclictest_on_device = '<STR_LIT>' <EOL> self . cyclictest_result = os . path . join ( self . device . working_directory , TXT_RESULT_NAME ) <EOL> self . cyclictest_command = '<STR_LIT>' <EOL> self . device_binary = None <EOL> if not self . device . is_rooted : <EOL> raise WorkloadError ( "<STR_LIT>" ) <EOL> host_binary = context . resolver . get ( Executable ( self , self . device . abi , '<STR_LIT>' ) ) <EOL> self . device_binary = self . device . install ( host_binary ) <EOL> self . cyclictest_command = self . cyclictest_command . format ( self . device_binary , <EOL> <NUM_LIT:0> if self . clock == '<STR_LIT>' else <NUM_LIT:1> , <EOL> self . duration , <EOL> self . thread , <EOL> self . latency , <EOL> "<STR_LIT>" if self . quiet else "<STR_LIT>" , <EOL> self . extra_parameters , <EOL> self . cyclictest_result ) <EOL> if self . clear_file_cache : <EOL> self . device . execute ( '<STR_LIT>' ) <EOL> self . device . set_sysfile_value ( '<STR_LIT>' , <NUM_LIT:3> ) <EOL> if self . device . platform == '<STR_LIT>' : <EOL> if self . screen_off and self . device . is_screen_on : <EOL> self . device . execute ( '<STR_LIT>' ) <EOL> def run ( self , context ) : <EOL> self . device . execute ( self . cyclictest_command , self . duration * <NUM_LIT:2> , as_root = True ) <EOL> def update_result ( self , context ) : <EOL> self . device . pull_file ( self . cyclictest_result , context . output_directory ) <EOL> with open ( os . path . join ( context . output_directory , TXT_RESULT_NAME ) ) as f : <EOL> for line in f : <EOL> if line . find ( '<STR_LIT>' ) is not - <NUM_LIT:1> : <EOL> ( key , sperator , remaing ) = line . partition ( '<STR_LIT>' ) <EOL> index = key . find ( '<STR_LIT:T>' ) <EOL> key = key . replace ( key [ index ] , RESULT_INTERPRETATION [ '<STR_LIT:T>' ] ) <EOL> index = key . find ( '<STR_LIT:P>' ) <EOL> key = key . replace ( key [ index ] , RESULT_INTERPRETATION [ '<STR_LIT:P>' ] ) <EOL> index = sperator . find ( '<STR_LIT:C>' ) <EOL> sperator = sperator . replace ( sperator [ index ] , RESULT_INTERPRETATION [ '<STR_LIT:C>' ] ) <EOL> metrics = ( sperator + remaing ) . split ( ) <EOL> for i in range ( <NUM_LIT:0> , len ( metrics ) , <NUM_LIT:2> ) : <EOL> full_key = key + '<STR_LIT:U+0020>' + metrics [ i ] [ : - <NUM_LIT:1> ] <EOL> value = int ( metrics [ i + <NUM_LIT:1> ] ) <EOL> context . result . add_metric ( full_key , value , '<STR_LIT>' ) <EOL> def teardown ( self , context ) : <EOL> if self . device . platform == '<STR_LIT>' : <EOL> if self . screen_off : <EOL> self . device . ensure_screen_is_on ( ) <EOL> self . device . execute ( '<STR_LIT>' . format ( self . cyclictest_result ) ) </s>

<s> import os <EOL> import re <EOL> from collections import defaultdict <EOL> from wlauto import Workload , Parameter , File <EOL> from wlauto . utils . types import caseless_string <EOL> from wlauto . exceptions import WorkloadError <EOL> class Recentfling ( Workload ) : <EOL> name = '<STR_LIT>' <EOL> description = """<STR_LIT>""" <EOL> supported_platforms = [ '<STR_LIT>' ] <EOL> parameters = [ <EOL> Parameter ( '<STR_LIT>' , kind = int , default = <NUM_LIT:3> , <EOL> description = "<STR_LIT>" ) , <EOL> ] <EOL> def initialise ( self , context ) : <EOL> if context . device . get_sdk_version ( ) < <NUM_LIT> : <EOL> raise WorkloadError ( "<STR_LIT>" ) <EOL> def setup ( self , context ) : <EOL> self . defs_host = context . resolver . get ( File ( self , "<STR_LIT>" ) ) <EOL> self . recentfling_host = context . resolver . get ( File ( self , "<STR_LIT>" ) ) <EOL> self . device . push_file ( self . recentfling_host , self . device . working_directory ) <EOL> self . device . push_file ( self . defs_host , self . device . working_directory ) <EOL> self . _kill_recentfling ( ) <EOL> self . device . ensure_screen_is_on ( ) <EOL> def run ( self , context ) : <EOL> cmd = "<STR_LIT>" <EOL> cmd = cmd . format ( self . loops , dir = self . device . working_directory ) <EOL> try : <EOL> self . output = self . device . execute ( cmd , timeout = <NUM_LIT> ) <EOL> except KeyboardInterrupt : <EOL> self . _kill_recentfling ( ) <EOL> raise <EOL> def update_result ( self , context ) : <EOL> group_names = [ "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ] <EOL> count = <NUM_LIT:0> <EOL> for line in self . output . strip ( ) . splitlines ( ) : <EOL> p = re . compile ( "<STR_LIT>" ) <EOL> match = p . search ( line ) <EOL> if match : <EOL> count += <NUM_LIT:1> <EOL> if line . startswith ( "<STR_LIT>" ) : <EOL> group_names = [ "<STR_LIT>" + g for g in group_names ] <EOL> count = <NUM_LIT:0> <EOL> for metric in zip ( group_names , match . groups ( ) ) : <EOL> context . result . add_metric ( metric [ <NUM_LIT:0> ] , <EOL> metric [ <NUM_LIT:1> ] , <EOL> None , <EOL> classifiers = { "<STR_LIT>" : count or "<STR_LIT>" } ) <EOL> def teardown ( self , context ) : <EOL> self . device . delete_file ( self . device . path . join ( self . device . working_directory , <EOL> "<STR_LIT>" ) ) <EOL> self . device . delete_file ( self . device . path . join ( self . device . working_directory , <EOL> "<STR_LIT>" ) ) <EOL> def _kill_recentfling ( self ) : <EOL> pid = self . device . execute ( '<STR_LIT>' . format ( self . device . working_directory ) ) <EOL> if pid : <EOL> self . device . kill ( pid . strip ( ) , signal = '<STR_LIT>' ) </s>

<s> """<STR_LIT>""" <EOL> import sys <EOL> from time import time <EOL> class HtrunLogger ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , prn_lock , name ) : <EOL> self . __prn_lock = prn_lock <EOL> self . __name = name <EOL> def __prn_func ( self , text , nl = True ) : <EOL> """<STR_LIT>""" <EOL> with self . __prn_lock : <EOL> if nl and not text . endswith ( '<STR_LIT:\n>' ) : <EOL> text += '<STR_LIT:\n>' <EOL> sys . stdout . write ( text ) <EOL> sys . stdout . flush ( ) <EOL> def __prn_log_human ( self , level , text , timestamp = None ) : <EOL> if not timestamp : <EOL> timestamp = time ( ) <EOL> timestamp_str = strftime ( "<STR_LIT>" , gmtime ( timestamp ) ) <EOL> frac , whole = modf ( timestamp ) <EOL> s = "<STR_LIT>" % ( timestamp_str , frac , self . __name , level , text ) <EOL> self . __prn_func ( s , nl = True ) <EOL> def __prn_log ( self , level , text , timestamp = None ) : <EOL> if not timestamp : <EOL> timestamp = time ( ) <EOL> s = "<STR_LIT>" % ( timestamp , self . __name , level , text ) <EOL> self . __prn_func ( s , nl = True ) <EOL> def prn_dbg ( self , text , timestamp = None ) : <EOL> self . __prn_log ( '<STR_LIT>' , text , timestamp ) <EOL> def prn_wrn ( self , text , timestamp = None ) : <EOL> self . __prn_log ( '<STR_LIT>' , text , timestamp ) <EOL> def prn_err ( self , text , timestamp = None ) : <EOL> self . __prn_log ( '<STR_LIT>' , text , timestamp ) <EOL> def prn_inf ( self , text , timestamp = None ) : <EOL> self . __prn_log ( '<STR_LIT>' , text , timestamp ) <EOL> def prn_txt ( self , text , timestamp = None ) : <EOL> self . __prn_log ( '<STR_LIT>' , text , timestamp ) <EOL> def prn_txd ( self , text , timestamp = None ) : <EOL> self . __prn_log ( '<STR_LIT>' , text , timestamp ) <EOL> def prn_rxd ( self , text , timestamp = None ) : <EOL> self . __prn_log ( '<STR_LIT>' , text , timestamp ) </s>

<s> """<STR_LIT>""" <EOL> import unittest <EOL> from mbed_host_tests import is_host_test <EOL> from mbed_host_tests import get_host_test <EOL> from mbed_host_tests import get_plugin_caps <EOL> from mbed_host_tests import get_host_test_list <EOL> class BasicHostTestsTestCase ( unittest . TestCase ) : <EOL> def setUp ( self ) : <EOL> pass <EOL> def tearDown ( self ) : <EOL> pass <EOL> def test_basic_get_host_test ( self ) : <EOL> self . assertNotEqual ( None , get_host_test ( '<STR_LIT:default>' ) ) <EOL> self . assertNotEqual ( None , get_host_test ( '<STR_LIT>' ) ) <EOL> def test_basic_is_host_test ( self ) : <EOL> self . assertFalse ( is_host_test ( '<STR_LIT>' ) ) <EOL> self . assertFalse ( is_host_test ( None ) ) <EOL> self . assertTrue ( is_host_test ( '<STR_LIT:default>' ) ) <EOL> self . assertTrue ( is_host_test ( '<STR_LIT>' ) ) <EOL> def test_get_host_test_list ( self ) : <EOL> d = get_host_test_list ( ) <EOL> self . assertIs ( type ( d ) , dict ) <EOL> self . assertIn ( '<STR_LIT:default>' , d ) <EOL> self . assertIn ( '<STR_LIT>' , d ) <EOL> def test_get_plugin_caps ( self ) : <EOL> d = get_plugin_caps ( ) <EOL> self . assertIs ( type ( d ) , dict ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> unittest . main ( ) </s>

<s> import sys <EOL> import os <EOL> import subprocess <EOL> import tempfile <EOL> import shutil <EOL> import argparse <EOL> def Parser ( ) : <EOL> the_parser = argparse . ArgumentParser ( <EOL> description = "<STR_LIT>" ) <EOL> the_parser . add_argument ( <EOL> '<STR_LIT>' , action = "<STR_LIT:store>" , type = str , help = "<STR_LIT>" ) <EOL> the_parser . add_argument ( <EOL> '<STR_LIT>' , dest = "<STR_LIT>" , action = "<STR_LIT:store>" , type = str , help = "<STR_LIT>" ) <EOL> the_parser . add_argument ( '<STR_LIT>' , action = "<STR_LIT:store>" , type = str , <EOL> help = "<STR_LIT>" ) <EOL> the_parser . add_argument ( '<STR_LIT>' , dest = "<STR_LIT>" , action = "<STR_LIT:store>" , <EOL> type = str , help = "<STR_LIT>" ) <EOL> the_parser . add_argument ( <EOL> '<STR_LIT>' , dest = "<STR_LIT>" , action = "<STR_LIT:store>" , type = str , help = "<STR_LIT>" ) <EOL> the_parser . add_argument ( <EOL> '<STR_LIT>' , action = "<STR_LIT:store>" , type = str , help = "<STR_LIT>" ) <EOL> the_parser . add_argument ( <EOL> '<STR_LIT>' , dest = "<STR_LIT>" , action = "<STR_LIT:store>" , type = str , help = "<STR_LIT>" ) <EOL> the_parser . add_argument ( '<STR_LIT>' , dest = "<STR_LIT>" , <EOL> action = "<STR_LIT:store>" , type = str , help = "<STR_LIT>" ) <EOL> the_parser . add_argument ( <EOL> '<STR_LIT>' , action = "<STR_LIT:store>" , type = str , help = "<STR_LIT>" ) <EOL> the_parser . add_argument ( '<STR_LIT>' , action = "<STR_LIT:store>" , <EOL> type = str , help = "<STR_LIT>" ) <EOL> the_parser . add_argument ( '<STR_LIT>' , dest = "<STR_LIT>" , <EOL> action = "<STR_LIT:store>" , type = str , help = "<STR_LIT>" ) <EOL> args = the_parser . parse_args ( ) <EOL> return args <EOL> def stop_err ( msg ) : <EOL> sys . stderr . write ( '<STR_LIT>' % msg ) <EOL> sys . exit ( ) <EOL> def bowtieCommandLiner ( alignment_method = "<STR_LIT>" , v_mis = "<STR_LIT:1>" , out_type = "<STR_LIT>" , <EOL> aligned = "<STR_LIT:None>" , unaligned = "<STR_LIT:None>" , input_format = "<STR_LIT>" , input = "<STR_LIT:path>" , <EOL> index = "<STR_LIT:path>" , output = "<STR_LIT:path>" , pslots = "<STR_LIT:4>" ) : <EOL> if input_format == "<STR_LIT>" : <EOL> input_format = "<STR_LIT>" <EOL> elif ( input_format == "<STR_LIT>" ) or ( input_format == "<STR_LIT>" ) : <EOL> input_format = "<STR_LIT>" <EOL> else : <EOL> raise Exception ( '<STR_LIT>' ) <EOL> if alignment_method == "<STR_LIT>" : <EOL> x = "<STR_LIT>" % ( <EOL> v_mis , pslots ) <EOL> elif alignment_method == "<STR_LIT>" : <EOL> x = "<STR_LIT>" % ( v_mis , pslots ) <EOL> elif alignment_method == "<STR_LIT>" : <EOL> x = "<STR_LIT>" % ( <EOL> v_mis , pslots ) <EOL> elif alignment_method == "<STR_LIT>" : <EOL> x = "<STR_LIT>" % ( v_mis , pslots ) <EOL> elif alignment_method == "<STR_LIT>" : <EOL> x = "<STR_LIT>" % ( v_mis , pslots ) <EOL> elif alignment_method == "<STR_LIT>" : <EOL> x = "<STR_LIT>" % ( v_mis , pslots ) <EOL> if aligned == "<STR_LIT:None>" and unaligned == "<STR_LIT:None>" : <EOL> fasta_command = "<STR_LIT>" <EOL> elif aligned != "<STR_LIT:None>" and unaligned == "<STR_LIT:None>" : <EOL> fasta_command = "<STR_LIT>" % aligned <EOL> elif aligned == "<STR_LIT:None>" and unaligned != "<STR_LIT:None>" : <EOL> fasta_command = "<STR_LIT>" % unaligned <EOL> else : <EOL> fasta_command = "<STR_LIT>" % ( aligned , unaligned ) <EOL> x = x + fasta_command <EOL> if out_type == "<STR_LIT>" : <EOL> return "<STR_LIT>" % ( x , index , input_format , input , output ) <EOL> elif out_type == "<STR_LIT>" : <EOL> return "<STR_LIT>" % ( x , index , input_format , input , output ) <EOL> elif out_type == "<STR_LIT>" : <EOL> return "<STR_LIT>" % ( <EOL> x , index , input_format , input , output ) <EOL> def bowtie_squash ( fasta ) : <EOL> tmp_index_dir = tempfile . mkdtemp ( ) <EOL> ref_file = tempfile . NamedTemporaryFile ( dir = tmp_index_dir ) <EOL> ref_file_name = ref_file . name <EOL> ref_file . close ( ) <EOL> os . symlink ( fasta , ref_file_name ) <EOL> cmd1 = '<STR_LIT>' % ( ref_file_name , ref_file_name ) <EOL> try : <EOL> FNULL = open ( os . devnull , '<STR_LIT:w>' ) <EOL> tmp = tempfile . NamedTemporaryFile ( dir = tmp_index_dir ) . name <EOL> tmp_stderr = open ( tmp , '<STR_LIT:wb>' ) <EOL> proc = subprocess . Popen ( <EOL> args = cmd1 , shell = True , cwd = tmp_index_dir , stderr = FNULL , stdout = FNULL ) <EOL> returncode = proc . wait ( ) <EOL> tmp_stderr . close ( ) <EOL> FNULL . close ( ) <EOL> sys . stdout . write ( cmd1 + "<STR_LIT:\n>" ) <EOL> except Exception as e : <EOL> if os . path . exists ( tmp_index_dir ) : <EOL> shutil . rmtree ( tmp_index_dir ) <EOL> stop_err ( '<STR_LIT>' + str ( e ) ) <EOL> index_full_path = os . path . join ( tmp_index_dir , ref_file_name ) <EOL> return tmp_index_dir , index_full_path <EOL> def bowtie_alignment ( command_line , flyPreIndexed = '<STR_LIT>' ) : <EOL> tmp_index_dir = tempfile . mkdtemp ( ) <EOL> tmp = tempfile . NamedTemporaryFile ( dir = tmp_index_dir ) . name <EOL> tmp_stderr = open ( tmp , '<STR_LIT:wb>' ) <EOL> if "<STR_LIT>" in command_line : <EOL> target_file = command_line . split ( ) [ - <NUM_LIT:1> ] <EOL> path_to_unsortedBam = os . path . join ( tmp_index_dir , "<STR_LIT>" ) <EOL> path_to_sortedBam = os . path . join ( tmp_index_dir , "<STR_LIT>" ) <EOL> first_command_line = "<STR_LIT:U+0020>" . join ( <EOL> command_line . split ( ) [ : - <NUM_LIT:3> ] ) + "<STR_LIT>" + path_to_unsortedBam + "<STR_LIT>" <EOL> second_command_line = "<STR_LIT>" % ( <EOL> path_to_unsortedBam , path_to_sortedBam ) <EOL> p = subprocess . Popen ( <EOL> args = first_command_line , cwd = tmp_index_dir , shell = True , stderr = tmp_stderr . fileno ( ) ) <EOL> returncode = p . wait ( ) <EOL> sys . stdout . write ( "<STR_LIT>" % first_command_line + str ( returncode ) ) <EOL> p = subprocess . Popen ( <EOL> args = second_command_line , cwd = tmp_index_dir , shell = True , stderr = tmp_stderr . fileno ( ) ) <EOL> returncode = p . wait ( ) <EOL> sys . stdout . write ( "<STR_LIT>" % second_command_line + str ( returncode ) ) <EOL> if os . path . isfile ( path_to_sortedBam + "<STR_LIT>" ) : <EOL> shutil . copy2 ( path_to_sortedBam + "<STR_LIT>" , target_file ) <EOL> else : <EOL> p = subprocess . Popen ( <EOL> args = command_line , shell = True , stderr = tmp_stderr . fileno ( ) ) <EOL> returncode = p . wait ( ) <EOL> sys . stdout . write ( command_line + "<STR_LIT:\n>" ) <EOL> tmp_stderr . close ( ) <EOL> if os . path . exists ( flyPreIndexed ) : <EOL> shutil . rmtree ( flyPreIndexed ) <EOL> if os . path . exists ( tmp_index_dir ) : <EOL> shutil . rmtree ( tmp_index_dir ) <EOL> return <EOL> def __main__ ( ) : <EOL> args = Parser ( ) <EOL> F = open ( args . output , "<STR_LIT:w>" ) <EOL> if args . index_from == "<STR_LIT>" : <EOL> tmp_dir , index_path = bowtie_squash ( args . index_source ) <EOL> else : <EOL> tmp_dir , index_path = "<STR_LIT>" , args . index_source <EOL> command_line = bowtieCommandLiner ( args . method , args . v_mismatches , args . output_format , <EOL> args . aligned , args . unaligned , args . input_format , args . input , <EOL> index_path , args . output , args . num_threads ) <EOL> bowtie_alignment ( command_line , flyPreIndexed = tmp_dir ) <EOL> F . close ( ) <EOL> if __name__ == "<STR_LIT:__main__>" : <EOL> __main__ ( ) </s>

<s> import sys <EOL> input = open ( sys . argv [ <NUM_LIT:1> ] , "<STR_LIT:r>" ) <EOL> output = open ( sys . argv [ <NUM_LIT:2> ] , "<STR_LIT:w>" ) <EOL> for line in input : <EOL> if line [ <NUM_LIT:0> ] == "<STR_LIT:>>" : <EOL> print >> output , "<STR_LIT>" + line [ <NUM_LIT:1> : - <NUM_LIT:1> ] <EOL> continue <EOL> else : <EOL> print >> output , line [ : - <NUM_LIT:1> ] <EOL> print >> output , "<STR_LIT:+>" <EOL> print >> output , "<STR_LIT:H>" * len ( line [ : - <NUM_LIT:1> ] ) <EOL> input . close ( ) <EOL> output . close ( ) </s>

<s> """<STR_LIT>""" <EOL> import sys <EOL> import subprocess <EOL> from pelita . simplesetup import SimpleServer , SimplePublisher , SimpleController <EOL> import logging <EOL> from pelita . ui . tk_viewer import TkViewer <EOL> try : <EOL> import colorama <EOL> MAGENTA = colorama . Fore . MAGENTA <EOL> RESET = colorama . Fore . RESET <EOL> except ImportError : <EOL> MAGENTA = "<STR_LIT>" <EOL> RESET = "<STR_LIT>" <EOL> def get_python_process ( ) : <EOL> py_proc = sys . executable <EOL> if not py_proc : <EOL> raise RuntimeError ( "<STR_LIT>" ) <EOL> return py_proc <EOL> FORMAT = '<STR_LIT>' + MAGENTA + '<STR_LIT>' + RESET <EOL> logging . basicConfig ( format = FORMAT , datefmt = "<STR_LIT>" , level = logging . INFO ) <EOL> layout = ( <EOL> """<STR_LIT>""" ) <EOL> server = SimpleServer ( layout_string = layout , rounds = <NUM_LIT:200> , bind_addrs = ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> publisher = SimplePublisher ( "<STR_LIT>" ) <EOL> server . game_master . register_viewer ( publisher ) <EOL> subscribe_sock = server <EOL> tk_open = "<STR_LIT>" % ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> tkprocess = subprocess . Popen ( [ get_python_process ( ) , <EOL> "<STR_LIT:-c>" , <EOL> "<STR_LIT>" + tk_open ] ) <EOL> try : <EOL> print ( server . bind_addresses ) <EOL> server . register_teams ( ) <EOL> controller = SimpleController ( server . game_master , "<STR_LIT>" ) <EOL> controller . run ( ) <EOL> server . exit_teams ( ) <EOL> except KeyboardInterrupt : <EOL> tkprocess . kill ( ) </s>

<s> import sublime , sublime_plugin <EOL> import os <EOL> import threading <EOL> import queue <EOL> import asyncore <EOL> import socket <EOL> from itertools import chain <EOL> import re <EOL> settings = sublime . load_settings ( "<STR_LIT>" ) <EOL> TCP_IP = '<STR_LIT:127.0.0.1>' <EOL> TCP_PORT = <NUM_LIT> <EOL> BUFFER_SIZE = <NUM_LIT> <EOL> BASEDIR = settings . get ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> STEP_ON_CONNECT = settings . get ( "<STR_LIT>" , False ) <EOL> class SubDebugHandler ( asyncore . dispatcher ) : <EOL> def __init__ ( self , socket , handler_id ) : <EOL> asyncore . dispatcher . __init__ ( self , socket ) <EOL> self . handler_id = handler_id <EOL> msg_queue . put ( b"<STR_LIT>" if STEP_ON_CONNECT else b"<STR_LIT>" ) <EOL> for view_name , row in state_handler . breakpoints ( ) : <EOL> msg_queue . put ( "<STR_LIT>" . format ( view_name , row ) . encode ( '<STR_LIT>' ) ) <EOL> def handle_read ( self ) : <EOL> data = self . recv ( BUFFER_SIZE ) <EOL> if data : <EOL> print ( self . handler_id , "<STR_LIT>" , data ) <EOL> split = data . split ( ) <EOL> if split [ <NUM_LIT:0> ] in message_parsers : <EOL> message_parsers [ split [ <NUM_LIT:0> ] ] ( split ) <EOL> def handle_write ( self ) : <EOL> if not msg_queue . empty ( ) : <EOL> msg = msg_queue . get ( ) <EOL> print ( "<STR_LIT>" , msg ) <EOL> self . send ( msg ) <EOL> def handle_error ( self ) : <EOL> raise <EOL> class SubDebugServer ( asyncore . dispatcher ) : <EOL> def __init__ ( self , host , port ) : <EOL> asyncore . dispatcher . __init__ ( self ) <EOL> self . handler_id = <NUM_LIT:0> <EOL> self . create_socket ( socket . AF_INET , socket . SOCK_STREAM ) <EOL> self . set_reuse_addr ( ) <EOL> self . bind ( ( host , port ) ) <EOL> self . listen ( <NUM_LIT:1> ) <EOL> print ( "<STR_LIT>" , host , "<STR_LIT::>" , port ) <EOL> def handle_accept ( self ) : <EOL> pair = self . accept ( ) <EOL> if pair is not None : <EOL> ( conn_sock , client_address ) = pair <EOL> print ( "<STR_LIT>" , client_address ) <EOL> SubDebugHandler ( conn_sock , + + self . handler_id ) <EOL> def handle_close ( self ) : <EOL> print ( "<STR_LIT>" ) <EOL> self . close ( ) <EOL> def handle_error ( self ) : <EOL> self . close ( ) <EOL> class RunCommand ( sublime_plugin . WindowCommand ) : <EOL> def run ( self ) : <EOL> print ( "<STR_LIT>" ) <EOL> msg_queue . put ( b"<STR_LIT>" ) <EOL> state_handler . remove_line_marker ( ) <EOL> class StepCommand ( sublime_plugin . WindowCommand ) : <EOL> def run ( self ) : <EOL> print ( "<STR_LIT>" ) <EOL> msg_queue . put ( b"<STR_LIT>" ) <EOL> class ToggleBreakpointCommand ( sublime_plugin . TextCommand ) : <EOL> def run ( self , edit ) : <EOL> view_name = simplify_path ( self . view . file_name ( ) ) <EOL> row , _ = self . view . rowcol ( self . view . sel ( ) [ <NUM_LIT:0> ] . begin ( ) ) <EOL> print ( "<STR_LIT>" , view_name , row ) <EOL> state_handler . toggle_breakpoint ( view_name , row + <NUM_LIT:1> ) <EOL> class SetBasedirCommand ( sublime_plugin . WindowCommand ) : <EOL> def run ( self ) : <EOL> def choose_other ( path ) : <EOL> global BASEDIR <EOL> BASEDIR = path . replace ( '<STR_LIT:\\>' , '<STR_LIT:/>' ) <EOL> if ( BASEDIR [ - <NUM_LIT:1> ] != "<STR_LIT:/>" ) : <EOL> BASEDIR += "<STR_LIT:/>" <EOL> print ( "<STR_LIT>" , BASEDIR ) <EOL> def selected_folder ( index ) : <EOL> global BASEDIR <EOL> if index != - <NUM_LIT:1> : <EOL> if ( index == len ( folders ) - <NUM_LIT:1> ) : <EOL> sublime . active_window ( ) . show_input_panel ( "<STR_LIT>" , BASEDIR , choose_other , None , None ) <EOL> else : <EOL> BASEDIR = folders [ index ] + "<STR_LIT:/>" <EOL> state_handler . clear_state ( ) <EOL> print ( "<STR_LIT>" , BASEDIR ) <EOL> folders = list ( chain . from_iterable ( [ w . folders ( ) for w in sublime . windows ( ) ] ) ) <EOL> folders = [ f . replace ( "<STR_LIT:\\>" , "<STR_LIT:/>" ) for f in folders ] <EOL> folders . insert ( len ( folders ) , "<STR_LIT>" ) <EOL> sublime . active_window ( ) . show_quick_panel ( folders , selected_folder ) <EOL> class ToggleStepOnConnectCommand ( sublime_plugin . WindowCommand ) : <EOL> def run ( self ) : <EOL> global STEP_ON_CONNECT <EOL> STEP_ON_CONNECT = not STEP_ON_CONNECT <EOL> print ( "<STR_LIT>" , STEP_ON_CONNECT ) <EOL> def is_checked ( self ) : <EOL> return STEP_ON_CONNECT or False <EOL> def paused_command ( args ) : <EOL> state_handler . set_line_marker ( args [ <NUM_LIT:2> ] . decode ( "<STR_LIT:utf-8>" ) , int ( args [ <NUM_LIT:3> ] ) ) <EOL> message_parsers = { <EOL> b"<STR_LIT>" : paused_command , <EOL> } <EOL> class StateHandler ( ) : <EOL> def __init__ ( self ) : <EOL> self . clear_state ( ) <EOL> self . update_regions ( ) <EOL> def clear_state ( self ) : <EOL> self . state = { } <EOL> self . update_regions ( ) <EOL> def add_missing_views ( self ) : <EOL> views = [ v for v in sum ( [ w . views ( ) for w in sublime . windows ( ) ] , [ ] ) ] <EOL> self . views = { simplify_path ( v . file_name ( ) ) : v for v in views if v . file_name ( ) != None } <EOL> print ( self . views ) <EOL> for view_name , view in self . views . items ( ) : <EOL> if view_name not in self . state : <EOL> self . state [ view_name ] = [ ] <EOL> def update_regions ( self ) : <EOL> self . add_missing_views ( ) <EOL> for view_name , regions in self . state . items ( ) : <EOL> for reg_type_name in self . region_types : <EOL> self . views [ view_name ] . erase_regions ( reg_type_name ) <EOL> region_sets = { } <EOL> for ( reg_type , line ) in regions : <EOL> if reg_type == "<STR_LIT>" or ( "<STR_LIT>" , line ) not in regions : <EOL> if reg_type not in region_sets : <EOL> region_sets [ reg_type ] = [ ] <EOL> region_sets [ reg_type ] . append ( sublime . Region ( self . views [ view_name ] . text_point ( line - <NUM_LIT:1> , <NUM_LIT:0> ) ) ) <EOL> for reg_name , v in region_sets . items ( ) : <EOL> print ( "<STR_LIT>" , view_name , reg_name , v ) <EOL> self . views [ view_name ] . add_regions ( reg_name , v , * self . region_types [ reg_name ] ) <EOL> def set_line_marker ( self , view_name , line_number ) : <EOL> view_name = simplify_path ( view_name ) <EOL> print ( "<STR_LIT>" , view_name , line_number ) <EOL> self . add_missing_views ( ) <EOL> if view_name in self . views : <EOL> self . state . setdefault ( view_name , [ ] ) <EOL> self . state [ view_name ] = [ ( k , v ) for k , v in self . state [ view_name ] if k != "<STR_LIT>" ] <EOL> self . state [ view_name ] . append ( ( "<STR_LIT>" , line_number ) ) <EOL> self . update_regions ( ) <EOL> def remove_line_marker ( self ) : <EOL> for name , view in self . state . items ( ) : <EOL> self . state [ name ] = [ ( t , n ) for t , n in view if t != "<STR_LIT>" ] <EOL> self . update_regions ( ) <EOL> def toggle_breakpoint ( self , view_name , line_number ) : <EOL> self . add_missing_views ( ) <EOL> if view_name in self . views and ( "<STR_LIT>" , line_number ) in self . state [ view_name ] : <EOL> self . remove_breakpoint ( view_name , line_number ) <EOL> else : <EOL> self . set_breakpoint ( view_name , line_number ) <EOL> self . update_regions ( ) <EOL> def set_breakpoint ( self , view_name , line_number ) : <EOL> self . state . setdefault ( view_name , [ ] ) <EOL> self . state [ view_name ] . append ( ( "<STR_LIT>" , line_number ) ) <EOL> msg_queue . put ( "<STR_LIT>" . format ( view_name , line_number ) . encode ( '<STR_LIT>' ) ) <EOL> def remove_breakpoint ( self , view_name , line_number ) : <EOL> self . state [ view_name ] . remove ( ( "<STR_LIT>" , line_number ) ) <EOL> msg_queue . put ( "<STR_LIT>" . format ( view_name , line_number ) . encode ( '<STR_LIT>' ) ) <EOL> def breakpoints ( self ) : <EOL> ret = [ ] <EOL> for k , v in self . state . items ( ) : <EOL> for t in v : <EOL> if t [ <NUM_LIT:0> ] == "<STR_LIT>" : <EOL> ret . append ( ( k , t [ <NUM_LIT:1> ] ) ) <EOL> return ret <EOL> views = { } <EOL> state = { } <EOL> region_types = { <EOL> "<STR_LIT>" : ( "<STR_LIT>" , "<STR_LIT>" ) , <EOL> "<STR_LIT>" : ( "<STR_LIT>" , "<STR_LIT>" ) , <EOL> } <EOL> def plugin_unloaded ( ) : <EOL> settings . set ( "<STR_LIT>" , BASEDIR ) <EOL> settings . set ( "<STR_LIT>" , STEP_ON_CONNECT ) <EOL> print ( "<STR_LIT>" ) <EOL> server . close ( ) <EOL> def simplify_path ( path ) : <EOL> path = path . replace ( "<STR_LIT:\\>" , "<STR_LIT:/>" ) . replace ( BASEDIR , "<STR_LIT>" ) <EOL> path = re . sub ( '<STR_LIT>' , '<STR_LIT>' , path ) <EOL> return path <EOL> msg_queue = queue . Queue ( ) <EOL> state_handler = StateHandler ( ) <EOL> server = SubDebugServer ( TCP_IP , TCP_PORT ) <EOL> if os . name == "<STR_LIT>" : <EOL> thread = threading . Thread ( target = asyncore . loop , kwargs = { "<STR_LIT>" : True } ) <EOL> else : <EOL> thread = threading . Thread ( target = asyncore . loop ) <EOL> thread . start ( ) </s>

<s> from django . contrib import sitemaps <EOL> from django . core . urlresolvers import reverse <EOL> class StaticViewSitemap ( sitemaps . Sitemap ) : <EOL> priority = <NUM_LIT:0.5> <EOL> changefreq = '<STR_LIT>' <EOL> def items ( self ) : <EOL> return [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , ] <EOL> def location ( self , item ) : <EOL> return reverse ( item ) </s>

<s> from django . conf . urls import patterns , include , url <EOL> from publisher . views import catalog <EOL> from publisher . views import my_publication <EOL> from publisher . views import publication <EOL> urlpatterns = patterns ( '<STR_LIT>' , <EOL> url ( r'<STR_LIT>' , catalog . catalog_page ) , <EOL> url ( r'<STR_LIT>' , publication . publication_page ) , <EOL> url ( r'<STR_LIT>' , publication . peer_review_modal ) , <EOL> url ( r'<STR_LIT>' , publication . save_peer_review ) , <EOL> url ( r'<STR_LIT>' , publication . delete_peer_review ) , <EOL> url ( r'<STR_LIT>' , my_publication . my_publications_page ) , <EOL> url ( r'<STR_LIT>' , my_publication . refresh_publications_table ) , <EOL> url ( r'<STR_LIT>' , my_publication . my_publication_modal ) , <EOL> url ( r'<STR_LIT>' , my_publication . save_publication ) , <EOL> url ( r'<STR_LIT>' , my_publication . delete_publication ) , <EOL> ) </s>

<s> from django . core . urlresolvers import resolve <EOL> from django . http import HttpRequest <EOL> from django . http import QueryDict <EOL> from django . test import TestCase <EOL> from django . test import Client <EOL> from django . contrib . auth . models import User <EOL> from django . contrib . auth import authenticate , login , logout <EOL> from django . contrib . auth . decorators import login_required <EOL> from django . conf . urls . static import static , settings <EOL> import json <EOL> from registrar . models import Course <EOL> from registrar . models import Teacher <EOL> from registrar . models import Student <EOL> from registrar . models import Assignment <EOL> from registrar . models import AssignmentSubmission <EOL> from registrar . models import Quiz <EOL> from registrar . models import QuizSubmission <EOL> from registrar . models import Exam <EOL> from registrar . models import ExamSubmission <EOL> from registrar . models import EssayQuestion <EOL> from registrar . models import EssaySubmission <EOL> from registrar . models import MultipleChoiceQuestion <EOL> from registrar . models import MultipleChoiceSubmission <EOL> from registrar . models import ResponseQuestion <EOL> from registrar . models import ResponseSubmission <EOL> from registrar . models import TrueFalseQuestion <EOL> from registrar . models import TrueFalseSubmission <EOL> from registrar . models import PeerReview <EOL> from student . views import assignment <EOL> from student . views import quiz <EOL> from student . views import exam <EOL> from student . views import credit <EOL> TEST_USER_EMAIL = "<STR_LIT>" <EOL> TEST_USER_USERNAME = "<STR_LIT>" <EOL> TEST_USER_PASSWORD = "<STR_LIT:password>" <EOL> class CreditTestCase ( TestCase ) : <EOL> def tearDown ( self ) : <EOL> courses = Course . objects . all ( ) <EOL> for course in courses : <EOL> course . delete ( ) <EOL> User . objects . get ( email = TEST_USER_EMAIL ) . delete ( ) <EOL> def setUp ( self ) : <EOL> User . objects . create_user ( <EOL> email = TEST_USER_EMAIL , <EOL> username = TEST_USER_USERNAME , <EOL> password = TEST_USER_PASSWORD <EOL> ) <EOL> user = User . objects . get ( email = TEST_USER_EMAIL ) <EOL> teacher = Teacher . objects . create ( user = user ) <EOL> student = Student . objects . create ( user = user ) <EOL> course = Course . objects . create ( <EOL> id = <NUM_LIT:1> , <EOL> title = "<STR_LIT>" , <EOL> sub_title = "<STR_LIT>" , <EOL> category = "<STR_LIT>" , <EOL> teacher = teacher , <EOL> ) <EOL> assignment = Assignment . objects . create ( <EOL> assignment_id = <NUM_LIT:1> , <EOL> assignment_num = <NUM_LIT:1> , <EOL> title = "<STR_LIT>" , <EOL> description = "<STR_LIT>" , <EOL> worth = <NUM_LIT> , <EOL> course = course , <EOL> ) <EOL> EssayQuestion . objects . create ( <EOL> question_id = <NUM_LIT:1> , <EOL> assignment = assignment , <EOL> title = "<STR_LIT>" , <EOL> description = "<STR_LIT>" , <EOL> ) <EOL> MultipleChoiceQuestion . objects . create ( <EOL> question_id = <NUM_LIT:2> , <EOL> assignment = assignment , <EOL> title = "<STR_LIT>" , <EOL> description = "<STR_LIT>" , <EOL> a = "<STR_LIT>" , <EOL> a_is_correct = True , <EOL> b = "<STR_LIT>" , <EOL> b_is_correct = False , <EOL> c = "<STR_LIT>" , <EOL> c_is_correct = False , <EOL> d = "<STR_LIT>" , <EOL> d_is_correct = False , <EOL> e = "<STR_LIT>" , <EOL> e_is_correct = False , <EOL> ) <EOL> TrueFalseQuestion . objects . create ( <EOL> question_id = <NUM_LIT:3> , <EOL> assignment = assignment , <EOL> title = "<STR_LIT>" , <EOL> description = "<STR_LIT>" , <EOL> true_choice = "<STR_LIT>" , <EOL> false_choice = "<STR_LIT>" , <EOL> answer = True , <EOL> ) <EOL> ResponseQuestion . objects . create ( <EOL> question_id = <NUM_LIT:4> , <EOL> assignment = assignment , <EOL> title = "<STR_LIT>" , <EOL> description = "<STR_LIT>" , <EOL> answer = "<STR_LIT>" , <EOL> ) <EOL> Quiz . objects . create ( <EOL> quiz_id = <NUM_LIT:1> , <EOL> quiz_num = <NUM_LIT:1> , <EOL> title = "<STR_LIT>" , <EOL> description = "<STR_LIT>" , <EOL> worth = <NUM_LIT> , <EOL> course = course , <EOL> ) <EOL> quiz = Quiz . objects . get ( quiz_id = <NUM_LIT:1> ) <EOL> TrueFalseQuestion . objects . create ( <EOL> question_id = <NUM_LIT:5> , <EOL> quiz = quiz , <EOL> title = "<STR_LIT>" , <EOL> description = "<STR_LIT>" , <EOL> true_choice = "<STR_LIT>" , <EOL> false_choice = "<STR_LIT>" , <EOL> answer = True , <EOL> ) <EOL> Exam . objects . create ( <EOL> exam_id = <NUM_LIT:1> , <EOL> exam_num = <NUM_LIT:1> , <EOL> title = "<STR_LIT>" , <EOL> description = "<STR_LIT>" , <EOL> worth = <NUM_LIT:50> , <EOL> course = course , <EOL> is_final = True , <EOL> ) <EOL> exam = Exam . objects . get ( exam_id = <NUM_LIT:1> ) <EOL> MultipleChoiceQuestion . objects . create ( <EOL> question_id = <NUM_LIT:6> , <EOL> exam = exam , <EOL> title = "<STR_LIT>" , <EOL> description = "<STR_LIT>" , <EOL> a = "<STR_LIT>" , <EOL> a_is_correct = True , <EOL> b = "<STR_LIT>" , <EOL> b_is_correct = False , <EOL> c = "<STR_LIT>" , <EOL> c_is_correct = False , <EOL> d = "<STR_LIT>" , <EOL> d_is_correct = False , <EOL> e = "<STR_LIT>" , <EOL> e_is_correct = False , <EOL> ) <EOL> def get_logged_in_client ( self ) : <EOL> client = Client ( ) <EOL> client . login ( <EOL> username = TEST_USER_USERNAME , <EOL> password = TEST_USER_PASSWORD <EOL> ) <EOL> return client <EOL> def test_url_resolves_to_credit_page_view ( self ) : <EOL> found = resolve ( '<STR_LIT>' ) <EOL> self . assertEqual ( found . func , credit . credit_page ) <EOL> def test_credit_page_with_no_submissions ( self ) : <EOL> client = self . get_logged_in_client ( ) <EOL> response = client . post ( '<STR_LIT>' ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> self . assertIn ( b'<STR_LIT>' , response . content ) <EOL> self . assertIn ( b'<STR_LIT>' , response . content ) <EOL> def test_url_resolves_to_submit_json ( self ) : <EOL> found = resolve ( '<STR_LIT>' ) <EOL> self . assertEqual ( found . func , credit . submit_credit_application ) <EOL> def test_submit_credit_application_on_no_failing_criteria ( self ) : <EOL> kwargs = { '<STR_LIT>' : '<STR_LIT>' } <EOL> client = self . get_logged_in_client ( ) <EOL> response = client . post ( '<STR_LIT>' , { <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> } , ** kwargs ) <EOL> json_string = response . content . decode ( encoding = '<STR_LIT>' ) <EOL> array = json . loads ( json_string ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> self . assertEqual ( array [ '<STR_LIT:status>' ] , '<STR_LIT>' ) <EOL> self . assertEqual ( array [ '<STR_LIT:message>' ] , '<STR_LIT>' ) <EOL> def test_submit_credit_application_on_passing_criteria_without_peer_reviews ( self ) : <EOL> kwargs = { '<STR_LIT>' : '<STR_LIT>' } <EOL> client = self . get_logged_in_client ( ) <EOL> file_path = settings . MEDIA_ROOT + '<STR_LIT>' <EOL> with open ( file_path , '<STR_LIT:rb>' ) as fp : <EOL> self . assertTrue ( fp is not None ) <EOL> client . post ( '<STR_LIT>' , { <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT:file>' : fp <EOL> } , ** kwargs ) <EOL> client . post ( '<STR_LIT>' , { <EOL> '<STR_LIT>' : <NUM_LIT:2> , <EOL> '<STR_LIT>' : '<STR_LIT:A>' , <EOL> } , ** kwargs ) <EOL> client . post ( '<STR_LIT>' , { <EOL> '<STR_LIT>' : <NUM_LIT:3> , <EOL> '<STR_LIT>' : '<STR_LIT:true>' , <EOL> } , ** kwargs ) <EOL> client . post ( '<STR_LIT>' , { <EOL> '<STR_LIT>' : <NUM_LIT:4> , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> } , ** kwargs ) <EOL> client . post ( '<STR_LIT>' , { } , ** kwargs ) <EOL> client . post ( '<STR_LIT>' , { <EOL> '<STR_LIT>' : <NUM_LIT:5> , <EOL> '<STR_LIT>' : '<STR_LIT:true>' , <EOL> } , ** kwargs ) <EOL> client . post ( '<STR_LIT>' , { } , ** kwargs ) <EOL> response = client . post ( '<STR_LIT>' , { <EOL> '<STR_LIT>' : <NUM_LIT:6> , <EOL> '<STR_LIT>' : '<STR_LIT:A>' , <EOL> } , ** kwargs ) <EOL> client . post ( '<STR_LIT>' , { } , ** kwargs ) <EOL> response = client . post ( '<STR_LIT>' , { <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> } , ** kwargs ) <EOL> json_string = response . content . decode ( encoding = '<STR_LIT>' ) <EOL> array = json . loads ( json_string ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> self . assertEqual ( array [ '<STR_LIT:status>' ] , '<STR_LIT:success>' ) <EOL> self . assertEqual ( array [ '<STR_LIT:message>' ] , '<STR_LIT>' ) <EOL> try : <EOL> EssaySubmission . objects . get ( submission_id = <NUM_LIT:1> ) . delete ( ) <EOL> except EssaySubmission . DoesNotExist : <EOL> pass <EOL> try : <EOL> EssaySubmission . objects . get ( submission_id = <NUM_LIT:2> ) . delete ( ) <EOL> except EssaySubmission . DoesNotExist : <EOL> pass <EOL> def test_submit_credit_application_on_passing_criteria_with_peer_reviews ( self ) : <EOL> kwargs = { '<STR_LIT>' : '<STR_LIT>' } <EOL> client = self . get_logged_in_client ( ) <EOL> file_path = settings . MEDIA_ROOT + '<STR_LIT>' <EOL> with open ( file_path , '<STR_LIT:rb>' ) as fp : <EOL> self . assertTrue ( fp is not None ) <EOL> client . post ( '<STR_LIT>' , { <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT:file>' : fp <EOL> } , ** kwargs ) <EOL> client . post ( '<STR_LIT>' , { <EOL> '<STR_LIT>' : <NUM_LIT:2> , <EOL> '<STR_LIT>' : '<STR_LIT:A>' , <EOL> } , ** kwargs ) <EOL> client . post ( '<STR_LIT>' , { <EOL> '<STR_LIT>' : <NUM_LIT:3> , <EOL> '<STR_LIT>' : '<STR_LIT:true>' , <EOL> } , ** kwargs ) <EOL> client . post ( '<STR_LIT>' , { <EOL> '<STR_LIT>' : <NUM_LIT:4> , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> } , ** kwargs ) <EOL> client . post ( '<STR_LIT>' , { } , ** kwargs ) <EOL> client . post ( '<STR_LIT>' , { <EOL> '<STR_LIT>' : <NUM_LIT:5> , <EOL> '<STR_LIT>' : '<STR_LIT:true>' , <EOL> } , ** kwargs ) <EOL> client . post ( '<STR_LIT>' , { } , ** kwargs ) <EOL> response = client . post ( '<STR_LIT>' , { <EOL> '<STR_LIT>' : <NUM_LIT:6> , <EOL> '<STR_LIT>' : '<STR_LIT:A>' , <EOL> } , ** kwargs ) <EOL> client . post ( '<STR_LIT>' , { } , ** kwargs ) <EOL> client . post ( '<STR_LIT>' , { <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : settings . ESSAY_QUESTION_TYPE , <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : <NUM_LIT:5> , <EOL> } , ** kwargs ) <EOL> client . post ( '<STR_LIT>' , { <EOL> '<STR_LIT>' : <NUM_LIT:4> , <EOL> '<STR_LIT>' : settings . RESPONSE_QUESTION_TYPE , <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : <NUM_LIT:5> , <EOL> } , ** kwargs ) <EOL> response = client . post ( '<STR_LIT>' , { <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> } , ** kwargs ) <EOL> json_string = response . content . decode ( encoding = '<STR_LIT>' ) <EOL> array = json . loads ( json_string ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> self . assertEqual ( array [ '<STR_LIT:status>' ] , '<STR_LIT:success>' ) <EOL> self . assertEqual ( array [ '<STR_LIT:message>' ] , '<STR_LIT>' ) <EOL> try : <EOL> EssaySubmission . objects . get ( submission_id = <NUM_LIT:1> ) . delete ( ) <EOL> except EssaySubmission . DoesNotExist : <EOL> pass <EOL> try : <EOL> EssaySubmission . objects . get ( submission_id = <NUM_LIT:2> ) . delete ( ) <EOL> except EssaySubmission . DoesNotExist : <EOL> pass </s>

<s> from django . core . urlresolvers import resolve <EOL> from django . http import HttpRequest <EOL> from django . http import QueryDict <EOL> from django . test import TestCase <EOL> from django . test import Client <EOL> from django . contrib . auth . models import User <EOL> from django . contrib . auth import authenticate , login , logout <EOL> from django . contrib . auth . decorators import login_required <EOL> from django . conf . urls . static import static , settings <EOL> import json <EOL> from registrar . models import Teacher <EOL> from registrar . models import Course <EOL> from registrar . models import Announcement <EOL> from registrar . models import Syllabus <EOL> from registrar . models import Policy <EOL> from registrar . models import Lecture <EOL> from registrar . models import Assignment <EOL> from registrar . models import Quiz <EOL> from registrar . models import Exam <EOL> from registrar . models import CourseSubmission <EOL> from teacher . views import overview <EOL> TEST_USER_EMAIL = "<STR_LIT>" <EOL> TEST_USER_USERNAME = "<STR_LIT>" <EOL> TEST_USER_PASSWORD = "<STR_LIT>" <EOL> TEST_USER_EMAIL2 = "<STR_LIT>" <EOL> TEST_USER_USERNAME2 = "<STR_LIT>" <EOL> TEST_USER_PASSWORD2 = "<STR_LIT>" <EOL> class OverviewTestCase ( TestCase ) : <EOL> def tearDown ( self ) : <EOL> syllabuses = Syllabus . objects . all ( ) <EOL> for syllabus in syllabuses : <EOL> syllabus . delete ( ) <EOL> policies = Policy . objects . all ( ) <EOL> for policy in policies : <EOL> policy . delete ( ) <EOL> courses = Course . objects . all ( ) <EOL> for course in courses : <EOL> course . delete ( ) <EOL> User . objects . all ( ) . delete ( ) <EOL> def setUp ( self ) : <EOL> User . objects . create_user ( <EOL> email = TEST_USER_EMAIL2 , <EOL> username = TEST_USER_USERNAME2 , <EOL> password = TEST_USER_PASSWORD2 <EOL> ) <EOL> user = User . objects . get ( email = TEST_USER_EMAIL2 ) <EOL> teacher = Teacher . objects . create ( user = user ) <EOL> user = User . objects . create_user ( <EOL> email = TEST_USER_EMAIL , <EOL> username = TEST_USER_USERNAME , <EOL> password = TEST_USER_PASSWORD <EOL> ) <EOL> teacher = Teacher . objects . create ( user = user ) <EOL> course = Course . objects . create ( <EOL> id = <NUM_LIT:1> , <EOL> title = "<STR_LIT>" , <EOL> sub_title = "<STR_LIT>" , <EOL> category = "<STR_LIT>" , <EOL> teacher = teacher , <EOL> ) <EOL> def populate_course_content ( self , client , kwargs ) : <EOL> course = Course . objects . get ( id = <NUM_LIT:1> ) <EOL> Announcement . objects . create ( <EOL> announcement_id = <NUM_LIT:1> , <EOL> course = course , <EOL> title = '<STR_LIT>' , <EOL> body = '<STR_LIT>' , <EOL> ) <EOL> course = Course . objects . get ( id = <NUM_LIT:1> ) <EOL> file_path = settings . MEDIA_ROOT + '<STR_LIT>' <EOL> with open ( file_path , '<STR_LIT:rb>' ) as fp : <EOL> self . assertTrue ( fp is not None ) <EOL> Syllabus . objects . create ( <EOL> syllabus_id = <NUM_LIT:1> , <EOL> file = '<STR_LIT>' , <EOL> course = course , <EOL> ) <EOL> with open ( file_path , '<STR_LIT:rb>' ) as fp : <EOL> self . assertTrue ( fp is not None ) <EOL> Policy . objects . create ( <EOL> policy_id = <NUM_LIT:1> , <EOL> file = '<STR_LIT>' , <EOL> course = course , <EOL> ) <EOL> Lecture . objects . create ( <EOL> lecture_id = <NUM_LIT:1> , <EOL> lecture_num = <NUM_LIT:1> , <EOL> week_num = <NUM_LIT:1> , <EOL> title = "<STR_LIT>" , <EOL> description = "<STR_LIT>" , <EOL> course = course , <EOL> ) <EOL> Lecture . objects . create ( <EOL> lecture_id = <NUM_LIT:2> , <EOL> lecture_num = <NUM_LIT:2> , <EOL> week_num = <NUM_LIT:1> , <EOL> title = "<STR_LIT>" , <EOL> description = "<STR_LIT>" , <EOL> course = course , <EOL> ) <EOL> Assignment . objects . create ( <EOL> assignment_id = <NUM_LIT:1> , <EOL> assignment_num = <NUM_LIT:1> , <EOL> title = "<STR_LIT>" , <EOL> description = "<STR_LIT>" , <EOL> worth = <NUM_LIT> , <EOL> course = course , <EOL> ) <EOL> Quiz . objects . create ( <EOL> quiz_id = <NUM_LIT:1> , <EOL> quiz_num = <NUM_LIT:1> , <EOL> title = "<STR_LIT>" , <EOL> description = "<STR_LIT>" , <EOL> worth = <NUM_LIT> , <EOL> course = course , <EOL> ) <EOL> Exam . objects . create ( <EOL> exam_id = <NUM_LIT:1> , <EOL> exam_num = <NUM_LIT:1> , <EOL> title = "<STR_LIT>" , <EOL> description = "<STR_LIT>" , <EOL> worth = <NUM_LIT:50> , <EOL> course = course , <EOL> is_final = True , <EOL> ) <EOL> def delete_course_content ( self ) : <EOL> for id in range ( <NUM_LIT:1> , <NUM_LIT:10> ) : <EOL> try : <EOL> Syllabus . objects . get ( syllabus_id = id ) . delete ( ) <EOL> except Syllabus . DoesNotExist : <EOL> pass <EOL> try : <EOL> Policy . objects . get ( policy_id = id ) . delete ( ) <EOL> except Policy . DoesNotExist : <EOL> pass <EOL> try : <EOL> Announcement . objects . get ( announcement_id = <NUM_LIT:1> ) . delete ( ) <EOL> except Announcement . DoesNotExist : <EOL> pass <EOL> def get_logged_in_client ( self ) : <EOL> client = Client ( ) <EOL> client . login ( <EOL> username = TEST_USER_USERNAME , <EOL> password = TEST_USER_PASSWORD <EOL> ) <EOL> return client <EOL> def test_url_resolves_to_overview_page_view ( self ) : <EOL> found = resolve ( '<STR_LIT>' ) <EOL> self . assertEqual ( found . func , overview . overview_page ) <EOL> def test_overview_page ( self ) : <EOL> client = self . get_logged_in_client ( ) <EOL> response = client . post ( '<STR_LIT>' ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> self . assertIn ( b'<STR_LIT>' , response . content ) <EOL> self . assertIn ( b'<STR_LIT>' , response . content ) <EOL> def test_submit_course_for_review ( self ) : <EOL> client = self . get_logged_in_client ( ) <EOL> kwargs = { '<STR_LIT>' : '<STR_LIT>' } <EOL> self . populate_course_content ( client , kwargs ) <EOL> response = client . post ( '<STR_LIT>' , { } , ** kwargs ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> json_string = response . content . decode ( encoding = '<STR_LIT>' ) <EOL> array = json . loads ( json_string ) <EOL> self . assertEqual ( array [ '<STR_LIT:message>' ] , '<STR_LIT>' ) <EOL> self . assertEqual ( array [ '<STR_LIT:status>' ] , '<STR_LIT:success>' ) <EOL> self . delete_course_content ( ) </s>

<s> """<STR_LIT>""" <EOL> revision = '<STR_LIT>' <EOL> down_revision = '<STR_LIT>' <EOL> branch_labels = None <EOL> depends_on = None <EOL> from alembic import op <EOL> import sqlalchemy as sa <EOL> def upgrade ( ) : <EOL> op . create_table ( '<STR_LIT>' , <EOL> sa . Column ( '<STR_LIT:id>' , sa . Integer ( ) , nullable = False ) , <EOL> sa . Column ( '<STR_LIT:name>' , sa . String ( length = <NUM_LIT:255> ) , nullable = False ) , <EOL> sa . Column ( '<STR_LIT>' , sa . Boolean ( ) , nullable = False ) , <EOL> sa . PrimaryKeyConstraint ( '<STR_LIT:id>' ) <EOL> ) <EOL> op . create_table ( '<STR_LIT>' , <EOL> sa . Column ( '<STR_LIT>' , sa . Integer ( ) , nullable = False ) , <EOL> sa . Column ( '<STR_LIT>' , sa . Integer ( ) , nullable = False ) , <EOL> sa . Column ( '<STR_LIT:value>' , sa . String ( length = <NUM_LIT:255> ) , nullable = True ) , <EOL> sa . Column ( '<STR_LIT>' , sa . Integer ( ) , nullable = True ) , <EOL> sa . Column ( '<STR_LIT>' , sa . Integer ( ) , nullable = False ) , <EOL> sa . ForeignKeyConstraint ( [ '<STR_LIT>' ] , [ '<STR_LIT>' ] , ondelete = '<STR_LIT>' ) , <EOL> sa . ForeignKeyConstraint ( [ '<STR_LIT>' ] , [ '<STR_LIT>' ] , ondelete = '<STR_LIT>' ) , <EOL> sa . ForeignKeyConstraint ( [ '<STR_LIT>' ] , [ '<STR_LIT>' ] , ondelete = '<STR_LIT>' ) , <EOL> sa . PrimaryKeyConstraint ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> ) <EOL> op . add_column ( u'<STR_LIT>' , sa . Column ( '<STR_LIT:name>' , sa . String ( length = <NUM_LIT:255> ) , nullable = False , server_default = "<STR_LIT>" ) ) <EOL> def downgrade ( ) : <EOL> op . drop_column ( u'<STR_LIT>' , '<STR_LIT:name>' ) <EOL> op . drop_table ( '<STR_LIT>' ) <EOL> op . drop_table ( '<STR_LIT>' ) </s>

<s> import logging <EOL> from applib . base import Cmdln , Application <EOL> from applib . misc import require_option <EOL> from applib import textui , sh , _cmdln as cmdln <EOL> LOG = logging . getLogger ( __name__ ) <EOL> application = Application ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> @ cmdln . option ( '<STR_LIT>' , '<STR_LIT>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' ) <EOL> class Commands ( Cmdln ) : <EOL> name = "<STR_LIT>" <EOL> def initialize ( self ) : <EOL> require_option ( self . options , '<STR_LIT:foo>' ) <EOL> @ cmdln . alias ( '<STR_LIT>' ) <EOL> @ cmdln . option ( '<STR_LIT>' , '<STR_LIT>' , action = '<STR_LIT:store_true>' , <EOL> help = '<STR_LIT>' ) <EOL> def do_currentdate ( self , subcmd , opts ) : <EOL> """<STR_LIT>""" <EOL> with self . bootstrapped ( ) : <EOL> from datetime import datetime <EOL> now = datetime . now ( ) <EOL> LOG . debug ( '<STR_LIT>' , now ) <EOL> if opts . show_time : <EOL> print ( now ) <EOL> else : <EOL> print ( now . date ( ) ) <EOL> def do_ls ( self , subcmd , opts ) : <EOL> """<STR_LIT>""" <EOL> with self . bootstrapped ( ) : <EOL> print ( sh . run ( '<STR_LIT>' ) [ <NUM_LIT:0> ] . decode ( '<STR_LIT:utf-8>' ) ) <EOL> def do_makeerror ( self , subcmd , opts , what ) : <EOL> """<STR_LIT>""" <EOL> with self . bootstrapped ( ) : <EOL> LOG . debug ( '<STR_LIT>' , what ) <EOL> textui . askyesno ( '<STR_LIT>' , default = True ) <EOL> <NUM_LIT:1> / <NUM_LIT:0> <EOL> @ cmdln . option ( '<STR_LIT>' , '<STR_LIT>' , action = '<STR_LIT:store_true>' , <EOL> help = '<STR_LIT>' ) <EOL> def do_think ( self , subcmd , opts , length = <NUM_LIT:200> ) : <EOL> """<STR_LIT>""" <EOL> with self . bootstrapped ( ) : <EOL> import time <EOL> length = int ( length ) <EOL> for x in textui . ProgressBar . iterate ( range ( length ) , <EOL> post = '<STR_LIT>' ) : <EOL> if x == length - <NUM_LIT:1> and not opts . no_break : <EOL> break <EOL> time . sleep ( <NUM_LIT:0.1> ) <EOL> def do_multable ( self , subcmd , opts , number = <NUM_LIT:10> , times = <NUM_LIT> ) : <EOL> """<STR_LIT>""" <EOL> with self . bootstrapped ( ) : <EOL> textui . colprint ( [ <EOL> [ str ( x * y ) for y in range ( <NUM_LIT:1> , <NUM_LIT:1> + int ( times ) ) ] <EOL> for x in range ( <NUM_LIT:1> , <NUM_LIT:1> + int ( number ) ) <EOL> ] ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> application . run ( Commands ) </s>

<s> from assertpy import assert_that , fail <EOL> class TestType ( object ) : <EOL> def test_is_type_of ( self ) : <EOL> assert_that ( '<STR_LIT:foo>' ) . is_type_of ( str ) <EOL> assert_that ( <NUM_LIT> ) . is_type_of ( int ) <EOL> assert_that ( <NUM_LIT> ) . is_type_of ( float ) <EOL> assert_that ( [ '<STR_LIT:a>' , '<STR_LIT:b>' ] ) . is_type_of ( list ) <EOL> assert_that ( ( '<STR_LIT:a>' , '<STR_LIT:b>' ) ) . is_type_of ( tuple ) <EOL> assert_that ( { '<STR_LIT:a>' : <NUM_LIT:1> , '<STR_LIT:b>' : <NUM_LIT:2> } ) . is_type_of ( dict ) <EOL> assert_that ( set ( [ '<STR_LIT:a>' , '<STR_LIT:b>' ] ) ) . is_type_of ( set ) <EOL> assert_that ( None ) . is_type_of ( type ( None ) ) <EOL> assert_that ( Foo ( ) ) . is_type_of ( Foo ) <EOL> assert_that ( Bar ( ) ) . is_type_of ( Bar ) <EOL> def test_is_type_of_failure ( self ) : <EOL> try : <EOL> assert_that ( '<STR_LIT:foo>' ) . is_type_of ( int ) <EOL> fail ( '<STR_LIT>' ) <EOL> except AssertionError as ex : <EOL> assert_that ( str ( ex ) ) . is_equal_to ( '<STR_LIT>' ) <EOL> def test_is_type_of_bad_arg_failure ( self ) : <EOL> try : <EOL> assert_that ( '<STR_LIT:foo>' ) . is_type_of ( '<STR_LIT>' ) <EOL> fail ( '<STR_LIT>' ) <EOL> except TypeError as ex : <EOL> assert_that ( str ( ex ) ) . is_equal_to ( '<STR_LIT>' ) <EOL> def test_is_type_of_subclass_failure ( self ) : <EOL> try : <EOL> assert_that ( Bar ( ) ) . is_type_of ( Foo ) <EOL> fail ( '<STR_LIT>' ) <EOL> except AssertionError as ex : <EOL> assert_that ( str ( ex ) ) . starts_with ( '<STR_LIT>' ) <EOL> assert_that ( str ( ex ) ) . ends_with ( '<STR_LIT>' ) <EOL> def test_is_instance_of ( self ) : <EOL> assert_that ( '<STR_LIT:foo>' ) . is_instance_of ( str ) <EOL> assert_that ( <NUM_LIT> ) . is_instance_of ( int ) <EOL> assert_that ( <NUM_LIT> ) . is_instance_of ( float ) <EOL> assert_that ( [ '<STR_LIT:a>' , '<STR_LIT:b>' ] ) . is_instance_of ( list ) <EOL> assert_that ( ( '<STR_LIT:a>' , '<STR_LIT:b>' ) ) . is_instance_of ( tuple ) <EOL> assert_that ( { '<STR_LIT:a>' : <NUM_LIT:1> , '<STR_LIT:b>' : <NUM_LIT:2> } ) . is_instance_of ( dict ) <EOL> assert_that ( set ( [ '<STR_LIT:a>' , '<STR_LIT:b>' ] ) ) . is_instance_of ( set ) <EOL> assert_that ( None ) . is_instance_of ( type ( None ) ) <EOL> assert_that ( Foo ( ) ) . is_instance_of ( Foo ) <EOL> assert_that ( Bar ( ) ) . is_instance_of ( Bar ) <EOL> assert_that ( Bar ( ) ) . is_instance_of ( Foo ) <EOL> def test_is_instance_of_failure ( self ) : <EOL> try : <EOL> assert_that ( '<STR_LIT:foo>' ) . is_instance_of ( int ) <EOL> fail ( '<STR_LIT>' ) <EOL> except AssertionError as ex : <EOL> assert_that ( str ( ex ) ) . is_equal_to ( '<STR_LIT>' ) <EOL> def test_is_instance_of_bad_arg_failure ( self ) : <EOL> try : <EOL> assert_that ( '<STR_LIT:foo>' ) . is_instance_of ( '<STR_LIT>' ) <EOL> fail ( '<STR_LIT>' ) <EOL> except TypeError as ex : <EOL> assert_that ( str ( ex ) ) . is_equal_to ( '<STR_LIT>' ) <EOL> class Foo ( object ) : <EOL> pass <EOL> class Bar ( Foo ) : <EOL> pass </s>

<s> import sys <EOL> import math <EOL> import scipy <EOL> import pylab <EOL> import scipy . io . wavfile as wav <EOL> import wave <EOL> from scipy import signal <EOL> from itertools import product <EOL> import numpy <EOL> def readWav ( ) : <EOL> """<STR_LIT>""" <EOL> sound_wave = wave . open ( sys . argv [ <NUM_LIT:1> ] , "<STR_LIT:r>" ) <EOL> nframes = sound_wave . getnframes ( ) <EOL> framerate = sound_wave . getframerate ( ) <EOL> params = sound_wave . getparams ( ) <EOL> duration = nframes / float ( framerate ) <EOL> print "<STR_LIT>" % ( framerate , ) <EOL> print "<STR_LIT>" % ( nframes , ) <EOL> print "<STR_LIT>" % ( duration , ) <EOL> print scipy . array ( sound_wave ) <EOL> return ( sound_wave , nframes , framerate , duration , params ) <EOL> def getDuration ( sound_file ) : <EOL> """<STR_LIT>""" <EOL> wr = wave . open ( sound_file , '<STR_LIT:r>' ) <EOL> nchannels , sampwidth , framerate , nframes , comptype , compname = wr . getparams ( ) <EOL> return nframes / float ( framerate ) <EOL> def getFrameRate ( sound_file ) : <EOL> """<STR_LIT>""" <EOL> wr = wave . open ( sound_file , '<STR_LIT:r>' ) <EOL> nchannels , sampwidth , framerate , nframes , comptype , compname = wr . getparams ( ) <EOL> return framerate <EOL> def get_channels_no ( sound_file ) : <EOL> """<STR_LIT>""" <EOL> wr = wave . open ( sound_file , '<STR_LIT:r>' ) <EOL> nchannels , sampwidth , framerate , nframes , comptype , compname = wr . getparams ( ) <EOL> return nchannels <EOL> def plotSoundWave ( rate , sample ) : <EOL> """<STR_LIT>""" <EOL> t = scipy . linspace ( <NUM_LIT:0> , <NUM_LIT:2> , <NUM_LIT:2> * rate , endpoint = False ) <EOL> pylab . figure ( '<STR_LIT>' ) <EOL> T = int ( <NUM_LIT> * rate ) <EOL> pylab . plot ( t [ : T ] , sample [ : T ] , ) <EOL> pylab . show ( ) <EOL> def plotPartials ( binFrequencies , maxFreq , magnitudes ) : <EOL> """<STR_LIT>""" <EOL> T = int ( maxFreq ) <EOL> pylab . figure ( '<STR_LIT>' ) <EOL> pylab . plot ( binFrequencies [ : T ] , magnitudes [ : T ] , ) <EOL> pylab . xlabel ( '<STR_LIT>' ) <EOL> pylab . ylabel ( '<STR_LIT>' ) <EOL> pylab . show ( ) <EOL> def plotPowerSpectrum ( FFT , binFrequencies , maxFreq ) : <EOL> """<STR_LIT>""" <EOL> T = int ( maxFreq ) <EOL> pylab . figure ( '<STR_LIT>' ) <EOL> pylab . plot ( binFrequencies [ : T ] , scipy . absolute ( FFT [ : T ] ) * scipy . absolute ( FFT [ : T ] ) , ) <EOL> pylab . xlabel ( '<STR_LIT>' ) <EOL> pylab . ylabel ( '<STR_LIT>' ) <EOL> pylab . show ( ) <EOL> def get_frequencies_axis ( framerate , fft_length ) : <EOL> binResolution = float ( framerate ) / float ( fft_length ) <EOL> binFreqs = [ ] <EOL> for k in range ( fft_length ) : <EOL> binFreq = k * binResolution <EOL> binFreqs . append ( binFreq ) <EOL> return binFreqs <EOL> def get_next_power_2 ( n ) : <EOL> """<STR_LIT>""" <EOL> power = <NUM_LIT:1> <EOL> while ( power < n ) : <EOL> power *= <NUM_LIT:2> <EOL> if power > <NUM_LIT:1> : <EOL> return power / <NUM_LIT:2> <EOL> else : <EOL> return <NUM_LIT:1> <EOL> class MIDI_Detector ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , wav_file ) : <EOL> self . wav_file = wav_file <EOL> self . minFreqConsidered = <NUM_LIT:20> <EOL> self . maxFreqConsidered = <NUM_LIT> <EOL> self . low_f0s = [ <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <EOL> <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <EOL> <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> ] <EOL> def detect_MIDI_notes ( self ) : <EOL> """<STR_LIT>""" <EOL> ( framerate , sample ) = wav . read ( self . wav_file ) <EOL> if get_channels_no ( self . wav_file ) > <NUM_LIT:1> : <EOL> sample = sample . mean ( axis = <NUM_LIT:1> ) <EOL> duration = getDuration ( self . wav_file ) <EOL> midi_notes = [ ] <EOL> if duration > <NUM_LIT> : <EOL> FFT , filteredFreqs , maxFreq , magnitudes , significant_freq = self . calculateFFT ( duration , framerate , sample ) <EOL> clusters = self . clusterFrequencies ( filteredFreqs ) <EOL> averagedClusters = self . getClustersMeans ( clusters ) <EOL> f0_candidates = self . getF0Candidates ( averagedClusters ) <EOL> midi_notes = self . matchWithMIDINotes ( f0_candidates ) <EOL> '''<STR_LIT>''' <EOL> '''<STR_LIT>''' <EOL> return midi_notes <EOL> def remove_lower_octave ( self , upper_octave , midi_notes ) : <EOL> lower_octave = upper_octave - <NUM_LIT:12> <EOL> if lower_octave in midi_notes : <EOL> midi_notes . remove ( lower_octave ) <EOL> return midi_notes <EOL> def get_candidates_with_partials ( self , frequencies , magnitudes ) : <EOL> print frequencies <EOL> partial_margin = <NUM_LIT> <EOL> candidates_freq = [ ] <EOL> candidates_magnitude = [ ] <EOL> for i in range ( len ( frequencies ) ) : <EOL> partials , partial_magnitudes = self . find_partials ( <EOL> frequencies [ i : ] , frequencies [ i ] , magnitudes [ i : ] ) <EOL> candidates_freq . append ( partials ) <EOL> candidates_magnitude . append ( partial_magnitudes ) <EOL> return ( candidates_freq , candidates_magnitude ) <EOL> def calculateFFT ( self , duration , framerate , sample ) : <EOL> """<STR_LIT>""" <EOL> fft_length = int ( duration * framerate ) <EOL> fft_length = get_next_power_2 ( fft_length ) <EOL> FFT = numpy . fft . fft ( sample , n = fft_length ) <EOL> '''<STR_LIT>''' <EOL> threshold = <NUM_LIT:0> <EOL> power_spectra = [ ] <EOL> frequency_bin_with_max_spectrum = <NUM_LIT:0> <EOL> for i in range ( len ( FFT ) / <NUM_LIT:2> ) : <EOL> power_spectrum = scipy . absolute ( FFT [ i ] ) * scipy . absolute ( FFT [ i ] ) <EOL> if power_spectrum > threshold : <EOL> threshold = power_spectrum <EOL> frequency_bin_with_max_spectrum = i <EOL> power_spectra . append ( power_spectrum ) <EOL> max_power_spectrum = threshold <EOL> threshold *= <NUM_LIT:0.1> <EOL> binFrequencies = [ ] <EOL> magnitudes = [ ] <EOL> binResolution = float ( framerate ) / float ( fft_length ) <EOL> sum_of_significant_spectra = <NUM_LIT:0> <EOL> for k in range ( len ( FFT ) ) : <EOL> binFreq = k * binResolution <EOL> if binFreq > self . maxFreqConsidered : <EOL> FFT = FFT [ : k ] <EOL> break <EOL> elif binFreq > self . minFreqConsidered : <EOL> power_spectrum = power_spectra [ k ] <EOL> if power_spectrum > threshold : <EOL> magnitudes . append ( power_spectrum ) <EOL> binFrequencies . append ( binFreq ) <EOL> if power_spectrum != max_power_spectrum : <EOL> sum_of_significant_spectra += power_spectrum <EOL> significant_freq = <NUM_LIT:0.0> <EOL> if max_power_spectrum > sum_of_significant_spectra : <EOL> significant_freq = frequency_bin_with_max_spectrum * binResolution <EOL> maxFreq = len ( FFT ) / duration <EOL> return ( FFT , binFrequencies , maxFreq , magnitudes , significant_freq ) <EOL> def STFT ( self , x , samplingFreq , framesz , hop ) : <EOL> """<STR_LIT>""" <EOL> framesamp = int ( framesz * samplingFreq ) <EOL> print '<STR_LIT>' + str ( framesamp ) <EOL> hopsamp = int ( hop * samplingFreq ) <EOL> print '<STR_LIT>' + str ( hopsamp ) <EOL> w = signal . hann ( framesamp ) <EOL> X = numpy . array ( [ numpy . fft . fft ( w * x [ i : i + framesamp ] ) <EOL> for i in range ( <NUM_LIT:0> , len ( x ) - framesamp , hopsamp ) ] ) <EOL> return X <EOL> def plotMagnitudeSpectrogram ( self , rate , sample , framesz , hop ) : <EOL> """<STR_LIT>""" <EOL> X = self . STFT ( sample , rate , framesz , hop ) <EOL> pylab . figure ( '<STR_LIT>' ) <EOL> pylab . imshow ( scipy . absolute ( X . T ) , origin = '<STR_LIT>' , aspect = '<STR_LIT>' , <EOL> interpolation = '<STR_LIT>' ) <EOL> pylab . xlabel ( '<STR_LIT>' ) <EOL> pylab . ylabel ( '<STR_LIT>' ) <EOL> pylab . show ( ) <EOL> def getFilteredFFT ( self , FFT , duration , threshold ) : <EOL> """<STR_LIT>""" <EOL> significantFreqs = [ ] <EOL> for i in range ( len ( FFT ) ) : <EOL> power_spectrum = scipy . absolute ( FFT [ i ] ) * scipy . absolute ( FFT [ i ] ) <EOL> if power_spectrum > threshold : <EOL> significantFreqs . append ( i / duration ) <EOL> return significantFreqs <EOL> def clusterFrequencies ( self , freqs ) : <EOL> """<STR_LIT>""" <EOL> if len ( freqs ) == <NUM_LIT:0> : <EOL> return { } <EOL> clusteredFreqs = { } <EOL> bin = <NUM_LIT:0> <EOL> clusteredFreqs [ <NUM_LIT:0> ] = [ freqs [ <NUM_LIT:0> ] ] <EOL> for i in range ( len ( freqs ) - <NUM_LIT:1> ) : <EOL> dist = self . calcDistance ( freqs [ i ] , freqs [ i + <NUM_LIT:1> ] ) <EOL> if dist < <NUM_LIT> : <EOL> clusteredFreqs [ bin ] . append ( freqs [ i + <NUM_LIT:1> ] ) <EOL> else : <EOL> bin += <NUM_LIT:1> <EOL> clusteredFreqs [ bin ] = [ freqs [ i + <NUM_LIT:1> ] ] <EOL> return clusteredFreqs <EOL> def getClustersMeans ( self , clusters ) : <EOL> """<STR_LIT>""" <EOL> means = [ ] <EOL> for bin , freqs in clusters . iteritems ( ) : <EOL> means . append ( sum ( freqs ) / len ( freqs ) ) <EOL> return means <EOL> def getDistances ( self , freqs ) : <EOL> """<STR_LIT>""" <EOL> distances = { ( freqs [ i ] , freqs [ j ] ) : self . calcDistance ( freqs [ i ] , freqs [ j ] ) <EOL> for ( i , j ) in product ( range ( len ( freqs ) ) , repeat = <NUM_LIT:2> ) } <EOL> distances = { freq_pair : dist for freq_pair , dist in distances . iteritems ( ) if dist < <NUM_LIT> } <EOL> return distances <EOL> def calcDistance ( self , freq1 , freq2 ) : <EOL> """<STR_LIT>""" <EOL> difference = abs ( freq1 - freq2 ) <EOL> log = math . log ( ( freq1 + freq2 ) / <NUM_LIT:2> ) <EOL> return difference / log <EOL> def getF0Candidates ( self , frequencies ) : <EOL> """<STR_LIT>""" <EOL> f0_candidates = [ ] <EOL> '''<STR_LIT>''' <EOL> '''<STR_LIT>''' <EOL> while len ( frequencies ) > <NUM_LIT:0> : <EOL> f0_candidate = frequencies [ <NUM_LIT:0> ] <EOL> f0_candidates . append ( f0_candidate ) <EOL> frequencies . remove ( f0_candidate ) <EOL> frequencies = self . filterOutHarmonics ( frequencies , f0_candidate ) <EOL> return f0_candidates <EOL> def filterOutHarmonics ( self , frequencies , f0_candidate ) : <EOL> """<STR_LIT>""" <EOL> REMAINDER_THRESHOLD = <NUM_LIT> <EOL> def is_multiple ( f , f0 ) : <EOL> return abs ( round ( f / f0 ) - f / f0 ) < REMAINDER_THRESHOLD <EOL> return [ f for f in frequencies if not is_multiple ( f , f0_candidate ) ] <EOL> def find_low_freq_candidate ( self , frequencies ) : <EOL> REMAINDER_THRESHOLD = <NUM_LIT> <EOL> f0_candidates = [ ] <EOL> def is_multiple ( f , f0 ) : <EOL> return abs ( round ( f / f0 ) - f / f0 ) < REMAINDER_THRESHOLD <EOL> best_candidate = - <NUM_LIT:1> <EOL> max_no_partials = <NUM_LIT:0> <EOL> for low_f0 in self . low_f0s : <EOL> num_of_partials = <NUM_LIT:0> <EOL> for f in frequencies : <EOL> if is_multiple ( f , low_f0 ) : <EOL> num_of_partials += <NUM_LIT:1> <EOL> if num_of_partials > max_no_partials : <EOL> max_no_partials = num_of_partials <EOL> best_candidate = low_f0 <EOL> return best_candidate <EOL> def find_partials ( self , frequencies , f0_candidate , magnitudes ) : <EOL> """<STR_LIT>""" <EOL> REMAINDER_THRESHOLD = <NUM_LIT> <EOL> def is_multiple ( f , f0 ) : <EOL> return abs ( round ( f / f0 ) - f / f0 ) < REMAINDER_THRESHOLD <EOL> partials = [ ] <EOL> partial_magnitudes = [ ] <EOL> for i in range ( len ( frequencies ) ) : <EOL> if is_multiple ( frequencies [ i ] , f0_candidate ) : <EOL> partials . append ( frequencies [ i ] ) <EOL> partial_magnitudes . append ( magnitudes [ i ] ) <EOL> return ( partials , partial_magnitudes ) <EOL> def matchWithMIDINotes ( self , f0_candidates ) : <EOL> midi_notes = [ ] <EOL> for freq in f0_candidates : <EOL> midi_notes . append ( int ( <EOL> round ( <NUM_LIT> + <NUM_LIT:12> * math . log ( freq / <NUM_LIT> ) / math . log ( <NUM_LIT:2> ) ) ) ) <EOL> return midi_notes <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> MIDI_detector = MIDI_Detector ( sys . argv [ <NUM_LIT:1> ] ) <EOL> midi_notes = MIDI_detector . detect_MIDI_notes ( ) <EOL> print midi_notes </s>

<s> __author__ = '<STR_LIT>' <EOL> class Action ( object ) : <EOL> def GetActionName ( self ) : <EOL> return self . __name <EOL> def SetActionName ( self , name ) : <EOL> self . __name = name <EOL> def __init__ ( self , name ) : <EOL> self . __name = name </s>

<s> import _cffi_backend <EOL> ffi = _cffi_backend . FFI ( '<STR_LIT>' , <EOL> _version = <NUM_LIT> , <EOL> _types = b'<STR_LIT>' , <EOL> _globals = ( b'<STR_LIT>' , <NUM_LIT:0> , ) , <EOL> ) </s>

<s> from dnslib import * <EOL> packet = binascii . unhexlify ( b'<STR_LIT>' ) <EOL> d = DNSRecord . parse ( packet ) <EOL> print d </s>

<s> from app import app <EOL> if __name__ == "<STR_LIT:__main__>" : <EOL> app . run ( ) </s>

<s> from flask import render_template , Blueprint , redirect , request , url_for <EOL> from . . forms import SigninForm , SignupForm <EOL> from . . utils . account import signin_user , signout_user <EOL> from . . utils . permissions import VisitorPermission , UserPermission <EOL> from . . models import db , User <EOL> bp = Blueprint ( '<STR_LIT>' , __name__ ) <EOL> @ bp . route ( '<STR_LIT>' , methods = [ '<STR_LIT:GET>' , '<STR_LIT:POST>' ] ) <EOL> @ VisitorPermission ( ) <EOL> def signin ( ) : <EOL> """<STR_LIT>""" <EOL> form = SigninForm ( ) <EOL> if form . validate_on_submit ( ) : <EOL> signin_user ( form . user ) <EOL> return redirect ( url_for ( '<STR_LIT>' ) ) <EOL> return render_template ( '<STR_LIT>' , form = form ) <EOL> @ bp . route ( '<STR_LIT>' , methods = [ '<STR_LIT:GET>' , '<STR_LIT:POST>' ] ) <EOL> @ VisitorPermission ( ) <EOL> def signup ( ) : <EOL> """<STR_LIT>""" <EOL> form = SignupForm ( ) <EOL> if form . validate_on_submit ( ) : <EOL> params = form . data . copy ( ) <EOL> params . pop ( '<STR_LIT>' ) <EOL> user = User ( ** params ) <EOL> db . session . add ( user ) <EOL> db . session . commit ( ) <EOL> signin_user ( user ) <EOL> return redirect ( url_for ( '<STR_LIT>' ) ) <EOL> return render_template ( '<STR_LIT>' , form = form ) <EOL> @ bp . route ( '<STR_LIT>' ) <EOL> def signout ( ) : <EOL> """<STR_LIT>""" <EOL> signout_user ( ) <EOL> return redirect ( request . referrer or url_for ( '<STR_LIT>' ) ) </s>

<s> from app import app , db <EOL> import unittest <EOL> import os <EOL> import tempfile <EOL> from flask import json <EOL> TEST_DB = '<STR_LIT>' <EOL> class BasicTestCase ( unittest . TestCase ) : <EOL> def test_index ( self ) : <EOL> """<STR_LIT>""" <EOL> tester = app . test_client ( self ) <EOL> response = tester . get ( '<STR_LIT:/>' , content_type = '<STR_LIT>' ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> def test_database ( self ) : <EOL> """<STR_LIT>""" <EOL> tester = os . path . exists ( "<STR_LIT>" ) <EOL> self . assertTrue ( tester ) <EOL> class FlaskrTestCase ( unittest . TestCase ) : <EOL> def setUp ( self ) : <EOL> """<STR_LIT>""" <EOL> basedir = os . path . abspath ( os . path . dirname ( __file__ ) ) <EOL> app . config [ '<STR_LIT>' ] = True <EOL> app . config [ '<STR_LIT>' ] = '<STR_LIT>' + os . path . join ( basedir , TEST_DB ) <EOL> self . app = app . test_client ( ) <EOL> db . create_all ( ) <EOL> def tearDown ( self ) : <EOL> """<STR_LIT>""" <EOL> db . drop_all ( ) <EOL> def login ( self , username , password ) : <EOL> """<STR_LIT>""" <EOL> return self . app . post ( '<STR_LIT>' , data = dict ( <EOL> username = username , <EOL> password = password <EOL> ) , follow_redirects = True ) <EOL> def logout ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . app . get ( '<STR_LIT>' , follow_redirects = True ) <EOL> def test_empty_db ( self ) : <EOL> """<STR_LIT>""" <EOL> rv = self . app . get ( '<STR_LIT:/>' ) <EOL> self . assertIn ( b'<STR_LIT>' , rv . data ) <EOL> def test_login_logout ( self ) : <EOL> """<STR_LIT>""" <EOL> rv = self . login ( app . config [ '<STR_LIT>' ] , app . config [ '<STR_LIT>' ] ) <EOL> self . assertIn ( b'<STR_LIT>' , rv . data ) <EOL> rv = self . logout ( ) <EOL> self . assertIn ( b'<STR_LIT>' , rv . data ) <EOL> rv = self . login ( app . config [ '<STR_LIT>' ] + '<STR_LIT:x>' , app . config [ '<STR_LIT>' ] ) <EOL> self . assertIn ( b'<STR_LIT>' , rv . data ) <EOL> rv = self . login ( app . config [ '<STR_LIT>' ] , app . config [ '<STR_LIT>' ] + '<STR_LIT:x>' ) <EOL> self . assertIn ( b'<STR_LIT>' , rv . data ) <EOL> def test_messages ( self ) : <EOL> """<STR_LIT>""" <EOL> self . login ( app . config [ '<STR_LIT>' ] , app . config [ '<STR_LIT>' ] ) <EOL> rv = self . app . post ( '<STR_LIT>' , data = dict ( <EOL> title = '<STR_LIT>' , <EOL> text = '<STR_LIT>' <EOL> ) , follow_redirects = True ) <EOL> self . assertNotIn ( b'<STR_LIT>' , rv . data ) <EOL> self . assertIn ( b'<STR_LIT>' , rv . data ) <EOL> self . assertIn ( b'<STR_LIT>' , rv . data ) <EOL> def test_delete_message ( self ) : <EOL> """<STR_LIT>""" <EOL> rv = self . app . get ( '<STR_LIT>' ) <EOL> data = json . loads ( rv . data ) <EOL> self . assertEqual ( data [ '<STR_LIT:status>' ] , <NUM_LIT:1> ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> unittest . main ( ) </s>

<s> import json <EOL> data = [ { '<STR_LIT:a>' : '<STR_LIT:A>' , '<STR_LIT:b>' : ( <NUM_LIT:2> , <NUM_LIT:4> ) , '<STR_LIT:c>' : <NUM_LIT> } ] <EOL> print '<STR_LIT>' , repr ( data ) <EOL> unsorted = json . dumps ( data ) <EOL> print '<STR_LIT>' , json . dumps ( data ) <EOL> print '<STR_LIT>' , json . dumps ( data , sort_keys = True ) <EOL> first = json . dumps ( data , sort_keys = True ) <EOL> second = json . dumps ( data , sort_keys = True ) <EOL> print '<STR_LIT>' , unsorted == first <EOL> print '<STR_LIT>' , first == second </s>

<s> people = <NUM_LIT:30> <EOL> cars = <NUM_LIT> <EOL> trucks = <NUM_LIT:15> <EOL> if cars > people : <EOL> print "<STR_LIT>" <EOL> elif cars < people : <EOL> print "<STR_LIT>" <EOL> else : <EOL> print "<STR_LIT>" <EOL> if trucks > cars : <EOL> print "<STR_LIT>" <EOL> elif trucks < cars : <EOL> print "<STR_LIT>" <EOL> else : <EOL> print "<STR_LIT>" <EOL> if people > trucks : <EOL> print "<STR_LIT>" <EOL> else : <EOL> print "<STR_LIT>" </s>

<s> import thread <EOL> import time <EOL> mylock = thread . allocate_lock ( ) <EOL> num = <NUM_LIT:0> <EOL> def add_num ( name ) : <EOL> global num <EOL> while True : <EOL> mylock . acquire ( ) <EOL> print ( '<STR_LIT>' % ( name , str ( num ) ) ) <EOL> if num >= <NUM_LIT:5> : <EOL> print ( '<STR_LIT>' % ( name , str ( num ) ) ) <EOL> mylock . release ( ) <EOL> thread . exit ( ) <EOL> num += <NUM_LIT:1> <EOL> print ( '<STR_LIT>' % ( name , str ( num ) ) ) <EOL> mylock . release ( ) <EOL> def test ( ) : <EOL> thread . start_new_thread ( add_num , ( '<STR_LIT:A>' , ) ) <EOL> thread . start_new_thread ( add_num , ( '<STR_LIT:B>' , ) ) <EOL> time . sleep ( <NUM_LIT:30> ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> test ( ) </s>

<s> """<STR_LIT>""" <EOL> import os . path <EOL> import os <EOL> os . environ [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> print os . path . expandvars ( '<STR_LIT>' ) </s>

<s> from __future__ import print_function <EOL> import pyglet <EOL> from pyglet . window import key <EOL> from pyglet . window import mouse <EOL> window = pyglet . window . Window ( ) <EOL> @ window . event <EOL> def on_key_press ( symbol , modifiers ) : <EOL> print ( "<STR_LIT>" % symbol ) <EOL> if symbol == key . A : <EOL> print ( '<STR_LIT>' ) <EOL> elif symbol == key . LEFT : <EOL> print ( '<STR_LIT>' ) <EOL> elif symbol == key . ENTER : <EOL> print ( '<STR_LIT>' ) <EOL> @ window . event <EOL> def on_mouse_press ( x , y , button , modifiers ) : <EOL> print ( "<STR_LIT>" % ( x , y , button ) ) <EOL> if button == mouse . LEFT : <EOL> print ( '<STR_LIT>' ) <EOL> @ window . event <EOL> def on_draw ( ) : <EOL> window . clear ( ) <EOL> pyglet . app . run ( ) </s>

<s> number = <NUM_LIT> <EOL> go = True <EOL> while go : <EOL> guess = int ( raw_input ( '<STR_LIT>' ) ) <EOL> if guess == number : <EOL> print '<STR_LIT>' <EOL> go = False <EOL> elif guess < number : <EOL> print '<STR_LIT>' <EOL> else : <EOL> print '<STR_LIT>' <EOL> else : <EOL> print '<STR_LIT>' </s>

<s> import os <EOL> from setuptools import setup , find_packages <EOL> here = os . path . abspath ( os . path . dirname ( __file__ ) ) <EOL> with open ( os . path . join ( here , '<STR_LIT>' ) ) as f : <EOL> README = f . read ( ) <EOL> with open ( os . path . join ( here , '<STR_LIT>' ) ) as f : <EOL> CHANGES = f . read ( ) <EOL> requires = [ <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ] <EOL> setup ( name = '<STR_LIT>' , <EOL> version = '<STR_LIT>' , <EOL> description = '<STR_LIT>' , <EOL> long_description = README + '<STR_LIT>' + CHANGES , <EOL> classifiers = [ <EOL> "<STR_LIT>" , <EOL> "<STR_LIT>" , <EOL> "<STR_LIT>" , <EOL> "<STR_LIT>" , <EOL> ] , <EOL> author = '<STR_LIT>' , <EOL> author_email = '<STR_LIT>' , <EOL> url = '<STR_LIT>' , <EOL> keywords = '<STR_LIT>' , <EOL> packages = find_packages ( ) , <EOL> include_package_data = True , <EOL> zip_safe = False , <EOL> test_suite = '<STR_LIT>' , <EOL> install_requires = requires , <EOL> entry_points = """<STR_LIT>""" , <EOL> ) </s>

<s> from mako . template import Template <EOL> from mako . runtime import Context <EOL> from StringIO import StringIO <EOL> mytemplate = Template ( "<STR_LIT>" ) <EOL> buf = StringIO ( ) <EOL> ctx = Context ( buf , name = "<STR_LIT>" ) <EOL> mytemplate . render_context ( ctx ) <EOL> print ( buf . getvalue ( ) ) </s>

<s> """<STR_LIT>""" <EOL> import unittest <EOL> class InequalityTest ( unittest . TestCase ) : <EOL> def testEqual ( self ) : <EOL> self . failIfEqual ( <NUM_LIT:1> , <NUM_LIT:3> - <NUM_LIT:2> ) <EOL> def testNotEqual ( self ) : <EOL> self . failUnlessEqual ( <NUM_LIT:2> , <NUM_LIT:3> - <NUM_LIT:2> ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> unittest . main ( ) </s>

<s> from flask import Flask <EOL> from flask . ext . fragment import Fragment <EOL> from flask . ext . login import LoginManager <EOL> from flask . ext . sqlalchemy import SQLAlchemy <EOL> app = Flask ( __name__ ) <EOL> db = SQLAlchemy ( app ) <EOL> fragment = Fragment ( app ) <EOL> login = LoginManager ( app ) <EOL> from models import User , Post , Comment , LoginForm , RegisterForm , PostForm , CommentForm <EOL> from flask . ext . login import current_user , login_required , login_user , logout_user <EOL> from flask import render_template , redirect , url_for , request , flash <EOL> from models import User , Post , Comment , LoginForm , RegisterForm , PostForm , CommentForm <EOL> from flask . ext . login import current_user , login_required , login_user , logout_user <EOL> from flask import render_template , redirect , url_for , request , flash <EOL> POSTS_ON_PAGE = <NUM_LIT:20> <EOL> COMMENTS_ON_PAGE = <NUM_LIT:20> <EOL> @ login . user_loader <EOL> def load_user ( userid ) : <EOL> return User . get ( userid ) <EOL> @ app . errorhandler ( <NUM_LIT> ) <EOL> def page_not_found ( e ) : <EOL> return render_template ( '<STR_LIT>' ) , <NUM_LIT> <EOL> @ login . unauthorized_handler <EOL> def unauthorized ( ) : <EOL> flash ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> return redirect ( url_for ( '<STR_LIT:index>' ) ) <EOL> @ fragment ( app ) <EOL> def login_form ( ) : <EOL> return render_template ( '<STR_LIT>' , form = LoginForm ( ) ) <EOL> @ app . route ( '<STR_LIT>' , methods = [ '<STR_LIT:POST>' ] ) <EOL> def login ( ) : <EOL> form = LoginForm ( ) <EOL> if form . validate_on_submit ( ) : <EOL> login_user ( form . user ) <EOL> flash ( '<STR_LIT>' , '<STR_LIT:info>' ) <EOL> return redirect ( request . args . get ( '<STR_LIT>' ) or url_for ( '<STR_LIT:index>' ) ) <EOL> return redirect ( url_for ( '<STR_LIT:index>' ) ) <EOL> @ app . route ( "<STR_LIT>" ) <EOL> @ login_required <EOL> def logout ( ) : <EOL> logout_user ( ) <EOL> return redirect ( url_for ( '<STR_LIT:index>' ) ) <EOL> @ app . route ( '<STR_LIT>' , methods = [ '<STR_LIT:GET>' , '<STR_LIT:POST>' ] ) <EOL> def register ( ) : <EOL> form = RegisterForm ( ) <EOL> if form . validate_on_submit ( ) : <EOL> db . session . add ( form . user ) <EOL> db . session . commit ( ) <EOL> login_user ( form . user ) <EOL> flash ( '<STR_LIT>' , '<STR_LIT:info>' ) <EOL> return redirect ( url_for ( '<STR_LIT:index>' ) ) <EOL> return render_template ( '<STR_LIT>' , form = form ) <EOL> @ fragment ( app , cache = <NUM_LIT> ) <EOL> def user_info ( userid ) : <EOL> return render_template ( '<STR_LIT>' ) <EOL> @ fragment ( app , cache = <NUM_LIT> ) <EOL> def posts_list ( page ) : <EOL> page = int ( page ) <EOL> page_size = POSTS_ON_PAGE <EOL> pagination = Post . query . filter_by ( ) . paginate ( page , page_size ) <EOL> posts = Post . query . filter_by ( ) . offset ( ( page - <NUM_LIT:1> ) * page_size ) . limit ( page_size ) . all ( ) <EOL> return render_template ( '<STR_LIT>' , pagination = pagination , posts = posts ) <EOL> @ fragment . resethandler ( posts_list ) <EOL> def reset_posts_list ( ) : <EOL> page_size = POSTS_ON_PAGE <EOL> pagination = Post . query . filter_by ( ) . paginate ( <NUM_LIT:1> , page_size ) <EOL> for N in range ( pagination . pages ) : <EOL> fragment . reset_url ( url_for ( '<STR_LIT>' , page = N + <NUM_LIT:1> ) ) <EOL> @ app . route ( '<STR_LIT>' ) <EOL> @ app . route ( '<STR_LIT:/>' , endpoint = '<STR_LIT:index>' , defaults = { '<STR_LIT>' : <NUM_LIT:1> } ) <EOL> def posts ( page ) : <EOL> return render_template ( '<STR_LIT>' , page = page ) <EOL> @ fragment ( app , cache = <NUM_LIT> ) <EOL> def post_show ( post_id ) : <EOL> post = Post . query . filter_by ( id = post_id ) . first ( ) <EOL> return render_template ( '<STR_LIT>' , post = post ) <EOL> @ fragment ( app , cache = <NUM_LIT> ) <EOL> def comments_list ( post_id , page ) : <EOL> page = int ( page ) <EOL> page_size = COMMENTS_ON_PAGE <EOL> pagination = Comment . query . filter_by ( post_id = post_id ) . paginate ( page , page_size ) <EOL> comments = Comment . query . filter_by ( post_id = post_id ) . offset ( ( page - <NUM_LIT:1> ) * page_size ) . limit ( page_size ) . all ( ) <EOL> return render_template ( '<STR_LIT>' , post_id = post_id , page = page , <EOL> pagination = pagination , comments = comments ) <EOL> @ fragment . resethandler ( comments_list ) <EOL> def reset_comments_list ( post_id ) : <EOL> page_size = COMMENTS_ON_PAGE <EOL> pagination = Comment . query . filter_by ( post_id = post_id ) . paginate ( <NUM_LIT:1> , page_size ) <EOL> for N in range ( pagination . pages ) : <EOL> fragment . reset_url ( url_for ( '<STR_LIT>' , post_id = post_id , page = N + <NUM_LIT:1> ) ) <EOL> @ app . route ( '<STR_LIT>' , methods = [ '<STR_LIT:GET>' , '<STR_LIT:POST>' ] ) <EOL> def post ( post_id , page ) : <EOL> form = CommentForm ( ) <EOL> if ( current_user . is_authenticated ( ) and form . validate_on_submit ( ) ) : <EOL> form . comment . author_id = current_user . id <EOL> form . comment . post_id = post_id <EOL> db . session . add ( form . comment ) <EOL> db . session . commit ( ) <EOL> fragment . reset ( posts_list ) <EOL> fragment . reset ( comments_list , post_id ) <EOL> fragment . reset ( user_info , current_user . id ) <EOL> flash ( '<STR_LIT>' , '<STR_LIT:info>' ) <EOL> return render_template ( '<STR_LIT>' , form = form , post_id = post_id , page = page ) <EOL> @ app . route ( '<STR_LIT>' , methods = [ '<STR_LIT:GET>' , '<STR_LIT:POST>' ] ) <EOL> @ login_required <EOL> def new_post ( ) : <EOL> form = PostForm ( ) <EOL> if form . validate_on_submit ( ) : <EOL> form . post . author_id = current_user . id <EOL> db . session . add ( form . post ) <EOL> db . session . commit ( ) <EOL> fragment . reset ( posts_list ) <EOL> fragment . reset ( user_info , current_user . id ) <EOL> flash ( '<STR_LIT>' , '<STR_LIT:info>' ) <EOL> return redirect ( url_for ( '<STR_LIT:index>' ) ) <EOL> return render_template ( '<STR_LIT>' , form = form ) <EOL> class DefaultConfig ( object ) : <EOL> FRAGMENT_CACHING = True <EOL> SQLALCHEMY_DATABASE_URI = '<STR_LIT>' <EOL> SECRET_KEY = '<STR_LIT>' <EOL> import sys <EOL> import os . path <EOL> PY2 = sys . version_info [ <NUM_LIT:0> ] == <NUM_LIT:2> <EOL> from flask . ext . script import Manager <EOL> manager = Manager ( app , with_default_commands = False ) <EOL> @ manager . command <EOL> def debug ( ) : <EOL> """<STR_LIT>""" <EOL> app . config [ '<STR_LIT>' ] = True <EOL> if PY2 : <EOL> from flask_debugtoolbar import DebugToolbarExtension <EOL> DebugToolbarExtension ( app ) <EOL> app . run ( debug = True ) <EOL> @ manager . command <EOL> def nginx_conf ( ) : <EOL> """<STR_LIT>""" <EOL> file_name = os . path . join ( os . path . dirname ( os . path . dirname ( __file__ ) ) , '<STR_LIT>' ) <EOL> fragment . _create_nginx_config ( file_name ) <EOL> @ manager . command <EOL> def create_db ( ) : <EOL> """<STR_LIT>""" <EOL> from models import DB <EOL> url = app . config . get ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> if url . startswith ( '<STR_LIT>' ) : <EOL> path = url [ <NUM_LIT:10> : ] <EOL> if not os . path . exists ( path ) : <EOL> os . makedirs ( path ) <EOL> DB . create_all ( ) <EOL> DB . session . commit ( ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> app . config . from_object ( DefaultConfig ) <EOL> manager . run ( ) </s>

<s> from tests . common import parent_id , parent_name , child_id , child_parent_id , relation , child , parent <EOL> from eralchemy . main import _intermediary_to_markdown <EOL> import re <EOL> import pytest <EOL> column_re = re . compile ( '<STR_LIT>' ) <EOL> def test_all_to_er ( ) : <EOL> tables = [ child , parent ] <EOL> relations = [ relation ] <EOL> output = _intermediary_to_markdown ( tables , relations ) <EOL> for element in relations + tables : <EOL> assert element . to_markdown ( ) in output <EOL> def assert_column_well_rendered_to_er ( col ) : <EOL> col_er = col . to_markdown ( ) . strip ( ) <EOL> col_parsed = column_re . match ( col_er ) <EOL> assert col_parsed . group ( '<STR_LIT:key>' ) == ( '<STR_LIT:*>' if col . is_key else '<STR_LIT>' ) <EOL> assert col_parsed . group ( '<STR_LIT:name>' ) == col . name <EOL> assert col_parsed . group ( '<STR_LIT:type>' ) == col . type <EOL> def test_column_to_er ( ) : <EOL> assert_column_well_rendered_to_er ( parent_id ) <EOL> assert_column_well_rendered_to_er ( parent_name ) <EOL> assert_column_well_rendered_to_er ( child_id ) <EOL> assert_column_well_rendered_to_er ( child_parent_id ) <EOL> def test_relation ( ) : <EOL> assert relation . to_markdown ( ) in [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> def assert_table_well_rendered_to_er ( table ) : <EOL> assert table . header_markdown == '<STR_LIT:[>' + table . name + '<STR_LIT:]>' <EOL> table_er = table . to_markdown ( ) <EOL> for col in table . columns : <EOL> assert col . to_markdown ( ) in table_er <EOL> def test_table ( ) : <EOL> assert_table_well_rendered_to_er ( child ) <EOL> assert_table_well_rendered_to_er ( parent ) </s>

<s> from django . http import Http404 <EOL> from django . shortcuts import render_to_response <EOL> from django . core . paginator import Paginator , EmptyPage , PageNotAnInteger <EOL> def choice_list ( request , app_label , module_name , field_name , models ) : <EOL> m , f = lookup_field ( app_label , module_name , field_name , models ) <EOL> return render_to_response ( <EOL> '<STR_LIT>' , <EOL> { '<STR_LIT>' : m , '<STR_LIT>' : f } <EOL> ) <EOL> def choice_detail ( request , app_label , module_name , field_name , <EOL> field_val , models ) : <EOL> m , f = lookup_field ( app_label , module_name , field_name , models ) <EOL> try : <EOL> label = dict ( f . field . choices ) [ field_val ] <EOL> except KeyError : <EOL> raise Http404 ( '<STR_LIT>' ) <EOL> obj_list = m . objects ( ** { f . field . name : field_val } ) <EOL> numitems = request . GET . get ( '<STR_LIT>' ) <EOL> items_per_page = [ <NUM_LIT> , <NUM_LIT:50> , <NUM_LIT:100> ] <EOL> if numitems and numitems . isdigit ( ) and int ( numitems ) > <NUM_LIT:0> : <EOL> paginator = Paginator ( obj_list , numitems ) <EOL> else : <EOL> paginator = Paginator ( obj_list , items_per_page [ <NUM_LIT:0> ] ) <EOL> page = request . GET . get ( '<STR_LIT>' ) <EOL> try : <EOL> obj_list_page = paginator . page ( page ) <EOL> except PageNotAnInteger : <EOL> obj_list_page = paginator . page ( <NUM_LIT:1> ) <EOL> except EmptyPage : <EOL> obj_list_page = paginator . page ( paginator . num_pages ) <EOL> return render_to_response ( <EOL> '<STR_LIT>' , <EOL> { <EOL> '<STR_LIT>' : m , <EOL> '<STR_LIT>' : f , <EOL> '<STR_LIT:value>' : label , <EOL> '<STR_LIT>' : obj_list_page , <EOL> '<STR_LIT>' : items_per_page , <EOL> } <EOL> ) </s>

<s> """<STR_LIT>""" </s>

<s> """<STR_LIT>""" </s>

<s> from __future__ import unicode_literals <EOL> from django . db import migrations , models <EOL> class Migration ( migrations . Migration ) : <EOL> dependencies = [ <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ] <EOL> operations = [ <EOL> migrations . AddField ( <EOL> model_name = '<STR_LIT:user>' , <EOL> name = '<STR_LIT>' , <EOL> field = models . TextField ( null = True , blank = True ) , <EOL> preserve_default = True , <EOL> ) , <EOL> migrations . AddField ( <EOL> model_name = '<STR_LIT:user>' , <EOL> name = '<STR_LIT>' , <EOL> field = models . ForeignKey ( blank = True , to = '<STR_LIT>' , null = True ) , <EOL> preserve_default = True , <EOL> ) , <EOL> ] </s>

<s> """<STR_LIT>""" <EOL> class User ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self ) : <EOL> """<STR_LIT>""" <EOL> pass <EOL> def current_user ( self ) : <EOL> """<STR_LIT>""" <EOL> url = self . root_collection [ '<STR_LIT>' ] [ '<STR_LIT>' ] [ <NUM_LIT:0> ] [ '<STR_LIT>' ] [ '<STR_LIT>' ] [ '<STR_LIT>' ] <EOL> return url <EOL> def current_user_person ( self ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> url = self . collections [ "<STR_LIT>" ] [ "<STR_LIT>" ] [ "<STR_LIT>" ] [ <NUM_LIT:0> ] [ <EOL> "<STR_LIT>" ] [ "<STR_LIT>" ] [ "<STR_LIT>" ] <EOL> except KeyError : <EOL> self . update_collection ( "<STR_LIT>" ) <EOL> url = self . collections [ "<STR_LIT>" ] [ "<STR_LIT>" ] [ "<STR_LIT>" ] [ <NUM_LIT:0> ] [ <EOL> "<STR_LIT>" ] [ "<STR_LIT>" ] [ "<STR_LIT>" ] <EOL> return url <EOL> def agent ( self , uid ) : <EOL> """<STR_LIT>""" <EOL> return self . user_base + "<STR_LIT>" + uid <EOL> def current_user_history ( self ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> url = self . collections [ "<STR_LIT>" ] [ "<STR_LIT>" ] [ "<STR_LIT>" ] [ <NUM_LIT:0> ] [ <EOL> "<STR_LIT>" ] [ "<STR_LIT>" ] [ "<STR_LIT>" ] <EOL> except KeyError : <EOL> self . update_collection ( "<STR_LIT>" ) <EOL> url = self . collections [ "<STR_LIT>" ] [ "<STR_LIT>" ] [ "<STR_LIT>" ] [ <NUM_LIT:0> ] [ <EOL> "<STR_LIT>" ] [ "<STR_LIT>" ] [ "<STR_LIT>" ] <EOL> return url </s>

<s> '''<STR_LIT>''' <EOL> from __future__ import unicode_literals , print_function <EOL> from argparse import FileType <EOL> import logging <EOL> import sys <EOL> import yaml <EOL> from chalmers . utils . cli import add_selection_group , select_programs <EOL> log = logging . getLogger ( '<STR_LIT>' ) <EOL> def main ( args ) : <EOL> export_data = [ ] <EOL> programs = select_programs ( args , filter_paused = False ) <EOL> for prog in programs : <EOL> export_data . append ( { '<STR_LIT>' : dict ( prog . raw_data ) } ) <EOL> yaml . safe_dump ( export_data , args . output , default_flow_style = False ) <EOL> def add_parser ( subparsers ) : <EOL> parser = subparsers . add_parser ( '<STR_LIT>' , <EOL> help = '<STR_LIT>' , <EOL> description = __doc__ ) <EOL> add_selection_group ( parser ) <EOL> parser . add_argument ( '<STR_LIT>' , '<STR_LIT>' , type = FileType ( '<STR_LIT:w>' ) , default = sys . stdout ) <EOL> parser . set_defaults ( main = main ) </s>

<s> """<STR_LIT>""" <EOL> from __future__ import unicode_literals , print_function <EOL> import logging <EOL> import platform <EOL> import sys <EOL> from . import cron_service , sysv_service , upstart_service , systemd_service <EOL> from chalmers import errors <EOL> if sys . version_info . major == <NUM_LIT:3> : <EOL> system_dist = ( '<STR_LIT>' , ) <EOL> else : <EOL> system_dist = ( b'<STR_LIT>' , ) <EOL> platform . _supported_dists += system_dist <EOL> log = logging . getLogger ( '<STR_LIT>' ) <EOL> class NoPosixSystemService ( object ) : <EOL> def __init__ ( self , target_user = None ) : <EOL> supported_dists = platform . _supported_dists + system_dist <EOL> linux = platform . linux_distribution ( supported_dists = supported_dists ) <EOL> raise errors . ChalmersError ( "<STR_LIT>" % linux [ <NUM_LIT:0> ] ) <EOL> if systemd_service . check ( ) : <EOL> PosixSystemService = systemd_service . SystemdService <EOL> elif sysv_service . check ( ) : <EOL> PosixSystemService = sysv_service . SysVService <EOL> elif upstart_service . check ( ) : <EOL> PosixSystemService = upstart_service . UpstartService <EOL> else : <EOL> PosixSystemService = NoPosixSystemService <EOL> PosixLocalService = cron_service . CronService </s>

<s> import abc <EOL> import logging <EOL> import traceback <EOL> import servicemanager <EOL> import win32event , win32service , win32api <EOL> from win32serviceutil import ServiceFramework <EOL> log = logging . getLogger ( __name__ ) <EOL> class WindowsService ( object , ServiceFramework ) : <EOL> """<STR_LIT>""" <EOL> __metaclass__ = abc . ABCMeta <EOL> def __init__ ( self , args ) : <EOL> try : <EOL> self . _svc_name_ = args [ <NUM_LIT:0> ] <EOL> self . _svc_display_name_ = args [ <NUM_LIT:0> ] <EOL> ServiceFramework . __init__ ( self , args ) <EOL> self . stop_event = win32event . CreateEvent ( None , <NUM_LIT:0> , <NUM_LIT:0> , None ) <EOL> except Exception : <EOL> self . log ( "<STR_LIT>" ) <EOL> self . log ( traceback . format_exc ( ) ) <EOL> raise <EOL> def log ( self , msg ) : <EOL> '<STR_LIT>' <EOL> servicemanager . LogInfoMsg ( str ( msg ) ) <EOL> def sleep ( self , sec ) : <EOL> win32api . Sleep ( sec * <NUM_LIT:1000> , True ) <EOL> def SvcDoRun ( self ) : <EOL> self . log ( '<STR_LIT:start>' ) <EOL> self . ReportServiceStatus ( win32service . SERVICE_START_PENDING ) <EOL> try : <EOL> self . ReportServiceStatus ( win32service . SERVICE_RUNNING ) <EOL> self . log ( '<STR_LIT:start>' ) <EOL> self . start ( ) <EOL> self . ReportServiceStatus ( win32service . SERVICE_STOPPED ) <EOL> self . log ( '<STR_LIT>' ) <EOL> except Exception : <EOL> self . log ( "<STR_LIT>" ) <EOL> self . log ( traceback . format_exc ( ) ) <EOL> self . SvcStop ( ) <EOL> def SvcStop ( self ) : <EOL> pass <EOL> self . ReportServiceStatus ( win32service . SERVICE_STOP_PENDING ) <EOL> self . log ( '<STR_LIT>' ) <EOL> self . stop ( ) <EOL> self . log ( '<STR_LIT>' ) <EOL> win32event . SetEvent ( self . stop_event ) <EOL> self . ReportServiceStatus ( win32service . SERVICE_STOPPED ) </s>

<s> from . . pyelliptic . ecc import * <EOL> from . . threads . threadutils import * <EOL> from . . constants import * <EOL> from . key import * <EOL> import hashlib <EOL> from struct import * <EOL> import sys <EOL> def encodeInt ( val , alphabet = ALPHABET ) : <EOL> base = len ( alphabet ) <EOL> result = "<STR_LIT>" <EOL> while val > <NUM_LIT:0> : <EOL> rem = val % base <EOL> result = str ( alphabet [ rem ] ) + result <EOL> val = val // base <EOL> return result <EOL> class Address : <EOL> def __init__ ( self , hashValue , version = VERSION ) : <EOL> self . version = version <EOL> self . hashValue = hashValue <EOL> self . encodedValue = "<STR_LIT>" <EOL> def encodeVersion ( self ) : <EOL> return pack ( '<STR_LIT>' , self . version ) <EOL> def encode ( self ) : <EOL> a = self . encodeVersion ( ) + self . hashValue <EOL> sha = hashlib . new ( '<STR_LIT>' ) <EOL> sha . update ( a ) <EOL> sha . update ( sha . digest ( ) ) <EOL> checksum = sha . digest ( ) [ <NUM_LIT:0> : <NUM_LIT:2> ] <EOL> intValue = int . from_bytes ( a + checksum , '<STR_LIT>' ) <EOL> self . encodedValue = encodeInt ( intValue ) <EOL> def genKey ( ) : <EOL> curve = ECC ( ) <EOL> pubKey = curve . get_pubkey ( ) <EOL> sha = hashlib . new ( '<STR_LIT>' ) <EOL> sha . update ( pubKey ) <EOL> ripemd = hashlib . new ( '<STR_LIT>' ) <EOL> ripemd . update ( sha . digest ( ) ) <EOL> sha . update ( ripemd . digest ( ) ) <EOL> ripemd . update ( sha . digest ( ) ) <EOL> a = Address ( ripemd . digest ( ) ) <EOL> a . encode ( ) <EOL> key = Key ( pubKey , curve . get_privkey ( ) , a . encodedValue ) <EOL> return key </s>

<s> from anymesh import AnyMesh , AnyMeshDelegateProtocol <EOL> class LeftDelegate ( AnyMeshDelegateProtocol ) : <EOL> def connected_to ( self , device_info ) : <EOL> print ( '<STR_LIT>' + device_info . name ) <EOL> def disconnected_from ( self , name ) : <EOL> pass <EOL> def received_msg ( self , message ) : <EOL> print ( '<STR_LIT>' + message . sender ) <EOL> print ( '<STR_LIT>' + message . data [ '<STR_LIT>' ] ) <EOL> leftMesh . request ( '<STR_LIT:right>' , { '<STR_LIT>' : '<STR_LIT>' } ) <EOL> class RightDelegate ( AnyMeshDelegateProtocol ) : <EOL> def connected_to ( self , device_info ) : <EOL> print ( '<STR_LIT>' + device_info . name ) <EOL> rightMesh . request ( '<STR_LIT:left>' , { '<STR_LIT>' : '<STR_LIT>' } ) <EOL> def disconnected_from ( self , name ) : <EOL> pass <EOL> def received_msg ( self , message ) : <EOL> print ( '<STR_LIT>' + message . sender ) <EOL> print ( '<STR_LIT>' + message . data [ '<STR_LIT>' ] ) <EOL> leftMesh = AnyMesh ( '<STR_LIT:left>' , '<STR_LIT>' , LeftDelegate ( ) ) <EOL> rightMesh = AnyMesh ( '<STR_LIT:right>' , '<STR_LIT>' , RightDelegate ( ) ) <EOL> AnyMesh . run ( ) </s>

<s> import unittest <EOL> import doctest <EOL> import urwid <EOL> def load_tests ( loader , tests , ignore ) : <EOL> module_doctests = [ <EOL> urwid . widget , <EOL> urwid . wimp , <EOL> urwid . decoration , <EOL> urwid . display_common , <EOL> urwid . main_loop , <EOL> urwid . monitored_list , <EOL> urwid . raw_display , <EOL> '<STR_LIT>' , <EOL> urwid . util , <EOL> urwid . signals , <EOL> ] <EOL> for m in module_doctests : <EOL> tests . addTests ( doctest . DocTestSuite ( m , <EOL> optionflags = doctest . ELLIPSIS | doctest . IGNORE_EXCEPTION_DETAIL ) ) <EOL> return tests </s>

<s> import logging <EOL> log = logging . getLogger ( __name__ ) <EOL> EXCLUDED_LOG_VARS = [ '<STR_LIT>' , '<STR_LIT:name>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:args>' , '<STR_LIT>' , '<STR_LIT:filename>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:message>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> def register_logging ( logger , client_config , cls ) : <EOL> found = False <EOL> for handler in logger . handlers : <EOL> if isinstance ( handler , cls ) : <EOL> found = True <EOL> reg_handler = handler <EOL> if not found : <EOL> reg_handler = cls ( client_config = client_config ) <EOL> logger . addHandler ( reg_handler ) <EOL> return reg_handler <EOL> def unregister_logger ( logger , handler ) : <EOL> logger . removeHandler ( handler ) </s>

<s> import uuid <EOL> import datetime <EOL> from appenlight_client . timing import get_local_storage <EOL> from appenlight_client . timing import default_timer <EOL> from appenlight_client . client import PY3 <EOL> import logging <EOL> log = logging . getLogger ( __name__ ) <EOL> class AppenlightWSGIWrapper ( object ) : <EOL> __version__ = '<STR_LIT>' <EOL> def __init__ ( self , app , appenlight_client ) : <EOL> self . app = app <EOL> self . appenlight_client = appenlight_client <EOL> def __call__ ( self , environ , start_response ) : <EOL> """<STR_LIT>""" <EOL> environ [ '<STR_LIT>' ] = str ( uuid . uuid4 ( ) ) <EOL> appenlight_storage = get_local_storage ( ) <EOL> appenlight_storage . clear ( ) <EOL> app_iter = None <EOL> detected_data = [ ] <EOL> create_report = False <EOL> traceback = None <EOL> http_status = <NUM_LIT:200> <EOL> start_time = default_timer ( ) <EOL> def detect_headers ( status , headers , * k , ** kw ) : <EOL> detected_data [ : ] = status [ : <NUM_LIT:3> ] , headers <EOL> return start_response ( status , headers , * k , ** kw ) <EOL> if '<STR_LIT>' not in environ : <EOL> environ [ '<STR_LIT>' ] = self . appenlight_client <EOL> def local_report ( message , include_traceback = True , http_status = <NUM_LIT:200> ) : <EOL> environ [ '<STR_LIT>' ] = True <EOL> def local_log ( level , message ) : <EOL> environ [ '<STR_LIT>' ] = True <EOL> environ [ '<STR_LIT>' ] = local_report <EOL> environ [ '<STR_LIT>' ] = local_log <EOL> if '<STR_LIT>' not in environ : <EOL> environ [ '<STR_LIT>' ] = { } <EOL> if '<STR_LIT>' not in environ : <EOL> environ [ '<STR_LIT>' ] = { } <EOL> try : <EOL> app_iter = self . app ( environ , detect_headers ) <EOL> return app_iter <EOL> except Exception : <EOL> if hasattr ( app_iter , '<STR_LIT>' ) : <EOL> app_iter . close ( ) <EOL> traceback = self . appenlight_client . get_current_traceback ( ) <EOL> if self . appenlight_client . config [ '<STR_LIT>' ] : <EOL> raise <EOL> try : <EOL> start_response ( '<STR_LIT>' , <EOL> [ ( '<STR_LIT:Content-Type>' , '<STR_LIT>' ) ] ) <EOL> except Exception : <EOL> environ [ '<STR_LIT>' ] . write ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> else : <EOL> return '<STR_LIT>' <EOL> finally : <EOL> end_time = default_timer ( ) <EOL> appenlight_storage . thread_stats [ '<STR_LIT>' ] = end_time - start_time <EOL> delta = datetime . timedelta ( seconds = ( end_time - start_time ) ) <EOL> stats , slow_calls = appenlight_storage . get_thread_stats ( ) <EOL> if '<STR_LIT>' not in environ : <EOL> environ [ '<STR_LIT>' ] = getattr ( appenlight_storage , '<STR_LIT>' , '<STR_LIT>' ) <EOL> if detected_data and detected_data [ <NUM_LIT:0> ] : <EOL> http_status = int ( detected_data [ <NUM_LIT:0> ] ) <EOL> if self . appenlight_client . config [ '<STR_LIT>' ] and not environ . get ( '<STR_LIT>' ) : <EOL> if ( delta >= self . appenlight_client . config [ '<STR_LIT>' ] or slow_calls ) : <EOL> create_report = True <EOL> if '<STR_LIT>' in environ and not environ . get ( '<STR_LIT>' ) : <EOL> traceback = environ [ '<STR_LIT>' ] <EOL> del environ [ '<STR_LIT>' ] <EOL> http_status = <NUM_LIT> <EOL> create_report = True <EOL> if traceback and self . appenlight_client . config [ '<STR_LIT>' ] and not environ . get ( '<STR_LIT>' ) : <EOL> http_status = <NUM_LIT> <EOL> create_report = True <EOL> elif ( self . appenlight_client . config [ '<STR_LIT>' ] and http_status == <NUM_LIT> ) : <EOL> create_report = True <EOL> if create_report : <EOL> self . appenlight_client . py_report ( environ , traceback , <EOL> message = None , <EOL> http_status = http_status , <EOL> start_time = datetime . datetime . utcfromtimestamp ( start_time ) , <EOL> end_time = datetime . datetime . utcfromtimestamp ( end_time ) , <EOL> request_stats = stats , <EOL> slow_calls = slow_calls ) <EOL> del traceback <EOL> self . appenlight_client . save_request_stats ( stats , view_name = environ . get ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> if self . appenlight_client . config [ '<STR_LIT>' ] : <EOL> records = self . appenlight_client . log_handlers_get_records ( ) <EOL> self . appenlight_client . log_handlers_clear_records ( ) <EOL> self . appenlight_client . py_log ( environ , <EOL> records = records , <EOL> r_uuid = environ [ '<STR_LIT>' ] , <EOL> created_report = create_report ) <EOL> self . appenlight_client . check_if_deliver ( self . appenlight_client . config [ '<STR_LIT>' ] or <EOL> environ . get ( '<STR_LIT>' ) ) </s>

<s> import json <EOL> import os <EOL> import re <EOL> import shutil <EOL> import subprocess <EOL> import sys <EOL> import unittest <EOL> import yaml <EOL> import boto . ec2 <EOL> from flexmock import flexmock <EOL> lib = os . path . dirname ( __file__ ) + os . sep + "<STR_LIT:..>" + os . sep + "<STR_LIT>" <EOL> sys . path . append ( lib ) <EOL> from agents . ec2_agent import EC2Agent <EOL> from appscale import AppScale <EOL> from appscale_tools import AppScaleTools <EOL> from custom_exceptions import AppScaleException <EOL> from custom_exceptions import AppScalefileException <EOL> from custom_exceptions import BadConfigurationException <EOL> from local_state import LocalState <EOL> from remote_helper import RemoteHelper <EOL> class TestAppScale ( unittest . TestCase ) : <EOL> def setUp ( self ) : <EOL> os . environ [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> os . environ [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> def tearDown ( self ) : <EOL> os . environ [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> os . environ [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> def addMockForNoAppScalefile ( self , appscale ) : <EOL> flexmock ( os ) <EOL> os . should_receive ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' ) <EOL> mock = flexmock ( sys . modules [ '<STR_LIT>' ] ) <EOL> mock . should_call ( '<STR_LIT>' ) <EOL> ( mock . should_receive ( '<STR_LIT>' ) <EOL> . with_args ( '<STR_LIT>' + appscale . APPSCALEFILE ) <EOL> . and_raise ( IOError ) ) <EOL> def addMockForAppScalefile ( self , appscale , contents ) : <EOL> flexmock ( os ) <EOL> os . should_receive ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' ) <EOL> mock = flexmock ( sys . modules [ '<STR_LIT>' ] ) <EOL> mock . should_call ( '<STR_LIT>' ) <EOL> ( mock . should_receive ( '<STR_LIT>' ) <EOL> . with_args ( '<STR_LIT>' + appscale . APPSCALEFILE ) <EOL> . and_return ( flexmock ( read = lambda : contents ) ) ) <EOL> return mock <EOL> def test_get_nodes ( self ) : <EOL> appscale = flexmock ( AppScale ( ) ) <EOL> builtin = flexmock ( sys . modules [ '<STR_LIT>' ] ) <EOL> builtin . should_call ( '<STR_LIT>' ) <EOL> nodes = [ { '<STR_LIT>' : '<STR_LIT>' } ] <EOL> appscale_yaml = { '<STR_LIT>' : '<STR_LIT>' } <EOL> appscale . should_receive ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' ) <EOL> builtin . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' ) . and_return ( flexmock ( read = lambda : json . dumps ( nodes ) ) ) <EOL> self . assertEqual ( nodes , appscale . get_nodes ( appscale_yaml [ '<STR_LIT>' ] ) ) <EOL> builtin . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' ) . and_raise ( IOError ) <EOL> with self . assertRaises ( AppScaleException ) : <EOL> appscale . get_nodes ( appscale_yaml [ '<STR_LIT>' ] ) <EOL> def test_get_head_node ( self ) : <EOL> shadow_node_1 = { '<STR_LIT>' : '<STR_LIT>' , '<STR_LIT>' : [ '<STR_LIT>' ] } <EOL> appengine_node = { '<STR_LIT>' : '<STR_LIT>' , '<STR_LIT>' : [ '<STR_LIT>' ] } <EOL> shadow_node_2 = { '<STR_LIT>' : '<STR_LIT>' , '<STR_LIT>' : [ '<STR_LIT>' ] } <EOL> appscale = AppScale ( ) <EOL> with self . assertRaises ( AppScaleException ) : <EOL> appscale . get_head_node ( [ appengine_node ] ) <EOL> self . assertEqual ( shadow_node_1 [ '<STR_LIT>' ] , <EOL> appscale . get_head_node ( [ shadow_node_1 , appengine_node , shadow_node_2 ] ) ) <EOL> def testInitWithNoAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> flexmock ( os ) <EOL> os . should_receive ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' ) <EOL> flexmock ( os . path ) <EOL> os . path . should_receive ( '<STR_LIT>' ) . with_args ( <EOL> '<STR_LIT>' + appscale . APPSCALEFILE ) . and_return ( False ) <EOL> flexmock ( shutil ) <EOL> shutil . should_receive ( '<STR_LIT>' ) . with_args ( <EOL> appscale . TEMPLATE_CLOUD_APPSCALEFILE , '<STR_LIT>' + appscale . APPSCALEFILE ) . and_return ( ) <EOL> appscale . init ( '<STR_LIT>' ) <EOL> def testInitWithAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> flexmock ( os ) <EOL> os . should_receive ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' ) <EOL> flexmock ( os . path ) <EOL> os . path . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' + appscale . APPSCALEFILE ) . and_return ( True ) <EOL> self . assertRaises ( AppScalefileException , appscale . init , '<STR_LIT>' ) <EOL> def testUpWithNoAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> self . addMockForNoAppScalefile ( appscale ) <EOL> self . assertRaises ( AppScalefileException , appscale . up ) <EOL> def testUpWithClusterAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { <EOL> '<STR_LIT>' : { '<STR_LIT>' : '<STR_LIT>' , '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , '<STR_LIT>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> flexmock ( os . path ) <EOL> os . path . should_call ( '<STR_LIT>' ) <EOL> os . path . should_receive ( '<STR_LIT>' ) . with_args ( <EOL> '<STR_LIT>' + appscale . APPSCALEFILE ) . and_return ( True ) <EOL> key_path = os . path . expanduser ( '<STR_LIT>' ) <EOL> os . path . should_receive ( '<STR_LIT>' ) . with_args ( key_path ) . and_return ( False ) <EOL> flexmock ( AppScaleTools ) <EOL> AppScaleTools . should_receive ( '<STR_LIT>' ) <EOL> AppScaleTools . should_receive ( '<STR_LIT>' ) <EOL> appscale . up ( ) <EOL> def testUpWithMalformedClusterAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { <EOL> '<STR_LIT>' : "<STR_LIT>" , <EOL> '<STR_LIT>' : '<STR_LIT>' , '<STR_LIT>' : '<STR_LIT>' <EOL> } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> flexmock ( os . path ) <EOL> os . path . should_call ( '<STR_LIT>' ) <EOL> os . path . should_receive ( '<STR_LIT>' ) . with_args ( <EOL> '<STR_LIT>' + appscale . APPSCALEFILE ) . and_return ( True ) <EOL> flexmock ( AppScaleTools ) <EOL> AppScaleTools . should_receive ( '<STR_LIT>' ) <EOL> self . assertRaises ( BadConfigurationException , appscale . up ) <EOL> def testUpWithCloudAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> flexmock ( os . path ) <EOL> os . path . should_call ( '<STR_LIT>' ) <EOL> os . path . should_receive ( '<STR_LIT>' ) . with_args ( <EOL> '<STR_LIT>' + appscale . APPSCALEFILE ) . and_return ( True ) <EOL> for credential in EC2Agent . REQUIRED_CREDENTIALS : <EOL> os . environ [ credential ] = "<STR_LIT>" <EOL> fake_ec2 = flexmock ( name = "<STR_LIT>" ) <EOL> fake_ec2 . should_receive ( '<STR_LIT>' ) <EOL> fake_ec2 . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' ) <EOL> fake_ec2 . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' ) . and_return ( ) <EOL> flexmock ( boto . ec2 ) <EOL> boto . ec2 . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , <EOL> aws_access_key_id = '<STR_LIT>' , aws_secret_access_key = '<STR_LIT>' ) . and_return ( fake_ec2 ) <EOL> flexmock ( AppScaleTools ) <EOL> AppScaleTools . should_receive ( '<STR_LIT>' ) <EOL> appscale . up ( ) <EOL> def testUpWithEC2EnvironmentVariables ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> flexmock ( os . path ) <EOL> os . path . should_call ( '<STR_LIT>' ) <EOL> os . path . should_receive ( '<STR_LIT>' ) . with_args ( <EOL> '<STR_LIT>' + appscale . APPSCALEFILE ) . and_return ( True ) <EOL> fake_ec2 = flexmock ( name = "<STR_LIT>" ) <EOL> fake_ec2 . should_receive ( '<STR_LIT>' ) <EOL> fake_ec2 . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' ) <EOL> fake_ec2 . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' ) . and_return ( ) <EOL> flexmock ( boto . ec2 ) <EOL> boto . ec2 . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , <EOL> aws_access_key_id = '<STR_LIT>' , <EOL> aws_secret_access_key = '<STR_LIT>' ) . and_return ( fake_ec2 ) <EOL> flexmock ( AppScaleTools ) <EOL> AppScaleTools . should_receive ( '<STR_LIT>' ) <EOL> appscale . up ( ) <EOL> self . assertEquals ( '<STR_LIT>' , os . environ [ '<STR_LIT>' ] ) <EOL> self . assertEquals ( '<STR_LIT>' , os . environ [ '<STR_LIT>' ] ) <EOL> def testSshWithNoAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> self . addMockForNoAppScalefile ( appscale ) <EOL> self . assertRaises ( AppScalefileException , appscale . ssh , <NUM_LIT:1> ) <EOL> def testSshWithNotIntArg ( self ) : <EOL> appscale = AppScale ( ) <EOL> self . addMockForAppScalefile ( appscale , "<STR_LIT>" ) <EOL> self . assertRaises ( TypeError , appscale . ssh , "<STR_LIT>" ) <EOL> def testSshWithNoNodesJson ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { '<STR_LIT>' : '<STR_LIT>' } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> mock = self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> ( mock . should_receive ( '<STR_LIT>' ) <EOL> . with_args ( appscale . get_locations_json_file ( '<STR_LIT>' ) ) <EOL> . and_raise ( IOError ) ) <EOL> self . assertRaises ( AppScaleException , appscale . ssh , <NUM_LIT:0> ) <EOL> def testSshWithIndexOutOfBounds ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { '<STR_LIT>' : '<STR_LIT>' } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> one = { <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } <EOL> nodes = [ one ] <EOL> nodes_contents = json . dumps ( nodes ) <EOL> mock = self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> ( mock . should_receive ( '<STR_LIT>' ) <EOL> . with_args ( appscale . get_locations_json_file ( '<STR_LIT>' ) ) <EOL> . and_return ( flexmock ( read = lambda : nodes_contents ) ) ) <EOL> self . assertRaises ( AppScaleException , appscale . ssh , <NUM_LIT:1> ) <EOL> def testSshWithIndexInBounds ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { '<STR_LIT>' : '<STR_LIT>' } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> one = { <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } <EOL> two = { <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } <EOL> nodes = [ one , two ] <EOL> nodes_contents = json . dumps ( nodes ) <EOL> mock = self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> ( mock . should_receive ( '<STR_LIT>' ) <EOL> . with_args ( appscale . get_locations_json_file ( '<STR_LIT>' ) ) <EOL> . and_return ( flexmock ( read = lambda : nodes_contents ) ) ) <EOL> flexmock ( subprocess ) <EOL> subprocess . should_receive ( '<STR_LIT>' ) . with_args ( [ "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , appscale . get_key_location ( '<STR_LIT>' ) , "<STR_LIT>" ] ) . and_return ( ) . once ( ) <EOL> appscale . ssh ( <NUM_LIT:1> ) <EOL> def testStatusWithNoAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> self . addMockForNoAppScalefile ( appscale ) <EOL> self . assertRaises ( AppScalefileException , appscale . status ) <EOL> def testStatusWithCloudAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : True , <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : <NUM_LIT:1> <EOL> } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> flexmock ( AppScaleTools ) <EOL> AppScaleTools . should_receive ( '<STR_LIT>' ) <EOL> appscale . status ( ) <EOL> def testDeployWithNoAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> self . addMockForNoAppScalefile ( appscale ) <EOL> app = "<STR_LIT>" <EOL> self . assertRaises ( AppScalefileException , appscale . deploy , app ) <EOL> def testDeployWithCloudAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : True , <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : <NUM_LIT:1> <EOL> } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> fake_port = <NUM_LIT> <EOL> fake_host = '<STR_LIT>' <EOL> flexmock ( AppScaleTools ) <EOL> AppScaleTools . should_receive ( '<STR_LIT>' ) . and_return ( <EOL> ( fake_host , fake_port ) ) <EOL> app = '<STR_LIT>' <EOL> ( host , port ) = appscale . deploy ( app ) <EOL> self . assertEquals ( fake_host , host ) <EOL> self . assertEquals ( fake_port , port ) <EOL> def testUndeployWithNoAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> self . addMockForNoAppScalefile ( appscale ) <EOL> appid = "<STR_LIT>" <EOL> self . assertRaises ( AppScalefileException , appscale . undeploy , appid ) <EOL> def testUndeployWithCloudAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : True , <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : <NUM_LIT:1> <EOL> } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> flexmock ( AppScaleTools ) <EOL> AppScaleTools . should_receive ( '<STR_LIT>' ) <EOL> app = '<STR_LIT>' <EOL> appscale . undeploy ( app ) <EOL> def testDeployWithCloudAppScalefileAndTestFlag ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : True , <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT:test>' : True <EOL> } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> fake_port = <NUM_LIT> <EOL> fake_host = '<STR_LIT>' <EOL> flexmock ( AppScaleTools ) <EOL> AppScaleTools . should_receive ( '<STR_LIT>' ) . and_return ( <EOL> ( fake_host , fake_port ) ) <EOL> app = '<STR_LIT>' <EOL> ( host , port ) = appscale . deploy ( app ) <EOL> self . assertEquals ( fake_host , host ) <EOL> self . assertEquals ( fake_port , port ) <EOL> def testTailWithNoAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> self . addMockForNoAppScalefile ( appscale ) <EOL> self . assertRaises ( AppScalefileException , appscale . tail , <NUM_LIT:0> , '<STR_LIT>' ) <EOL> def testTailWithNotIntArg ( self ) : <EOL> appscale = AppScale ( ) <EOL> self . addMockForAppScalefile ( appscale , "<STR_LIT>" ) <EOL> self . assertRaises ( TypeError , appscale . tail , "<STR_LIT>" , "<STR_LIT>" ) <EOL> def testTailWithNoNodesJson ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { '<STR_LIT>' : '<STR_LIT>' } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> mock = self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> ( mock . should_receive ( '<STR_LIT>' ) <EOL> . with_args ( appscale . get_locations_json_file ( '<STR_LIT>' ) ) <EOL> . and_raise ( IOError ) ) <EOL> self . assertRaises ( AppScaleException , appscale . tail , <NUM_LIT:0> , "<STR_LIT>" ) <EOL> def testTailWithIndexOutOfBounds ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { '<STR_LIT>' : '<STR_LIT>' } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> one = { <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } <EOL> nodes = [ one ] <EOL> nodes_contents = json . dumps ( nodes ) <EOL> mock = self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> ( mock . should_receive ( '<STR_LIT>' ) <EOL> . with_args ( appscale . get_locations_json_file ( '<STR_LIT>' ) ) <EOL> . and_return ( flexmock ( read = lambda : nodes_contents ) ) ) <EOL> self . assertRaises ( AppScaleException , appscale . tail , <NUM_LIT:1> , '<STR_LIT>' ) <EOL> def testTailWithIndexInBounds ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { '<STR_LIT>' : '<STR_LIT>' } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> one = { <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } <EOL> two = { <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } <EOL> nodes = [ one , two ] <EOL> nodes_contents = json . dumps ( nodes ) <EOL> mock = self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> ( mock . should_receive ( '<STR_LIT>' ) <EOL> . with_args ( appscale . get_locations_json_file ( '<STR_LIT>' ) ) <EOL> . and_return ( flexmock ( read = lambda : nodes_contents ) ) ) <EOL> flexmock ( subprocess ) <EOL> subprocess . should_receive ( '<STR_LIT>' ) . with_args ( [ "<STR_LIT>" , "<STR_LIT>" , <EOL> "<STR_LIT>" , "<STR_LIT>" , appscale . get_key_location ( '<STR_LIT>' ) , <EOL> "<STR_LIT>" , "<STR_LIT>" ] ) . and_return ( ) . once ( ) <EOL> appscale . tail ( <NUM_LIT:1> , "<STR_LIT>" ) <EOL> def testGetLogsWithNoAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> self . addMockForNoAppScalefile ( appscale ) <EOL> self . assertRaises ( AppScalefileException , appscale . logs , '<STR_LIT>' ) <EOL> def testGetLogsWithKeyname ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { <EOL> "<STR_LIT>" : "<STR_LIT>" <EOL> } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> flexmock ( AppScaleTools ) <EOL> AppScaleTools . should_receive ( '<STR_LIT>' ) <EOL> self . assertRaises ( BadConfigurationException , appscale . logs , '<STR_LIT>' ) <EOL> def testRelocateWithNoAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> self . addMockForNoAppScalefile ( appscale ) <EOL> self . assertRaises ( AppScalefileException , appscale . relocate , '<STR_LIT>' , <NUM_LIT> , <NUM_LIT> ) <EOL> def testRelocateWithAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : True , <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : <NUM_LIT:1> <EOL> } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> flexmock ( AppScaleTools ) <EOL> AppScaleTools . should_receive ( '<STR_LIT>' ) <EOL> appscale . relocate ( '<STR_LIT>' , <NUM_LIT> , <NUM_LIT> ) <EOL> def testGetPropertyWithNoAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> self . addMockForNoAppScalefile ( appscale ) <EOL> self . assertRaises ( AppScalefileException , appscale . get , '<STR_LIT>' ) <EOL> def testGetPropertyWithAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : True , <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : <NUM_LIT:1> <EOL> } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> flexmock ( AppScaleTools ) <EOL> AppScaleTools . should_receive ( '<STR_LIT>' ) <EOL> appscale . get ( '<STR_LIT>' ) <EOL> def testSetPropertyWithNoAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> self . addMockForNoAppScalefile ( appscale ) <EOL> self . assertRaises ( AppScalefileException , appscale . set , '<STR_LIT:key>' , '<STR_LIT:value>' ) <EOL> def testSetPropertyWithAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : True , <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : <NUM_LIT:1> <EOL> } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> flexmock ( AppScaleTools ) <EOL> AppScaleTools . should_receive ( '<STR_LIT>' ) <EOL> appscale . set ( '<STR_LIT:key>' , '<STR_LIT:value>' ) <EOL> def testDestroyWithNoAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> self . addMockForNoAppScalefile ( appscale ) <EOL> self . assertRaises ( AppScalefileException , appscale . destroy ) <EOL> def testDestroyWithCloudAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : True , <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : <NUM_LIT:1> <EOL> } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> flexmock ( AppScaleTools ) <EOL> AppScaleTools . should_receive ( '<STR_LIT>' ) <EOL> appscale . destroy ( ) <EOL> def testDestroyWithEC2EnvironmentVariables ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> flexmock ( AppScaleTools ) <EOL> AppScaleTools . should_receive ( '<STR_LIT>' ) <EOL> appscale . destroy ( ) <EOL> self . assertEquals ( '<STR_LIT>' , os . environ [ '<STR_LIT>' ] ) <EOL> self . assertEquals ( '<STR_LIT>' , os . environ [ '<STR_LIT>' ] ) <EOL> def testCleanWithNoAppScalefile ( self ) : <EOL> appscale = AppScale ( ) <EOL> self . addMockForNoAppScalefile ( appscale ) <EOL> self . assertRaises ( AppScalefileException , appscale . clean ) <EOL> def testCleanInCloudDeployment ( self ) : <EOL> appscale = AppScale ( ) <EOL> contents = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : True , <EOL> '<STR_LIT>' : <NUM_LIT:1> , <EOL> '<STR_LIT>' : <NUM_LIT:1> <EOL> } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> self . assertRaises ( BadConfigurationException , appscale . clean ) <EOL> def testCleanInClusterDeployment ( self ) : <EOL> contents = { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> } , <EOL> '<STR_LIT:test>' : True <EOL> } <EOL> yaml_dumped_contents = yaml . dump ( contents ) <EOL> flexmock ( RemoteHelper ) <EOL> RemoteHelper . should_receive ( '<STR_LIT>' ) . with_args ( re . compile ( '<STR_LIT>' ) , '<STR_LIT>' , str , False ) <EOL> flexmock ( LocalState ) <EOL> LocalState . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' ) <EOL> appscale = AppScale ( ) <EOL> self . addMockForAppScalefile ( appscale , yaml_dumped_contents ) <EOL> expected = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> self . assertEquals ( expected , appscale . clean ( ) ) </s>

<s> """<STR_LIT>""" <EOL> import logging <EOL> import os <EOL> import re <EOL> import shutil <EOL> import SOAPpy <EOL> import statvfs <EOL> import sys <EOL> import tarfile <EOL> import time <EOL> from os . path import getsize <EOL> import backup_exceptions <EOL> import backup_recovery_constants <EOL> import gcs_helper <EOL> from backup_recovery_constants import APP_BACKUP_DIR_LOCATION <EOL> from backup_recovery_constants import APP_DIR_LOCATION <EOL> from backup_recovery_constants import BACKUP_DIR_LOCATION <EOL> from backup_recovery_constants import BACKUP_ROLLBACK_SUFFIX <EOL> from backup_recovery_constants import StorageTypes <EOL> sys . path . append ( os . path . join ( os . path . dirname ( __file__ ) , "<STR_LIT>" ) ) <EOL> import appscale_info <EOL> from constants import APPSCALE_DATA_DIR <EOL> from google . appengine . api . appcontroller_client import AppControllerClient <EOL> UA_SERVER_PORT = <NUM_LIT> <EOL> def delete_local_backup_file ( local_file ) : <EOL> """<STR_LIT>""" <EOL> if not remove ( local_file ) : <EOL> logging . warning ( "<STR_LIT>" <EOL> "<STR_LIT>" . format ( local_file ) ) <EOL> def delete_secondary_backup ( base_path ) : <EOL> """<STR_LIT>""" <EOL> if not remove ( "<STR_LIT>" . format ( base_path , BACKUP_ROLLBACK_SUFFIX ) ) : <EOL> logging . warning ( "<STR_LIT>" ) <EOL> def does_file_exist ( path ) : <EOL> """<STR_LIT>""" <EOL> return os . path . isfile ( path ) <EOL> def enough_disk_space ( service ) : <EOL> """<STR_LIT>""" <EOL> available_space = get_available_disk_space ( ) <EOL> logging . debug ( "<STR_LIT>" . format ( available_space ) ) <EOL> backup_size = get_backup_size ( service ) <EOL> logging . debug ( "<STR_LIT>" . format ( backup_size ) ) <EOL> if backup_size > available_space * backup_recovery_constants . PADDING_PERCENTAGE : <EOL> logging . warning ( "<STR_LIT>" ) <EOL> return False <EOL> return True <EOL> def get_available_disk_space ( ) : <EOL> """<STR_LIT>""" <EOL> stat_struct = os . statvfs ( os . path . dirname ( BACKUP_DIR_LOCATION ) ) <EOL> return stat_struct [ statvfs . F_BAVAIL ] * stat_struct [ statvfs . F_BSIZE ] <EOL> def get_backup_size ( service ) : <EOL> """<STR_LIT>""" <EOL> backup_files = get_snapshot_paths ( service ) <EOL> total_size = sum ( getsize ( file ) for file in backup_files ) <EOL> return total_size <EOL> def get_snapshot_paths ( service ) : <EOL> """<STR_LIT>""" <EOL> file_list = [ ] <EOL> if service != '<STR_LIT>' : <EOL> return file_list <EOL> look_for = '<STR_LIT>' <EOL> data_dir = "<STR_LIT>" . format ( APPSCALE_DATA_DIR , service ) <EOL> for full_path , _ , file in os . walk ( data_dir ) : <EOL> if look_for in full_path : <EOL> file_list . append ( full_path ) <EOL> logging . debug ( "<STR_LIT>" . format ( <EOL> service , file_list ) ) <EOL> return file_list <EOL> def move_secondary_backup ( base_path ) : <EOL> """<STR_LIT>""" <EOL> source = "<STR_LIT>" . format ( base_path , BACKUP_ROLLBACK_SUFFIX ) <EOL> target = base_path <EOL> if not rename ( source , target ) : <EOL> logging . warning ( "<STR_LIT>" ) <EOL> def mkdir ( path ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> os . mkdir ( path ) <EOL> except OSError : <EOL> logging . error ( "<STR_LIT>" . format ( path ) ) <EOL> return False <EOL> return True <EOL> def makedirs ( path ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> os . makedirs ( path ) <EOL> except OSError : <EOL> logging . error ( "<STR_LIT>" . format ( path ) ) <EOL> return False <EOL> return True <EOL> def rename ( source , destination ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> os . rename ( source , destination ) <EOL> except OSError : <EOL> logging . error ( "<STR_LIT>" . <EOL> format ( source , destination ) ) <EOL> return False <EOL> return True <EOL> def remove ( path ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> os . remove ( path ) <EOL> except OSError : <EOL> logging . error ( "<STR_LIT>" . <EOL> format ( path ) ) <EOL> return False <EOL> return True <EOL> def tar_backup_files ( file_paths , target ) : <EOL> """<STR_LIT>""" <EOL> backup_file_location = target <EOL> if not rename ( backup_file_location , "<STR_LIT>" . <EOL> format ( backup_file_location , BACKUP_ROLLBACK_SUFFIX ) ) : <EOL> logging . warning ( "<STR_LIT>" . <EOL> format ( backup_file_location ) ) <EOL> tar = tarfile . open ( backup_file_location , "<STR_LIT:w>" ) <EOL> for name in file_paths : <EOL> tar . add ( name ) <EOL> tar . close ( ) <EOL> return backup_file_location <EOL> def untar_backup_files ( source ) : <EOL> """<STR_LIT>""" <EOL> logging . info ( "<STR_LIT>" . format ( source ) ) <EOL> try : <EOL> tar = tarfile . open ( source , "<STR_LIT>" ) <EOL> tar . extractall ( path = "<STR_LIT:/>" ) <EOL> tar . close ( ) <EOL> except tarfile . TarError , tar_error : <EOL> logging . exception ( tar_error ) <EOL> raise backup_exceptions . BRException ( <EOL> "<STR_LIT>" . format ( source ) ) <EOL> logging . info ( "<STR_LIT>" . format ( source ) ) <EOL> def app_backup ( storage , full_bucket_name = None ) : <EOL> """<STR_LIT>""" <EOL> if not makedirs ( APP_BACKUP_DIR_LOCATION ) : <EOL> logging . warning ( "<STR_LIT>" . <EOL> format ( APP_BACKUP_DIR_LOCATION ) ) <EOL> for dir_path , _ , filenames in os . walk ( APP_DIR_LOCATION ) : <EOL> for filename in filenames : <EOL> source = '<STR_LIT>' . format ( dir_path , filename ) <EOL> destination = '<STR_LIT>' . format ( APP_BACKUP_DIR_LOCATION , filename ) <EOL> try : <EOL> shutil . copy ( source , destination ) <EOL> except : <EOL> logging . error ( "<STR_LIT>" . format ( source ) ) <EOL> delete_app_tars ( APP_BACKUP_DIR_LOCATION ) <EOL> return False <EOL> if storage == StorageTypes . GCS : <EOL> source = '<STR_LIT>' . format ( APP_DIR_LOCATION , filename ) <EOL> destination = '<STR_LIT>' . format ( full_bucket_name , filename ) <EOL> logging . debug ( "<STR_LIT>" . format ( destination ) ) <EOL> if not gcs_helper . upload_to_bucket ( destination , source ) : <EOL> logging . error ( "<STR_LIT>" . format ( source ) ) <EOL> delete_app_tars ( APP_BACKUP_DIR_LOCATION ) <EOL> return False <EOL> return True <EOL> def app_restore ( storage , bucket_name = None ) : <EOL> """<STR_LIT>""" <EOL> if not makedirs ( APP_BACKUP_DIR_LOCATION ) : <EOL> logging . warning ( "<STR_LIT>" . <EOL> format ( APP_BACKUP_DIR_LOCATION ) ) <EOL> if storage == StorageTypes . GCS : <EOL> objects = gcs_helper . list_bucket ( bucket_name ) <EOL> for app_path in objects : <EOL> if not app_path . startswith ( gcs_helper . APPS_GCS_PREFIX ) : <EOL> continue <EOL> app_file = app_path [ len ( gcs_helper . APPS_GCS_PREFIX ) : ] <EOL> source = '<STR_LIT>' . format ( bucket_name , app_path ) <EOL> destination = '<STR_LIT>' . format ( APP_BACKUP_DIR_LOCATION , app_file ) <EOL> if not gcs_helper . download_from_bucket ( source , destination ) : <EOL> logging . error ( "<STR_LIT>" . format ( source ) ) <EOL> delete_app_tars ( APP_BACKUP_DIR_LOCATION ) <EOL> return False <EOL> apps_to_deploy = [ os . path . join ( APP_BACKUP_DIR_LOCATION , app ) for app in <EOL> os . listdir ( APP_BACKUP_DIR_LOCATION ) ] <EOL> if not deploy_apps ( apps_to_deploy ) : <EOL> logging . error ( "<STR_LIT>" <EOL> "<STR_LIT>" . format ( apps_to_deploy ) ) <EOL> return False <EOL> return True <EOL> def delete_app_tars ( location ) : <EOL> """<STR_LIT>""" <EOL> for dir_path , _ , filenames in os . walk ( location ) : <EOL> for filename in filenames : <EOL> if not remove ( '<STR_LIT>' . format ( dir_path , filename ) ) : <EOL> return False <EOL> return True <EOL> def deploy_apps ( app_paths ) : <EOL> """<STR_LIT>""" <EOL> uaserver = SOAPpy . SOAPProxy ( '<STR_LIT>' . format ( <EOL> appscale_info . get_db_master_ip ( ) , UA_SERVER_PORT ) ) <EOL> acc = AppControllerClient ( appscale_info . get_login_ip ( ) , <EOL> appscale_info . get_secret ( ) ) <EOL> time . sleep ( <NUM_LIT:15> ) <EOL> for app_path in app_paths : <EOL> app_id = app_path [ app_path . rfind ( '<STR_LIT:/>' ) + <NUM_LIT:1> : app_path . find ( '<STR_LIT:.>' ) ] <EOL> if not app_id : <EOL> logging . error ( "<STR_LIT>" <EOL> "<STR_LIT>" . format ( app_path ) ) <EOL> return False <EOL> app_data = uaserver . get_app_data ( app_id , appscale_info . get_secret ( ) ) <EOL> app_admin_re = re . search ( "<STR_LIT>" , app_data ) <EOL> if app_admin_re : <EOL> app_admin = app_admin_re . group ( <NUM_LIT:1> ) <EOL> else : <EOL> logging . error ( "<STR_LIT>" <EOL> "<STR_LIT>" . format ( app_id ) ) <EOL> return False <EOL> file_suffix = re . search ( "<STR_LIT>" , app_path ) . group ( <NUM_LIT:1> ) <EOL> logging . warning ( "<STR_LIT>" . <EOL> format ( app_id , app_path , app_admin ) ) <EOL> acc . upload_app ( app_path , file_suffix , app_admin ) <EOL> return True </s>

<s> """<STR_LIT>""" <EOL> import datetime <EOL> import logging <EOL> import os <EOL> import random <EOL> import re <EOL> import sys <EOL> import threading <EOL> import time <EOL> import appscale_datastore_batch <EOL> import dbconstants <EOL> import datastore_server <EOL> import entity_utils <EOL> from zkappscale import zktransaction as zk <EOL> from google . appengine . api import apiproxy_stub_map <EOL> from google . appengine . api import datastore_distributed <EOL> from google . appengine . api . memcache import memcache_distributed <EOL> from google . appengine . datastore import datastore_pb <EOL> from google . appengine . datastore import entity_pb <EOL> from google . appengine . datastore . datastore_query import Cursor <EOL> from google . appengine . ext import db <EOL> from google . appengine . ext . db import stats <EOL> from google . appengine . ext . db import metadata <EOL> from google . appengine . api import datastore_errors <EOL> sys . path . append ( os . path . join ( os . path . dirname ( __file__ ) , "<STR_LIT>" ) ) <EOL> import appscale_info <EOL> import constants <EOL> sys . path . append ( os . path . join ( os . path . dirname ( __file__ ) , "<STR_LIT>" ) ) <EOL> from app_dashboard_data import InstanceInfo <EOL> from app_dashboard_data import ServerStatus <EOL> from app_dashboard_data import RequestInfo <EOL> from dashboard_logs import RequestLogLine <EOL> sys . path . append ( os . path . join ( os . path . dirname ( __file__ ) , "<STR_LIT>" ) ) <EOL> from distributed_tq import TaskName <EOL> class DatastoreGroomer ( threading . Thread ) : <EOL> """<STR_LIT>""" <EOL> LOCK_POLL_PERIOD = <NUM_LIT:4> * <NUM_LIT> * <NUM_LIT> <EOL> DB_ERROR_PERIOD = <NUM_LIT:30> <EOL> BATCH_SIZE = <NUM_LIT:100> <EOL> PRIVATE_KINDS = '<STR_LIT>' <EOL> PROTECTED_KINDS = '<STR_LIT>' <EOL> TASK_NAME_TIMEOUT = <NUM_LIT> * <NUM_LIT> * <NUM_LIT> <EOL> LOG_STORAGE_TIMEOUT = <NUM_LIT> * <NUM_LIT> * <NUM_LIT> * <NUM_LIT:7> <EOL> APPSCALE_APPLICATIONS = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> NO_COMPOSITES = "<STR_LIT>" <EOL> DASHBOARD_DATA_TIMEOUT = <NUM_LIT> * <NUM_LIT> <EOL> DASHBOARD_DATA_MODELS = [ InstanceInfo , ServerStatus , RequestInfo ] <EOL> DASHBOARD_BATCH = <NUM_LIT:1000> <EOL> GROOMER_STATE_PATH = '<STR_LIT>' <EOL> GROOMER_STATE_DELIMITER = '<STR_LIT>' <EOL> CLEAN_ENTITIES_TASK = '<STR_LIT>' <EOL> CLEAN_ASC_INDICES_TASK = '<STR_LIT>' <EOL> CLEAN_DSC_INDICES_TASK = '<STR_LIT>' <EOL> CLEAN_KIND_INDICES_TASK = '<STR_LIT>' <EOL> CLEAN_LOGS_TASK = '<STR_LIT>' <EOL> CLEAN_TASKS_TASK = '<STR_LIT>' <EOL> CLEAN_DASHBOARD_TASK = '<STR_LIT>' <EOL> LOG_PROGRESS_FREQUENCY = <NUM_LIT> * <NUM_LIT:5> <EOL> def __init__ ( self , zoo_keeper , table_name , ds_path ) : <EOL> """<STR_LIT>""" <EOL> log_format = logging . Formatter ( '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> logging . getLogger ( ) . handlers [ <NUM_LIT:0> ] . setFormatter ( log_format ) <EOL> logging . info ( "<STR_LIT>" ) <EOL> threading . Thread . __init__ ( self ) <EOL> self . zoo_keeper = zoo_keeper <EOL> self . table_name = table_name <EOL> self . db_access = None <EOL> self . ds_access = None <EOL> self . datastore_path = ds_path <EOL> self . stats = { } <EOL> self . namespace_info = { } <EOL> self . num_deletes = <NUM_LIT:0> <EOL> self . composite_index_cache = { } <EOL> self . entities_checked = <NUM_LIT:0> <EOL> self . journal_entries_cleaned = <NUM_LIT:0> <EOL> self . index_entries_checked = <NUM_LIT:0> <EOL> self . index_entries_delete_failures = <NUM_LIT:0> <EOL> self . index_entries_cleaned = <NUM_LIT:0> <EOL> self . last_logged = time . time ( ) <EOL> self . groomer_state = [ ] <EOL> def stop ( self ) : <EOL> """<STR_LIT>""" <EOL> self . zoo_keeper . close ( ) <EOL> def run ( self ) : <EOL> """<STR_LIT>""" <EOL> while True : <EOL> logging . debug ( "<STR_LIT>" ) <EOL> if self . get_groomer_lock ( ) : <EOL> logging . info ( "<STR_LIT>" ) <EOL> self . run_groomer ( ) <EOL> try : <EOL> self . zoo_keeper . release_lock_with_path ( zk . DS_GROOM_LOCK_PATH ) <EOL> except zk . ZKTransactionException , zk_exception : <EOL> logging . error ( "<STR_LIT>" . format ( str ( zk_exception ) ) ) <EOL> except zk . ZKInternalException , zk_exception : <EOL> logging . error ( "<STR_LIT>" . format ( str ( zk_exception ) ) ) <EOL> else : <EOL> logging . info ( "<STR_LIT>" ) <EOL> sleep_time = random . randint ( <NUM_LIT:1> , self . LOCK_POLL_PERIOD ) <EOL> logging . info ( '<STR_LIT>' . format ( sleep_time / <NUM_LIT> ) ) <EOL> time . sleep ( sleep_time ) <EOL> def get_groomer_lock ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . zoo_keeper . get_lock_with_path ( zk . DS_GROOM_LOCK_PATH ) <EOL> def get_entity_batch ( self , last_key ) : <EOL> """<STR_LIT>""" <EOL> return self . db_access . range_query ( dbconstants . APP_ENTITY_TABLE , <EOL> dbconstants . APP_ENTITY_SCHEMA , last_key , "<STR_LIT>" , self . BATCH_SIZE , <EOL> start_inclusive = False ) <EOL> def reset_statistics ( self ) : <EOL> """<STR_LIT>""" <EOL> self . stats = { } <EOL> self . namespace_info = { } <EOL> self . num_deletes = <NUM_LIT:0> <EOL> self . journal_entries_cleaned = <NUM_LIT:0> <EOL> def remove_deprecated_dashboard_data ( self , model_type ) : <EOL> """<STR_LIT>""" <EOL> query = model_type . query ( ) <EOL> entities = query . fetch ( self . DASHBOARD_BATCH ) <EOL> counter = <NUM_LIT:0> <EOL> for entity in entities : <EOL> if not hasattr ( entity , "<STR_LIT>" ) : <EOL> entity . key . delete ( ) <EOL> counter += <NUM_LIT:1> <EOL> if counter > <NUM_LIT:0> : <EOL> logging . warning ( "<STR_LIT>" . format ( <EOL> counter , entity . _get_kind ( ) ) ) <EOL> def remove_old_dashboard_data ( self ) : <EOL> """<STR_LIT>""" <EOL> last_cursor = None <EOL> last_model = None <EOL> if ( len ( self . groomer_state ) > <NUM_LIT:1> and <EOL> self . groomer_state [ <NUM_LIT:0> ] == self . CLEAN_DASHBOARD_TASK ) : <EOL> last_model = self . DASHBOARD_DATA_MODELS [ int ( self . groomer_state [ <NUM_LIT:1> ] ) ] <EOL> if len ( self . groomer_state ) > <NUM_LIT:2> : <EOL> last_cursor = Cursor ( self . groomer_state [ <NUM_LIT:2> ] ) <EOL> self . register_db_accessor ( constants . DASHBOARD_APP_ID ) <EOL> timeout = datetime . datetime . utcnow ( ) - datetime . timedelta ( seconds = self . DASHBOARD_DATA_TIMEOUT ) <EOL> for model_number in range ( len ( self . DASHBOARD_DATA_MODELS ) ) : <EOL> model_type = self . DASHBOARD_DATA_MODELS [ model_number ] <EOL> if last_model and model_type != last_model : <EOL> continue <EOL> counter = <NUM_LIT:0> <EOL> while True : <EOL> query = model_type . query ( ) . filter ( model_type . timestamp < timeout ) <EOL> entities , next_cursor , more = query . fetch_page ( self . BATCH_SIZE , <EOL> start_cursor = last_cursor ) <EOL> for entity in entities : <EOL> entity . key . delete ( ) <EOL> counter += <NUM_LIT:1> <EOL> if time . time ( ) > self . last_logged + self . LOG_PROGRESS_FREQUENCY : <EOL> logging . info ( '<STR_LIT>' <EOL> . format ( counter , model_type . __class__ . __name__ ) ) <EOL> self . last_logged = time . time ( ) <EOL> if more : <EOL> last_cursor = next_cursor <EOL> self . update_groomer_state ( [ self . CLEAN_DASHBOARD_TASK , <EOL> str ( model_number ) , last_cursor . urlsafe ( ) ] ) <EOL> else : <EOL> break <EOL> if model_number != len ( self . DASHBOARD_DATA_MODELS ) - <NUM_LIT:1> : <EOL> self . update_groomer_state ( [ self . CLEAN_DASHBOARD_TASK , <EOL> str ( model_number + <NUM_LIT:1> ) ] ) <EOL> last_model = None <EOL> last_cursor = None <EOL> if counter > <NUM_LIT:0> : <EOL> logging . info ( "<STR_LIT>" . format ( counter , <EOL> model_type ) ) <EOL> self . remove_deprecated_dashboard_data ( model_type ) <EOL> return <EOL> def clean_journal_entries ( self , txn_id , key ) : <EOL> """<STR_LIT>""" <EOL> if txn_id == <NUM_LIT:0> : <EOL> return True <EOL> start_row = datastore_server . DatastoreDistributed . get_journal_key ( key , <NUM_LIT:0> ) <EOL> end_row = datastore_server . DatastoreDistributed . get_journal_key ( key , <EOL> int ( txn_id ) - <NUM_LIT:1> ) <EOL> last_key = start_row <EOL> keys_to_delete = [ ] <EOL> while True : <EOL> try : <EOL> results = self . db_access . range_query ( dbconstants . JOURNAL_TABLE , <EOL> dbconstants . JOURNAL_SCHEMA , last_key , end_row , self . BATCH_SIZE , <EOL> start_inclusive = False , end_inclusive = True ) <EOL> if len ( results ) == <NUM_LIT:0> : <EOL> return True <EOL> keys_to_delete = [ ] <EOL> for item in results : <EOL> keys_to_delete . append ( item . keys ( ) [ <NUM_LIT:0> ] ) <EOL> self . db_access . batch_delete ( dbconstants . JOURNAL_TABLE , <EOL> keys_to_delete ) <EOL> self . journal_entries_cleaned += len ( keys_to_delete ) <EOL> except dbconstants . AppScaleDBConnectionError , db_error : <EOL> logging . error ( "<STR_LIT>" . format ( <EOL> keys_to_delete , db_error ) ) <EOL> logging . error ( "<STR_LIT>" ) <EOL> time . sleep ( self . DB_ERROR_PERIOD ) <EOL> return False <EOL> except Exception , exception : <EOL> logging . error ( "<STR_LIT>" . format ( exception ) ) <EOL> logging . error ( "<STR_LIT>" ) <EOL> time . sleep ( self . DB_ERROR_PERIOD ) <EOL> return False <EOL> def hard_delete_row ( self , row_key ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> self . db_access . batch_delete ( dbconstants . APP_ENTITY_TABLE , <EOL> [ row_key ] ) <EOL> except dbconstants . AppScaleDBConnectionError , db_error : <EOL> logging . error ( "<STR_LIT>" . format ( <EOL> row_key , db_error ) ) <EOL> return False <EOL> except Exception , exception : <EOL> logging . error ( "<STR_LIT>" . format ( exception ) ) <EOL> return False <EOL> return True <EOL> def load_composite_cache ( self , app_id ) : <EOL> """<STR_LIT>""" <EOL> start_key = datastore_server . DatastoreDistributed . get_meta_data_key ( <EOL> app_id , "<STR_LIT:index>" , "<STR_LIT>" ) <EOL> end_key = datastore_server . DatastoreDistributed . get_meta_data_key ( <EOL> app_id , "<STR_LIT:index>" , dbconstants . TERMINATING_STRING ) <EOL> results = self . db_access . range_query ( dbconstants . METADATA_TABLE , <EOL> dbconstants . METADATA_TABLE , start_key , end_key , <EOL> dbconstants . MAX_NUMBER_OF_COMPOSITE_INDEXES ) <EOL> list_result = [ ] <EOL> for list_item in results : <EOL> for _ , value in list_item . iteritems ( ) : <EOL> list_result . append ( value [ '<STR_LIT:data>' ] ) <EOL> self . composite_index_cache [ app_id ] = self . NO_COMPOSITES <EOL> kind_index_dictionary = { } <EOL> for index in list_result : <EOL> new_index = entity_pb . CompositeIndex ( ) <EOL> new_index . ParseFromString ( index ) <EOL> kind = new_index . definition ( ) . entity_type ( ) <EOL> if kind in kind_index_dictionary : <EOL> kind_index_dictionary [ kind ] . append ( new_index ) <EOL> else : <EOL> kind_index_dictionary [ kind ] = [ new_index ] <EOL> if kind_index_dictionary : <EOL> self . composite_index_cache [ app_id ] = kind_index_dictionary <EOL> return True <EOL> return False <EOL> def acquire_lock_for_key ( self , app_id , key , retries , retry_time ) : <EOL> """<STR_LIT>""" <EOL> root_key = key . split ( dbconstants . KIND_SEPARATOR ) [ <NUM_LIT:0> ] <EOL> root_key += dbconstants . KIND_SEPARATOR <EOL> txn_id = self . zoo_keeper . get_transaction_id ( app_id , is_xg = False ) <EOL> try : <EOL> self . zoo_keeper . acquire_lock ( app_id , txn_id , root_key ) <EOL> except zk . ZKTransactionException as zkte : <EOL> logging . warning ( '<STR_LIT>' <EOL> '<STR_LIT>' . format ( app_id , str ( zkte ) ) ) <EOL> if retries > <NUM_LIT:0> : <EOL> logging . info ( '<STR_LIT>' <EOL> . format ( str ( zkte ) , retries ) ) <EOL> time . sleep ( retry_time ) <EOL> return self . acquire_lock_for_key ( <EOL> app_id = app_id , <EOL> key = key , <EOL> retries = retries - <NUM_LIT:1> , <EOL> retry_time = retry_time <EOL> ) <EOL> self . zoo_keeper . notify_failed_transaction ( app_id , txn_id ) <EOL> raise zkte <EOL> return txn_id <EOL> def release_lock_for_key ( self , app_id , key , txn_id , retries , retry_time ) : <EOL> """<STR_LIT>""" <EOL> root_key = key . split ( dbconstants . KIND_SEPARATOR ) [ <NUM_LIT:0> ] <EOL> root_key += dbconstants . KIND_SEPARATOR <EOL> try : <EOL> self . zoo_keeper . release_lock ( app_id , txn_id ) <EOL> except zk . ZKTransactionException as zkte : <EOL> logging . warning ( str ( zkte ) ) <EOL> if retries > <NUM_LIT:0> : <EOL> logging . info ( '<STR_LIT>' . <EOL> format ( txn_id , retries ) ) <EOL> time . sleep ( retry_time ) <EOL> self . release_lock_for_key ( <EOL> app_id = app_id , <EOL> key = key , <EOL> txn_id = txn_id , <EOL> retries = retries - <NUM_LIT:1> , <EOL> retry_time = retry_time <EOL> ) <EOL> else : <EOL> self . zoo_keeper . notify_failed_transaction ( app_id , txn_id ) <EOL> def fetch_entity_dict_for_references ( self , references ) : <EOL> """<STR_LIT>""" <EOL> keys = [ ] <EOL> for item in references : <EOL> keys . append ( item . values ( ) [ <NUM_LIT:0> ] [ self . ds_access . INDEX_REFERENCE_COLUMN ] ) <EOL> keys = list ( set ( keys ) ) <EOL> entities = self . db_access . batch_get_entity ( dbconstants . APP_ENTITY_TABLE , <EOL> keys , dbconstants . APP_ENTITY_SCHEMA ) <EOL> entities_by_app = { } <EOL> for key in entities : <EOL> app = key . split ( self . ds_access . _SEPARATOR ) [ <NUM_LIT:0> ] <EOL> if app not in entities_by_app : <EOL> entities_by_app [ app ] = { } <EOL> entities_by_app [ app ] [ key ] = entities [ key ] <EOL> entities = { } <EOL> for app in entities_by_app : <EOL> app_entities = entities_by_app [ app ] <EOL> app_entities = self . ds_access . validated_result ( app , app_entities ) <EOL> app_entities = self . ds_access . remove_tombstoned_entities ( app_entities ) <EOL> for key in keys : <EOL> if key not in app_entities : <EOL> continue <EOL> if dbconstants . APP_ENTITY_SCHEMA [ <NUM_LIT:0> ] not in app_entities [ key ] : <EOL> continue <EOL> entities [ key ] = app_entities [ key ] [ dbconstants . APP_ENTITY_SCHEMA [ <NUM_LIT:0> ] ] <EOL> return entities <EOL> def lock_and_delete_indexes ( self , references , direction , entity_key ) : <EOL> """<STR_LIT>""" <EOL> if direction == datastore_pb . Query_Order . ASCENDING : <EOL> table_name = dbconstants . ASC_PROPERTY_TABLE <EOL> else : <EOL> table_name = dbconstants . DSC_PROPERTY_TABLE <EOL> app = entity_key . split ( self . ds_access . _SEPARATOR ) [ <NUM_LIT:0> ] <EOL> try : <EOL> txn_id = self . acquire_lock_for_key ( <EOL> app_id = app , <EOL> key = entity_key , <EOL> retries = self . ds_access . NON_TRANS_LOCK_RETRY_COUNT , <EOL> retry_time = self . ds_access . LOCK_RETRY_TIME <EOL> ) <EOL> except zk . ZKTransactionException : <EOL> self . index_entries_delete_failures += <NUM_LIT:1> <EOL> return <EOL> entities = self . fetch_entity_dict_for_references ( references ) <EOL> refs_to_delete = [ ] <EOL> for reference in references : <EOL> index_elements = reference . keys ( ) [ <NUM_LIT:0> ] . split ( self . ds_access . _SEPARATOR ) <EOL> prop_name = index_elements [ self . ds_access . PROP_NAME_IN_SINGLE_PROP_INDEX ] <EOL> if not self . ds_access . _DatastoreDistributed__valid_index_entry ( <EOL> reference , entities , direction , prop_name ) : <EOL> refs_to_delete . append ( reference . keys ( ) [ <NUM_LIT:0> ] ) <EOL> logging . debug ( '<STR_LIT>' . <EOL> format ( len ( refs_to_delete ) , [ refs_to_delete [ <NUM_LIT:0> ] ] ) ) <EOL> try : <EOL> self . db_access . batch_delete ( table_name , refs_to_delete , <EOL> column_names = dbconstants . PROPERTY_SCHEMA ) <EOL> self . index_entries_cleaned += len ( refs_to_delete ) <EOL> except Exception : <EOL> logging . exception ( '<STR_LIT>' ) <EOL> self . index_entries_delete_failures += <NUM_LIT:1> <EOL> self . release_lock_for_key ( <EOL> app_id = app , <EOL> key = entity_key , <EOL> txn_id = txn_id , <EOL> retries = self . ds_access . NON_TRANS_LOCK_RETRY_COUNT , <EOL> retry_time = self . ds_access . LOCK_RETRY_TIME <EOL> ) <EOL> def lock_and_delete_kind_index ( self , reference ) : <EOL> """<STR_LIT>""" <EOL> table_name = dbconstants . APP_KIND_TABLE <EOL> entity_key = reference . values ( ) [ <NUM_LIT:0> ] . values ( ) [ <NUM_LIT:0> ] <EOL> app = entity_key . split ( self . ds_access . _SEPARATOR ) [ <NUM_LIT:0> ] <EOL> try : <EOL> txn_id = self . acquire_lock_for_key ( <EOL> app_id = app , <EOL> key = entity_key , <EOL> retries = self . ds_access . NON_TRANS_LOCK_RETRY_COUNT , <EOL> retry_time = self . ds_access . LOCK_RETRY_TIME <EOL> ) <EOL> except zk . ZKTransactionException : <EOL> self . index_entries_delete_failures += <NUM_LIT:1> <EOL> return <EOL> entities = self . fetch_entity_dict_for_references ( [ reference ] ) <EOL> if entity_key not in entities : <EOL> index_to_delete = reference . keys ( ) [ <NUM_LIT:0> ] <EOL> logging . debug ( '<STR_LIT>' . format ( [ index_to_delete ] ) ) <EOL> try : <EOL> self . db_access . batch_delete ( table_name , [ index_to_delete ] , <EOL> column_names = dbconstants . APP_KIND_SCHEMA ) <EOL> self . index_entries_cleaned += <NUM_LIT:1> <EOL> except dbconstants . AppScaleDBConnectionError : <EOL> logging . exception ( '<STR_LIT>' ) <EOL> self . index_entries_delete_failures += <NUM_LIT:1> <EOL> self . release_lock_for_key ( <EOL> app_id = app , <EOL> key = entity_key , <EOL> txn_id = txn_id , <EOL> retries = self . ds_access . NON_TRANS_LOCK_RETRY_COUNT , <EOL> retry_time = self . ds_access . LOCK_RETRY_TIME <EOL> ) <EOL> def clean_up_indexes ( self , direction ) : <EOL> """<STR_LIT>""" <EOL> if direction == datastore_pb . Query_Order . ASCENDING : <EOL> table_name = dbconstants . ASC_PROPERTY_TABLE <EOL> task_id = self . CLEAN_ASC_INDICES_TASK <EOL> else : <EOL> table_name = dbconstants . DSC_PROPERTY_TABLE <EOL> task_id = self . CLEAN_DSC_INDICES_TASK <EOL> if len ( self . groomer_state ) > <NUM_LIT:1> and self . groomer_state [ <NUM_LIT:0> ] == task_id : <EOL> start_key = self . groomer_state [ <NUM_LIT:1> ] <EOL> else : <EOL> start_key = '<STR_LIT>' <EOL> end_key = dbconstants . TERMINATING_STRING <EOL> while True : <EOL> references = self . db_access . range_query ( <EOL> table_name = table_name , <EOL> column_names = dbconstants . PROPERTY_SCHEMA , <EOL> start_key = start_key , <EOL> end_key = end_key , <EOL> limit = self . BATCH_SIZE , <EOL> start_inclusive = False , <EOL> ) <EOL> if len ( references ) == <NUM_LIT:0> : <EOL> break <EOL> self . index_entries_checked += len ( references ) <EOL> if time . time ( ) > self . last_logged + self . LOG_PROGRESS_FREQUENCY : <EOL> logging . info ( '<STR_LIT>' <EOL> . format ( self . index_entries_checked ) ) <EOL> self . last_logged = time . time ( ) <EOL> first_ref = references [ <NUM_LIT:0> ] . keys ( ) [ <NUM_LIT:0> ] <EOL> logging . debug ( '<STR_LIT>' <EOL> . format ( self . index_entries_checked , [ first_ref ] , direction ) ) <EOL> last_start_key = start_key <EOL> start_key = references [ - <NUM_LIT:1> ] . keys ( ) [ <NUM_LIT:0> ] <EOL> if start_key == last_start_key : <EOL> raise dbconstants . AppScaleDBError ( <EOL> '<STR_LIT>' ) <EOL> entities = self . fetch_entity_dict_for_references ( references ) <EOL> invalid_refs = { } <EOL> for reference in references : <EOL> prop_name = reference . keys ( ) [ <NUM_LIT:0> ] . split ( self . ds_access . _SEPARATOR ) [ <NUM_LIT:3> ] <EOL> if not self . ds_access . _DatastoreDistributed__valid_index_entry ( <EOL> reference , entities , direction , prop_name ) : <EOL> entity_key = reference . values ( ) [ <NUM_LIT:0> ] [ self . ds_access . INDEX_REFERENCE_COLUMN ] <EOL> if entity_key not in invalid_refs : <EOL> invalid_refs [ entity_key ] = [ ] <EOL> invalid_refs [ entity_key ] . append ( reference ) <EOL> for entity_key in invalid_refs : <EOL> self . lock_and_delete_indexes ( invalid_refs [ entity_key ] , direction , entity_key ) <EOL> self . update_groomer_state ( [ task_id , start_key ] ) <EOL> def clean_up_kind_indices ( self ) : <EOL> """<STR_LIT>""" <EOL> table_name = dbconstants . APP_KIND_TABLE <EOL> task_id = self . CLEAN_KIND_INDICES_TASK <EOL> start_key = '<STR_LIT>' <EOL> end_key = dbconstants . TERMINATING_STRING <EOL> if len ( self . groomer_state ) > <NUM_LIT:1> : <EOL> start_key = self . groomer_state [ <NUM_LIT:1> ] <EOL> while True : <EOL> references = self . db_access . range_query ( <EOL> table_name = table_name , <EOL> column_names = dbconstants . APP_KIND_SCHEMA , <EOL> start_key = start_key , <EOL> end_key = end_key , <EOL> limit = self . BATCH_SIZE , <EOL> start_inclusive = False , <EOL> ) <EOL> if len ( references ) == <NUM_LIT:0> : <EOL> break <EOL> self . index_entries_checked += len ( references ) <EOL> if time . time ( ) > self . last_logged + self . LOG_PROGRESS_FREQUENCY : <EOL> logging . info ( '<STR_LIT>' . <EOL> format ( self . index_entries_checked ) ) <EOL> self . last_logged = time . time ( ) <EOL> first_ref = references [ <NUM_LIT:0> ] . keys ( ) [ <NUM_LIT:0> ] <EOL> logging . debug ( '<STR_LIT>' . <EOL> format ( len ( references ) , [ first_ref ] ) ) <EOL> last_start_key = start_key <EOL> start_key = references [ - <NUM_LIT:1> ] . keys ( ) [ <NUM_LIT:0> ] <EOL> if start_key == last_start_key : <EOL> raise dbconstants . AppScaleDBError ( <EOL> '<STR_LIT>' ) <EOL> entities = self . fetch_entity_dict_for_references ( references ) <EOL> for reference in references : <EOL> entity_key = reference . values ( ) [ <NUM_LIT:0> ] . values ( ) [ <NUM_LIT:0> ] <EOL> if entity_key not in entities : <EOL> self . lock_and_delete_kind_index ( reference ) <EOL> self . update_groomer_state ( [ task_id , start_key ] ) <EOL> def clean_up_composite_indexes ( self ) : <EOL> """<STR_LIT>""" <EOL> return True <EOL> def get_composite_indexes ( self , app_id , kind ) : <EOL> """<STR_LIT>""" <EOL> if not kind : <EOL> return [ ] <EOL> if app_id in self . composite_index_cache : <EOL> if self . composite_index_cache [ app_id ] == self . NO_COMPOSITES : <EOL> return [ ] <EOL> elif kind in self . composite_index_cache [ app_id ] : <EOL> return self . composite_index_cache [ app_id ] [ kind ] <EOL> else : <EOL> return [ ] <EOL> else : <EOL> if self . load_composite_cache ( app_id ) : <EOL> if kind in self . composite_index_cache [ app_id ] : <EOL> return self . composite_index_cache [ kind ] <EOL> return [ ] <EOL> def delete_indexes ( self , entity ) : <EOL> """<STR_LIT>""" <EOL> return <EOL> def delete_composite_indexes ( self , entity , composites ) : <EOL> """<STR_LIT>""" <EOL> row_keys = datastore_server . DatastoreDistributed . get_composite_indexes_rows ( [ entity ] , composites ) <EOL> self . db_access . batch_delete ( dbconstants . COMPOSITE_TABLE , <EOL> row_keys , column_names = dbconstants . COMPOSITE_SCHEMA ) <EOL> def fix_badlisted_entity ( self , key , version ) : <EOL> """<STR_LIT>""" <EOL> app_prefix = entity_utils . get_prefix_from_entity_key ( key ) <EOL> root_key = entity_utils . get_root_key_from_entity_key ( key ) <EOL> try : <EOL> txn_id = self . zoo_keeper . get_transaction_id ( app_prefix ) <EOL> if self . zoo_keeper . acquire_lock ( app_prefix , txn_id , root_key ) : <EOL> valid_id = self . zoo_keeper . get_valid_transaction_id ( app_prefix , <EOL> version , key ) <EOL> ds_distributed = self . register_db_accessor ( app_prefix ) <EOL> bad_key = datastore_server . DatastoreDistributed . get_journal_key ( key , <EOL> version ) <EOL> good_key = datastore_server . DatastoreDistributed . get_journal_key ( key , <EOL> valid_id ) <EOL> good_entry = entity_utils . fetch_journal_entry ( self . db_access , good_key ) <EOL> bad_entry = entity_utils . fetch_journal_entry ( self . db_access , bad_key ) <EOL> kind = None <EOL> if good_entry : <EOL> kind = datastore_server . DatastoreDistributed . get_entity_kind ( <EOL> good_entry . key ( ) ) <EOL> elif bad_entry : <EOL> kind = datastore_server . DatastoreDistributed . get_entity_kind ( <EOL> bad_entry . key ( ) ) <EOL> composites = self . get_composite_indexes ( app_prefix , kind ) <EOL> if bad_entry : <EOL> self . delete_indexes ( bad_entry ) <EOL> self . delete_composite_indexes ( bad_entry , composites ) <EOL> if good_entry : <EOL> pass <EOL> else : <EOL> pass <EOL> del ds_distributed <EOL> else : <EOL> success = False <EOL> except zk . ZKTransactionException , zk_exception : <EOL> logging . error ( "<STR_LIT>" . format ( zk_exception ) ) <EOL> success = False <EOL> except zk . ZKInternalException , zk_exception : <EOL> logging . error ( "<STR_LIT>" . format ( zk_exception ) ) <EOL> success = False <EOL> except dbconstants . AppScaleDBConnectionError , db_exception : <EOL> logging . error ( "<STR_LIT>" . format ( db_exception ) ) <EOL> success = False <EOL> finally : <EOL> if not success : <EOL> if not self . zoo_keeper . notify_failed_transaction ( app_prefix , txn_id ) : <EOL> logging . error ( "<STR_LIT>" . format ( app_prefix , txn_id ) ) <EOL> try : <EOL> self . zoo_keeper . release_lock ( app_prefix , txn_id ) <EOL> except zk . ZKTransactionException , zk_exception : <EOL> pass <EOL> except zk . ZKInternalException , zk_exception : <EOL> pass <EOL> return True <EOL> def process_tombstone ( self , key , entity , version ) : <EOL> """<STR_LIT>""" <EOL> success = False <EOL> app_prefix = entity_utils . get_prefix_from_entity_key ( key ) <EOL> root_key = entity_utils . get_root_key_from_entity_key ( key ) <EOL> try : <EOL> if self . zoo_keeper . is_blacklisted ( app_prefix , version ) : <EOL> logging . error ( "<STR_LIT>" . format ( version , key ) ) <EOL> return True <EOL> return self . fix_badlisted_entity ( key , version ) <EOL> except zk . ZKTransactionException , zk_exception : <EOL> logging . error ( "<STR_LIT>" . format ( zk_exception ) ) <EOL> time . sleep ( self . DB_ERROR_PERIOD ) <EOL> return False <EOL> except zk . ZKInternalException , zk_exception : <EOL> logging . error ( "<STR_LIT>" . format ( zk_exception ) ) <EOL> time . sleep ( self . DB_ERROR_PERIOD ) <EOL> return False <EOL> txn_id = <NUM_LIT:0> <EOL> try : <EOL> txn_id = self . zoo_keeper . get_transaction_id ( app_prefix ) <EOL> except zk . ZKTransactionException , zk_exception : <EOL> logging . error ( "<STR_LIT>" . format ( zk_exception ) ) <EOL> logging . error ( "<STR_LIT>" ) <EOL> time . sleep ( self . DB_ERROR_PERIOD ) <EOL> return False <EOL> except zk . ZKInternalException , zk_exception : <EOL> logging . error ( "<STR_LIT>" . format ( zk_exception ) ) <EOL> logging . error ( "<STR_LIT>" ) <EOL> time . sleep ( self . DB_ERROR_PERIOD ) <EOL> return False <EOL> try : <EOL> if self . zoo_keeper . acquire_lock ( app_prefix , txn_id , root_key ) : <EOL> success = self . hard_delete_row ( key ) <EOL> if success : <EOL> success = self . clean_journal_entries ( txn_id + <NUM_LIT:1> , key ) <EOL> else : <EOL> success = False <EOL> except zk . ZKTransactionException , zk_exception : <EOL> logging . error ( "<STR_LIT>" . format ( zk_exception ) ) <EOL> logging . error ( "<STR_LIT>" ) <EOL> time . sleep ( self . DB_ERROR_PERIOD ) <EOL> success = False <EOL> except zk . ZKInternalException , zk_exception : <EOL> logging . error ( "<STR_LIT>" . format ( zk_exception ) ) <EOL> logging . error ( "<STR_LIT>" ) <EOL> time . sleep ( self . DB_ERROR_PERIOD ) <EOL> success = False <EOL> finally : <EOL> if not success : <EOL> try : <EOL> if not self . zoo_keeper . notify_failed_transaction ( app_prefix , txn_id ) : <EOL> logging . error ( "<STR_LIT>" . format ( app_prefix , txn_id ) ) <EOL> self . zoo_keeper . release_lock ( app_prefix , txn_id ) <EOL> except zk . ZKTransactionException , zk_exception : <EOL> logging . error ( "<STR_LIT>" . format ( <EOL> zk_exception ) ) <EOL> except zk . ZKInternalException , zk_exception : <EOL> logging . error ( "<STR_LIT>" . format ( <EOL> zk_exception ) ) <EOL> if success : <EOL> try : <EOL> self . zoo_keeper . release_lock ( app_prefix , txn_id ) <EOL> except Exception , exception : <EOL> logging . error ( "<STR_LIT>" . format ( exception ) ) <EOL> self . num_deletes += <NUM_LIT:1> <EOL> logging . debug ( "<STR_LIT>" . format ( key , success ) ) <EOL> return success <EOL> def initialize_kind ( self , app_id , kind ) : <EOL> """<STR_LIT>""" <EOL> if app_id not in self . stats : <EOL> self . stats [ app_id ] = { kind : { '<STR_LIT:size>' : <NUM_LIT:0> , '<STR_LIT>' : <NUM_LIT:0> } } <EOL> if kind not in self . stats [ app_id ] : <EOL> self . stats [ app_id ] [ kind ] = { '<STR_LIT:size>' : <NUM_LIT:0> , '<STR_LIT>' : <NUM_LIT:0> } <EOL> def initialize_namespace ( self , app_id , namespace ) : <EOL> """<STR_LIT>""" <EOL> if app_id not in self . namespace_info : <EOL> self . namespace_info [ app_id ] = { namespace : { '<STR_LIT:size>' : <NUM_LIT:0> , '<STR_LIT>' : <NUM_LIT:0> } } <EOL> if namespace not in self . namespace_info [ app_id ] : <EOL> self . namespace_info [ app_id ] = { namespace : { '<STR_LIT:size>' : <NUM_LIT:0> , '<STR_LIT>' : <NUM_LIT:0> } } <EOL> if namespace not in self . namespace_info [ app_id ] : <EOL> self . stats [ app_id ] [ namespace ] = { '<STR_LIT:size>' : <NUM_LIT:0> , '<STR_LIT>' : <NUM_LIT:0> } <EOL> def process_statistics ( self , key , entity , size ) : <EOL> """<STR_LIT>""" <EOL> kind = datastore_server . DatastoreDistributed . get_entity_kind ( entity . key ( ) ) <EOL> namespace = entity . key ( ) . name_space ( ) <EOL> if not kind : <EOL> logging . warning ( "<STR_LIT>" . format ( entity ) ) <EOL> return False <EOL> if re . match ( self . PROTECTED_KINDS , kind ) : <EOL> return True <EOL> if re . match ( self . PRIVATE_KINDS , kind ) : <EOL> return True <EOL> app_id = entity . key ( ) . app ( ) <EOL> if not app_id : <EOL> logging . warning ( "<STR_LIT>" . format ( kind ) ) <EOL> return False <EOL> if app_id in self . APPSCALE_APPLICATIONS : <EOL> return True <EOL> self . initialize_kind ( app_id , kind ) <EOL> self . initialize_namespace ( app_id , namespace ) <EOL> self . namespace_info [ app_id ] [ namespace ] [ '<STR_LIT:size>' ] += size <EOL> self . namespace_info [ app_id ] [ namespace ] [ '<STR_LIT>' ] += <NUM_LIT:1> <EOL> self . stats [ app_id ] [ kind ] [ '<STR_LIT:size>' ] += size <EOL> self . stats [ app_id ] [ kind ] [ '<STR_LIT>' ] += <NUM_LIT:1> <EOL> return True <EOL> def txn_blacklist_cleanup ( self ) : <EOL> """<STR_LIT>""" <EOL> return True <EOL> def verify_entity ( self , entity , key , txn_id ) : <EOL> """<STR_LIT>""" <EOL> app_prefix = entity_utils . get_prefix_from_entity_key ( key ) <EOL> try : <EOL> if not self . zoo_keeper . is_blacklisted ( app_prefix , txn_id ) : <EOL> self . clean_journal_entries ( txn_id , key ) <EOL> else : <EOL> logging . error ( "<STR_LIT>" . format ( txn_id , key ) ) <EOL> return True <EOL> return self . fix_badlisted_entity ( key , txn_id ) <EOL> except zk . ZKTransactionException , zk_exception : <EOL> logging . error ( "<STR_LIT>" . format ( zk_exception ) ) <EOL> time . sleep ( self . DB_ERROR_PERIOD ) <EOL> return True <EOL> except zk . ZKInternalException , zk_exception : <EOL> logging . error ( "<STR_LIT>" . format ( <EOL> zk_exception ) ) <EOL> time . sleep ( self . DB_ERROR_PERIOD ) <EOL> return True <EOL> return True <EOL> def process_entity ( self , entity ) : <EOL> """<STR_LIT>""" <EOL> logging . debug ( "<STR_LIT>" . format ( str ( entity ) ) ) <EOL> key = entity . keys ( ) [ <NUM_LIT:0> ] <EOL> one_entity = entity [ key ] [ dbconstants . APP_ENTITY_SCHEMA [ <NUM_LIT:0> ] ] <EOL> version = entity [ key ] [ dbconstants . APP_ENTITY_SCHEMA [ <NUM_LIT:1> ] ] <EOL> logging . debug ( "<STR_LIT>" . format ( entity ) ) <EOL> if one_entity == datastore_server . TOMBSTONE : <EOL> return self . process_tombstone ( key , one_entity , version ) <EOL> ent_proto = entity_pb . EntityProto ( ) <EOL> ent_proto . ParseFromString ( one_entity ) <EOL> self . verify_entity ( ent_proto , key , version ) <EOL> self . process_statistics ( key , ent_proto , len ( one_entity ) ) <EOL> return True <EOL> def create_namespace_entry ( self , namespace , size , number , timestamp ) : <EOL> """<STR_LIT>""" <EOL> entities_to_write = [ ] <EOL> namespace_stat = stats . NamespaceStat ( subject_namespace = namespace , <EOL> bytes = size , <EOL> count = number , <EOL> timestamp = timestamp ) <EOL> entities_to_write . append ( namespace_stat ) <EOL> if namespace != "<STR_LIT>" : <EOL> namespace_entry = metadata . Namespace ( key_name = namespace ) <EOL> entities_to_write . append ( namespace_entry ) <EOL> try : <EOL> db . put ( entities_to_write ) <EOL> except datastore_errors . InternalError , internal_error : <EOL> logging . error ( "<STR_LIT>" . format ( internal_error ) ) <EOL> return False <EOL> logging . debug ( "<STR_LIT>" ) <EOL> return True <EOL> def create_kind_stat_entry ( self , kind , size , number , timestamp ) : <EOL> """<STR_LIT>""" <EOL> kind_stat = stats . KindStat ( kind_name = kind , <EOL> bytes = size , <EOL> count = number , <EOL> timestamp = timestamp ) <EOL> kind_entry = metadata . Kind ( key_name = kind ) <EOL> entities_to_write = [ kind_stat , kind_entry ] <EOL> try : <EOL> db . put ( entities_to_write ) <EOL> except datastore_errors . InternalError , internal_error : <EOL> logging . error ( "<STR_LIT>" . format ( internal_error ) ) <EOL> return False <EOL> logging . debug ( "<STR_LIT>" ) <EOL> return True <EOL> def create_global_stat_entry ( self , app_id , size , number , timestamp ) : <EOL> """<STR_LIT>""" <EOL> global_stat = stats . GlobalStat ( key_name = app_id , <EOL> bytes = size , <EOL> count = number , <EOL> timestamp = timestamp ) <EOL> try : <EOL> db . put ( global_stat ) <EOL> except datastore_errors . InternalError , internal_error : <EOL> logging . error ( "<STR_LIT>" . format ( internal_error ) ) <EOL> return False <EOL> logging . debug ( "<STR_LIT>" ) <EOL> return True <EOL> def remove_old_tasks_entities ( self ) : <EOL> """<STR_LIT>""" <EOL> if ( len ( self . groomer_state ) > <NUM_LIT:1> and <EOL> self . groomer_state [ <NUM_LIT:0> ] == self . CLEAN_TASKS_TASK ) : <EOL> last_cursor = Cursor ( self . groomer_state [ <NUM_LIT:1> ] ) <EOL> else : <EOL> last_cursor = None <EOL> self . register_db_accessor ( constants . DASHBOARD_APP_ID ) <EOL> timeout = datetime . datetime . utcnow ( ) - datetime . timedelta ( seconds = self . TASK_NAME_TIMEOUT ) <EOL> counter = <NUM_LIT:0> <EOL> logging . debug ( "<STR_LIT>" . format ( datetime . datetime . utcnow ( ) ) ) <EOL> logging . debug ( "<STR_LIT>" . format ( timeout ) ) <EOL> while True : <EOL> query = TaskName . all ( ) <EOL> if last_cursor : <EOL> query . with_cursor ( last_cursor ) <EOL> query . filter ( "<STR_LIT>" , timeout ) <EOL> entities = query . fetch ( self . BATCH_SIZE ) <EOL> if len ( entities ) == <NUM_LIT:0> : <EOL> break <EOL> last_cursor = query . cursor ( ) <EOL> for entity in entities : <EOL> logging . debug ( "<STR_LIT>" . format ( entity . timestamp ) ) <EOL> entity . delete ( ) <EOL> counter += <NUM_LIT:1> <EOL> if time . time ( ) > self . last_logged + self . LOG_PROGRESS_FREQUENCY : <EOL> logging . info ( '<STR_LIT>' . format ( counter ) ) <EOL> self . last_logged = self . LOG_PROGRESS_FREQUENCY <EOL> self . update_groomer_state ( [ self . CLEAN_TASKS_TASK , last_cursor ] ) <EOL> logging . info ( "<STR_LIT>" . format ( counter ) ) <EOL> return True <EOL> def clean_up_entities ( self ) : <EOL> if ( len ( self . groomer_state ) > <NUM_LIT:1> and <EOL> self . groomer_state [ <NUM_LIT:0> ] == self . CLEAN_ENTITIES_TASK ) : <EOL> last_key = self . groomer_state [ <NUM_LIT:1> ] <EOL> else : <EOL> last_key = "<STR_LIT>" <EOL> while True : <EOL> try : <EOL> logging . debug ( '<STR_LIT>' . format ( self . BATCH_SIZE ) ) <EOL> entities = self . get_entity_batch ( last_key ) <EOL> if not entities : <EOL> break <EOL> for entity in entities : <EOL> self . process_entity ( entity ) <EOL> last_key = entities [ - <NUM_LIT:1> ] . keys ( ) [ <NUM_LIT:0> ] <EOL> self . entities_checked += len ( entities ) <EOL> if time . time ( ) > self . last_logged + self . LOG_PROGRESS_FREQUENCY : <EOL> logging . info ( '<STR_LIT>' . format ( self . entities_checked ) ) <EOL> self . last_logged = time . time ( ) <EOL> self . update_groomer_state ( [ self . CLEAN_ENTITIES_TASK , last_key ] ) <EOL> except datastore_errors . Error , error : <EOL> logging . error ( "<STR_LIT>" . format ( error ) ) <EOL> time . sleep ( self . DB_ERROR_PERIOD ) <EOL> except dbconstants . AppScaleDBConnectionError , connection_error : <EOL> logging . error ( "<STR_LIT>" . format ( connection_error ) ) <EOL> time . sleep ( self . DB_ERROR_PERIOD ) <EOL> def register_db_accessor ( self , app_id ) : <EOL> """<STR_LIT>""" <EOL> ds_distributed = datastore_distributed . DatastoreDistributed ( app_id , <EOL> self . datastore_path , require_indexes = False ) <EOL> apiproxy_stub_map . apiproxy . RegisterStub ( '<STR_LIT>' , ds_distributed ) <EOL> apiproxy_stub_map . apiproxy . RegisterStub ( '<STR_LIT>' , <EOL> memcache_distributed . MemcacheService ( ) ) <EOL> os . environ [ '<STR_LIT>' ] = app_id <EOL> os . environ [ '<STR_LIT>' ] = app_id <EOL> os . environ [ '<STR_LIT>' ] = "<STR_LIT>" <EOL> return ds_distributed <EOL> def remove_old_logs ( self , log_timeout ) : <EOL> """<STR_LIT>""" <EOL> if ( len ( self . groomer_state ) > <NUM_LIT:1> and <EOL> self . groomer_state [ <NUM_LIT:0> ] == self . CLEAN_LOGS_TASK ) : <EOL> last_cursor = Cursor ( self . groomer_state [ <NUM_LIT:1> ] ) <EOL> else : <EOL> last_cursor = None <EOL> self . register_db_accessor ( constants . DASHBOARD_APP_ID ) <EOL> if log_timeout : <EOL> timeout = ( datetime . datetime . utcnow ( ) - <EOL> datetime . timedelta ( seconds = log_timeout ) ) <EOL> query = RequestLogLine . query ( RequestLogLine . timestamp < timeout ) <EOL> logging . debug ( "<STR_LIT>" . format ( timeout ) ) <EOL> else : <EOL> query = RequestLogLine . query ( ) <EOL> counter = <NUM_LIT:0> <EOL> logging . debug ( "<STR_LIT>" . format ( datetime . datetime . utcnow ( ) ) ) <EOL> while True : <EOL> entities , next_cursor , more = query . fetch_page ( self . BATCH_SIZE , <EOL> start_cursor = last_cursor ) <EOL> for entity in entities : <EOL> logging . debug ( "<STR_LIT>" . format ( entity ) ) <EOL> entity . key . delete ( ) <EOL> counter += <NUM_LIT:1> <EOL> if time . time ( ) > self . last_logged + self . LOG_PROGRESS_FREQUENCY : <EOL> logging . info ( '<STR_LIT>' . format ( counter ) ) <EOL> self . last_logged = time . time ( ) <EOL> if more : <EOL> last_cursor = next_cursor <EOL> self . update_groomer_state ( [ self . CLEAN_LOGS_TASK , <EOL> last_cursor . urlsafe ( ) ] ) <EOL> else : <EOL> break <EOL> logging . info ( "<STR_LIT>" . format ( counter ) ) <EOL> return True <EOL> def remove_old_statistics ( self ) : <EOL> """<STR_LIT>""" <EOL> for app_id in self . stats . keys ( ) : <EOL> self . register_db_accessor ( app_id ) <EOL> query = stats . KindStat . all ( ) <EOL> entities = query . run ( ) <EOL> logging . debug ( "<STR_LIT>" . format ( str ( entities ) ) ) <EOL> for entity in entities : <EOL> logging . debug ( "<STR_LIT>" . format ( entity ) ) <EOL> entity . delete ( ) <EOL> query = stats . GlobalStat . all ( ) <EOL> entities = query . run ( ) <EOL> logging . debug ( "<STR_LIT>" . format ( str ( entities ) ) ) <EOL> for entity in entities : <EOL> logging . debug ( "<STR_LIT>" . format ( entity ) ) <EOL> entity . delete ( ) <EOL> logging . debug ( "<STR_LIT>" . format ( app_id ) ) <EOL> def update_namespaces ( self , timestamp ) : <EOL> """<STR_LIT>""" <EOL> for app_id in self . namespace_info . keys ( ) : <EOL> ds_distributed = self . register_db_accessor ( app_id ) <EOL> namespaces = self . namespace_info [ app_id ] . keys ( ) <EOL> for namespace in namespaces : <EOL> size = self . namespace_info [ app_id ] [ namespace ] [ '<STR_LIT:size>' ] <EOL> number = self . namespace_info [ app_id ] [ namespace ] [ '<STR_LIT>' ] <EOL> if not self . create_namespace_entry ( namespace , size , number , timestamp ) : <EOL> return False <EOL> logging . info ( "<STR_LIT>" . format ( app_id , self . namespace_info [ app_id ] ) ) <EOL> del ds_distributed <EOL> return True <EOL> def update_statistics ( self , timestamp ) : <EOL> """<STR_LIT>""" <EOL> for app_id in self . stats . keys ( ) : <EOL> ds_distributed = self . register_db_accessor ( app_id ) <EOL> total_size = <NUM_LIT:0> <EOL> total_number = <NUM_LIT:0> <EOL> kinds = self . stats [ app_id ] . keys ( ) <EOL> for kind in kinds : <EOL> size = self . stats [ app_id ] [ kind ] [ '<STR_LIT:size>' ] <EOL> number = self . stats [ app_id ] [ kind ] [ '<STR_LIT>' ] <EOL> total_size += size <EOL> total_number += number <EOL> if not self . create_kind_stat_entry ( kind , size , number , timestamp ) : <EOL> return False <EOL> if not self . create_global_stat_entry ( app_id , total_size , total_number , <EOL> timestamp ) : <EOL> return False <EOL> logging . info ( "<STR_LIT>" . format ( app_id , self . stats [ app_id ] ) ) <EOL> logging . info ( "<STR_LIT>" "<STR_LIT>" . format ( app_id , total_size , total_number ) ) <EOL> logging . info ( "<STR_LIT>" . format ( self . num_deletes ) ) <EOL> del ds_distributed <EOL> return True <EOL> def update_groomer_state ( self , state ) : <EOL> """<STR_LIT>""" <EOL> zk_data = self . GROOMER_STATE_DELIMITER . join ( state ) <EOL> try : <EOL> self . zoo_keeper . update_node ( self . GROOMER_STATE_PATH , zk_data ) <EOL> except zk . ZKInternalException as zkie : <EOL> logging . exception ( zkie ) <EOL> self . groomer_state = state <EOL> def run_groomer ( self ) : <EOL> """<STR_LIT>""" <EOL> self . db_access = appscale_datastore_batch . DatastoreFactory . getDatastore ( <EOL> self . table_name ) <EOL> self . ds_access = datastore_server . DatastoreDistributed ( <EOL> datastore_batch = self . db_access , zookeeper = self . zoo_keeper ) <EOL> logging . info ( "<STR_LIT>" ) <EOL> start = time . time ( ) <EOL> self . reset_statistics ( ) <EOL> self . composite_index_cache = { } <EOL> tasks = [ <EOL> { <EOL> '<STR_LIT:id>' : self . CLEAN_ENTITIES_TASK , <EOL> '<STR_LIT:description>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : self . clean_up_entities , <EOL> '<STR_LIT:args>' : [ ] <EOL> } , <EOL> { <EOL> '<STR_LIT:id>' : self . CLEAN_ASC_INDICES_TASK , <EOL> '<STR_LIT:description>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : self . clean_up_indexes , <EOL> '<STR_LIT:args>' : [ datastore_pb . Query_Order . ASCENDING ] <EOL> } , <EOL> { <EOL> '<STR_LIT:id>' : self . CLEAN_DSC_INDICES_TASK , <EOL> '<STR_LIT:description>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : self . clean_up_indexes , <EOL> '<STR_LIT:args>' : [ datastore_pb . Query_Order . DESCENDING ] <EOL> } , <EOL> { <EOL> '<STR_LIT:id>' : self . CLEAN_KIND_INDICES_TASK , <EOL> '<STR_LIT:description>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : self . clean_up_kind_indices , <EOL> '<STR_LIT:args>' : [ ] <EOL> } , <EOL> { <EOL> '<STR_LIT:id>' : self . CLEAN_LOGS_TASK , <EOL> '<STR_LIT:description>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : self . remove_old_logs , <EOL> '<STR_LIT:args>' : [ self . LOG_STORAGE_TIMEOUT ] <EOL> } , <EOL> { <EOL> '<STR_LIT:id>' : self . CLEAN_TASKS_TASK , <EOL> '<STR_LIT:description>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : self . remove_old_tasks_entities , <EOL> '<STR_LIT:args>' : [ ] <EOL> } , <EOL> { <EOL> '<STR_LIT:id>' : self . CLEAN_DASHBOARD_TASK , <EOL> '<STR_LIT:description>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : self . remove_old_dashboard_data , <EOL> '<STR_LIT:args>' : [ ] <EOL> } <EOL> ] <EOL> groomer_state = self . zoo_keeper . get_node ( self . GROOMER_STATE_PATH ) <EOL> logging . info ( '<STR_LIT>' . format ( groomer_state ) ) <EOL> if groomer_state : <EOL> self . update_groomer_state ( <EOL> groomer_state [ <NUM_LIT:0> ] . split ( self . GROOMER_STATE_DELIMITER ) ) <EOL> for task_number in range ( len ( tasks ) ) : <EOL> task = tasks [ task_number ] <EOL> if ( len ( self . groomer_state ) > <NUM_LIT:0> and self . groomer_state [ <NUM_LIT:0> ] != '<STR_LIT>' and <EOL> self . groomer_state [ <NUM_LIT:0> ] != task [ '<STR_LIT:id>' ] ) : <EOL> continue <EOL> logging . info ( '<STR_LIT>' . format ( task [ '<STR_LIT:description>' ] ) ) <EOL> try : <EOL> task [ '<STR_LIT>' ] ( * task [ '<STR_LIT:args>' ] ) <EOL> if task_number != len ( tasks ) - <NUM_LIT:1> : <EOL> next_task = tasks [ task_number + <NUM_LIT:1> ] <EOL> self . update_groomer_state ( [ next_task [ '<STR_LIT:id>' ] ] ) <EOL> except Exception as exception : <EOL> logging . error ( '<STR_LIT>' . <EOL> format ( task [ '<STR_LIT:description>' ] ) ) <EOL> logging . exception ( exception ) <EOL> self . update_groomer_state ( [ ] ) <EOL> timestamp = datetime . datetime . utcnow ( ) <EOL> if not self . update_statistics ( timestamp ) : <EOL> logging . error ( "<STR_LIT>" ) <EOL> if not self . update_namespaces ( timestamp ) : <EOL> logging . error ( "<STR_LIT>" ) <EOL> del self . db_access <EOL> del self . ds_access <EOL> time_taken = time . time ( ) - start <EOL> logging . info ( "<STR_LIT>" . format ( <EOL> self . journal_entries_cleaned ) ) <EOL> logging . info ( "<STR_LIT>" . format ( <EOL> self . index_entries_checked ) ) <EOL> logging . info ( "<STR_LIT>" . format ( <EOL> self . index_entries_cleaned ) ) <EOL> if self . index_entries_delete_failures > <NUM_LIT:0> : <EOL> logging . info ( "<STR_LIT>" . format ( <EOL> self . index_entries_delete_failures ) ) <EOL> logging . info ( "<STR_LIT>" . format ( str ( time_taken ) ) ) <EOL> def main ( ) : <EOL> """<STR_LIT>""" <EOL> zk_connection_locations = appscale_info . get_zk_locations_string ( ) <EOL> zookeeper = zk . ZKTransaction ( host = zk_connection_locations , start_gc = False ) <EOL> db_info = appscale_info . get_db_info ( ) <EOL> table = db_info [ '<STR_LIT>' ] <EOL> master = appscale_info . get_db_master_ip ( ) <EOL> datastore_path = "<STR_LIT>" . format ( master ) <EOL> ds_groomer = DatastoreGroomer ( zookeeper , table , datastore_path ) <EOL> logging . debug ( "<STR_LIT>" ) <EOL> if ds_groomer . get_groomer_lock ( ) : <EOL> logging . info ( "<STR_LIT>" ) <EOL> try : <EOL> ds_groomer . run_groomer ( ) <EOL> except Exception as exception : <EOL> logging . exception ( '<STR_LIT>' <EOL> . format ( str ( exception ) ) ) <EOL> try : <EOL> ds_groomer . zoo_keeper . release_lock_with_path ( zk . DS_GROOM_LOCK_PATH ) <EOL> except zk . ZKTransactionException , zk_exception : <EOL> logging . error ( "<STR_LIT>" . format ( str ( zk_exception ) ) ) <EOL> except zk . ZKInternalException , zk_exception : <EOL> logging . error ( "<STR_LIT>" . format ( str ( zk_exception ) ) ) <EOL> finally : <EOL> zookeeper . close ( ) <EOL> else : <EOL> logging . info ( "<STR_LIT>" ) <EOL> if __name__ == "<STR_LIT:__main__>" : <EOL> main ( ) </s>

<s> import os <EOL> import sys <EOL> import time <EOL> import unittest <EOL> from flexmock import flexmock <EOL> import kazoo . client <EOL> import kazoo . exceptions <EOL> import kazoo . protocol <EOL> import kazoo . protocol . states <EOL> sys . path . append ( os . path . join ( os . path . dirname ( __file__ ) , "<STR_LIT>" ) ) <EOL> from dbconstants import * <EOL> sys . path . append ( os . path . join ( os . path . dirname ( __file__ ) , "<STR_LIT>" ) ) <EOL> from zkappscale import zktransaction as zk <EOL> from zkappscale . zktransaction import ZKTransactionException <EOL> class TestZookeeperTransaction ( unittest . TestCase ) : <EOL> """<STR_LIT:U+0020>""" <EOL> def setUp ( self ) : <EOL> self . appid = '<STR_LIT>' <EOL> self . handle = None <EOL> def test_increment_and_get_counter ( self ) : <EOL> flexmock ( zk . ZKTransaction ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . with_args ( <EOL> self . appid ) . and_return ( '<STR_LIT>' ) <EOL> fake_zookeeper = flexmock ( name = '<STR_LIT>' , create = '<STR_LIT>' , <EOL> delete_async = '<STR_LIT>' , connected = lambda : True ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT:start>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . and_return ( None ) <EOL> fake_counter = flexmock ( name = '<STR_LIT>' , value = '<STR_LIT:value>' ) <EOL> fake_counter . value = <NUM_LIT:1> <EOL> fake_counter . should_receive ( '<STR_LIT>' ) . and_return ( <NUM_LIT:2> ) <EOL> fake_zookeeper . should_receive ( "<STR_LIT>" ) . and_return ( fake_counter ) <EOL> flexmock ( kazoo . client ) <EOL> kazoo . client . should_receive ( '<STR_LIT>' ) . and_return ( fake_zookeeper ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( ( <NUM_LIT:0> , <NUM_LIT:1> ) , transaction . increment_and_get_counter ( <EOL> self . appid , <NUM_LIT:1> ) ) <EOL> def test_create_sequence_node ( self ) : <EOL> flexmock ( zk . ZKTransaction ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . with_args ( <EOL> self . appid ) . and_return ( '<STR_LIT>' ) <EOL> fake_zookeeper = flexmock ( name = '<STR_LIT>' , create = '<STR_LIT>' , <EOL> delete = '<STR_LIT>' , connected = lambda : True ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT:start>' ) <EOL> path_to_create = "<STR_LIT>" + self . appid <EOL> zero_path = path_to_create + "<STR_LIT>" <EOL> nonzero_path = path_to_create + "<STR_LIT>" <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str , value = str , <EOL> acl = None , makepath = bool , sequence = bool , ephemeral = bool ) . and_return ( zero_path ) . and_return ( nonzero_path ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , zero_path ) <EOL> flexmock ( kazoo . client ) <EOL> kazoo . client . should_receive ( '<STR_LIT>' ) . and_return ( fake_zookeeper ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( <NUM_LIT:1> , transaction . create_sequence_node ( '<STR_LIT>' + self . appid , '<STR_LIT>' ) ) <EOL> def test_create_node ( self ) : <EOL> flexmock ( zk . ZKTransaction ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . with_args ( <EOL> self . appid ) . and_return ( '<STR_LIT>' ) <EOL> fake_zookeeper = flexmock ( name = '<STR_LIT>' , create = '<STR_LIT>' , <EOL> connected = lambda : True ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT:start>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str , value = str , <EOL> acl = None , makepath = bool , sequence = bool , ephemeral = bool ) <EOL> flexmock ( kazoo . client ) <EOL> kazoo . client . should_receive ( '<STR_LIT>' ) . and_return ( fake_zookeeper ) <EOL> path_to_create = "<STR_LIT>" + self . appid <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( None , transaction . create_node ( '<STR_LIT>' + self . appid , <EOL> '<STR_LIT>' ) ) <EOL> def test_get_transaction_id ( self ) : <EOL> flexmock ( zk . ZKTransaction ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . with_args ( <EOL> self . appid ) . and_return ( '<STR_LIT>' + self . appid ) <EOL> path_to_create = "<STR_LIT>" + self . appid + "<STR_LIT:/>" + zk . APP_TX_PREFIX <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . with_args ( self . appid ) . and_return ( path_to_create ) <EOL> flexmock ( time ) <EOL> time . should_receive ( '<STR_LIT:time>' ) . and_return ( <NUM_LIT:1000> ) <EOL> fake_zookeeper = flexmock ( name = '<STR_LIT>' , connected = lambda : True ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT:start>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) <EOL> flexmock ( kazoo . client ) <EOL> kazoo . client . should_receive ( '<STR_LIT>' ) . and_return ( fake_zookeeper ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . with_args ( <EOL> path_to_create , '<STR_LIT>' ) . and_return ( <NUM_LIT:1> ) <EOL> xg_path = path_to_create + "<STR_LIT>" + zk . XG_PREFIX <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( xg_path ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . with_args ( xg_path , '<STR_LIT>' ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( <NUM_LIT:1> , transaction . get_transaction_id ( self . appid , is_xg = True ) ) <EOL> def test_get_txn_path_before_getting_id ( self ) : <EOL> flexmock ( zk . ZKTransaction ) <EOL> fake_zookeeper = flexmock ( name = '<STR_LIT>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT:start>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) <EOL> flexmock ( kazoo . client ) <EOL> kazoo . client . should_receive ( '<STR_LIT>' ) . and_return ( fake_zookeeper ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( "<STR_LIT>" ) <EOL> expected = zk . PATH_SEPARATOR . join ( [ "<STR_LIT>" , zk . APP_TX_PATH , zk . APP_TX_PREFIX ] ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( expected , <EOL> transaction . get_txn_path_before_getting_id ( self . appid ) ) <EOL> def test_get_xg_path ( self ) : <EOL> flexmock ( zk . ZKTransaction ) <EOL> fake_zookeeper = flexmock ( name = '<STR_LIT>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT:start>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) <EOL> flexmock ( kazoo . client ) <EOL> kazoo . client . should_receive ( '<STR_LIT>' ) . and_return ( fake_zookeeper ) <EOL> tx_id = <NUM_LIT:100> <EOL> tx_str = zk . APP_TX_PREFIX + "<STR_LIT>" % tx_id <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( "<STR_LIT>" ) <EOL> expected = zk . PATH_SEPARATOR . join ( [ "<STR_LIT>" , zk . APP_TX_PATH , <EOL> tx_str , zk . XG_PREFIX ] ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( expected , transaction . get_xg_path ( "<STR_LIT>" , <NUM_LIT:100> ) ) <EOL> def test_is_in_transaction ( self ) : <EOL> flexmock ( zk . ZKTransaction ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' ) <EOL> fake_zookeeper = flexmock ( name = '<STR_LIT>' , exists = '<STR_LIT>' , <EOL> connected = lambda : True ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT:start>' ) <EOL> flexmock ( kazoo . client ) <EOL> kazoo . client . should_receive ( '<STR_LIT>' ) . and_return ( fake_zookeeper ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( False ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( True ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( True , transaction . is_in_transaction ( self . appid , <NUM_LIT:1> ) ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( False ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( False ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( False , transaction . is_in_transaction ( self . appid , <NUM_LIT:1> ) ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( True ) <EOL> fake_transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertRaises ( zk . ZKTransactionException , transaction . is_in_transaction , <EOL> self . appid , <NUM_LIT:1> ) <EOL> def test_acquire_lock ( self ) : <EOL> flexmock ( zk . ZKTransaction ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' + self . appid ) <EOL> fake_zookeeper = flexmock ( name = '<STR_LIT>' , get = '<STR_LIT>' , <EOL> connected = lambda : True ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT:start>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) <EOL> flexmock ( kazoo . client ) <EOL> kazoo . client . should_receive ( '<STR_LIT>' ) . and_return ( fake_zookeeper ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( False ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( True ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( True , transaction . acquire_lock ( self . appid , "<STR_LIT>" , <EOL> "<STR_LIT>" ) ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( True ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' + self . appid + "<STR_LIT>" ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( [ '<STR_LIT>' ] ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( True , transaction . acquire_lock ( self . appid , "<STR_LIT>" , <EOL> "<STR_LIT>" ) ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( True ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' + self . appid + "<STR_LIT>" ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( [ '<STR_LIT>' ] ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( False ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertRaises ( zk . ZKTransactionException , transaction . acquire_lock , <EOL> self . appid , "<STR_LIT>" , "<STR_LIT>" ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( True ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' + self . appid + "<STR_LIT>" ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( [ '<STR_LIT>' ] ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( True ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( True , transaction . acquire_lock ( self . appid , "<STR_LIT>" , <EOL> "<STR_LIT>" ) ) <EOL> def test_acquire_additional_lock ( self ) : <EOL> flexmock ( zk . ZKTransaction ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' + self . appid ) <EOL> fake_zookeeper = flexmock ( name = '<STR_LIT>' , create = '<STR_LIT>' , <EOL> create_async = '<STR_LIT>' , get = '<STR_LIT>' , set_async = '<STR_LIT>' , <EOL> connected = lambda : True ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT:start>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str , makepath = bool , sequence = bool , <EOL> ephemeral = bool , value = str , acl = None ) . and_return ( "<STR_LIT>" ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str , value = str , <EOL> acl = None , ephemeral = bool , makepath = bool , sequence = bool ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str , value = str , <EOL> acl = str , ephemeral = bool , makepath = bool , sequence = bool ) <EOL> lock_list = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> lock_list_str = zk . LOCK_LIST_SEPARATOR . join ( lock_list ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( [ lock_list_str ] ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str , str ) <EOL> flexmock ( kazoo . client ) <EOL> kazoo . client . should_receive ( '<STR_LIT>' ) . and_return ( fake_zookeeper ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( True , transaction . acquire_additional_lock ( self . appid , <EOL> "<STR_LIT>" , "<STR_LIT>" , False ) ) <EOL> self . assertEquals ( True , transaction . acquire_additional_lock ( self . appid , <EOL> "<STR_LIT>" , "<STR_LIT>" , True ) ) <EOL> lock_list = [ '<STR_LIT:path>' + str ( num + <NUM_LIT:1> ) for num in range ( zk . MAX_GROUPS_FOR_XG ) ] <EOL> lock_list_str = zk . LOCK_LIST_SEPARATOR . join ( lock_list ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( [ lock_list_str ] ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertRaises ( zk . ZKTransactionException , <EOL> transaction . acquire_additional_lock , self . appid , "<STR_LIT>" , "<STR_LIT>" , False ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str , str , None , <EOL> bool , bool , bool ) . and_raise ( kazoo . exceptions . NodeExistsError ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertRaises ( zk . ZKTransactionException , <EOL> transaction . acquire_additional_lock , self . appid , "<STR_LIT>" , "<STR_LIT>" , False ) <EOL> def test_check_transaction ( self ) : <EOL> flexmock ( zk . ZKTransaction ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . with_args ( <EOL> self . appid ) . and_return ( '<STR_LIT>' ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( False ) <EOL> fake_zookeeper = flexmock ( name = '<STR_LIT>' , exists = '<STR_LIT>' , <EOL> connected = lambda : True ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT:start>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( True ) <EOL> flexmock ( kazoo . client ) <EOL> kazoo . client . should_receive ( '<STR_LIT>' ) . and_return ( fake_zookeeper ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( True , transaction . check_transaction ( self . appid , <NUM_LIT:1> ) ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( True ) <EOL> self . assertRaises ( zk . ZKTransactionException , transaction . check_transaction , <EOL> self . appid , <NUM_LIT:1> ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( False ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( False ) <EOL> self . assertRaises ( zk . ZKTransactionException , transaction . check_transaction , <EOL> self . appid , <NUM_LIT:1> ) <EOL> def test_is_xg ( self ) : <EOL> fake_zookeeper = flexmock ( name = '<STR_LIT>' , exists = '<STR_LIT>' , <EOL> connected = lambda : True ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT:start>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( True ) <EOL> flexmock ( kazoo . client ) <EOL> kazoo . client . should_receive ( '<STR_LIT>' ) . and_return ( fake_zookeeper ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( True , transaction . is_xg ( self . appid , <NUM_LIT:1> ) ) <EOL> def test_release_lock ( self ) : <EOL> flexmock ( zk . ZKTransaction ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( False ) <EOL> fake_zookeeper = flexmock ( name = '<STR_LIT>' , exists = '<STR_LIT>' , get = '<STR_LIT>' , <EOL> delete = '<STR_LIT>' , delete_async = '<STR_LIT>' , <EOL> get_children = '<STR_LIT>' , connected = lambda : True ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT:start>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( True ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( [ '<STR_LIT>' ] ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( [ '<STR_LIT:1>' , '<STR_LIT:2>' ] ) <EOL> flexmock ( kazoo . client ) <EOL> kazoo . client . should_receive ( '<STR_LIT>' ) . and_return ( fake_zookeeper ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( True , transaction . release_lock ( self . appid , <NUM_LIT:1> ) ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( True ) <EOL> self . assertEquals ( True , transaction . release_lock ( self . appid , <NUM_LIT:1> ) ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( False ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_raise ( kazoo . exceptions . NoNodeError ) <EOL> self . assertRaises ( zk . ZKTransactionException , transaction . release_lock , <EOL> self . appid , <NUM_LIT:1> ) <EOL> def test_is_blacklisted ( self ) : <EOL> flexmock ( zk . ZKTransaction ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( "<STR_LIT>" ) <EOL> fake_zookeeper = flexmock ( name = '<STR_LIT>' , create = '<STR_LIT>' , exists = '<STR_LIT>' , <EOL> get_children = '<STR_LIT>' , connected = lambda : True ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT:start>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str , str , None , <EOL> bool , bool , bool ) . and_return ( ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( True ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( [ '<STR_LIT:1>' , '<STR_LIT:2>' ] ) <EOL> flexmock ( kazoo . client ) <EOL> kazoo . client . should_receive ( '<STR_LIT>' ) . and_return ( fake_zookeeper ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( True , transaction . is_blacklisted ( self . appid , <NUM_LIT:1> ) ) <EOL> def test_register_updated_key ( self ) : <EOL> flexmock ( zk . ZKTransaction ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( '<STR_LIT>' ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) . and_return ( "<STR_LIT>" ) <EOL> fake_zookeeper = flexmock ( name = '<STR_LIT>' , exists = '<STR_LIT>' , <EOL> set_async = '<STR_LIT>' , connected = lambda : True ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT:start>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( True ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str , str ) <EOL> flexmock ( kazoo . client ) <EOL> kazoo . client . should_receive ( '<STR_LIT>' ) . and_return ( fake_zookeeper ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( True , transaction . register_updated_key ( self . appid , <EOL> "<STR_LIT:1>" , "<STR_LIT:2>" , "<STR_LIT>" ) ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( False ) <EOL> self . assertRaises ( ZKTransactionException , <EOL> transaction . register_updated_key , self . appid , "<STR_LIT:1>" , "<STR_LIT:2>" , "<STR_LIT>" ) <EOL> def test_try_garbage_collection ( self ) : <EOL> flexmock ( zk . ZKTransaction ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) <EOL> fake_zookeeper = flexmock ( name = '<STR_LIT>' , exists = '<STR_LIT>' , get = '<STR_LIT>' , <EOL> get_children = '<STR_LIT>' , create = '<STR_LIT>' , delete = '<STR_LIT>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT:start>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( True ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( [ str ( time . time ( ) + <NUM_LIT> ) ] ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( [ '<STR_LIT:1>' , '<STR_LIT:2>' , '<STR_LIT:3>' ] ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str , value = str , <EOL> acl = None , ephemeral = bool ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) <EOL> flexmock ( kazoo . client ) <EOL> kazoo . client . should_receive ( '<STR_LIT>' ) . and_return ( fake_zookeeper ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( False , transaction . try_garbage_collection ( self . appid , <EOL> "<STR_LIT>" ) ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( [ str ( time . time ( ) ) ] ) <EOL> self . assertEquals ( False , transaction . try_garbage_collection ( self . appid , <EOL> "<STR_LIT>" ) ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( [ str ( time . time ( ) - <NUM_LIT:1000> ) ] ) <EOL> self . assertEquals ( True , transaction . try_garbage_collection ( self . appid , <EOL> "<STR_LIT>" ) ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_raise ( kazoo . exceptions . NoNodeError ) <EOL> self . assertEquals ( True , transaction . try_garbage_collection ( self . appid , <EOL> "<STR_LIT>" ) ) <EOL> def test_notify_failed_transaction ( self ) : <EOL> pass <EOL> def test_execute_garbage_collection ( self ) : <EOL> flexmock ( zk . ZKTransaction ) <EOL> zk . ZKTransaction . should_receive ( '<STR_LIT>' ) <EOL> fake_zookeeper = flexmock ( name = '<STR_LIT>' , exists = '<STR_LIT>' , get = '<STR_LIT>' , <EOL> get_children = '<STR_LIT>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT:start>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( True ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( [ str ( time . time ( ) + <NUM_LIT> ) ] ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_return ( [ '<STR_LIT:1>' , '<STR_LIT:2>' , '<STR_LIT:3>' ] ) <EOL> flexmock ( kazoo . client ) <EOL> kazoo . client . should_receive ( '<STR_LIT>' ) . and_return ( fake_zookeeper ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> transaction . execute_garbage_collection ( self . appid , "<STR_LIT>" ) <EOL> def test_get_lock_with_path ( self ) : <EOL> flexmock ( zk . ZKTransaction ) <EOL> fake_zookeeper = flexmock ( name = '<STR_LIT>' , create = '<STR_LIT>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT:start>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str , value = str , <EOL> acl = None , ephemeral = bool ) . and_return ( True ) <EOL> flexmock ( kazoo . client ) <EOL> kazoo . client . should_receive ( '<STR_LIT>' ) . and_return ( fake_zookeeper ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( True , transaction . get_lock_with_path ( '<STR_LIT:path>' ) ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str , value = str , <EOL> acl = None , ephemeral = bool ) . and_raise ( kazoo . exceptions . NodeExistsError ) <EOL> self . assertEquals ( False , transaction . get_lock_with_path ( '<STR_LIT>' ) ) <EOL> def test_release_lock_with_path ( self ) : <EOL> flexmock ( zk . ZKTransaction ) <EOL> fake_zookeeper = flexmock ( name = '<STR_LIT>' , delete = '<STR_LIT>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT:start>' ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) <EOL> flexmock ( kazoo . client ) <EOL> kazoo . client . should_receive ( '<STR_LIT>' ) . and_return ( fake_zookeeper ) <EOL> transaction = zk . ZKTransaction ( host = "<STR_LIT>" , start_gc = False ) <EOL> self . assertEquals ( True , transaction . release_lock_with_path ( '<STR_LIT>' ) ) <EOL> fake_zookeeper . should_receive ( '<STR_LIT>' ) . with_args ( '<STR_LIT>' , str ) . and_raise ( kazoo . exceptions . NoNodeError ) <EOL> self . assertRaises ( ZKTransactionException , <EOL> transaction . release_lock_with_path , '<STR_LIT>' ) <EOL> if __name__ == "<STR_LIT:__main__>" : <EOL> unittest . main ( ) </s>

<s> import cgi <EOL> import datetime <EOL> import wsgiref . handlers <EOL> from google . appengine . ext import webapp <EOL> class MainPage ( webapp . RequestHandler ) : <EOL> def get ( self ) : <EOL> self . response . out . write ( '<STR_LIT>' ) <EOL> self . response . out . write ( '<STR_LIT>' ) <EOL> self . response . out . write ( '<STR_LIT>' ) <EOL> application = webapp . WSGIApplication ( [ <EOL> ( '<STR_LIT:/>' , MainPage ) , <EOL> ] , debug = True ) <EOL> def main ( ) : <EOL> wsgiref . handlers . CGIHandler ( ) . run ( application ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> main ( ) </s>

<s> from google . appengine . _internal . django . core . management import execute_manager <EOL> try : <EOL> import settings <EOL> except ImportError : <EOL> import sys <EOL> sys . stderr . write ( "<STR_LIT>" % __file__ ) <EOL> sys . exit ( <NUM_LIT:1> ) <EOL> if __name__ == "<STR_LIT:__main__>" : <EOL> execute_manager ( settings ) </s>

<s> class FileProxyMixin ( object ) : <EOL> """<STR_LIT>""" <EOL> encoding = property ( lambda self : self . file . encoding ) <EOL> fileno = property ( lambda self : self . file . fileno ) <EOL> flush = property ( lambda self : self . file . flush ) <EOL> isatty = property ( lambda self : self . file . isatty ) <EOL> newlines = property ( lambda self : self . file . newlines ) <EOL> read = property ( lambda self : self . file . read ) <EOL> readinto = property ( lambda self : self . file . readinto ) <EOL> readline = property ( lambda self : self . file . readline ) <EOL> readlines = property ( lambda self : self . file . readlines ) <EOL> seek = property ( lambda self : self . file . seek ) <EOL> softspace = property ( lambda self : self . file . softspace ) <EOL> tell = property ( lambda self : self . file . tell ) <EOL> truncate = property ( lambda self : self . file . truncate ) <EOL> write = property ( lambda self : self . file . write ) <EOL> writelines = property ( lambda self : self . file . writelines ) <EOL> xreadlines = property ( lambda self : self . file . xreadlines ) <EOL> def __iter__ ( self ) : <EOL> return iter ( self . file ) </s>

<s> import fnmatch <EOL> import glob <EOL> import os <EOL> import re <EOL> import sys <EOL> from itertools import dropwhile <EOL> from optparse import make_option <EOL> from subprocess import PIPE , Popen <EOL> from google . appengine . _internal . django . core . management . base import CommandError , BaseCommand <EOL> from google . appengine . _internal . django . utils . text import get_text_list <EOL> pythonize_re = re . compile ( r'<STR_LIT>' ) <EOL> plural_forms_re = re . compile ( r'<STR_LIT>' , re . MULTILINE | re . DOTALL ) <EOL> def handle_extensions ( extensions = ( '<STR_LIT:html>' , ) ) : <EOL> """<STR_LIT>""" <EOL> ext_list = [ ] <EOL> for ext in extensions : <EOL> ext_list . extend ( ext . replace ( '<STR_LIT:U+0020>' , '<STR_LIT>' ) . split ( '<STR_LIT:U+002C>' ) ) <EOL> for i , ext in enumerate ( ext_list ) : <EOL> if not ext . startswith ( '<STR_LIT:.>' ) : <EOL> ext_list [ i ] = '<STR_LIT>' % ext_list [ i ] <EOL> return set ( [ x for x in ext_list if x != '<STR_LIT>' ] ) <EOL> def _popen ( cmd ) : <EOL> """<STR_LIT>""" <EOL> p = Popen ( cmd , shell = True , stdout = PIPE , stderr = PIPE , close_fds = os . name != '<STR_LIT>' , universal_newlines = True ) <EOL> return p . communicate ( ) <EOL> def walk ( root , topdown = True , onerror = None , followlinks = False ) : <EOL> """<STR_LIT>""" <EOL> for dirpath , dirnames , filenames in os . walk ( root , topdown , onerror ) : <EOL> yield ( dirpath , dirnames , filenames ) <EOL> if followlinks : <EOL> for d in dirnames : <EOL> p = os . path . join ( dirpath , d ) <EOL> if os . path . islink ( p ) : <EOL> for link_dirpath , link_dirnames , link_filenames in walk ( p ) : <EOL> yield ( link_dirpath , link_dirnames , link_filenames ) <EOL> def is_ignored ( path , ignore_patterns ) : <EOL> """<STR_LIT>""" <EOL> for pattern in ignore_patterns : <EOL> if fnmatch . fnmatchcase ( path , pattern ) : <EOL> return True <EOL> return False <EOL> def find_files ( root , ignore_patterns , verbosity , symlinks = False ) : <EOL> """<STR_LIT>""" <EOL> all_files = [ ] <EOL> for ( dirpath , dirnames , filenames ) in walk ( "<STR_LIT:.>" , followlinks = symlinks ) : <EOL> for f in filenames : <EOL> norm_filepath = os . path . normpath ( os . path . join ( dirpath , f ) ) <EOL> if is_ignored ( norm_filepath , ignore_patterns ) : <EOL> if verbosity > <NUM_LIT:1> : <EOL> sys . stdout . write ( '<STR_LIT>' % ( f , dirpath ) ) <EOL> else : <EOL> all_files . extend ( [ ( dirpath , f ) ] ) <EOL> all_files . sort ( ) <EOL> return all_files <EOL> def copy_plural_forms ( msgs , locale , domain , verbosity ) : <EOL> """<STR_LIT>""" <EOL> import django <EOL> django_dir = os . path . normpath ( os . path . join ( os . path . dirname ( django . __file__ ) ) ) <EOL> if domain == '<STR_LIT>' : <EOL> domains = ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> else : <EOL> domains = ( '<STR_LIT>' , ) <EOL> for domain in domains : <EOL> django_po = os . path . join ( django_dir , '<STR_LIT>' , '<STR_LIT>' , locale , '<STR_LIT>' , '<STR_LIT>' % domain ) <EOL> if os . path . exists ( django_po ) : <EOL> m = plural_forms_re . search ( open ( django_po , '<STR_LIT>' ) . read ( ) ) <EOL> if m : <EOL> if verbosity > <NUM_LIT:1> : <EOL> sys . stderr . write ( "<STR_LIT>" % m . group ( '<STR_LIT:value>' ) ) <EOL> lines = [ ] <EOL> seen = False <EOL> for line in msgs . split ( '<STR_LIT:\n>' ) : <EOL> if not line and not seen : <EOL> line = '<STR_LIT>' % m . group ( '<STR_LIT:value>' ) <EOL> seen = True <EOL> lines . append ( line ) <EOL> msgs = '<STR_LIT:\n>' . join ( lines ) <EOL> break <EOL> return msgs <EOL> def make_messages ( locale = None , domain = '<STR_LIT>' , verbosity = '<STR_LIT:1>' , all = False , <EOL> extensions = None , symlinks = False , ignore_patterns = [ ] ) : <EOL> """<STR_LIT>""" <EOL> from google . appengine . _internal . django . conf import settings <EOL> if settings . configured : <EOL> settings . USE_I18N = True <EOL> else : <EOL> settings . configure ( USE_I18N = True ) <EOL> from google . appengine . _internal . django . utils . translation import templatize <EOL> invoked_for_django = False <EOL> if os . path . isdir ( os . path . join ( '<STR_LIT>' , '<STR_LIT>' ) ) : <EOL> localedir = os . path . abspath ( os . path . join ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> invoked_for_django = True <EOL> elif os . path . isdir ( '<STR_LIT>' ) : <EOL> localedir = os . path . abspath ( '<STR_LIT>' ) <EOL> else : <EOL> raise CommandError ( "<STR_LIT>" ) <EOL> if domain not in ( '<STR_LIT>' , '<STR_LIT>' ) : <EOL> raise CommandError ( "<STR_LIT>" ) <EOL> if ( locale is None and not all ) or domain is None : <EOL> if not sys . argv [ <NUM_LIT:0> ] . endswith ( "<STR_LIT>" ) : <EOL> message = "<STR_LIT>" % ( os . path . basename ( sys . argv [ <NUM_LIT:0> ] ) , sys . argv [ <NUM_LIT:1> ] ) <EOL> else : <EOL> message = "<STR_LIT>" <EOL> raise CommandError ( message ) <EOL> output = _popen ( '<STR_LIT>' ) [ <NUM_LIT:0> ] <EOL> match = re . search ( r'<STR_LIT>' , output ) <EOL> if match : <EOL> xversion = ( int ( match . group ( '<STR_LIT>' ) ) , int ( match . group ( '<STR_LIT>' ) ) ) <EOL> if xversion < ( <NUM_LIT:0> , <NUM_LIT:15> ) : <EOL> raise CommandError ( "<STR_LIT>" % match . group ( ) ) <EOL> languages = [ ] <EOL> if locale is not None : <EOL> languages . append ( locale ) <EOL> elif all : <EOL> locale_dirs = filter ( os . path . isdir , glob . glob ( '<STR_LIT>' % localedir ) ) <EOL> languages = [ os . path . basename ( l ) for l in locale_dirs ] <EOL> for locale in languages : <EOL> if verbosity > <NUM_LIT:0> : <EOL> print "<STR_LIT>" , locale <EOL> basedir = os . path . join ( localedir , locale , '<STR_LIT>' ) <EOL> if not os . path . isdir ( basedir ) : <EOL> os . makedirs ( basedir ) <EOL> pofile = os . path . join ( basedir , '<STR_LIT>' % domain ) <EOL> potfile = os . path . join ( basedir , '<STR_LIT>' % domain ) <EOL> if os . path . exists ( potfile ) : <EOL> os . unlink ( potfile ) <EOL> for dirpath , file in find_files ( "<STR_LIT:.>" , ignore_patterns , verbosity , symlinks = symlinks ) : <EOL> file_base , file_ext = os . path . splitext ( file ) <EOL> if domain == '<STR_LIT>' and file_ext in extensions : <EOL> if verbosity > <NUM_LIT:1> : <EOL> sys . stdout . write ( '<STR_LIT>' % ( file , dirpath ) ) <EOL> src = open ( os . path . join ( dirpath , file ) , "<STR_LIT>" ) . read ( ) <EOL> src = pythonize_re . sub ( '<STR_LIT>' , src ) <EOL> thefile = '<STR_LIT>' % file <EOL> f = open ( os . path . join ( dirpath , thefile ) , "<STR_LIT:w>" ) <EOL> try : <EOL> f . write ( src ) <EOL> finally : <EOL> f . close ( ) <EOL> cmd = '<STR_LIT>' % ( domain , os . path . join ( dirpath , thefile ) ) <EOL> msgs , errors = _popen ( cmd ) <EOL> if errors : <EOL> raise CommandError ( "<STR_LIT>" % ( file , errors ) ) <EOL> old = '<STR_LIT>' + os . path . join ( dirpath , thefile ) [ <NUM_LIT:2> : ] <EOL> new = '<STR_LIT>' + os . path . join ( dirpath , file ) [ <NUM_LIT:2> : ] <EOL> msgs = msgs . replace ( old , new ) <EOL> if os . path . exists ( potfile ) : <EOL> msgs = '<STR_LIT:\n>' . join ( dropwhile ( len , msgs . split ( '<STR_LIT:\n>' ) ) ) <EOL> else : <EOL> msgs = msgs . replace ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> if msgs : <EOL> f = open ( potfile , '<STR_LIT>' ) <EOL> try : <EOL> f . write ( msgs ) <EOL> finally : <EOL> f . close ( ) <EOL> os . unlink ( os . path . join ( dirpath , thefile ) ) <EOL> elif domain == '<STR_LIT>' and ( file_ext == '<STR_LIT>' or file_ext in extensions ) : <EOL> thefile = file <EOL> if file_ext in extensions : <EOL> src = open ( os . path . join ( dirpath , file ) , "<STR_LIT>" ) . read ( ) <EOL> thefile = '<STR_LIT>' % file <EOL> try : <EOL> f = open ( os . path . join ( dirpath , thefile ) , "<STR_LIT:w>" ) <EOL> try : <EOL> f . write ( templatize ( src ) ) <EOL> finally : <EOL> f . close ( ) <EOL> except SyntaxError , msg : <EOL> msg = "<STR_LIT>" % ( msg , os . path . join ( dirpath , file ) ) <EOL> raise SyntaxError ( msg ) <EOL> if verbosity > <NUM_LIT:1> : <EOL> sys . stdout . write ( '<STR_LIT>' % ( file , dirpath ) ) <EOL> cmd = '<STR_LIT>' % ( <EOL> domain , os . path . join ( dirpath , thefile ) ) <EOL> msgs , errors = _popen ( cmd ) <EOL> if errors : <EOL> raise CommandError ( "<STR_LIT>" % ( file , errors ) ) <EOL> if thefile != file : <EOL> old = '<STR_LIT>' + os . path . join ( dirpath , thefile ) [ <NUM_LIT:2> : ] <EOL> new = '<STR_LIT>' + os . path . join ( dirpath , file ) [ <NUM_LIT:2> : ] <EOL> msgs = msgs . replace ( old , new ) <EOL> if os . path . exists ( potfile ) : <EOL> msgs = '<STR_LIT:\n>' . join ( dropwhile ( len , msgs . split ( '<STR_LIT:\n>' ) ) ) <EOL> else : <EOL> msgs = msgs . replace ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> if msgs : <EOL> f = open ( potfile , '<STR_LIT>' ) <EOL> try : <EOL> f . write ( msgs ) <EOL> finally : <EOL> f . close ( ) <EOL> if thefile != file : <EOL> os . unlink ( os . path . join ( dirpath , thefile ) ) <EOL> if os . path . exists ( potfile ) : <EOL> msgs , errors = _popen ( '<STR_LIT>' % potfile ) <EOL> if errors : <EOL> raise CommandError ( "<STR_LIT>" % errors ) <EOL> f = open ( potfile , '<STR_LIT:w>' ) <EOL> try : <EOL> f . write ( msgs ) <EOL> finally : <EOL> f . close ( ) <EOL> if os . path . exists ( pofile ) : <EOL> msgs , errors = _popen ( '<STR_LIT>' % ( pofile , potfile ) ) <EOL> if errors : <EOL> raise CommandError ( "<STR_LIT>" % errors ) <EOL> elif not invoked_for_django : <EOL> msgs = copy_plural_forms ( msgs , locale , domain , verbosity ) <EOL> f = open ( pofile , '<STR_LIT:wb>' ) <EOL> try : <EOL> f . write ( msgs ) <EOL> finally : <EOL> f . close ( ) <EOL> os . unlink ( potfile ) <EOL> class Command ( BaseCommand ) : <EOL> option_list = BaseCommand . option_list + ( <EOL> make_option ( '<STR_LIT>' , '<STR_LIT>' , default = None , dest = '<STR_LIT>' , <EOL> help = '<STR_LIT>' ) , <EOL> make_option ( '<STR_LIT>' , '<STR_LIT>' , default = '<STR_LIT>' , dest = '<STR_LIT>' , <EOL> help = '<STR_LIT>' ) , <EOL> make_option ( '<STR_LIT>' , '<STR_LIT>' , action = '<STR_LIT:store_true>' , dest = '<STR_LIT:all>' , <EOL> default = False , help = '<STR_LIT>' ) , <EOL> make_option ( '<STR_LIT>' , '<STR_LIT>' , dest = '<STR_LIT>' , <EOL> help = '<STR_LIT>' , <EOL> action = '<STR_LIT>' ) , <EOL> make_option ( '<STR_LIT>' , '<STR_LIT>' , action = '<STR_LIT:store_true>' , dest = '<STR_LIT>' , <EOL> default = False , help = '<STR_LIT>' ) , <EOL> make_option ( '<STR_LIT>' , '<STR_LIT>' , action = '<STR_LIT>' , dest = '<STR_LIT>' , <EOL> default = [ ] , metavar = '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> make_option ( '<STR_LIT>' , action = '<STR_LIT>' , dest = '<STR_LIT>' , <EOL> default = True , help = "<STR_LIT>" ) , <EOL> ) <EOL> help = "<STR_LIT>" <EOL> requires_model_validation = False <EOL> can_import_settings = False <EOL> def handle ( self , * args , ** options ) : <EOL> if len ( args ) != <NUM_LIT:0> : <EOL> raise CommandError ( "<STR_LIT>" ) <EOL> locale = options . get ( '<STR_LIT>' ) <EOL> domain = options . get ( '<STR_LIT>' ) <EOL> verbosity = int ( options . get ( '<STR_LIT>' ) ) <EOL> process_all = options . get ( '<STR_LIT:all>' ) <EOL> extensions = options . get ( '<STR_LIT>' ) <EOL> symlinks = options . get ( '<STR_LIT>' ) <EOL> ignore_patterns = options . get ( '<STR_LIT>' ) <EOL> if options . get ( '<STR_LIT>' ) : <EOL> ignore_patterns += [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> ignore_patterns = list ( set ( ignore_patterns ) ) <EOL> if domain == '<STR_LIT>' : <EOL> extensions = handle_extensions ( extensions or [ '<STR_LIT>' ] ) <EOL> else : <EOL> extensions = handle_extensions ( extensions or [ '<STR_LIT:html>' ] ) <EOL> if verbosity > <NUM_LIT:1> : <EOL> sys . stdout . write ( '<STR_LIT>' % get_text_list ( list ( extensions ) , '<STR_LIT>' ) ) <EOL> make_messages ( locale , domain , verbosity , process_all , extensions , symlinks , ignore_patterns ) </s>

<s> """<STR_LIT>""" <EOL> from google . appengine . _internal . django . conf import settings <EOL> from google . appengine . _internal . django . core . serializers import base <EOL> from google . appengine . _internal . django . db import models , DEFAULT_DB_ALIAS <EOL> from google . appengine . _internal . django . utils . xmlutils import SimplerXMLGenerator <EOL> from google . appengine . _internal . django . utils . encoding import smart_unicode <EOL> from xml . dom import pulldom <EOL> class Serializer ( base . Serializer ) : <EOL> """<STR_LIT>""" <EOL> def indent ( self , level ) : <EOL> if self . options . get ( '<STR_LIT>' , None ) is not None : <EOL> self . xml . ignorableWhitespace ( '<STR_LIT:\n>' + '<STR_LIT:U+0020>' * self . options . get ( '<STR_LIT>' , None ) * level ) <EOL> def start_serialization ( self ) : <EOL> """<STR_LIT>""" <EOL> self . xml = SimplerXMLGenerator ( self . stream , self . options . get ( "<STR_LIT>" , settings . DEFAULT_CHARSET ) ) <EOL> self . xml . startDocument ( ) <EOL> self . xml . startElement ( "<STR_LIT>" , { "<STR_LIT:version>" : "<STR_LIT:1.0>" } ) <EOL> def end_serialization ( self ) : <EOL> """<STR_LIT>""" <EOL> self . indent ( <NUM_LIT:0> ) <EOL> self . xml . endElement ( "<STR_LIT>" ) <EOL> self . xml . endDocument ( ) <EOL> def start_object ( self , obj ) : <EOL> """<STR_LIT>""" <EOL> if not hasattr ( obj , "<STR_LIT>" ) : <EOL> raise base . SerializationError ( "<STR_LIT>" % type ( obj ) ) <EOL> self . indent ( <NUM_LIT:1> ) <EOL> obj_pk = obj . _get_pk_val ( ) <EOL> if obj_pk is None : <EOL> attrs = { "<STR_LIT>" : smart_unicode ( obj . _meta ) , } <EOL> else : <EOL> attrs = { <EOL> "<STR_LIT>" : smart_unicode ( obj . _get_pk_val ( ) ) , <EOL> "<STR_LIT>" : smart_unicode ( obj . _meta ) , <EOL> } <EOL> self . xml . startElement ( "<STR_LIT:object>" , attrs ) <EOL> def end_object ( self , obj ) : <EOL> """<STR_LIT>""" <EOL> self . indent ( <NUM_LIT:1> ) <EOL> self . xml . endElement ( "<STR_LIT:object>" ) <EOL> def handle_field ( self , obj , field ) : <EOL> """<STR_LIT>""" <EOL> self . indent ( <NUM_LIT:2> ) <EOL> self . xml . startElement ( "<STR_LIT>" , { <EOL> "<STR_LIT:name>" : field . name , <EOL> "<STR_LIT:type>" : field . get_internal_type ( ) <EOL> } ) <EOL> if getattr ( obj , field . name ) is not None : <EOL> self . xml . characters ( field . value_to_string ( obj ) ) <EOL> else : <EOL> self . xml . addQuickElement ( "<STR_LIT:None>" ) <EOL> self . xml . endElement ( "<STR_LIT>" ) <EOL> def handle_fk_field ( self , obj , field ) : <EOL> """<STR_LIT>""" <EOL> self . _start_relational_field ( field ) <EOL> related = getattr ( obj , field . name ) <EOL> if related is not None : <EOL> if self . use_natural_keys and hasattr ( related , '<STR_LIT>' ) : <EOL> related = related . natural_key ( ) <EOL> for key_value in related : <EOL> self . xml . startElement ( "<STR_LIT>" , { } ) <EOL> self . xml . characters ( smart_unicode ( key_value ) ) <EOL> self . xml . endElement ( "<STR_LIT>" ) <EOL> else : <EOL> if field . rel . field_name == related . _meta . pk . name : <EOL> related = related . _get_pk_val ( ) <EOL> else : <EOL> related = getattr ( related , field . rel . field_name ) <EOL> self . xml . characters ( smart_unicode ( related ) ) <EOL> else : <EOL> self . xml . addQuickElement ( "<STR_LIT:None>" ) <EOL> self . xml . endElement ( "<STR_LIT>" ) <EOL> def handle_m2m_field ( self , obj , field ) : <EOL> """<STR_LIT>""" <EOL> if field . rel . through . _meta . auto_created : <EOL> self . _start_relational_field ( field ) <EOL> if self . use_natural_keys and hasattr ( field . rel . to , '<STR_LIT>' ) : <EOL> def handle_m2m ( value ) : <EOL> natural = value . natural_key ( ) <EOL> self . xml . startElement ( "<STR_LIT:object>" , { } ) <EOL> for key_value in natural : <EOL> self . xml . startElement ( "<STR_LIT>" , { } ) <EOL> self . xml . characters ( smart_unicode ( key_value ) ) <EOL> self . xml . endElement ( "<STR_LIT>" ) <EOL> self . xml . endElement ( "<STR_LIT:object>" ) <EOL> else : <EOL> def handle_m2m ( value ) : <EOL> self . xml . addQuickElement ( "<STR_LIT:object>" , attrs = { <EOL> '<STR_LIT>' : smart_unicode ( value . _get_pk_val ( ) ) <EOL> } ) <EOL> for relobj in getattr ( obj , field . name ) . iterator ( ) : <EOL> handle_m2m ( relobj ) <EOL> self . xml . endElement ( "<STR_LIT>" ) <EOL> def _start_relational_field ( self , field ) : <EOL> """<STR_LIT>""" <EOL> self . indent ( <NUM_LIT:2> ) <EOL> self . xml . startElement ( "<STR_LIT>" , { <EOL> "<STR_LIT:name>" : field . name , <EOL> "<STR_LIT>" : field . rel . __class__ . __name__ , <EOL> "<STR_LIT:to>" : smart_unicode ( field . rel . to . _meta ) , <EOL> } ) <EOL> class Deserializer ( base . Deserializer ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , stream_or_string , ** options ) : <EOL> super ( Deserializer , self ) . __init__ ( stream_or_string , ** options ) <EOL> self . event_stream = pulldom . parse ( self . stream ) <EOL> self . db = options . pop ( '<STR_LIT>' , DEFAULT_DB_ALIAS ) <EOL> def next ( self ) : <EOL> for event , node in self . event_stream : <EOL> if event == "<STR_LIT>" and node . nodeName == "<STR_LIT:object>" : <EOL> self . event_stream . expandNode ( node ) <EOL> return self . _handle_object ( node ) <EOL> raise StopIteration <EOL> def _handle_object ( self , node ) : <EOL> """<STR_LIT>""" <EOL> Model = self . _get_model_from_node ( node , "<STR_LIT>" ) <EOL> if node . hasAttribute ( "<STR_LIT>" ) : <EOL> pk = node . getAttribute ( "<STR_LIT>" ) <EOL> else : <EOL> pk = None <EOL> data = { Model . _meta . pk . attname : Model . _meta . pk . to_python ( pk ) } <EOL> m2m_data = { } <EOL> for field_node in node . getElementsByTagName ( "<STR_LIT>" ) : <EOL> field_name = field_node . getAttribute ( "<STR_LIT:name>" ) <EOL> if not field_name : <EOL> raise base . DeserializationError ( "<STR_LIT>" ) <EOL> field = Model . _meta . get_field ( field_name ) <EOL> if field . rel and isinstance ( field . rel , models . ManyToManyRel ) : <EOL> m2m_data [ field . name ] = self . _handle_m2m_field_node ( field_node , field ) <EOL> elif field . rel and isinstance ( field . rel , models . ManyToOneRel ) : <EOL> data [ field . attname ] = self . _handle_fk_field_node ( field_node , field ) <EOL> else : <EOL> if field_node . getElementsByTagName ( '<STR_LIT:None>' ) : <EOL> value = None <EOL> else : <EOL> value = field . to_python ( getInnerText ( field_node ) . strip ( ) ) <EOL> data [ field . name ] = value <EOL> return base . DeserializedObject ( Model ( ** data ) , m2m_data ) <EOL> def _handle_fk_field_node ( self , node , field ) : <EOL> """<STR_LIT>""" <EOL> if node . getElementsByTagName ( '<STR_LIT:None>' ) : <EOL> return None <EOL> else : <EOL> if hasattr ( field . rel . to . _default_manager , '<STR_LIT>' ) : <EOL> keys = node . getElementsByTagName ( '<STR_LIT>' ) <EOL> if keys : <EOL> field_value = [ getInnerText ( k ) . strip ( ) for k in keys ] <EOL> obj = field . rel . to . _default_manager . db_manager ( self . db ) . get_by_natural_key ( * field_value ) <EOL> obj_pk = getattr ( obj , field . rel . field_name ) <EOL> if field . rel . to . _meta . pk . rel : <EOL> obj_pk = obj_pk . pk <EOL> else : <EOL> field_value = getInnerText ( node ) . strip ( ) <EOL> obj_pk = field . rel . to . _meta . get_field ( field . rel . field_name ) . to_python ( field_value ) <EOL> return obj_pk <EOL> else : <EOL> field_value = getInnerText ( node ) . strip ( ) <EOL> return field . rel . to . _meta . get_field ( field . rel . field_name ) . to_python ( field_value ) <EOL> def _handle_m2m_field_node ( self , node , field ) : <EOL> """<STR_LIT>""" <EOL> if hasattr ( field . rel . to . _default_manager , '<STR_LIT>' ) : <EOL> def m2m_convert ( n ) : <EOL> keys = n . getElementsByTagName ( '<STR_LIT>' ) <EOL> if keys : <EOL> field_value = [ getInnerText ( k ) . strip ( ) for k in keys ] <EOL> obj_pk = field . rel . to . _default_manager . db_manager ( self . db ) . get_by_natural_key ( * field_value ) . pk <EOL> else : <EOL> obj_pk = field . rel . to . _meta . pk . to_python ( n . getAttribute ( '<STR_LIT>' ) ) <EOL> return obj_pk <EOL> else : <EOL> m2m_convert = lambda n : field . rel . to . _meta . pk . to_python ( n . getAttribute ( '<STR_LIT>' ) ) <EOL> return [ m2m_convert ( c ) for c in node . getElementsByTagName ( "<STR_LIT:object>" ) ] <EOL> def _get_model_from_node ( self , node , attr ) : <EOL> """<STR_LIT>""" <EOL> model_identifier = node . getAttribute ( attr ) <EOL> if not model_identifier : <EOL> raise base . DeserializationError ( <EOL> "<STR_LIT>" % ( node . nodeName , attr ) ) <EOL> try : <EOL> Model = models . get_model ( * model_identifier . split ( "<STR_LIT:.>" ) ) <EOL> except TypeError : <EOL> Model = None <EOL> if Model is None : <EOL> raise base . DeserializationError ( <EOL> "<STR_LIT>" % ( node . nodeName , model_identifier ) ) <EOL> return Model <EOL> def getInnerText ( node ) : <EOL> """<STR_LIT>""" <EOL> inner_text = [ ] <EOL> for child in node . childNodes : <EOL> if child . nodeType == child . TEXT_NODE or child . nodeType == child . CDATA_SECTION_NODE : <EOL> inner_text . append ( child . data ) <EOL> elif child . nodeType == child . ELEMENT_NODE : <EOL> inner_text . extend ( getInnerText ( child ) ) <EOL> else : <EOL> pass <EOL> return u"<STR_LIT>" . join ( inner_text ) </s>

<s> import os <EOL> import sys <EOL> if os . name == '<STR_LIT>' : <EOL> def become_daemon ( our_home_dir = '<STR_LIT:.>' , out_log = '<STR_LIT>' , <EOL> err_log = '<STR_LIT>' , umask = <NUM_LIT:0> <NUM_LIT> ) : <EOL> "<STR_LIT>" <EOL> try : <EOL> if os . fork ( ) > <NUM_LIT:0> : <EOL> sys . exit ( <NUM_LIT:0> ) <EOL> except OSError , e : <EOL> sys . stderr . write ( "<STR_LIT>" % ( e . errno , e . strerror ) ) <EOL> sys . exit ( <NUM_LIT:1> ) <EOL> os . setsid ( ) <EOL> os . chdir ( our_home_dir ) <EOL> os . umask ( umask ) <EOL> try : <EOL> if os . fork ( ) > <NUM_LIT:0> : <EOL> os . _exit ( <NUM_LIT:0> ) <EOL> except OSError , e : <EOL> sys . stderr . write ( "<STR_LIT>" % ( e . errno , e . strerror ) ) <EOL> os . _exit ( <NUM_LIT:1> ) <EOL> si = open ( '<STR_LIT>' , '<STR_LIT:r>' ) <EOL> so = open ( out_log , '<STR_LIT>' , <NUM_LIT:0> ) <EOL> se = open ( err_log , '<STR_LIT>' , <NUM_LIT:0> ) <EOL> os . dup2 ( si . fileno ( ) , sys . stdin . fileno ( ) ) <EOL> os . dup2 ( so . fileno ( ) , sys . stdout . fileno ( ) ) <EOL> os . dup2 ( se . fileno ( ) , sys . stderr . fileno ( ) ) <EOL> sys . stdout , sys . stderr = so , se <EOL> else : <EOL> def become_daemon ( our_home_dir = '<STR_LIT:.>' , out_log = None , err_log = None , umask = <NUM_LIT:0> <NUM_LIT> ) : <EOL> """<STR_LIT>""" <EOL> os . chdir ( our_home_dir ) <EOL> os . umask ( umask ) <EOL> sys . stdin . close ( ) <EOL> sys . stdout . close ( ) <EOL> sys . stderr . close ( ) <EOL> if err_log : <EOL> sys . stderr = open ( err_log , '<STR_LIT:a>' , <NUM_LIT:0> ) <EOL> else : <EOL> sys . stderr = NullDevice ( ) <EOL> if out_log : <EOL> sys . stdout = open ( out_log , '<STR_LIT:a>' , <NUM_LIT:0> ) <EOL> else : <EOL> sys . stdout = NullDevice ( ) <EOL> class NullDevice : <EOL> "<STR_LIT>" <EOL> def write ( self , s ) : <EOL> pass </s>

<s> """<STR_LIT>""" <EOL> try : <EOL> import threading <EOL> currentThread = threading . currentThread <EOL> except ImportError : <EOL> def currentThread ( ) : <EOL> return "<STR_LIT>" </s>

<s> """<STR_LIT>""" <EOL> ident = '<STR_LIT>' <EOL> from version import __version__ <EOL> import UserList <EOL> import base64 <EOL> import cgi <EOL> import urllib <EOL> import copy <EOL> import re <EOL> import time <EOL> from types import * <EOL> from Errors import * <EOL> from NS import NS <EOL> from Utilities import encodeHexString , cleanDate <EOL> from Config import Config <EOL> def isPrivate ( name ) : return name [ <NUM_LIT:0> ] == '<STR_LIT:_>' <EOL> def isPublic ( name ) : return name [ <NUM_LIT:0> ] != '<STR_LIT:_>' <EOL> class anyType : <EOL> _validURIs = ( NS . XSD , NS . XSD2 , NS . XSD3 , NS . ENC ) <EOL> def __init__ ( self , data = None , name = None , typed = <NUM_LIT:1> , attrs = None ) : <EOL> if self . __class__ == anyType : <EOL> raise Error , "<STR_LIT>" <EOL> if type ( name ) in ( ListType , TupleType ) : <EOL> self . _ns , self . _name = name <EOL> else : <EOL> self . _ns = self . _validURIs [ <NUM_LIT:0> ] <EOL> self . _name = name <EOL> self . _typed = typed <EOL> self . _attrs = { } <EOL> self . _cache = None <EOL> self . _type = self . _typeName ( ) <EOL> self . _data = self . _checkValueSpace ( data ) <EOL> if attrs != None : <EOL> self . _setAttrs ( attrs ) <EOL> def __str__ ( self ) : <EOL> if hasattr ( self , '<STR_LIT>' ) and self . _name : <EOL> return "<STR_LIT>" % ( self . __class__ , self . _name , id ( self ) ) <EOL> return "<STR_LIT>" % ( self . __class__ , id ( self ) ) <EOL> __repr__ = __str__ <EOL> def _checkValueSpace ( self , data ) : <EOL> return data <EOL> def _marshalData ( self ) : <EOL> return str ( self . _data ) <EOL> def _marshalAttrs ( self , ns_map , builder ) : <EOL> a = '<STR_LIT>' <EOL> for attr , value in self . _attrs . items ( ) : <EOL> ns , n = builder . genns ( ns_map , attr [ <NUM_LIT:0> ] ) <EOL> a += n + '<STR_LIT>' % ( ns , attr [ <NUM_LIT:1> ] , cgi . escape ( str ( value ) , <NUM_LIT:1> ) ) <EOL> return a <EOL> def _fixAttr ( self , attr ) : <EOL> if type ( attr ) in ( StringType , UnicodeType ) : <EOL> attr = ( None , attr ) <EOL> elif type ( attr ) == ListType : <EOL> attr = tuple ( attr ) <EOL> elif type ( attr ) != TupleType : <EOL> raise AttributeError , "<STR_LIT>" <EOL> if len ( attr ) != <NUM_LIT:2> : <EOL> raise AttributeError , "<STR_LIT>" <EOL> if type ( attr [ <NUM_LIT:0> ] ) not in ( NoneType , StringType , UnicodeType ) : <EOL> raise AttributeError , "<STR_LIT>" <EOL> return attr <EOL> def _getAttr ( self , attr ) : <EOL> attr = self . _fixAttr ( attr ) <EOL> try : <EOL> return self . _attrs [ attr ] <EOL> except : <EOL> return None <EOL> def _setAttr ( self , attr , value ) : <EOL> attr = self . _fixAttr ( attr ) <EOL> if type ( value ) is StringType : <EOL> value = unicode ( value ) <EOL> self . _attrs [ attr ] = value <EOL> def _setAttrs ( self , attrs ) : <EOL> if type ( attrs ) in ( ListType , TupleType ) : <EOL> for i in range ( <NUM_LIT:0> , len ( attrs ) , <NUM_LIT:2> ) : <EOL> self . _setAttr ( attrs [ i ] , attrs [ i + <NUM_LIT:1> ] ) <EOL> return <EOL> if type ( attrs ) == DictType : <EOL> d = attrs <EOL> elif isinstance ( attrs , anyType ) : <EOL> d = attrs . _attrs <EOL> else : <EOL> raise AttributeError , "<STR_LIT>" <EOL> for attr , value in d . items ( ) : <EOL> self . _setAttr ( attr , value ) <EOL> def _setMustUnderstand ( self , val ) : <EOL> self . _setAttr ( ( NS . ENV , "<STR_LIT>" ) , val ) <EOL> def _getMustUnderstand ( self ) : <EOL> return self . _getAttr ( ( NS . ENV , "<STR_LIT>" ) ) <EOL> def _setActor ( self , val ) : <EOL> self . _setAttr ( ( NS . ENV , "<STR_LIT>" ) , val ) <EOL> def _getActor ( self ) : <EOL> return self . _getAttr ( ( NS . ENV , "<STR_LIT>" ) ) <EOL> def _typeName ( self ) : <EOL> return self . __class__ . __name__ [ : - <NUM_LIT:4> ] <EOL> def _validNamespaceURI ( self , URI , strict ) : <EOL> if not hasattr ( self , '<STR_LIT>' ) or not self . _typed : <EOL> return None <EOL> if URI in self . _validURIs : <EOL> return URI <EOL> if not strict : <EOL> return self . _ns <EOL> raise AttributeError , "<STR_LIT>" % self . _type <EOL> class voidType ( anyType ) : <EOL> pass <EOL> class stringType ( anyType ) : <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( StringType , UnicodeType ) : <EOL> raise AttributeError , "<STR_LIT>" % self . _type <EOL> return data <EOL> class untypedType ( stringType ) : <EOL> def __init__ ( self , data = None , name = None , attrs = None ) : <EOL> stringType . __init__ ( self , data , name , <NUM_LIT:0> , attrs ) <EOL> class IDType ( stringType ) : pass <EOL> class NCNameType ( stringType ) : pass <EOL> class NameType ( stringType ) : pass <EOL> class ENTITYType ( stringType ) : pass <EOL> class IDREFType ( stringType ) : pass <EOL> class languageType ( stringType ) : pass <EOL> class NMTOKENType ( stringType ) : pass <EOL> class QNameType ( stringType ) : pass <EOL> class tokenType ( anyType ) : <EOL> _validURIs = ( NS . XSD2 , NS . XSD3 ) <EOL> __invalidre = '<STR_LIT>' <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( StringType , UnicodeType ) : <EOL> raise AttributeError , "<STR_LIT>" % self . _type <EOL> if type ( self . __invalidre ) == StringType : <EOL> self . __invalidre = re . compile ( self . __invalidre ) <EOL> if self . __invalidre . search ( data ) : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> return data <EOL> class normalizedStringType ( anyType ) : <EOL> _validURIs = ( NS . XSD3 , ) <EOL> __invalidre = '<STR_LIT>' <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( StringType , UnicodeType ) : <EOL> raise AttributeError , "<STR_LIT>" % self . _type <EOL> if type ( self . __invalidre ) == StringType : <EOL> self . __invalidre = re . compile ( self . __invalidre ) <EOL> if self . __invalidre . search ( data ) : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> return data <EOL> class CDATAType ( normalizedStringType ) : <EOL> _validURIs = ( NS . XSD2 , ) <EOL> class booleanType ( anyType ) : <EOL> def __int__ ( self ) : <EOL> return self . _data <EOL> __nonzero__ = __int__ <EOL> def _marshalData ( self ) : <EOL> return [ '<STR_LIT:false>' , '<STR_LIT:true>' ] [ self . _data ] <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if data in ( <NUM_LIT:0> , '<STR_LIT:0>' , '<STR_LIT:false>' , '<STR_LIT>' ) : <EOL> return <NUM_LIT:0> <EOL> if data in ( <NUM_LIT:1> , '<STR_LIT:1>' , '<STR_LIT:true>' ) : <EOL> return <NUM_LIT:1> <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> class decimalType ( anyType ) : <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( IntType , LongType , FloatType ) : <EOL> raise Error , "<STR_LIT>" % self . _type <EOL> return data <EOL> class floatType ( anyType ) : <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( IntType , LongType , FloatType ) or data < - <NUM_LIT> or data > <NUM_LIT> : <EOL> raise ValueError , "<STR_LIT>" % ( self . _type , repr ( data ) ) <EOL> return data <EOL> def _marshalData ( self ) : <EOL> return "<STR_LIT>" % self . _data <EOL> class doubleType ( anyType ) : <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( IntType , LongType , FloatType ) or data < - <NUM_LIT> or data > <NUM_LIT> : <EOL> raise ValueError , "<STR_LIT>" % ( self . _type , repr ( data ) ) <EOL> return data <EOL> def _marshalData ( self ) : <EOL> return "<STR_LIT>" % self . _data <EOL> class durationType ( anyType ) : <EOL> _validURIs = ( NS . XSD3 , ) <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> try : <EOL> if type ( data ) == TupleType : <EOL> data = list ( data ) <EOL> elif type ( data ) != ListType : <EOL> data = [ data ] <EOL> if len ( data ) > <NUM_LIT:6> : <EOL> raise Exception , "<STR_LIT>" <EOL> f = - <NUM_LIT:1> <EOL> for i in range ( len ( data ) ) : <EOL> if data [ i ] == None : <EOL> data [ i ] = <NUM_LIT:0> <EOL> continue <EOL> if type ( data [ i ] ) not in ( IntType , LongType , FloatType ) : <EOL> raise Exception , "<STR_LIT>" % i <EOL> if data [ i ] and f == - <NUM_LIT:1> : <EOL> f = i <EOL> if f == - <NUM_LIT:1> : <EOL> self . _cache = '<STR_LIT>' <EOL> return ( <NUM_LIT:0> , ) * <NUM_LIT:6> <EOL> d = - <NUM_LIT:1> <EOL> for i in range ( f , len ( data ) ) : <EOL> if data [ i ] : <EOL> if d != - <NUM_LIT:1> : <EOL> raise Exception , "<STR_LIT>" "<STR_LIT>" <EOL> if data [ i ] < <NUM_LIT:0> and i > f : <EOL> raise Exception , "<STR_LIT>" <EOL> elif data [ i ] != long ( data [ i ] ) : <EOL> d = i <EOL> if len ( data ) < <NUM_LIT:6> : <EOL> n = <NUM_LIT:6> - len ( data ) <EOL> f += n <EOL> d += n <EOL> data = [ <NUM_LIT:0> ] * n + data <EOL> self . __firstnonzero = f <EOL> self . __decimal = d <EOL> except Exception , e : <EOL> raise ValueError , "<STR_LIT>" % ( self . _type , e ) <EOL> return tuple ( data ) <EOL> def _marshalData ( self ) : <EOL> if self . _cache == None : <EOL> d = self . _data <EOL> t = <NUM_LIT:0> <EOL> if d [ self . __firstnonzero ] < <NUM_LIT:0> : <EOL> s = '<STR_LIT>' <EOL> else : <EOL> s = '<STR_LIT:P>' <EOL> t = <NUM_LIT:0> <EOL> for i in range ( self . __firstnonzero , len ( d ) ) : <EOL> if d [ i ] : <EOL> if i > <NUM_LIT:2> and not t : <EOL> s += '<STR_LIT:T>' <EOL> t = <NUM_LIT:1> <EOL> if self . __decimal == i : <EOL> s += "<STR_LIT>" % abs ( d [ i ] ) <EOL> else : <EOL> s += "<STR_LIT>" % long ( abs ( d [ i ] ) ) <EOL> s += [ '<STR_LIT:Y>' , '<STR_LIT:M>' , '<STR_LIT:D>' , '<STR_LIT:H>' , '<STR_LIT:M>' , '<STR_LIT:S>' ] [ i ] <EOL> self . _cache = s <EOL> return self . _cache <EOL> class timeDurationType ( durationType ) : <EOL> _validURIs = ( NS . XSD , NS . XSD2 , NS . ENC ) <EOL> class dateTimeType ( anyType ) : <EOL> _validURIs = ( NS . XSD3 , ) <EOL> def _checkValueSpace ( self , data ) : <EOL> try : <EOL> if data == None : <EOL> data = time . time ( ) <EOL> if ( type ( data ) in ( IntType , LongType ) ) : <EOL> data = list ( time . gmtime ( data ) [ : <NUM_LIT:6> ] ) <EOL> elif ( type ( data ) == FloatType ) : <EOL> f = data - int ( data ) <EOL> data = list ( time . gmtime ( int ( data ) ) [ : <NUM_LIT:6> ] ) <EOL> data [ <NUM_LIT:5> ] += f <EOL> elif type ( data ) in ( ListType , TupleType ) : <EOL> if len ( data ) < <NUM_LIT:6> : <EOL> raise Exception , "<STR_LIT>" <EOL> if len ( data ) > <NUM_LIT:9> : <EOL> raise Exception , "<STR_LIT>" <EOL> data = list ( data [ : <NUM_LIT:6> ] ) <EOL> cleanDate ( data ) <EOL> else : <EOL> raise Exception , "<STR_LIT>" <EOL> except Exception , e : <EOL> raise ValueError , "<STR_LIT>" % ( self . _type , e ) <EOL> return tuple ( data ) <EOL> def _marshalData ( self ) : <EOL> if self . _cache == None : <EOL> d = self . _data <EOL> s = "<STR_LIT>" % ( ( abs ( d [ <NUM_LIT:0> ] ) , ) + d [ <NUM_LIT:1> : ] ) <EOL> if d [ <NUM_LIT:0> ] < <NUM_LIT:0> : <EOL> s = '<STR_LIT:->' + s <EOL> f = d [ <NUM_LIT:5> ] - int ( d [ <NUM_LIT:5> ] ) <EOL> if f != <NUM_LIT:0> : <EOL> s += ( "<STR_LIT>" % f ) [ <NUM_LIT:1> : ] <EOL> s += '<STR_LIT>' <EOL> self . _cache = s <EOL> return self . _cache <EOL> class recurringInstantType ( anyType ) : <EOL> _validURIs = ( NS . XSD , ) <EOL> def _checkValueSpace ( self , data ) : <EOL> try : <EOL> if data == None : <EOL> data = list ( time . gmtime ( time . time ( ) ) [ : <NUM_LIT:6> ] ) <EOL> if ( type ( data ) in ( IntType , LongType ) ) : <EOL> data = list ( time . gmtime ( data ) [ : <NUM_LIT:6> ] ) <EOL> elif ( type ( data ) == FloatType ) : <EOL> f = data - int ( data ) <EOL> data = list ( time . gmtime ( int ( data ) ) [ : <NUM_LIT:6> ] ) <EOL> data [ <NUM_LIT:5> ] += f <EOL> elif type ( data ) in ( ListType , TupleType ) : <EOL> if len ( data ) < <NUM_LIT:1> : <EOL> raise Exception , "<STR_LIT>" <EOL> if len ( data ) > <NUM_LIT:9> : <EOL> raise Exception , "<STR_LIT>" <EOL> data = list ( data [ : <NUM_LIT:6> ] ) <EOL> if len ( data ) < <NUM_LIT:6> : <EOL> data += [ <NUM_LIT:0> ] * ( <NUM_LIT:6> - len ( data ) ) <EOL> f = len ( data ) <EOL> for i in range ( f ) : <EOL> if data [ i ] == None : <EOL> if f < i : <EOL> raise Exception , "<STR_LIT>" <EOL> else : <EOL> f = i <EOL> break <EOL> cleanDate ( data , f ) <EOL> else : <EOL> raise Exception , "<STR_LIT>" <EOL> except Exception , e : <EOL> raise ValueError , "<STR_LIT>" % ( self . _type , e ) <EOL> return tuple ( data ) <EOL> def _marshalData ( self ) : <EOL> if self . _cache == None : <EOL> d = self . _data <EOL> e = list ( d ) <EOL> neg = '<STR_LIT>' <EOL> if not e [ <NUM_LIT:0> ] : <EOL> e [ <NUM_LIT:0> ] = '<STR_LIT>' <EOL> else : <EOL> if e [ <NUM_LIT:0> ] < <NUM_LIT:0> : <EOL> neg = '<STR_LIT:->' <EOL> e [ <NUM_LIT:0> ] = abs ( e [ <NUM_LIT:0> ] ) <EOL> if e [ <NUM_LIT:0> ] < <NUM_LIT:100> : <EOL> e [ <NUM_LIT:0> ] = '<STR_LIT:->' + "<STR_LIT>" % e [ <NUM_LIT:0> ] <EOL> else : <EOL> e [ <NUM_LIT:0> ] = "<STR_LIT>" % e [ <NUM_LIT:0> ] <EOL> for i in range ( <NUM_LIT:1> , len ( e ) ) : <EOL> if e [ i ] == None or ( i < <NUM_LIT:3> and e [ i ] == <NUM_LIT:0> ) : <EOL> e [ i ] = '<STR_LIT:->' <EOL> else : <EOL> if e [ i ] < <NUM_LIT:0> : <EOL> neg = '<STR_LIT:->' <EOL> e [ i ] = abs ( e [ i ] ) <EOL> e [ i ] = "<STR_LIT>" % e [ i ] <EOL> if d [ <NUM_LIT:5> ] : <EOL> f = abs ( d [ <NUM_LIT:5> ] - int ( d [ <NUM_LIT:5> ] ) ) <EOL> if f : <EOL> e [ <NUM_LIT:5> ] += ( "<STR_LIT>" % f ) [ <NUM_LIT:1> : ] <EOL> s = "<STR_LIT>" % ( ( neg , ) + tuple ( e ) ) <EOL> self . _cache = s <EOL> return self . _cache <EOL> class timeInstantType ( dateTimeType ) : <EOL> _validURIs = ( NS . XSD , NS . XSD2 , NS . ENC ) <EOL> class timePeriodType ( dateTimeType ) : <EOL> _validURIs = ( NS . XSD2 , NS . ENC ) <EOL> class timeType ( anyType ) : <EOL> def _checkValueSpace ( self , data ) : <EOL> try : <EOL> if data == None : <EOL> data = time . gmtime ( time . time ( ) ) [ <NUM_LIT:3> : <NUM_LIT:6> ] <EOL> elif ( type ( data ) == FloatType ) : <EOL> f = data - int ( data ) <EOL> data = list ( time . gmtime ( int ( data ) ) [ <NUM_LIT:3> : <NUM_LIT:6> ] ) <EOL> data [ <NUM_LIT:2> ] += f <EOL> elif type ( data ) in ( IntType , LongType ) : <EOL> data = time . gmtime ( data ) [ <NUM_LIT:3> : <NUM_LIT:6> ] <EOL> elif type ( data ) in ( ListType , TupleType ) : <EOL> if len ( data ) == <NUM_LIT:9> : <EOL> data = data [ <NUM_LIT:3> : <NUM_LIT:6> ] <EOL> elif len ( data ) > <NUM_LIT:3> : <EOL> raise Exception , "<STR_LIT>" <EOL> data = [ None , None , None ] + list ( data ) <EOL> if len ( data ) < <NUM_LIT:6> : <EOL> data += [ <NUM_LIT:0> ] * ( <NUM_LIT:6> - len ( data ) ) <EOL> cleanDate ( data , <NUM_LIT:3> ) <EOL> data = data [ <NUM_LIT:3> : ] <EOL> else : <EOL> raise Exception , "<STR_LIT>" <EOL> except Exception , e : <EOL> raise ValueError , "<STR_LIT>" % ( self . _type , e ) <EOL> return tuple ( data ) <EOL> def _marshalData ( self ) : <EOL> if self . _cache == None : <EOL> d = self . _data <EOL> s = '<STR_LIT>' <EOL> s = time . strftime ( "<STR_LIT>" , ( <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> ) + d + ( <NUM_LIT:0> , <NUM_LIT:0> , - <NUM_LIT:1> ) ) <EOL> f = d [ <NUM_LIT:2> ] - int ( d [ <NUM_LIT:2> ] ) <EOL> if f != <NUM_LIT:0> : <EOL> s += ( "<STR_LIT>" % f ) [ <NUM_LIT:1> : ] <EOL> s += '<STR_LIT>' <EOL> self . _cache = s <EOL> return self . _cache <EOL> class dateType ( anyType ) : <EOL> def _checkValueSpace ( self , data ) : <EOL> try : <EOL> if data == None : <EOL> data = time . gmtime ( time . time ( ) ) [ <NUM_LIT:0> : <NUM_LIT:3> ] <EOL> elif type ( data ) in ( IntType , LongType , FloatType ) : <EOL> data = time . gmtime ( data ) [ <NUM_LIT:0> : <NUM_LIT:3> ] <EOL> elif type ( data ) in ( ListType , TupleType ) : <EOL> if len ( data ) == <NUM_LIT:9> : <EOL> data = data [ <NUM_LIT:0> : <NUM_LIT:3> ] <EOL> elif len ( data ) > <NUM_LIT:3> : <EOL> raise Exception , "<STR_LIT>" <EOL> data = list ( data ) <EOL> if len ( data ) < <NUM_LIT:3> : <EOL> data += [ <NUM_LIT:1> , <NUM_LIT:1> , <NUM_LIT:1> ] [ len ( data ) : ] <EOL> data += [ <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> ] <EOL> cleanDate ( data ) <EOL> data = data [ : <NUM_LIT:3> ] <EOL> else : <EOL> raise Exception , "<STR_LIT>" <EOL> except Exception , e : <EOL> raise ValueError , "<STR_LIT>" % ( self . _type , e ) <EOL> return tuple ( data ) <EOL> def _marshalData ( self ) : <EOL> if self . _cache == None : <EOL> d = self . _data <EOL> s = "<STR_LIT>" % ( ( abs ( d [ <NUM_LIT:0> ] ) , ) + d [ <NUM_LIT:1> : ] ) <EOL> if d [ <NUM_LIT:0> ] < <NUM_LIT:0> : <EOL> s = '<STR_LIT:->' + s <EOL> self . _cache = s <EOL> return self . _cache <EOL> class gYearMonthType ( anyType ) : <EOL> _validURIs = ( NS . XSD3 , ) <EOL> def _checkValueSpace ( self , data ) : <EOL> try : <EOL> if data == None : <EOL> data = time . gmtime ( time . time ( ) ) [ <NUM_LIT:0> : <NUM_LIT:2> ] <EOL> elif type ( data ) in ( IntType , LongType , FloatType ) : <EOL> data = time . gmtime ( data ) [ <NUM_LIT:0> : <NUM_LIT:2> ] <EOL> elif type ( data ) in ( ListType , TupleType ) : <EOL> if len ( data ) == <NUM_LIT:9> : <EOL> data = data [ <NUM_LIT:0> : <NUM_LIT:2> ] <EOL> elif len ( data ) > <NUM_LIT:2> : <EOL> raise Exception , "<STR_LIT>" <EOL> data = list ( data ) <EOL> if len ( data ) < <NUM_LIT:2> : <EOL> data += [ <NUM_LIT:1> , <NUM_LIT:1> ] [ len ( data ) : ] <EOL> data += [ <NUM_LIT:1> , <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> ] <EOL> cleanDate ( data ) <EOL> data = data [ : <NUM_LIT:2> ] <EOL> else : <EOL> raise Exception , "<STR_LIT>" <EOL> except Exception , e : <EOL> raise ValueError , "<STR_LIT>" % ( self . _type , e ) <EOL> return tuple ( data ) <EOL> def _marshalData ( self ) : <EOL> if self . _cache == None : <EOL> d = self . _data <EOL> s = "<STR_LIT>" % ( ( abs ( d [ <NUM_LIT:0> ] ) , ) + d [ <NUM_LIT:1> : ] ) <EOL> if d [ <NUM_LIT:0> ] < <NUM_LIT:0> : <EOL> s = '<STR_LIT:->' + s <EOL> self . _cache = s <EOL> return self . _cache <EOL> class gYearType ( anyType ) : <EOL> _validURIs = ( NS . XSD3 , ) <EOL> def _checkValueSpace ( self , data ) : <EOL> try : <EOL> if data == None : <EOL> data = time . gmtime ( time . time ( ) ) [ <NUM_LIT:0> : <NUM_LIT:1> ] <EOL> elif type ( data ) in ( IntType , LongType , FloatType ) : <EOL> data = [ data ] <EOL> if type ( data ) in ( ListType , TupleType ) : <EOL> if len ( data ) == <NUM_LIT:9> : <EOL> data = data [ <NUM_LIT:0> : <NUM_LIT:1> ] <EOL> elif len ( data ) < <NUM_LIT:1> : <EOL> raise Exception , "<STR_LIT>" <EOL> elif len ( data ) > <NUM_LIT:1> : <EOL> raise Exception , "<STR_LIT>" <EOL> if type ( data [ <NUM_LIT:0> ] ) == FloatType : <EOL> try : s = int ( data [ <NUM_LIT:0> ] ) <EOL> except : s = long ( data [ <NUM_LIT:0> ] ) <EOL> if s != data [ <NUM_LIT:0> ] : <EOL> raise Exception , "<STR_LIT>" <EOL> data = [ s ] <EOL> elif type ( data [ <NUM_LIT:0> ] ) not in ( IntType , LongType ) : <EOL> raise Exception , "<STR_LIT>" <EOL> else : <EOL> raise Exception , "<STR_LIT>" <EOL> except Exception , e : <EOL> raise ValueError , "<STR_LIT>" % ( self . _type , e ) <EOL> return data [ <NUM_LIT:0> ] <EOL> def _marshalData ( self ) : <EOL> if self . _cache == None : <EOL> d = self . _data <EOL> s = "<STR_LIT>" % abs ( d ) <EOL> if d < <NUM_LIT:0> : <EOL> s = '<STR_LIT:->' + s <EOL> self . _cache = s <EOL> return self . _cache <EOL> class centuryType ( anyType ) : <EOL> _validURIs = ( NS . XSD2 , NS . ENC ) <EOL> def _checkValueSpace ( self , data ) : <EOL> try : <EOL> if data == None : <EOL> data = time . gmtime ( time . time ( ) ) [ <NUM_LIT:0> : <NUM_LIT:1> ] / <NUM_LIT:100> <EOL> elif type ( data ) in ( IntType , LongType , FloatType ) : <EOL> data = [ data ] <EOL> if type ( data ) in ( ListType , TupleType ) : <EOL> if len ( data ) == <NUM_LIT:9> : <EOL> data = data [ <NUM_LIT:0> : <NUM_LIT:1> ] / <NUM_LIT:100> <EOL> elif len ( data ) < <NUM_LIT:1> : <EOL> raise Exception , "<STR_LIT>" <EOL> elif len ( data ) > <NUM_LIT:1> : <EOL> raise Exception , "<STR_LIT>" <EOL> if type ( data [ <NUM_LIT:0> ] ) == FloatType : <EOL> try : s = int ( data [ <NUM_LIT:0> ] ) <EOL> except : s = long ( data [ <NUM_LIT:0> ] ) <EOL> if s != data [ <NUM_LIT:0> ] : <EOL> raise Exception , "<STR_LIT>" <EOL> data = [ s ] <EOL> elif type ( data [ <NUM_LIT:0> ] ) not in ( IntType , LongType ) : <EOL> raise Exception , "<STR_LIT>" <EOL> else : <EOL> raise Exception , "<STR_LIT>" <EOL> except Exception , e : <EOL> raise ValueError , "<STR_LIT>" % ( self . _type , e ) <EOL> return data [ <NUM_LIT:0> ] <EOL> def _marshalData ( self ) : <EOL> if self . _cache == None : <EOL> d = self . _data <EOL> s = "<STR_LIT>" % abs ( d ) <EOL> if d < <NUM_LIT:0> : <EOL> s = '<STR_LIT:->' + s <EOL> self . _cache = s <EOL> return self . _cache <EOL> class yearType ( gYearType ) : <EOL> _validURIs = ( NS . XSD2 , NS . ENC ) <EOL> class gMonthDayType ( anyType ) : <EOL> _validURIs = ( NS . XSD3 , ) <EOL> def _checkValueSpace ( self , data ) : <EOL> try : <EOL> if data == None : <EOL> data = time . gmtime ( time . time ( ) ) [ <NUM_LIT:1> : <NUM_LIT:3> ] <EOL> elif type ( data ) in ( IntType , LongType , FloatType ) : <EOL> data = time . gmtime ( data ) [ <NUM_LIT:1> : <NUM_LIT:3> ] <EOL> elif type ( data ) in ( ListType , TupleType ) : <EOL> if len ( data ) == <NUM_LIT:9> : <EOL> data = data [ <NUM_LIT:0> : <NUM_LIT:2> ] <EOL> elif len ( data ) > <NUM_LIT:2> : <EOL> raise Exception , "<STR_LIT>" <EOL> data = list ( data ) <EOL> if len ( data ) < <NUM_LIT:2> : <EOL> data += [ <NUM_LIT:1> , <NUM_LIT:1> ] [ len ( data ) : ] <EOL> data = [ <NUM_LIT:0> ] + data + [ <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> ] <EOL> cleanDate ( data , <NUM_LIT:1> ) <EOL> data = data [ <NUM_LIT:1> : <NUM_LIT:3> ] <EOL> else : <EOL> raise Exception , "<STR_LIT>" <EOL> except Exception , e : <EOL> raise ValueError , "<STR_LIT>" % ( self . _type , e ) <EOL> return tuple ( data ) <EOL> def _marshalData ( self ) : <EOL> if self . _cache == None : <EOL> self . _cache = "<STR_LIT>" % self . _data <EOL> return self . _cache <EOL> class recurringDateType ( gMonthDayType ) : <EOL> _validURIs = ( NS . XSD2 , NS . ENC ) <EOL> class gMonthType ( anyType ) : <EOL> _validURIs = ( NS . XSD3 , ) <EOL> def _checkValueSpace ( self , data ) : <EOL> try : <EOL> if data == None : <EOL> data = time . gmtime ( time . time ( ) ) [ <NUM_LIT:1> : <NUM_LIT:2> ] <EOL> elif type ( data ) in ( IntType , LongType , FloatType ) : <EOL> data = [ data ] <EOL> if type ( data ) in ( ListType , TupleType ) : <EOL> if len ( data ) == <NUM_LIT:9> : <EOL> data = data [ <NUM_LIT:1> : <NUM_LIT:2> ] <EOL> elif len ( data ) < <NUM_LIT:1> : <EOL> raise Exception , "<STR_LIT>" <EOL> elif len ( data ) > <NUM_LIT:1> : <EOL> raise Exception , "<STR_LIT>" <EOL> if type ( data [ <NUM_LIT:0> ] ) == FloatType : <EOL> try : s = int ( data [ <NUM_LIT:0> ] ) <EOL> except : s = long ( data [ <NUM_LIT:0> ] ) <EOL> if s != data [ <NUM_LIT:0> ] : <EOL> raise Exception , "<STR_LIT>" <EOL> data = [ s ] <EOL> elif type ( data [ <NUM_LIT:0> ] ) not in ( IntType , LongType ) : <EOL> raise Exception , "<STR_LIT>" <EOL> if data [ <NUM_LIT:0> ] < <NUM_LIT:1> or data [ <NUM_LIT:0> ] > <NUM_LIT:12> : <EOL> raise Exception , "<STR_LIT>" <EOL> else : <EOL> raise Exception , "<STR_LIT>" <EOL> except Exception , e : <EOL> raise ValueError , "<STR_LIT>" % ( self . _type , e ) <EOL> return data [ <NUM_LIT:0> ] <EOL> def _marshalData ( self ) : <EOL> if self . _cache == None : <EOL> self . _cache = "<STR_LIT>" % self . _data <EOL> return self . _cache <EOL> class monthType ( gMonthType ) : <EOL> _validURIs = ( NS . XSD2 , NS . ENC ) <EOL> class gDayType ( anyType ) : <EOL> _validURIs = ( NS . XSD3 , ) <EOL> def _checkValueSpace ( self , data ) : <EOL> try : <EOL> if data == None : <EOL> data = time . gmtime ( time . time ( ) ) [ <NUM_LIT:2> : <NUM_LIT:3> ] <EOL> elif type ( data ) in ( IntType , LongType , FloatType ) : <EOL> data = [ data ] <EOL> if type ( data ) in ( ListType , TupleType ) : <EOL> if len ( data ) == <NUM_LIT:9> : <EOL> data = data [ <NUM_LIT:2> : <NUM_LIT:3> ] <EOL> elif len ( data ) < <NUM_LIT:1> : <EOL> raise Exception , "<STR_LIT>" <EOL> elif len ( data ) > <NUM_LIT:1> : <EOL> raise Exception , "<STR_LIT>" <EOL> if type ( data [ <NUM_LIT:0> ] ) == FloatType : <EOL> try : s = int ( data [ <NUM_LIT:0> ] ) <EOL> except : s = long ( data [ <NUM_LIT:0> ] ) <EOL> if s != data [ <NUM_LIT:0> ] : <EOL> raise Exception , "<STR_LIT>" <EOL> data = [ s ] <EOL> elif type ( data [ <NUM_LIT:0> ] ) not in ( IntType , LongType ) : <EOL> raise Exception , "<STR_LIT>" <EOL> if data [ <NUM_LIT:0> ] < <NUM_LIT:1> or data [ <NUM_LIT:0> ] > <NUM_LIT> : <EOL> raise Exception , "<STR_LIT>" <EOL> else : <EOL> raise Exception , "<STR_LIT>" <EOL> except Exception , e : <EOL> raise ValueError , "<STR_LIT>" % ( self . _type , e ) <EOL> return data [ <NUM_LIT:0> ] <EOL> def _marshalData ( self ) : <EOL> if self . _cache == None : <EOL> self . _cache = "<STR_LIT>" % self . _data <EOL> return self . _cache <EOL> class recurringDayType ( gDayType ) : <EOL> _validURIs = ( NS . XSD2 , NS . ENC ) <EOL> class hexBinaryType ( anyType ) : <EOL> _validURIs = ( NS . XSD3 , ) <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( StringType , UnicodeType ) : <EOL> raise AttributeError , "<STR_LIT>" % self . _type <EOL> return data <EOL> def _marshalData ( self ) : <EOL> if self . _cache == None : <EOL> self . _cache = encodeHexString ( self . _data ) <EOL> return self . _cache <EOL> class base64BinaryType ( anyType ) : <EOL> _validURIs = ( NS . XSD3 , ) <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( StringType , UnicodeType ) : <EOL> raise AttributeError , "<STR_LIT>" % self . _type <EOL> return data <EOL> def _marshalData ( self ) : <EOL> if self . _cache == None : <EOL> self . _cache = base64 . encodestring ( self . _data ) <EOL> return self . _cache <EOL> class base64Type ( base64BinaryType ) : <EOL> _validURIs = ( NS . ENC , ) <EOL> class binaryType ( anyType ) : <EOL> _validURIs = ( NS . XSD , NS . ENC ) <EOL> def __init__ ( self , data , name = None , typed = <NUM_LIT:1> , encoding = '<STR_LIT>' , <EOL> attrs = None ) : <EOL> anyType . __init__ ( self , data , name , typed , attrs ) <EOL> self . _setAttr ( '<STR_LIT>' , encoding ) <EOL> def _marshalData ( self ) : <EOL> if self . _cache == None : <EOL> if self . _getAttr ( ( None , '<STR_LIT>' ) ) == '<STR_LIT>' : <EOL> self . _cache = base64 . encodestring ( self . _data ) <EOL> else : <EOL> self . _cache = encodeHexString ( self . _data ) <EOL> return self . _cache <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( StringType , UnicodeType ) : <EOL> raise AttributeError , "<STR_LIT>" % self . _type <EOL> return data <EOL> def _setAttr ( self , attr , value ) : <EOL> attr = self . _fixAttr ( attr ) <EOL> if attr [ <NUM_LIT:1> ] == '<STR_LIT>' : <EOL> if attr [ <NUM_LIT:0> ] != None or value not in ( '<STR_LIT>' , '<STR_LIT>' ) : <EOL> raise AttributeError , "<STR_LIT>" <EOL> self . _cache = None <EOL> anyType . _setAttr ( self , attr , value ) <EOL> class anyURIType ( anyType ) : <EOL> _validURIs = ( NS . XSD3 , ) <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( StringType , UnicodeType ) : <EOL> raise AttributeError , "<STR_LIT>" % self . _type <EOL> return data <EOL> def _marshalData ( self ) : <EOL> if self . _cache == None : <EOL> self . _cache = urllib . quote ( self . _data ) <EOL> return self . _cache <EOL> class uriType ( anyURIType ) : <EOL> _validURIs = ( NS . XSD , ) <EOL> class uriReferenceType ( anyURIType ) : <EOL> _validURIs = ( NS . XSD2 , ) <EOL> class NOTATIONType ( anyType ) : <EOL> def __init__ ( self , data , name = None , typed = <NUM_LIT:1> , attrs = None ) : <EOL> if self . __class__ == NOTATIONType : <EOL> raise Error , "<STR_LIT>" <EOL> anyType . __init__ ( self , data , name , typed , attrs ) <EOL> class ENTITIESType ( anyType ) : <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) in ( StringType , UnicodeType ) : <EOL> return ( data , ) <EOL> if type ( data ) not in ( ListType , TupleType ) or filter ( lambda x : type ( x ) not in ( StringType , UnicodeType ) , data ) : <EOL> raise AttributeError , "<STR_LIT>" % self . _type <EOL> return data <EOL> def _marshalData ( self ) : <EOL> return '<STR_LIT:U+0020>' . join ( self . _data ) <EOL> class IDREFSType ( ENTITIESType ) : pass <EOL> class NMTOKENSType ( ENTITIESType ) : pass <EOL> class integerType ( anyType ) : <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( IntType , LongType ) : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> return data <EOL> class nonPositiveIntegerType ( anyType ) : <EOL> _validURIs = ( NS . XSD2 , NS . XSD3 , NS . ENC ) <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( IntType , LongType ) or data > <NUM_LIT:0> : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> return data <EOL> class non_Positive_IntegerType ( nonPositiveIntegerType ) : <EOL> _validURIs = ( NS . XSD , ) <EOL> def _typeName ( self ) : <EOL> return '<STR_LIT>' <EOL> class negativeIntegerType ( anyType ) : <EOL> _validURIs = ( NS . XSD2 , NS . XSD3 , NS . ENC ) <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( IntType , LongType ) or data >= <NUM_LIT:0> : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> return data <EOL> class negative_IntegerType ( negativeIntegerType ) : <EOL> _validURIs = ( NS . XSD , ) <EOL> def _typeName ( self ) : <EOL> return '<STR_LIT>' <EOL> class longType ( anyType ) : <EOL> _validURIs = ( NS . XSD2 , NS . XSD3 , NS . ENC ) <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( IntType , LongType ) or data < - <NUM_LIT> L or data > <NUM_LIT> L : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> return data <EOL> class intType ( anyType ) : <EOL> _validURIs = ( NS . XSD2 , NS . XSD3 , NS . ENC ) <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( IntType , LongType ) or data < - <NUM_LIT> L or data > <NUM_LIT> : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> return data <EOL> class shortType ( anyType ) : <EOL> _validURIs = ( NS . XSD2 , NS . XSD3 , NS . ENC ) <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( IntType , LongType ) or data < - <NUM_LIT> or data > <NUM_LIT> : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> return data <EOL> class byteType ( anyType ) : <EOL> _validURIs = ( NS . XSD2 , NS . XSD3 , NS . ENC ) <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( IntType , LongType ) or data < - <NUM_LIT> or data > <NUM_LIT> : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> return data <EOL> class nonNegativeIntegerType ( anyType ) : <EOL> _validURIs = ( NS . XSD2 , NS . XSD3 , NS . ENC ) <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( IntType , LongType ) or data < <NUM_LIT:0> : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> return data <EOL> class non_Negative_IntegerType ( nonNegativeIntegerType ) : <EOL> _validURIs = ( NS . XSD , ) <EOL> def _typeName ( self ) : <EOL> return '<STR_LIT>' <EOL> class unsignedLongType ( anyType ) : <EOL> _validURIs = ( NS . XSD2 , NS . XSD3 , NS . ENC ) <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( IntType , LongType ) or data < <NUM_LIT:0> or data > <NUM_LIT> L : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> return data <EOL> class unsignedIntType ( anyType ) : <EOL> _validURIs = ( NS . XSD2 , NS . XSD3 , NS . ENC ) <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( IntType , LongType ) or data < <NUM_LIT:0> or data > <NUM_LIT> L : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> return data <EOL> class unsignedShortType ( anyType ) : <EOL> _validURIs = ( NS . XSD2 , NS . XSD3 , NS . ENC ) <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( IntType , LongType ) or data < <NUM_LIT:0> or data > <NUM_LIT> : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> return data <EOL> class unsignedByteType ( anyType ) : <EOL> _validURIs = ( NS . XSD2 , NS . XSD3 , NS . ENC ) <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( IntType , LongType ) or data < <NUM_LIT:0> or data > <NUM_LIT:255> : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> return data <EOL> class positiveIntegerType ( anyType ) : <EOL> _validURIs = ( NS . XSD2 , NS . XSD3 , NS . ENC ) <EOL> def _checkValueSpace ( self , data ) : <EOL> if data == None : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> if type ( data ) not in ( IntType , LongType ) or data <= <NUM_LIT:0> : <EOL> raise ValueError , "<STR_LIT>" % self . _type <EOL> return data <EOL> class positive_IntegerType ( positiveIntegerType ) : <EOL> _validURIs = ( NS . XSD , ) <EOL> def _typeName ( self ) : <EOL> return '<STR_LIT>' <EOL> class compoundType ( anyType ) : <EOL> def __init__ ( self , data = None , name = None , typed = <NUM_LIT:1> , attrs = None ) : <EOL> if self . __class__ == compoundType : <EOL> raise Error , "<STR_LIT>" <EOL> anyType . __init__ ( self , data , name , typed , attrs ) <EOL> self . _keyord = [ ] <EOL> if type ( data ) == DictType : <EOL> self . __dict__ . update ( data ) <EOL> def _aslist ( self , item = None ) : <EOL> if item is not None : <EOL> return self . __dict__ [ self . _keyord [ item ] ] <EOL> else : <EOL> return map ( lambda x : self . __dict__ [ x ] , self . _keyord ) <EOL> def _asdict ( self , item = None , encoding = Config . dict_encoding ) : <EOL> if item is not None : <EOL> if type ( item ) in ( UnicodeType , StringType ) : <EOL> item = item . encode ( encoding ) <EOL> return self . __dict__ [ item ] <EOL> else : <EOL> retval = { } <EOL> def fun ( x ) : retval [ x . encode ( encoding ) ] = self . __dict__ [ x ] <EOL> if hasattr ( self , '<STR_LIT>' ) : <EOL> map ( fun , self . _keyord ) <EOL> else : <EOL> for name in dir ( self ) : <EOL> if isPublic ( name ) : <EOL> retval [ name ] = getattr ( self , name ) <EOL> return retval <EOL> def __getitem__ ( self , item ) : <EOL> if type ( item ) == IntType : <EOL> return self . __dict__ [ self . _keyord [ item ] ] <EOL> else : <EOL> return getattr ( self , item ) <EOL> def __len__ ( self ) : <EOL> return len ( self . _keyord ) <EOL> def __nonzero__ ( self ) : <EOL> return <NUM_LIT:1> <EOL> def _keys ( self ) : <EOL> return filter ( lambda x : x [ <NUM_LIT:0> ] != '<STR_LIT:_>' , self . __dict__ . keys ( ) ) <EOL> def _addItem ( self , name , value , attrs = None ) : <EOL> if name in self . _keyord : <EOL> if type ( self . __dict__ [ name ] ) != ListType : <EOL> self . __dict__ [ name ] = [ self . __dict__ [ name ] ] <EOL> self . __dict__ [ name ] . append ( value ) <EOL> else : <EOL> self . __dict__ [ name ] = value <EOL> self . _keyord . append ( name ) <EOL> def _placeItem ( self , name , value , pos , subpos = <NUM_LIT:0> , attrs = None ) : <EOL> if subpos == <NUM_LIT:0> and type ( self . __dict__ [ name ] ) != ListType : <EOL> self . __dict__ [ name ] = value <EOL> else : <EOL> self . __dict__ [ name ] [ subpos ] = value <EOL> self . _keyord [ pos ] = name <EOL> def _getItemAsList ( self , name , default = [ ] ) : <EOL> try : <EOL> d = self . __dict__ [ name ] <EOL> except : <EOL> return default <EOL> if type ( d ) == ListType : <EOL> return d <EOL> return [ d ] <EOL> def __str__ ( self ) : <EOL> return anyType . __str__ ( self ) + "<STR_LIT>" + str ( self . _asdict ( ) ) <EOL> def __repr__ ( self ) : <EOL> return self . __str__ ( ) <EOL> class structType ( compoundType ) : <EOL> pass <EOL> class headerType ( structType ) : <EOL> _validURIs = ( NS . ENV , ) <EOL> def __init__ ( self , data = None , typed = <NUM_LIT:1> , attrs = None ) : <EOL> structType . __init__ ( self , data , "<STR_LIT>" , typed , attrs ) <EOL> class bodyType ( structType ) : <EOL> _validURIs = ( NS . ENV , ) <EOL> def __init__ ( self , data = None , typed = <NUM_LIT:1> , attrs = None ) : <EOL> structType . __init__ ( self , data , "<STR_LIT>" , typed , attrs ) <EOL> class arrayType ( UserList . UserList , compoundType ) : <EOL> def __init__ ( self , data = None , name = None , attrs = None , <EOL> offset = <NUM_LIT:0> , rank = None , asize = <NUM_LIT:0> , elemsname = None ) : <EOL> if data : <EOL> if type ( data ) not in ( ListType , TupleType ) : <EOL> raise Error , "<STR_LIT>" <EOL> UserList . UserList . __init__ ( self , data ) <EOL> compoundType . __init__ ( self , data , name , <NUM_LIT:0> , attrs ) <EOL> self . _elemsname = elemsname or "<STR_LIT>" <EOL> if data == None : <EOL> self . _rank = rank <EOL> self . _posstate = - <NUM_LIT:1> <EOL> self . _full = <NUM_LIT:0> <EOL> if asize in ( '<STR_LIT>' , None ) : <EOL> asize = '<STR_LIT:0>' <EOL> self . _dims = map ( lambda x : int ( x ) , str ( asize ) . split ( '<STR_LIT:U+002C>' ) ) <EOL> self . _dims . reverse ( ) <EOL> self . _poss = [ <NUM_LIT:0> ] * len ( self . _dims ) <EOL> for i in range ( len ( self . _dims ) ) : <EOL> if self . _dims [ i ] < <NUM_LIT:0> or self . _dims [ i ] == <NUM_LIT:0> and len ( self . _dims ) > <NUM_LIT:1> : <EOL> raise TypeError , "<STR_LIT>" <EOL> if offset > <NUM_LIT:0> : <EOL> self . _poss [ i ] = offset % self . _dims [ i ] <EOL> offset = int ( offset / self . _dims [ i ] ) <EOL> if offset : <EOL> raise AttributeError , "<STR_LIT>" <EOL> a = [ None ] * self . _dims [ <NUM_LIT:0> ] <EOL> for i in range ( <NUM_LIT:1> , len ( self . _dims ) ) : <EOL> b = [ ] <EOL> for j in range ( self . _dims [ i ] ) : <EOL> b . append ( copy . deepcopy ( a ) ) <EOL> a = b <EOL> self . data = a <EOL> def _aslist ( self , item = None ) : <EOL> if item is not None : <EOL> return self . data [ int ( item ) ] <EOL> else : <EOL> return self . data <EOL> def _asdict ( self , item = None , encoding = Config . dict_encoding ) : <EOL> if item is not None : <EOL> if type ( item ) in ( UnicodeType , StringType ) : <EOL> item = item . encode ( encoding ) <EOL> return self . data [ int ( item ) ] <EOL> else : <EOL> retval = { } <EOL> def fun ( x ) : retval [ str ( x ) . encode ( encoding ) ] = self . data [ x ] <EOL> map ( fun , range ( len ( self . data ) ) ) <EOL> return retval <EOL> def __getitem__ ( self , item ) : <EOL> try : <EOL> return self . data [ int ( item ) ] <EOL> except ValueError : <EOL> return getattr ( self , item ) <EOL> def __len__ ( self ) : <EOL> return len ( self . data ) <EOL> def __nonzero__ ( self ) : <EOL> return <NUM_LIT:1> <EOL> def __str__ ( self ) : <EOL> return anyType . __str__ ( self ) + "<STR_LIT>" + str ( self . _aslist ( ) ) <EOL> def _keys ( self ) : <EOL> return filter ( lambda x : x [ <NUM_LIT:0> ] != '<STR_LIT:_>' , self . __dict__ . keys ( ) ) <EOL> def _addItem ( self , name , value , attrs ) : <EOL> if self . _full : <EOL> raise ValueError , "<STR_LIT>" <EOL> pos = attrs . get ( ( NS . ENC , '<STR_LIT>' ) ) <EOL> if pos != None : <EOL> if self . _posstate == <NUM_LIT:0> : <EOL> raise AttributeError , "<STR_LIT>" "<STR_LIT>" <EOL> self . _posstate = <NUM_LIT:1> <EOL> try : <EOL> if pos [ <NUM_LIT:0> ] == '<STR_LIT:[>' and pos [ - <NUM_LIT:1> ] == '<STR_LIT:]>' : <EOL> pos = map ( lambda x : int ( x ) , pos [ <NUM_LIT:1> : - <NUM_LIT:1> ] . split ( '<STR_LIT:U+002C>' ) ) <EOL> pos . reverse ( ) <EOL> if len ( pos ) == <NUM_LIT:1> : <EOL> pos = pos [ <NUM_LIT:0> ] <EOL> curpos = [ <NUM_LIT:0> ] * len ( self . _dims ) <EOL> for i in range ( len ( self . _dims ) ) : <EOL> curpos [ i ] = pos % self . _dims [ i ] <EOL> pos = int ( pos / self . _dims [ i ] ) <EOL> if pos == <NUM_LIT:0> : <EOL> break <EOL> if pos : <EOL> raise Exception <EOL> elif len ( pos ) != len ( self . _dims ) : <EOL> raise Exception <EOL> else : <EOL> for i in range ( len ( self . _dims ) ) : <EOL> if pos [ i ] >= self . _dims [ i ] : <EOL> raise Exception <EOL> curpos = pos <EOL> else : <EOL> raise Exception <EOL> except : <EOL> raise AttributeError , "<STR_LIT>" % str ( pos ) <EOL> else : <EOL> if self . _posstate == <NUM_LIT:1> : <EOL> raise AttributeError , "<STR_LIT>" "<STR_LIT>" <EOL> self . _posstate = <NUM_LIT:0> <EOL> curpos = self . _poss <EOL> a = self . data <EOL> for i in range ( len ( self . _dims ) - <NUM_LIT:1> , <NUM_LIT:0> , - <NUM_LIT:1> ) : <EOL> a = a [ curpos [ i ] ] <EOL> if curpos [ <NUM_LIT:0> ] >= len ( a ) : <EOL> a += [ None ] * ( len ( a ) - curpos [ <NUM_LIT:0> ] + <NUM_LIT:1> ) <EOL> a [ curpos [ <NUM_LIT:0> ] ] = value <EOL> if pos == None : <EOL> self . _poss [ <NUM_LIT:0> ] += <NUM_LIT:1> <EOL> for i in range ( len ( self . _dims ) - <NUM_LIT:1> ) : <EOL> if self . _poss [ i ] < self . _dims [ i ] : <EOL> break <EOL> self . _poss [ i ] = <NUM_LIT:0> <EOL> self . _poss [ i + <NUM_LIT:1> ] += <NUM_LIT:1> <EOL> if self . _dims [ - <NUM_LIT:1> ] and self . _poss [ - <NUM_LIT:1> ] >= self . _dims [ - <NUM_LIT:1> ] : <EOL> pass <EOL> def _placeItem ( self , name , value , pos , subpos , attrs = None ) : <EOL> curpos = [ <NUM_LIT:0> ] * len ( self . _dims ) <EOL> for i in range ( len ( self . _dims ) ) : <EOL> if self . _dims [ i ] == <NUM_LIT:0> : <EOL> curpos [ <NUM_LIT:0> ] = pos <EOL> break <EOL> curpos [ i ] = pos % self . _dims [ i ] <EOL> pos = int ( pos / self . _dims [ i ] ) <EOL> if pos == <NUM_LIT:0> : <EOL> break <EOL> if self . _dims [ i ] != <NUM_LIT:0> and pos : <EOL> raise Error , "<STR_LIT>" <EOL> a = self . data <EOL> for i in range ( len ( self . _dims ) - <NUM_LIT:1> , <NUM_LIT:0> , - <NUM_LIT:1> ) : <EOL> a = a [ curpos [ i ] ] <EOL> if curpos [ <NUM_LIT:0> ] >= len ( a ) : <EOL> a += [ None ] * ( len ( a ) - curpos [ <NUM_LIT:0> ] + <NUM_LIT:1> ) <EOL> a [ curpos [ <NUM_LIT:0> ] ] = value <EOL> class typedArrayType ( arrayType ) : <EOL> def __init__ ( self , data = None , name = None , typed = None , attrs = None , <EOL> offset = <NUM_LIT:0> , rank = None , asize = <NUM_LIT:0> , elemsname = None , complexType = <NUM_LIT:0> ) : <EOL> arrayType . __init__ ( self , data , name , attrs , offset , rank , asize , <EOL> elemsname ) <EOL> self . _typed = <NUM_LIT:1> <EOL> self . _type = typed <EOL> self . _complexType = complexType <EOL> class faultType ( structType , Error ) : <EOL> def __init__ ( self , faultcode = "<STR_LIT>" , faultstring = "<STR_LIT>" , detail = None ) : <EOL> self . faultcode = faultcode <EOL> self . faultstring = faultstring <EOL> if detail != None : <EOL> self . detail = detail <EOL> structType . __init__ ( self , None , <NUM_LIT:0> ) <EOL> def _setDetail ( self , detail = None ) : <EOL> if detail != None : <EOL> self . detail = detail <EOL> else : <EOL> try : del self . detail <EOL> except AttributeError : pass <EOL> def __repr__ ( self ) : <EOL> if getattr ( self , '<STR_LIT>' , None ) != None : <EOL> return "<STR_LIT>" % ( self . faultcode , <EOL> self . faultstring , <EOL> self . detail ) <EOL> else : <EOL> return "<STR_LIT>" % ( self . faultcode , self . faultstring ) <EOL> __str__ = __repr__ <EOL> def __call__ ( self ) : <EOL> return ( self . faultcode , self . faultstring , self . detail ) <EOL> class SOAPException ( Exception ) : <EOL> def __init__ ( self , code = "<STR_LIT>" , string = "<STR_LIT>" , detail = None ) : <EOL> self . value = ( "<STR_LIT>" , code , string , detail ) <EOL> self . code = code <EOL> self . string = string <EOL> self . detail = detail <EOL> def __str__ ( self ) : <EOL> return repr ( self . value ) <EOL> class RequiredHeaderMismatch ( Exception ) : <EOL> def __init__ ( self , value ) : <EOL> self . value = value <EOL> def __str__ ( self ) : <EOL> return repr ( self . value ) <EOL> class MethodNotFound ( Exception ) : <EOL> def __init__ ( self , value ) : <EOL> ( val , detail ) = value . split ( "<STR_LIT::>" ) <EOL> self . value = val <EOL> self . detail = detail <EOL> def __str__ ( self ) : <EOL> return repr ( self . value , self . detail ) <EOL> class AuthorizationFailed ( Exception ) : <EOL> def __init__ ( self , value ) : <EOL> self . value = value <EOL> def __str__ ( self ) : <EOL> return repr ( self . value ) <EOL> class MethodFailed ( Exception ) : <EOL> def __init__ ( self , value ) : <EOL> self . value = value <EOL> def __str__ ( self ) : <EOL> return repr ( self . value ) <EOL> def simplify ( object , level = <NUM_LIT:0> ) : <EOL> """<STR_LIT>""" <EOL> if level > <NUM_LIT:10> : <EOL> return object <EOL> if isinstance ( object , faultType ) : <EOL> if object . faultstring == "<STR_LIT>" : <EOL> raise RequiredHeaderMismatch ( object . detail ) <EOL> elif object . faultstring == "<STR_LIT>" : <EOL> raise MethodNotFound ( object . detail ) <EOL> elif object . faultstring == "<STR_LIT>" : <EOL> raise AuthorizationFailed ( object . detail ) <EOL> elif object . faultstring == "<STR_LIT>" : <EOL> raise MethodFailed ( object . detail ) <EOL> else : <EOL> se = SOAPException ( object . faultcode , object . faultstring , <EOL> object . detail ) <EOL> raise se <EOL> elif isinstance ( object , arrayType ) : <EOL> data = object . _aslist ( ) <EOL> for k in range ( len ( data ) ) : <EOL> data [ k ] = simplify ( data [ k ] , level = level + <NUM_LIT:1> ) <EOL> return data <EOL> elif isinstance ( object , compoundType ) or isinstance ( object , structType ) : <EOL> data = object . _asdict ( ) <EOL> for k in data . keys ( ) : <EOL> if isPublic ( k ) : <EOL> data [ k ] = simplify ( data [ k ] , level = level + <NUM_LIT:1> ) <EOL> return data <EOL> elif type ( object ) == DictType : <EOL> for k in object . keys ( ) : <EOL> if isPublic ( k ) : <EOL> object [ k ] = simplify ( object [ k ] ) <EOL> return object <EOL> elif type ( object ) == list : <EOL> for k in range ( len ( object ) ) : <EOL> object [ k ] = simplify ( object [ k ] ) <EOL> return object <EOL> else : <EOL> return object <EOL> def simplify_contents ( object , level = <NUM_LIT:0> ) : <EOL> """<STR_LIT>""" <EOL> if level > <NUM_LIT:10> : return object <EOL> if isinstance ( object , faultType ) : <EOL> for k in object . _keys ( ) : <EOL> if isPublic ( k ) : <EOL> setattr ( object , k , simplify ( object [ k ] , level = level + <NUM_LIT:1> ) ) <EOL> raise object <EOL> elif isinstance ( object , arrayType ) : <EOL> data = object . _aslist ( ) <EOL> for k in range ( len ( data ) ) : <EOL> object [ k ] = simplify ( data [ k ] , level = level + <NUM_LIT:1> ) <EOL> elif isinstance ( object , structType ) : <EOL> data = object . _asdict ( ) <EOL> for k in data . keys ( ) : <EOL> if isPublic ( k ) : <EOL> setattr ( object , k , simplify ( data [ k ] , level = level + <NUM_LIT:1> ) ) <EOL> elif isinstance ( object , compoundType ) : <EOL> data = object . _asdict ( ) <EOL> for k in data . keys ( ) : <EOL> if isPublic ( k ) : <EOL> object [ k ] = simplify ( data [ k ] , level = level + <NUM_LIT:1> ) <EOL> elif type ( object ) == DictType : <EOL> for k in object . keys ( ) : <EOL> if isPublic ( k ) : <EOL> object [ k ] = simplify ( object [ k ] ) <EOL> elif type ( object ) == list : <EOL> for k in range ( len ( object ) ) : <EOL> object [ k ] = simplify ( object [ k ] ) <EOL> return object </s>

<s> """<STR_LIT>""" <EOL> import heapq <EOL> import itertools <EOL> import logging <EOL> import os <EOL> import re <EOL> import sys <EOL> import threading <EOL> import traceback <EOL> from xml . sax import saxutils <EOL> from google . appengine . api import apiproxy_stub_map <EOL> from google . appengine . api import capabilities <EOL> from google . appengine . api import datastore_errors <EOL> from google . appengine . api import datastore_types <EOL> from google . appengine . datastore import datastore_pb <EOL> from google . appengine . datastore import datastore_query <EOL> from google . appengine . datastore import datastore_rpc <EOL> from google . appengine . datastore import entity_pb <EOL> MAX_ALLOWABLE_QUERIES = <NUM_LIT:30> <EOL> MAXIMUM_RESULTS = <NUM_LIT:1000> <EOL> DEFAULT_TRANSACTION_RETRIES = <NUM_LIT:3> <EOL> READ_CAPABILITY = capabilities . CapabilitySet ( '<STR_LIT>' ) <EOL> WRITE_CAPABILITY = capabilities . CapabilitySet ( <EOL> '<STR_LIT>' , <EOL> capabilities = [ '<STR_LIT>' ] ) <EOL> _MAX_INDEXED_PROPERTIES = <NUM_LIT> <EOL> _MAX_ID_BATCH_SIZE = datastore_rpc . _MAX_ID_BATCH_SIZE <EOL> Key = datastore_types . Key <EOL> typename = datastore_types . typename <EOL> STRONG_CONSISTENCY = datastore_rpc . Configuration . STRONG_CONSISTENCY <EOL> EVENTUAL_CONSISTENCY = datastore_rpc . Configuration . EVENTUAL_CONSISTENCY <EOL> _MAX_INT_32 = <NUM_LIT:2> ** <NUM_LIT> - <NUM_LIT:1> <EOL> def NormalizeAndTypeCheck ( arg , types ) : <EOL> """<STR_LIT>""" <EOL> if not isinstance ( types , ( list , tuple ) ) : <EOL> types = ( types , ) <EOL> assert list not in types and tuple not in types <EOL> if isinstance ( arg , types ) : <EOL> return [ arg ] , False <EOL> else : <EOL> if isinstance ( arg , basestring ) : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' % <EOL> ( types , arg , typename ( arg ) ) ) <EOL> try : <EOL> arg_list = list ( arg ) <EOL> except TypeError : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' % <EOL> ( types , arg , typename ( arg ) ) ) <EOL> for val in arg_list : <EOL> if not isinstance ( val , types ) : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' % <EOL> ( types , val , typename ( val ) ) ) <EOL> return arg_list , True <EOL> def NormalizeAndTypeCheckKeys ( keys ) : <EOL> """<STR_LIT>""" <EOL> keys , multiple = NormalizeAndTypeCheck ( keys , ( basestring , Entity , Key ) ) <EOL> keys = [ _GetCompleteKeyOrError ( key ) for key in keys ] <EOL> return ( keys , multiple ) <EOL> def _GetConfigFromKwargs ( kwargs , convert_rpc = False , <EOL> config_class = datastore_rpc . Configuration ) : <EOL> """<STR_LIT>""" <EOL> if not kwargs : <EOL> return None <EOL> rpc = kwargs . pop ( '<STR_LIT>' , None ) <EOL> if rpc is not None : <EOL> if not isinstance ( rpc , apiproxy_stub_map . UserRPC ) : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' ) <EOL> if '<STR_LIT>' in kwargs : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' ) <EOL> if not convert_rpc : <EOL> if kwargs : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' % '<STR_LIT:U+002CU+0020>' . join ( kwargs ) ) <EOL> return rpc <EOL> read_policy = getattr ( rpc , '<STR_LIT>' , None ) <EOL> kwargs [ '<STR_LIT>' ] = datastore_rpc . Configuration ( <EOL> deadline = rpc . deadline , read_policy = read_policy , <EOL> config = _GetConnection ( ) . config ) <EOL> return config_class ( ** kwargs ) <EOL> class _BaseIndex ( object ) : <EOL> BUILDING , SERVING , DELETING , ERROR = range ( <NUM_LIT:4> ) <EOL> ASCENDING = datastore_query . PropertyOrder . ASCENDING <EOL> DESCENDING = datastore_query . PropertyOrder . DESCENDING <EOL> def __init__ ( self , index_id , kind , has_ancestor , properties ) : <EOL> """<STR_LIT>""" <EOL> argument_error = datastore_errors . BadArgumentError <EOL> datastore_types . ValidateInteger ( index_id , '<STR_LIT>' , argument_error , <EOL> zero_ok = True ) <EOL> datastore_types . ValidateString ( kind , '<STR_LIT>' , argument_error , empty_ok = True ) <EOL> if not isinstance ( properties , ( list , tuple ) ) : <EOL> raise argument_error ( '<STR_LIT>' ) <EOL> for idx , index_property in enumerate ( properties ) : <EOL> if not isinstance ( index_property , ( list , tuple ) ) : <EOL> raise argument_error ( '<STR_LIT>' % idx ) <EOL> if len ( index_property ) != <NUM_LIT:2> : <EOL> raise argument_error ( '<STR_LIT>' % <EOL> ( idx , len ( index_property ) ) ) <EOL> datastore_types . ValidateString ( index_property [ <NUM_LIT:0> ] , '<STR_LIT>' , <EOL> argument_error ) <EOL> _BaseIndex . __ValidateEnum ( index_property [ <NUM_LIT:1> ] , <EOL> ( self . ASCENDING , self . DESCENDING ) , <EOL> '<STR_LIT>' ) <EOL> self . __id = long ( index_id ) <EOL> self . __kind = kind <EOL> self . __has_ancestor = bool ( has_ancestor ) <EOL> self . __properties = properties <EOL> @ staticmethod <EOL> def __ValidateEnum ( value , accepted_values , name = '<STR_LIT:value>' , <EOL> exception = datastore_errors . BadArgumentError ) : <EOL> datastore_types . ValidateInteger ( value , name , exception ) <EOL> if not value in accepted_values : <EOL> raise exception ( '<STR_LIT>' % <EOL> ( name , str ( accepted_values ) , value ) ) <EOL> def _Id ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __id <EOL> def _Kind ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __kind <EOL> def _HasAncestor ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __has_ancestor <EOL> def _Properties ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __properties <EOL> def __eq__ ( self , other ) : <EOL> return self . __id == other . __id <EOL> def __ne__ ( self , other ) : <EOL> return self . __id != other . __id <EOL> def __hash__ ( self ) : <EOL> return hash ( self . __id ) <EOL> class Index ( _BaseIndex ) : <EOL> """<STR_LIT>""" <EOL> Id = _BaseIndex . _Id <EOL> Kind = _BaseIndex . _Kind <EOL> HasAncestor = _BaseIndex . _HasAncestor <EOL> Properties = _BaseIndex . _Properties <EOL> class DatastoreAdapter ( datastore_rpc . AbstractAdapter ) : <EOL> """<STR_LIT>""" <EOL> index_state_mappings = { <EOL> entity_pb . CompositeIndex . ERROR : Index . ERROR , <EOL> entity_pb . CompositeIndex . DELETED : Index . DELETING , <EOL> entity_pb . CompositeIndex . READ_WRITE : Index . SERVING , <EOL> entity_pb . CompositeIndex . WRITE_ONLY : Index . BUILDING <EOL> } <EOL> index_direction_mappings = { <EOL> entity_pb . Index_Property . ASCENDING : Index . ASCENDING , <EOL> entity_pb . Index_Property . DESCENDING : Index . DESCENDING <EOL> } <EOL> def key_to_pb ( self , key ) : <EOL> return key . _Key__reference <EOL> def pb_to_key ( self , pb ) : <EOL> return Key . _FromPb ( pb ) <EOL> def entity_to_pb ( self , entity ) : <EOL> return entity . _ToPb ( ) <EOL> def pb_to_entity ( self , pb ) : <EOL> return Entity . _FromPb ( pb ) <EOL> def pb_to_index ( self , pb ) : <EOL> index_def = pb . definition ( ) <EOL> properties = [ ( property . name ( ) , <EOL> DatastoreAdapter . index_direction_mappings . get ( property . direction ( ) ) ) <EOL> for property in index_def . property_list ( ) ] <EOL> index = Index ( pb . id ( ) , index_def . entity_type ( ) , index_def . ancestor ( ) , <EOL> properties ) <EOL> state = DatastoreAdapter . index_state_mappings . get ( pb . state ( ) ) <EOL> return index , state <EOL> _adapter = DatastoreAdapter ( ) <EOL> _thread_local = threading . local ( ) <EOL> _ENV_KEY = '<STR_LIT>' <EOL> def _GetConnection ( ) : <EOL> """<STR_LIT>""" <EOL> connection = None <EOL> if os . getenv ( _ENV_KEY ) : <EOL> try : <EOL> connection = _thread_local . connection <EOL> except AttributeError : <EOL> pass <EOL> if connection is None : <EOL> connection = datastore_rpc . Connection ( adapter = _adapter ) <EOL> _SetConnection ( connection ) <EOL> return connection <EOL> def _SetConnection ( connection ) : <EOL> """<STR_LIT>""" <EOL> _thread_local . connection = connection <EOL> os . environ [ _ENV_KEY ] = '<STR_LIT:1>' <EOL> def _MakeSyncCall ( service , call , request , response , config = None ) : <EOL> """<STR_LIT>""" <EOL> conn = _GetConnection ( ) <EOL> if isinstance ( request , datastore_pb . Query ) : <EOL> conn . _set_request_read_policy ( request , config ) <EOL> conn . _set_request_transaction ( request ) <EOL> rpc = conn . make_rpc_call ( config , call , request , response ) <EOL> conn . check_rpc_success ( rpc ) <EOL> return response <EOL> def CreateRPC ( service = '<STR_LIT>' , <EOL> deadline = None , callback = None , read_policy = None ) : <EOL> """<STR_LIT>""" <EOL> assert service == '<STR_LIT>' <EOL> conn = _GetConnection ( ) <EOL> config = None <EOL> if deadline is not None : <EOL> config = datastore_rpc . Configuration ( deadline = deadline ) <EOL> rpc = conn . create_rpc ( config ) <EOL> rpc . callback = callback <EOL> if read_policy is not None : <EOL> rpc . read_policy = read_policy <EOL> return rpc <EOL> def CreateConfig ( ** kwds ) : <EOL> """<STR_LIT>""" <EOL> return datastore_rpc . Configuration ( ** kwds ) <EOL> def CreateTransactionOptions ( ** kwds ) : <EOL> """<STR_LIT>""" <EOL> return datastore_rpc . TransactionOptions ( ** kwds ) <EOL> def PutAsync ( entities , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> extra_hook = kwargs . pop ( '<STR_LIT>' , None ) <EOL> config = _GetConfigFromKwargs ( kwargs ) <EOL> if getattr ( config , '<STR_LIT>' , None ) == EVENTUAL_CONSISTENCY : <EOL> raise datastore_errors . BadRequestError ( <EOL> '<STR_LIT>' ) <EOL> entities , multiple = NormalizeAndTypeCheck ( entities , Entity ) <EOL> for entity in entities : <EOL> if entity . is_projection ( ) : <EOL> raise datastore_errors . BadRequestError ( <EOL> '<STR_LIT>' % entity ) <EOL> if not entity . kind ( ) or not entity . app ( ) : <EOL> raise datastore_errors . BadRequestError ( <EOL> '<STR_LIT>' % entity ) <EOL> def local_extra_hook ( keys ) : <EOL> num_keys = len ( keys ) <EOL> num_entities = len ( entities ) <EOL> if num_keys != num_entities : <EOL> raise datastore_errors . InternalError ( <EOL> '<STR_LIT>' % <EOL> ( num_entities , num_keys ) ) <EOL> for entity , key in zip ( entities , keys ) : <EOL> if entity . _Entity__key . _Key__reference != key . _Key__reference : <EOL> assert not entity . _Entity__key . has_id_or_name ( ) <EOL> entity . _Entity__key . _Key__reference . CopyFrom ( key . _Key__reference ) <EOL> if multiple : <EOL> result = keys <EOL> else : <EOL> result = keys [ <NUM_LIT:0> ] <EOL> if extra_hook : <EOL> return extra_hook ( result ) <EOL> return result <EOL> return _GetConnection ( ) . async_put ( config , entities , local_extra_hook ) <EOL> def Put ( entities , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return PutAsync ( entities , ** kwargs ) . get_result ( ) <EOL> def GetAsync ( keys , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> extra_hook = kwargs . pop ( '<STR_LIT>' , None ) <EOL> config = _GetConfigFromKwargs ( kwargs ) <EOL> keys , multiple = NormalizeAndTypeCheckKeys ( keys ) <EOL> def local_extra_hook ( entities ) : <EOL> if multiple : <EOL> result = entities <EOL> else : <EOL> if not entities or entities [ <NUM_LIT:0> ] is None : <EOL> raise datastore_errors . EntityNotFoundError ( ) <EOL> result = entities [ <NUM_LIT:0> ] <EOL> if extra_hook : <EOL> return extra_hook ( result ) <EOL> return result <EOL> return _GetConnection ( ) . async_get ( config , keys , local_extra_hook ) <EOL> def Get ( keys , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return GetAsync ( keys , ** kwargs ) . get_result ( ) <EOL> def GetIndexesAsync ( ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> extra_hook = kwargs . pop ( '<STR_LIT>' , None ) <EOL> config = _GetConfigFromKwargs ( kwargs ) <EOL> def local_extra_hook ( result ) : <EOL> if extra_hook : <EOL> return extra_hook ( result ) <EOL> return result <EOL> return _GetConnection ( ) . async_get_indexes ( config , local_extra_hook ) <EOL> def GetIndexes ( ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return GetIndexesAsync ( ** kwargs ) . get_result ( ) <EOL> def DeleteAsync ( keys , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> config = _GetConfigFromKwargs ( kwargs ) <EOL> if getattr ( config , '<STR_LIT>' , None ) == EVENTUAL_CONSISTENCY : <EOL> raise datastore_errors . BadRequestError ( <EOL> '<STR_LIT>' ) <EOL> keys , _ = NormalizeAndTypeCheckKeys ( keys ) <EOL> return _GetConnection ( ) . async_delete ( config , keys ) <EOL> def Delete ( keys , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return DeleteAsync ( keys , ** kwargs ) . get_result ( ) <EOL> class Entity ( dict ) : <EOL> """<STR_LIT>""" <EOL> __projection = False <EOL> def __init__ ( self , kind , parent = None , _app = None , name = None , id = None , <EOL> unindexed_properties = [ ] , namespace = None , ** kwds ) : <EOL> """<STR_LIT>""" <EOL> ref = entity_pb . Reference ( ) <EOL> _app = datastore_types . ResolveAppId ( _app ) <EOL> ref . set_app ( _app ) <EOL> _namespace = kwds . pop ( '<STR_LIT>' , None ) <EOL> if kwds : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' + repr ( kwds ) ) <EOL> if namespace is None : <EOL> namespace = _namespace <EOL> elif _namespace is not None : <EOL> raise datastore_errors . BadArgumentError ( <EOL> "<STR_LIT>" ) <EOL> datastore_types . ValidateString ( kind , '<STR_LIT>' , <EOL> datastore_errors . BadArgumentError ) <EOL> if parent is not None : <EOL> parent = _GetCompleteKeyOrError ( parent ) <EOL> if _app != parent . app ( ) : <EOL> raise datastore_errors . BadArgumentError ( <EOL> "<STR_LIT>" % <EOL> ( _app , parent . app ( ) ) ) <EOL> if namespace is None : <EOL> namespace = parent . namespace ( ) <EOL> elif namespace != parent . namespace ( ) : <EOL> raise datastore_errors . BadArgumentError ( <EOL> "<STR_LIT>" % <EOL> ( namespace , parent . namespace ( ) ) ) <EOL> ref . CopyFrom ( parent . _Key__reference ) <EOL> namespace = datastore_types . ResolveNamespace ( namespace ) <EOL> datastore_types . SetNamespace ( ref , namespace ) <EOL> last_path = ref . mutable_path ( ) . add_element ( ) <EOL> last_path . set_type ( kind . encode ( '<STR_LIT:utf-8>' ) ) <EOL> if name is not None and id is not None : <EOL> raise datastore_errors . BadArgumentError ( <EOL> "<STR_LIT>" ) <EOL> if name is not None : <EOL> datastore_types . ValidateString ( name , '<STR_LIT:name>' ) <EOL> last_path . set_name ( name . encode ( '<STR_LIT:utf-8>' ) ) <EOL> if id is not None : <EOL> datastore_types . ValidateInteger ( id , '<STR_LIT:id>' ) <EOL> last_path . set_id ( id ) <EOL> self . set_unindexed_properties ( unindexed_properties ) <EOL> self . __key = Key . _FromPb ( ref ) <EOL> def app ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __key . app ( ) <EOL> def namespace ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __key . namespace ( ) <EOL> def kind ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __key . kind ( ) <EOL> def is_saved ( self ) : <EOL> """<STR_LIT>""" <EOL> last_path = self . __key . _Key__reference . path ( ) . element_list ( ) [ - <NUM_LIT:1> ] <EOL> return ( ( last_path . has_name ( ) ^ last_path . has_id ( ) ) and <EOL> self . __key . has_id_or_name ( ) ) <EOL> def is_projection ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __projection <EOL> def key ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __key <EOL> def parent ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . key ( ) . parent ( ) <EOL> def entity_group ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . key ( ) . entity_group ( ) <EOL> def unindexed_properties ( self ) : <EOL> """<STR_LIT>""" <EOL> return getattr ( self , '<STR_LIT>' , [ ] ) <EOL> def set_unindexed_properties ( self , unindexed_properties ) : <EOL> unindexed_properties , multiple = NormalizeAndTypeCheck ( unindexed_properties , basestring ) <EOL> if not multiple : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' % <EOL> ( unindexed_properties , typename ( unindexed_properties ) ) ) <EOL> for prop in unindexed_properties : <EOL> datastore_types . ValidateProperty ( prop , None ) <EOL> self . __unindexed_properties = frozenset ( unindexed_properties ) <EOL> def __setitem__ ( self , name , value ) : <EOL> """<STR_LIT>""" <EOL> datastore_types . ValidateProperty ( name , value ) <EOL> dict . __setitem__ ( self , name , value ) <EOL> def setdefault ( self , name , value ) : <EOL> """<STR_LIT>""" <EOL> datastore_types . ValidateProperty ( name , value ) <EOL> return dict . setdefault ( self , name , value ) <EOL> def update ( self , other ) : <EOL> """<STR_LIT>""" <EOL> for name , value in other . items ( ) : <EOL> self . __setitem__ ( name , value ) <EOL> def copy ( self ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError ( '<STR_LIT>' ) <EOL> def ToXml ( self ) : <EOL> """<STR_LIT>""" <EOL> xml = u'<STR_LIT>' % saxutils . quoteattr ( self . kind ( ) ) <EOL> if self . __key . has_id_or_name ( ) : <EOL> xml += '<STR_LIT>' % saxutils . quoteattr ( str ( self . __key ) ) <EOL> xml += '<STR_LIT:>>' <EOL> if self . __key . has_id_or_name ( ) : <EOL> xml += '<STR_LIT>' % self . __key . ToTagUri ( ) <EOL> properties = self . keys ( ) <EOL> if properties : <EOL> properties . sort ( ) <EOL> xml += '<STR_LIT>' + '<STR_LIT>' . join ( self . _PropertiesToXml ( properties ) ) <EOL> xml += '<STR_LIT>' <EOL> return xml <EOL> def _PropertiesToXml ( self , properties ) : <EOL> """<STR_LIT>""" <EOL> xml_properties = [ ] <EOL> for propname in properties : <EOL> if not self . has_key ( propname ) : <EOL> continue <EOL> propname_xml = saxutils . quoteattr ( propname ) <EOL> values = self [ propname ] <EOL> if not isinstance ( values , list ) : <EOL> values = [ values ] <EOL> proptype = datastore_types . PropertyTypeName ( values [ <NUM_LIT:0> ] ) <EOL> proptype_xml = saxutils . quoteattr ( proptype ) <EOL> escaped_values = self . _XmlEscapeValues ( propname ) <EOL> open_tag = u'<STR_LIT>' % ( propname_xml , proptype_xml ) <EOL> close_tag = u'<STR_LIT>' <EOL> xml_properties += [ open_tag + val + close_tag for val in escaped_values ] <EOL> return xml_properties <EOL> def _XmlEscapeValues ( self , property ) : <EOL> """<STR_LIT>""" <EOL> assert self . has_key ( property ) <EOL> xml = [ ] <EOL> values = self [ property ] <EOL> if not isinstance ( values , list ) : <EOL> values = [ values ] <EOL> for val in values : <EOL> if hasattr ( val , '<STR_LIT>' ) : <EOL> xml . append ( val . ToXml ( ) ) <EOL> else : <EOL> if val is None : <EOL> xml . append ( '<STR_LIT>' ) <EOL> else : <EOL> xml . append ( saxutils . escape ( unicode ( val ) ) ) <EOL> return xml <EOL> def ToPb ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _ToPb ( False ) <EOL> def _ToPb ( self , mark_key_as_saved = True ) : <EOL> """<STR_LIT>""" <EOL> pb = entity_pb . EntityProto ( ) <EOL> pb . mutable_key ( ) . CopyFrom ( self . key ( ) . _ToPb ( ) ) <EOL> last_path = pb . key ( ) . path ( ) . element_list ( ) [ - <NUM_LIT:1> ] <EOL> if mark_key_as_saved and last_path . has_name ( ) and last_path . has_id ( ) : <EOL> last_path . clear_id ( ) <EOL> group = pb . mutable_entity_group ( ) <EOL> if self . __key . has_id_or_name ( ) : <EOL> root = pb . key ( ) . path ( ) . element ( <NUM_LIT:0> ) <EOL> group . add_element ( ) . CopyFrom ( root ) <EOL> properties = self . items ( ) <EOL> properties . sort ( ) <EOL> for ( name , values ) in properties : <EOL> properties = datastore_types . ToPropertyPb ( name , values ) <EOL> if not isinstance ( properties , list ) : <EOL> properties = [ properties ] <EOL> for prop in properties : <EOL> if ( ( prop . has_meaning ( ) and <EOL> prop . meaning ( ) in datastore_types . _RAW_PROPERTY_MEANINGS ) or <EOL> name in self . unindexed_properties ( ) ) : <EOL> pb . raw_property_list ( ) . append ( prop ) <EOL> else : <EOL> pb . property_list ( ) . append ( prop ) <EOL> if pb . property_size ( ) > _MAX_INDEXED_PROPERTIES : <EOL> raise datastore_errors . BadRequestError ( <EOL> '<STR_LIT>' % self . key ( ) ) <EOL> return pb <EOL> @ staticmethod <EOL> def FromPb ( pb , validate_reserved_properties = True , <EOL> default_kind = '<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( pb , str ) : <EOL> real_pb = entity_pb . EntityProto ( ) <EOL> real_pb . ParsePartialFromString ( pb ) <EOL> pb = real_pb <EOL> return Entity . _FromPb ( <EOL> pb , require_valid_key = False , default_kind = default_kind ) <EOL> @ staticmethod <EOL> def _FromPb ( pb , require_valid_key = True , default_kind = '<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> if not pb . key ( ) . path ( ) . element_size ( ) : <EOL> pb . mutable_key ( ) . CopyFrom ( Key . from_path ( default_kind , <NUM_LIT:0> ) . _ToPb ( ) ) <EOL> last_path = pb . key ( ) . path ( ) . element_list ( ) [ - <NUM_LIT:1> ] <EOL> if require_valid_key : <EOL> assert last_path . has_id ( ) ^ last_path . has_name ( ) <EOL> if last_path . has_id ( ) : <EOL> assert last_path . id ( ) != <NUM_LIT:0> <EOL> else : <EOL> assert last_path . has_name ( ) <EOL> assert last_path . name ( ) <EOL> unindexed_properties = [ unicode ( p . name ( ) , '<STR_LIT:utf-8>' ) <EOL> for p in pb . raw_property_list ( ) ] <EOL> if pb . key ( ) . has_name_space ( ) : <EOL> namespace = pb . key ( ) . name_space ( ) <EOL> else : <EOL> namespace = '<STR_LIT>' <EOL> e = Entity ( unicode ( last_path . type ( ) , '<STR_LIT:utf-8>' ) , <EOL> unindexed_properties = unindexed_properties , <EOL> _app = pb . key ( ) . app ( ) , namespace = namespace ) <EOL> ref = e . __key . _Key__reference <EOL> ref . CopyFrom ( pb . key ( ) ) <EOL> temporary_values = { } <EOL> for prop_list in ( pb . property_list ( ) , pb . raw_property_list ( ) ) : <EOL> for prop in prop_list : <EOL> if prop . meaning ( ) == entity_pb . Property . INDEX_VALUE : <EOL> e . __projection = True <EOL> try : <EOL> value = datastore_types . FromPropertyPb ( prop ) <EOL> except ( AssertionError , AttributeError , TypeError , ValueError ) , e : <EOL> raise datastore_errors . Error ( <EOL> '<STR_LIT>' % <EOL> ( prop . name ( ) , traceback . format_exc ( ) ) ) <EOL> multiple = prop . multiple ( ) <EOL> if multiple : <EOL> value = [ value ] <EOL> name = prop . name ( ) <EOL> cur_value = temporary_values . get ( name ) <EOL> if cur_value is None : <EOL> temporary_values [ name ] = value <EOL> elif not multiple or not isinstance ( cur_value , list ) : <EOL> raise datastore_errors . Error ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' % name ) <EOL> else : <EOL> cur_value . extend ( value ) <EOL> for name , value in temporary_values . iteritems ( ) : <EOL> decoded_name = unicode ( name , '<STR_LIT:utf-8>' ) <EOL> datastore_types . ValidateReadProperty ( decoded_name , value ) <EOL> dict . __setitem__ ( e , decoded_name , value ) <EOL> return e <EOL> class Query ( dict ) : <EOL> """<STR_LIT>""" <EOL> ASCENDING = datastore_query . PropertyOrder . ASCENDING <EOL> DESCENDING = datastore_query . PropertyOrder . DESCENDING <EOL> ORDER_FIRST = datastore_query . QueryOptions . ORDER_FIRST <EOL> ANCESTOR_FIRST = datastore_query . QueryOptions . ANCESTOR_FIRST <EOL> FILTER_FIRST = datastore_query . QueryOptions . FILTER_FIRST <EOL> OPERATORS = { '<STR_LIT>' : datastore_query . PropertyFilter . _OPERATORS [ '<STR_LIT:=>' ] } <EOL> OPERATORS . update ( datastore_query . PropertyFilter . _OPERATORS ) <EOL> INEQUALITY_OPERATORS = datastore_query . PropertyFilter . _INEQUALITY_OPERATORS <EOL> UPPERBOUND_INEQUALITY_OPERATORS = frozenset ( [ '<STR_LIT:<>' , '<STR_LIT>' ] ) <EOL> FILTER_REGEX = re . compile ( <EOL> '<STR_LIT>' % '<STR_LIT:|>' . join ( OPERATORS ) , <EOL> re . IGNORECASE | re . UNICODE ) <EOL> __kind = None <EOL> __app = None <EOL> __namespace = None <EOL> __orderings = None <EOL> __ancestor_pb = None <EOL> __distinct = False <EOL> __group_by = None <EOL> __index_list_source = None <EOL> __cursor_source = None <EOL> __compiled_query_source = None <EOL> __filter_order = None <EOL> __filter_counter = <NUM_LIT:0> <EOL> __inequality_prop = None <EOL> __inequality_count = <NUM_LIT:0> <EOL> def __init__ ( self , kind = None , filters = { } , _app = None , keys_only = False , <EOL> compile = True , cursor = None , namespace = None , end_cursor = None , <EOL> projection = None , distinct = None , _namespace = None ) : <EOL> """<STR_LIT>""" <EOL> if namespace is None : <EOL> namespace = _namespace <EOL> elif _namespace is not None : <EOL> raise datastore_errors . BadArgumentError ( <EOL> "<STR_LIT>" ) <EOL> if kind is not None : <EOL> datastore_types . ValidateString ( kind , '<STR_LIT>' , <EOL> datastore_errors . BadArgumentError ) <EOL> self . __kind = kind <EOL> self . __orderings = [ ] <EOL> self . __filter_order = { } <EOL> self . update ( filters ) <EOL> self . __app = datastore_types . ResolveAppId ( _app ) <EOL> self . __namespace = datastore_types . ResolveNamespace ( namespace ) <EOL> self . __query_options = datastore_query . QueryOptions ( <EOL> keys_only = keys_only , <EOL> produce_cursors = compile , <EOL> start_cursor = cursor , <EOL> end_cursor = end_cursor , <EOL> projection = projection ) <EOL> if distinct : <EOL> if not self . __query_options . projection : <EOL> raise datastore_errors . BadQueryError ( <EOL> '<STR_LIT>' ) <EOL> self . __distinct = True <EOL> self . __group_by = self . __query_options . projection <EOL> def Order ( self , * orderings ) : <EOL> """<STR_LIT>""" <EOL> orderings = list ( orderings ) <EOL> for ( order , i ) in zip ( orderings , range ( len ( orderings ) ) ) : <EOL> if not ( isinstance ( order , basestring ) or <EOL> ( isinstance ( order , tuple ) and len ( order ) in [ <NUM_LIT:2> , <NUM_LIT:3> ] ) ) : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' % <EOL> ( order , typename ( order ) ) ) <EOL> if isinstance ( order , basestring ) : <EOL> order = ( order , ) <EOL> datastore_types . ValidateString ( order [ <NUM_LIT:0> ] , '<STR_LIT>' , <EOL> datastore_errors . BadArgumentError ) <EOL> property = order [ <NUM_LIT:0> ] <EOL> direction = order [ - <NUM_LIT:1> ] <EOL> if direction not in ( Query . ASCENDING , Query . DESCENDING ) : <EOL> if len ( order ) == <NUM_LIT:3> : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' % <EOL> str ( direction ) ) <EOL> direction = Query . ASCENDING <EOL> if ( self . __kind is None and <EOL> ( property != datastore_types . KEY_SPECIAL_PROPERTY or <EOL> direction != Query . ASCENDING ) ) : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' % <EOL> datastore_types . KEY_SPECIAL_PROPERTY ) <EOL> orderings [ i ] = ( property , direction ) <EOL> if ( orderings and self . __inequality_prop and <EOL> orderings [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] != self . __inequality_prop ) : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' % <EOL> ( orderings [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] , self . __inequality_prop ) ) <EOL> self . __orderings = orderings <EOL> return self <EOL> def Hint ( self , hint ) : <EOL> """<STR_LIT>""" <EOL> if hint is not self . __query_options . hint : <EOL> self . __query_options = datastore_query . QueryOptions ( <EOL> hint = hint , config = self . __query_options ) <EOL> return self <EOL> def Ancestor ( self , ancestor ) : <EOL> """<STR_LIT>""" <EOL> self . __ancestor_pb = _GetCompleteKeyOrError ( ancestor ) . _ToPb ( ) <EOL> return self <EOL> def IsKeysOnly ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __query_options . keys_only <EOL> def GetQueryOptions ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __query_options <EOL> def GetQuery ( self ) : <EOL> """<STR_LIT>""" <EOL> return datastore_query . Query ( app = self . __app , <EOL> namespace = self . __namespace , <EOL> kind = self . __kind , <EOL> ancestor = self . __ancestor_pb , <EOL> filter_predicate = self . GetFilterPredicate ( ) , <EOL> order = self . GetOrder ( ) , <EOL> group_by = self . __group_by ) <EOL> def GetOrder ( self ) : <EOL> """<STR_LIT>""" <EOL> orders = [ datastore_query . PropertyOrder ( property , direction ) <EOL> for property , direction in self . __orderings ] <EOL> if orders : <EOL> return datastore_query . CompositeOrder ( orders ) <EOL> return None <EOL> def GetFilterPredicate ( self ) : <EOL> """<STR_LIT>""" <EOL> ordered_filters = [ ( i , f ) for f , i in self . __filter_order . iteritems ( ) ] <EOL> ordered_filters . sort ( ) <EOL> property_filters = [ ] <EOL> for _ , filter_str in ordered_filters : <EOL> if filter_str not in self : <EOL> continue <EOL> values = self [ filter_str ] <EOL> match = self . _CheckFilter ( filter_str , values ) <EOL> name = match . group ( <NUM_LIT:1> ) <EOL> op = match . group ( <NUM_LIT:3> ) <EOL> if op is None or op == '<STR_LIT>' : <EOL> op = '<STR_LIT:=>' <EOL> property_filters . append ( datastore_query . make_filter ( name , op , values ) ) <EOL> if property_filters : <EOL> return datastore_query . CompositeFilter ( <EOL> datastore_query . CompositeFilter . AND , <EOL> property_filters ) <EOL> return None <EOL> def GetDistinct ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __distinct <EOL> def GetIndexList ( self ) : <EOL> """<STR_LIT>""" <EOL> index_list_function = self . __index_list_source <EOL> if index_list_function : <EOL> return index_list_function ( ) <EOL> raise AssertionError ( '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> def GetCursor ( self ) : <EOL> """<STR_LIT>""" <EOL> cursor_function = self . __cursor_source <EOL> if cursor_function : <EOL> cursor = cursor_function ( ) <EOL> if cursor : <EOL> return cursor <EOL> raise AssertionError ( '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> def GetBatcher ( self , config = None ) : <EOL> """<STR_LIT>""" <EOL> query_options = self . GetQueryOptions ( ) . merge ( config ) <EOL> if self . __distinct and query_options . projection != self . __group_by : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' ) <EOL> return self . GetQuery ( ) . run ( _GetConnection ( ) , query_options ) <EOL> def Run ( self , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> config = _GetConfigFromKwargs ( kwargs , convert_rpc = True , <EOL> config_class = datastore_query . QueryOptions ) <EOL> itr = Iterator ( self . GetBatcher ( config = config ) ) <EOL> self . __index_list_source = itr . GetIndexList <EOL> self . __cursor_source = itr . cursor <EOL> self . __compiled_query_source = itr . _compiled_query <EOL> return itr <EOL> def Get ( self , limit , offset = <NUM_LIT:0> , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> if limit is None : <EOL> kwargs . setdefault ( '<STR_LIT>' , _MAX_INT_32 ) <EOL> return list ( self . Run ( limit = limit , offset = offset , ** kwargs ) ) <EOL> def Count ( self , limit = <NUM_LIT:1000> , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> original_offset = kwargs . pop ( '<STR_LIT>' , <NUM_LIT:0> ) <EOL> if limit is None : <EOL> offset = _MAX_INT_32 <EOL> else : <EOL> offset = min ( limit + original_offset , _MAX_INT_32 ) <EOL> kwargs [ '<STR_LIT>' ] = <NUM_LIT:0> <EOL> kwargs [ '<STR_LIT>' ] = offset <EOL> config = _GetConfigFromKwargs ( kwargs , convert_rpc = True , <EOL> config_class = datastore_query . QueryOptions ) <EOL> batch = self . GetBatcher ( config = config ) . next ( ) <EOL> self . __index_list_source = ( <EOL> lambda : [ index for index , state in batch . index_list ] ) <EOL> self . __cursor_source = lambda : batch . cursor ( <NUM_LIT:0> ) <EOL> self . __compiled_query_source = lambda : batch . _compiled_query <EOL> return max ( <NUM_LIT:0> , batch . skipped_results - original_offset ) <EOL> def __iter__ ( self ) : <EOL> raise NotImplementedError ( <EOL> '<STR_LIT>' ) <EOL> def __getstate__ ( self ) : <EOL> state = self . __dict__ . copy ( ) <EOL> state [ '<STR_LIT>' ] = None <EOL> state [ '<STR_LIT>' ] = None <EOL> state [ '<STR_LIT>' ] = None <EOL> return state <EOL> def __setstate__ ( self , state ) : <EOL> if '<STR_LIT>' not in state : <EOL> state [ '<STR_LIT>' ] = datastore_query . QueryOptions ( <EOL> keys_only = state . pop ( '<STR_LIT>' ) , <EOL> produce_cursors = state . pop ( '<STR_LIT>' ) , <EOL> start_cursor = state . pop ( '<STR_LIT>' ) , <EOL> end_cursor = state . pop ( '<STR_LIT>' ) ) <EOL> self . __dict__ = state <EOL> def __setitem__ ( self , filter , value ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( value , tuple ) : <EOL> value = list ( value ) <EOL> datastore_types . ValidateProperty ( '<STR_LIT:U+0020>' , value ) <EOL> match = self . _CheckFilter ( filter , value ) <EOL> property = match . group ( <NUM_LIT:1> ) <EOL> operator = match . group ( <NUM_LIT:3> ) <EOL> dict . __setitem__ ( self , filter , value ) <EOL> if ( operator in self . INEQUALITY_OPERATORS and <EOL> property != datastore_types . _UNAPPLIED_LOG_TIMESTAMP_SPECIAL_PROPERTY ) : <EOL> if self . __inequality_prop is None : <EOL> self . __inequality_prop = property <EOL> else : <EOL> assert self . __inequality_prop == property <EOL> self . __inequality_count += <NUM_LIT:1> <EOL> if filter not in self . __filter_order : <EOL> self . __filter_order [ filter ] = self . __filter_counter <EOL> self . __filter_counter += <NUM_LIT:1> <EOL> def setdefault ( self , filter , value ) : <EOL> """<STR_LIT>""" <EOL> datastore_types . ValidateProperty ( '<STR_LIT:U+0020>' , value ) <EOL> self . _CheckFilter ( filter , value ) <EOL> return dict . setdefault ( self , filter , value ) <EOL> def __delitem__ ( self , filter ) : <EOL> """<STR_LIT>""" <EOL> dict . __delitem__ ( self , filter ) <EOL> del self . __filter_order [ filter ] <EOL> match = Query . FILTER_REGEX . match ( filter ) <EOL> property = match . group ( <NUM_LIT:1> ) <EOL> operator = match . group ( <NUM_LIT:3> ) <EOL> if operator in self . INEQUALITY_OPERATORS : <EOL> assert self . __inequality_count >= <NUM_LIT:1> <EOL> assert property == self . __inequality_prop <EOL> self . __inequality_count -= <NUM_LIT:1> <EOL> if self . __inequality_count == <NUM_LIT:0> : <EOL> self . __inequality_prop = None <EOL> def update ( self , other ) : <EOL> """<STR_LIT>""" <EOL> for filter , value in other . items ( ) : <EOL> self . __setitem__ ( filter , value ) <EOL> def copy ( self ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError ( '<STR_LIT>' ) <EOL> def _CheckFilter ( self , filter , values ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> match = Query . FILTER_REGEX . match ( filter ) <EOL> if not match : <EOL> raise datastore_errors . BadFilterError ( <EOL> '<STR_LIT>' % str ( filter ) ) <EOL> except TypeError : <EOL> raise datastore_errors . BadFilterError ( <EOL> '<STR_LIT>' % str ( filter ) ) <EOL> property = match . group ( <NUM_LIT:1> ) <EOL> operator = match . group ( <NUM_LIT:3> ) <EOL> if operator is None : <EOL> operator = '<STR_LIT:=>' <EOL> if isinstance ( values , tuple ) : <EOL> values = list ( values ) <EOL> elif not isinstance ( values , list ) : <EOL> values = [ values ] <EOL> if isinstance ( values [ <NUM_LIT:0> ] , datastore_types . _RAW_PROPERTY_TYPES ) : <EOL> raise datastore_errors . BadValueError ( <EOL> '<STR_LIT>' % typename ( values [ <NUM_LIT:0> ] ) ) <EOL> if ( operator in self . INEQUALITY_OPERATORS and <EOL> property != datastore_types . _UNAPPLIED_LOG_TIMESTAMP_SPECIAL_PROPERTY ) : <EOL> if self . __inequality_prop and property != self . __inequality_prop : <EOL> raise datastore_errors . BadFilterError ( <EOL> '<STR_LIT>' % <EOL> '<STR_LIT:U+002CU+0020>' . join ( self . INEQUALITY_OPERATORS ) ) <EOL> elif len ( self . __orderings ) >= <NUM_LIT:1> and self . __orderings [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] != property : <EOL> raise datastore_errors . BadFilterError ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' % <EOL> '<STR_LIT:U+002CU+0020>' . join ( self . INEQUALITY_OPERATORS ) ) <EOL> if ( self . __kind is None and <EOL> property != datastore_types . KEY_SPECIAL_PROPERTY and <EOL> property != datastore_types . _UNAPPLIED_LOG_TIMESTAMP_SPECIAL_PROPERTY ) : <EOL> raise datastore_errors . BadFilterError ( <EOL> '<STR_LIT>' % <EOL> datastore_types . KEY_SPECIAL_PROPERTY ) <EOL> if property == datastore_types . _UNAPPLIED_LOG_TIMESTAMP_SPECIAL_PROPERTY : <EOL> if self . __kind : <EOL> raise datastore_errors . BadFilterError ( <EOL> '<STR_LIT>' % <EOL> datastore_types . _UNAPPLIED_LOG_TIMESTAMP_SPECIAL_PROPERTY ) <EOL> if not operator in self . UPPERBOUND_INEQUALITY_OPERATORS : <EOL> raise datastore_errors . BadFilterError ( <EOL> '<STR_LIT>' % ( <EOL> self . UPPERBOUND_INEQUALITY_OPERATORS , <EOL> datastore_types . _UNAPPLIED_LOG_TIMESTAMP_SPECIAL_PROPERTY ) ) <EOL> if property in datastore_types . _SPECIAL_PROPERTIES : <EOL> if property == datastore_types . KEY_SPECIAL_PROPERTY : <EOL> for value in values : <EOL> if not isinstance ( value , Key ) : <EOL> raise datastore_errors . BadFilterError ( <EOL> '<STR_LIT>' % <EOL> ( datastore_types . KEY_SPECIAL_PROPERTY , value , typename ( value ) ) ) <EOL> return match <EOL> def _Run ( self , limit = None , offset = None , <EOL> prefetch_count = None , next_count = None , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return self . Run ( limit = limit , offset = offset , <EOL> prefetch_size = prefetch_count , batch_size = next_count , <EOL> ** kwargs ) <EOL> def _ToPb ( self , limit = None , offset = None , count = None ) : <EOL> query_options = datastore_query . QueryOptions ( <EOL> config = self . GetQueryOptions ( ) , <EOL> limit = limit , <EOL> offset = offset , <EOL> batch_size = count ) <EOL> return self . GetQuery ( ) . _to_pb ( _GetConnection ( ) , query_options ) <EOL> def _GetCompiledQuery ( self ) : <EOL> """<STR_LIT>""" <EOL> compiled_query_function = self . __compiled_query_source <EOL> if compiled_query_function : <EOL> compiled_query = compiled_query_function ( ) <EOL> if compiled_query : <EOL> return compiled_query <EOL> raise AssertionError ( '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> GetCompiledQuery = _GetCompiledQuery <EOL> GetCompiledCursor = GetCursor <EOL> def AllocateIdsAsync ( model_key , size = None , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> max = kwargs . pop ( '<STR_LIT>' , None ) <EOL> config = _GetConfigFromKwargs ( kwargs ) <EOL> if getattr ( config , '<STR_LIT>' , None ) == EVENTUAL_CONSISTENCY : <EOL> raise datastore_errors . BadRequestError ( <EOL> '<STR_LIT>' ) <EOL> keys , _ = NormalizeAndTypeCheckKeys ( model_key ) <EOL> if len ( keys ) > <NUM_LIT:1> : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' ) <EOL> rpc = _GetConnection ( ) . async_allocate_ids ( config , keys [ <NUM_LIT:0> ] , size , max ) <EOL> return rpc <EOL> def AllocateIds ( model_key , size = None , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return AllocateIdsAsync ( model_key , size , ** kwargs ) . get_result ( ) <EOL> class MultiQuery ( Query ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , bound_queries , orderings ) : <EOL> if len ( bound_queries ) > MAX_ALLOWABLE_QUERIES : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' % <EOL> ( MAX_ALLOWABLE_QUERIES , len ( bound_queries ) ) ) <EOL> projection = ( bound_queries and <EOL> bound_queries [ <NUM_LIT:0> ] . GetQueryOptions ( ) . projection ) <EOL> for query in bound_queries : <EOL> if projection != query . GetQueryOptions ( ) . projection : <EOL> raise datastore_errors . BadQueryError ( <EOL> '<STR_LIT>' ) <EOL> if query . IsKeysOnly ( ) : <EOL> raise datastore_errors . BadQueryError ( <EOL> '<STR_LIT>' ) <EOL> self . __projection = projection <EOL> self . __bound_queries = bound_queries <EOL> self . __orderings = orderings <EOL> self . __compile = False <EOL> def __str__ ( self ) : <EOL> res = '<STR_LIT>' <EOL> for query in self . __bound_queries : <EOL> res = '<STR_LIT>' % ( res , str ( query ) ) <EOL> return res <EOL> def Get ( self , limit , offset = <NUM_LIT:0> , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> if limit is None : <EOL> kwargs . setdefault ( '<STR_LIT>' , _MAX_INT_32 ) <EOL> return list ( self . Run ( limit = limit , offset = offset , ** kwargs ) ) <EOL> class SortOrderEntity ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , entity_iterator , orderings ) : <EOL> """<STR_LIT>""" <EOL> self . __entity_iterator = entity_iterator <EOL> self . __entity = None <EOL> self . __min_max_value_cache = { } <EOL> try : <EOL> self . __entity = entity_iterator . next ( ) <EOL> except StopIteration : <EOL> pass <EOL> else : <EOL> self . __orderings = orderings <EOL> def __str__ ( self ) : <EOL> return str ( self . __entity ) <EOL> def GetEntity ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __entity <EOL> def GetNext ( self ) : <EOL> """<STR_LIT>""" <EOL> return MultiQuery . SortOrderEntity ( self . __entity_iterator , <EOL> self . __orderings ) <EOL> def CmpProperties ( self , that ) : <EOL> """<STR_LIT>""" <EOL> if not self . __entity : <EOL> return cmp ( self . __entity , that . __entity ) <EOL> for ( identifier , order ) in self . __orderings : <EOL> value1 = self . __GetValueForId ( self , identifier , order ) <EOL> value2 = self . __GetValueForId ( that , identifier , order ) <EOL> result = cmp ( value1 , value2 ) <EOL> if order == Query . DESCENDING : <EOL> result = - result <EOL> if result : <EOL> return result <EOL> return <NUM_LIT:0> <EOL> def __GetValueForId ( self , sort_order_entity , identifier , sort_order ) : <EOL> value = _GetPropertyValue ( sort_order_entity . __entity , identifier ) <EOL> if isinstance ( value , list ) : <EOL> entity_key = sort_order_entity . __entity . key ( ) <EOL> if ( entity_key , identifier ) in self . __min_max_value_cache : <EOL> value = self . __min_max_value_cache [ ( entity_key , identifier ) ] <EOL> elif sort_order == Query . DESCENDING : <EOL> value = min ( value ) <EOL> else : <EOL> value = max ( value ) <EOL> self . __min_max_value_cache [ ( entity_key , identifier ) ] = value <EOL> return value <EOL> def __cmp__ ( self , that ) : <EOL> """<STR_LIT>""" <EOL> property_compare = self . CmpProperties ( that ) <EOL> if property_compare : <EOL> return property_compare <EOL> else : <EOL> return cmp ( self . __entity . key ( ) , that . __entity . key ( ) ) <EOL> def _ExtractBounds ( self , config ) : <EOL> """<STR_LIT>""" <EOL> if config is None : <EOL> return <NUM_LIT:0> , None , None <EOL> lower_bound = config . offset or <NUM_LIT:0> <EOL> upper_bound = config . limit <EOL> if lower_bound : <EOL> if upper_bound is not None : <EOL> upper_bound = min ( lower_bound + upper_bound , _MAX_INT_32 ) <EOL> config = datastore_query . QueryOptions ( offset = <NUM_LIT:0> , <EOL> limit = upper_bound , <EOL> config = config ) <EOL> return lower_bound , upper_bound , config <EOL> def __GetProjectionOverride ( self , config ) : <EOL> """<STR_LIT>""" <EOL> projection = datastore_query . QueryOptions . projection ( config ) <EOL> if projection is None : <EOL> projection = self . __projection <EOL> else : <EOL> projection = projection <EOL> if not projection : <EOL> return None , None <EOL> override = set ( ) <EOL> for prop , _ in self . __orderings : <EOL> if prop not in projection : <EOL> override . add ( prop ) <EOL> if not override : <EOL> return projection , None <EOL> return projection , projection + tuple ( override ) <EOL> def Run ( self , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> config = _GetConfigFromKwargs ( kwargs , convert_rpc = True , <EOL> config_class = datastore_query . QueryOptions ) <EOL> if config and config . keys_only : <EOL> raise datastore_errors . BadRequestError ( <EOL> '<STR_LIT>' ) <EOL> lower_bound , upper_bound , config = self . _ExtractBounds ( config ) <EOL> projection , override = self . __GetProjectionOverride ( config ) <EOL> if override : <EOL> config = datastore_query . QueryOptions ( projection = override , config = config ) <EOL> results = [ ] <EOL> count = <NUM_LIT:1> <EOL> log_level = logging . DEBUG - <NUM_LIT:1> <EOL> for bound_query in self . __bound_queries : <EOL> logging . log ( log_level , '<STR_LIT>' % count ) <EOL> results . append ( bound_query . Run ( config = config ) ) <EOL> count += <NUM_LIT:1> <EOL> def GetDedupeKey ( sort_order_entity ) : <EOL> if projection : <EOL> return ( sort_order_entity . GetEntity ( ) . key ( ) , <EOL> frozenset ( sort_order_entity . GetEntity ( ) . iteritems ( ) ) ) <EOL> else : <EOL> return sort_order_entity . GetEntity ( ) . key ( ) <EOL> def IterateResults ( results ) : <EOL> """<STR_LIT>""" <EOL> result_heap = [ ] <EOL> for result in results : <EOL> heap_value = MultiQuery . SortOrderEntity ( result , self . __orderings ) <EOL> if heap_value . GetEntity ( ) : <EOL> heapq . heappush ( result_heap , heap_value ) <EOL> used_keys = set ( ) <EOL> while result_heap : <EOL> if upper_bound is not None and len ( used_keys ) >= upper_bound : <EOL> break <EOL> top_result = heapq . heappop ( result_heap ) <EOL> dedupe_key = GetDedupeKey ( top_result ) <EOL> if dedupe_key not in used_keys : <EOL> result = top_result . GetEntity ( ) <EOL> if override : <EOL> for key in result . keys ( ) : <EOL> if key not in projection : <EOL> del result [ key ] <EOL> yield result <EOL> else : <EOL> pass <EOL> used_keys . add ( dedupe_key ) <EOL> results_to_push = [ ] <EOL> while result_heap : <EOL> next = heapq . heappop ( result_heap ) <EOL> if dedupe_key != GetDedupeKey ( next ) : <EOL> results_to_push . append ( next ) <EOL> break <EOL> else : <EOL> results_to_push . append ( next . GetNext ( ) ) <EOL> results_to_push . append ( top_result . GetNext ( ) ) <EOL> for popped_result in results_to_push : <EOL> if popped_result . GetEntity ( ) : <EOL> heapq . heappush ( result_heap , popped_result ) <EOL> it = IterateResults ( results ) <EOL> try : <EOL> for _ in xrange ( lower_bound ) : <EOL> it . next ( ) <EOL> except StopIteration : <EOL> pass <EOL> return it <EOL> def Count ( self , limit = <NUM_LIT:1000> , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> kwargs [ '<STR_LIT>' ] = limit <EOL> config = _GetConfigFromKwargs ( kwargs , convert_rpc = True , <EOL> config_class = datastore_query . QueryOptions ) <EOL> projection , override = self . __GetProjectionOverride ( config ) <EOL> if not projection : <EOL> config = datastore_query . QueryOptions ( keys_only = True , config = config ) <EOL> elif override : <EOL> config = datastore_query . QueryOptions ( projection = override , config = config ) <EOL> lower_bound , upper_bound , config = self . _ExtractBounds ( config ) <EOL> used_keys = set ( ) <EOL> for bound_query in self . __bound_queries : <EOL> for result in bound_query . Run ( config = config ) : <EOL> if projection : <EOL> dedupe_key = ( result . key ( ) , <EOL> tuple ( result . iteritems ( ) ) ) <EOL> else : <EOL> dedupe_key = result <EOL> used_keys . add ( dedupe_key ) <EOL> if upper_bound and len ( used_keys ) >= upper_bound : <EOL> return upper_bound - lower_bound <EOL> return max ( <NUM_LIT:0> , len ( used_keys ) - lower_bound ) <EOL> def GetIndexList ( self ) : <EOL> raise AssertionError ( '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> def GetCursor ( self ) : <EOL> raise AssertionError ( '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> def _GetCompiledQuery ( self ) : <EOL> """<STR_LIT>""" <EOL> raise AssertionError ( '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> def __setitem__ ( self , query_filter , value ) : <EOL> """<STR_LIT>""" <EOL> saved_items = [ ] <EOL> for index , query in enumerate ( self . __bound_queries ) : <EOL> saved_items . append ( query . get ( query_filter , None ) ) <EOL> try : <EOL> query [ query_filter ] = value <EOL> except : <EOL> for q , old_value in itertools . izip ( self . __bound_queries [ : index ] , <EOL> saved_items ) : <EOL> if old_value is not None : <EOL> q [ query_filter ] = old_value <EOL> else : <EOL> del q [ query_filter ] <EOL> raise <EOL> def __delitem__ ( self , query_filter ) : <EOL> """<STR_LIT>""" <EOL> subquery_count = len ( self . __bound_queries ) <EOL> keyerror_count = <NUM_LIT:0> <EOL> saved_items = [ ] <EOL> for index , query in enumerate ( self . __bound_queries ) : <EOL> try : <EOL> saved_items . append ( query . get ( query_filter , None ) ) <EOL> del query [ query_filter ] <EOL> except KeyError : <EOL> keyerror_count += <NUM_LIT:1> <EOL> except : <EOL> for q , old_value in itertools . izip ( self . __bound_queries [ : index ] , <EOL> saved_items ) : <EOL> if old_value is not None : <EOL> q [ query_filter ] = old_value <EOL> raise <EOL> if keyerror_count == subquery_count : <EOL> raise KeyError ( query_filter ) <EOL> def __iter__ ( self ) : <EOL> return iter ( self . __bound_queries ) <EOL> GetCompiledCursor = GetCursor <EOL> GetCompiledQuery = _GetCompiledQuery <EOL> def RunInTransaction ( function , * args , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return RunInTransactionOptions ( None , function , * args , ** kwargs ) <EOL> def RunInTransactionCustomRetries ( retries , function , * args , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> options = datastore_rpc . TransactionOptions ( retries = retries ) <EOL> return RunInTransactionOptions ( options , function , * args , ** kwargs ) <EOL> def RunInTransactionOptions ( options , function , * args , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> options = datastore_rpc . TransactionOptions ( options ) <EOL> if IsInTransaction ( ) : <EOL> if options . propagation in ( None , datastore_rpc . TransactionOptions . NESTED ) : <EOL> raise datastore_errors . BadRequestError ( <EOL> '<STR_LIT>' ) <EOL> elif options . propagation is datastore_rpc . TransactionOptions . INDEPENDENT : <EOL> txn_connection = _GetConnection ( ) <EOL> _SetConnection ( _thread_local . old_connection ) <EOL> try : <EOL> return RunInTransactionOptions ( options , function , * args , ** kwargs ) <EOL> finally : <EOL> _SetConnection ( txn_connection ) <EOL> return function ( * args , ** kwargs ) <EOL> if options . propagation is datastore_rpc . TransactionOptions . MANDATORY : <EOL> raise datastore_errors . BadRequestError ( <EOL> '<STR_LIT>' ) <EOL> retries = options . retries <EOL> if retries is None : <EOL> retries = DEFAULT_TRANSACTION_RETRIES <EOL> _thread_local . old_connection = _GetConnection ( ) <EOL> for _ in range ( <NUM_LIT:0> , retries + <NUM_LIT:1> ) : <EOL> new_connection = _thread_local . old_connection . new_transaction ( options ) <EOL> _SetConnection ( new_connection ) <EOL> try : <EOL> ok , result = _DoOneTry ( new_connection , function , args , kwargs ) <EOL> if ok : <EOL> return result <EOL> finally : <EOL> _SetConnection ( _thread_local . old_connection ) <EOL> raise datastore_errors . TransactionFailedError ( <EOL> '<STR_LIT>' ) <EOL> def _DoOneTry ( new_connection , function , args , kwargs ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> result = function ( * args , ** kwargs ) <EOL> except : <EOL> original_exception = sys . exc_info ( ) <EOL> try : <EOL> new_connection . rollback ( ) <EOL> except Exception : <EOL> logging . exception ( '<STR_LIT>' ) <EOL> type , value , trace = original_exception <EOL> if isinstance ( value , datastore_errors . Rollback ) : <EOL> return True , None <EOL> else : <EOL> raise type , value , trace <EOL> else : <EOL> if new_connection . commit ( ) : <EOL> return True , result <EOL> else : <EOL> logging . warning ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> return False , None <EOL> def _MaybeSetupTransaction ( request , keys ) : <EOL> """<STR_LIT>""" <EOL> return _GetConnection ( ) . _set_request_transaction ( request ) <EOL> def IsInTransaction ( ) : <EOL> """<STR_LIT>""" <EOL> return isinstance ( _GetConnection ( ) , datastore_rpc . TransactionalConnection ) <EOL> def Transactional ( _func = None , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> if _func is not None : <EOL> return Transactional ( ) ( _func ) <EOL> if not kwargs . pop ( '<STR_LIT>' , None ) : <EOL> kwargs . setdefault ( '<STR_LIT>' , datastore_rpc . TransactionOptions . ALLOWED ) <EOL> options = datastore_rpc . TransactionOptions ( ** kwargs ) <EOL> def outer_wrapper ( func ) : <EOL> def inner_wrapper ( * args , ** kwds ) : <EOL> return RunInTransactionOptions ( options , func , * args , ** kwds ) <EOL> return inner_wrapper <EOL> return outer_wrapper <EOL> @ datastore_rpc . _positional ( <NUM_LIT:1> ) <EOL> def NonTransactional ( _func = None , allow_existing = True ) : <EOL> """<STR_LIT>""" <EOL> if _func is not None : <EOL> return NonTransactional ( ) ( _func ) <EOL> def outer_wrapper ( func ) : <EOL> def inner_wrapper ( * args , ** kwds ) : <EOL> if not IsInTransaction ( ) : <EOL> return func ( * args , ** kwds ) <EOL> if not allow_existing : <EOL> raise datastore_errors . BadRequestError ( <EOL> '<STR_LIT>' ) <EOL> txn_connection = _GetConnection ( ) <EOL> _SetConnection ( _thread_local . old_connection ) <EOL> try : <EOL> return func ( * args , ** kwds ) <EOL> finally : <EOL> _SetConnection ( txn_connection ) <EOL> return inner_wrapper <EOL> return outer_wrapper <EOL> def _GetCompleteKeyOrError ( arg ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( arg , Key ) : <EOL> key = arg <EOL> elif isinstance ( arg , basestring ) : <EOL> key = Key ( arg ) <EOL> elif isinstance ( arg , Entity ) : <EOL> key = arg . key ( ) <EOL> elif not isinstance ( arg , Key ) : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' % <EOL> ( arg , typename ( arg ) ) ) <EOL> assert isinstance ( key , Key ) <EOL> if not key . has_id_or_name ( ) : <EOL> raise datastore_errors . BadKeyError ( '<STR_LIT>' % key ) <EOL> return key <EOL> def _GetPropertyValue ( entity , property ) : <EOL> """<STR_LIT>""" <EOL> if property in datastore_types . _SPECIAL_PROPERTIES : <EOL> if property == datastore_types . _UNAPPLIED_LOG_TIMESTAMP_SPECIAL_PROPERTY : <EOL> raise KeyError ( property ) <EOL> assert property == datastore_types . KEY_SPECIAL_PROPERTY <EOL> return entity . key ( ) <EOL> else : <EOL> return entity [ property ] <EOL> def _AddOrAppend ( dictionary , key , value ) : <EOL> """<STR_LIT>""" <EOL> if key in dictionary : <EOL> existing_value = dictionary [ key ] <EOL> if isinstance ( existing_value , list ) : <EOL> existing_value . append ( value ) <EOL> else : <EOL> dictionary [ key ] = [ existing_value , value ] <EOL> else : <EOL> dictionary [ key ] = value <EOL> class Iterator ( datastore_query . ResultsIterator ) : <EOL> """<STR_LIT>""" <EOL> def _Next ( self , count = None ) : <EOL> if count is None : <EOL> count = <NUM_LIT:20> <EOL> result = [ ] <EOL> for r in self : <EOL> if len ( result ) >= count : <EOL> break <EOL> result . append ( r ) <EOL> return result <EOL> def GetCompiledCursor ( self , query ) : <EOL> return self . cursor ( ) <EOL> def GetIndexList ( self ) : <EOL> """<STR_LIT>""" <EOL> tuple_index_list = super ( Iterator , self ) . index_list ( ) <EOL> return [ index for index , state in tuple_index_list ] <EOL> _Get = _Next <EOL> index_list = GetIndexList <EOL> DatastoreRPC = apiproxy_stub_map . UserRPC <EOL> GetRpcFromKwargs = _GetConfigFromKwargs <EOL> _CurrentTransactionKey = IsInTransaction <EOL> _ToDatastoreError = datastore_rpc . _ToDatastoreError <EOL> _DatastoreExceptionFromErrorCodeAndDetail = datastore_rpc . _DatastoreExceptionFromErrorCodeAndDetail </s>

<s> """<STR_LIT>""" <EOL> import google <EOL> from google . appengine . api import validation <EOL> from google . appengine . api import yaml_builder <EOL> from google . appengine . api import yaml_listener <EOL> from google . appengine . api import yaml_object <EOL> _URL_BLACKLIST_REGEX = r'<STR_LIT>' <EOL> _REWRITER_NAME_REGEX = r'<STR_LIT>' <EOL> _DOMAINS_TO_REWRITE_REGEX = r'<STR_LIT>' <EOL> URL_BLACKLIST = '<STR_LIT>' <EOL> ENABLED_REWRITERS = '<STR_LIT>' <EOL> DISABLED_REWRITERS = '<STR_LIT>' <EOL> DOMAINS_TO_REWRITE = '<STR_LIT>' <EOL> class MalformedPagespeedConfiguration ( Exception ) : <EOL> """<STR_LIT>""" <EOL> class PagespeedEntry ( validation . Validated ) : <EOL> """<STR_LIT>""" <EOL> ATTRIBUTES = { <EOL> URL_BLACKLIST : validation . Optional ( <EOL> validation . Repeated ( validation . Regex ( _URL_BLACKLIST_REGEX ) ) ) , <EOL> ENABLED_REWRITERS : validation . Optional ( <EOL> validation . Repeated ( validation . Regex ( _REWRITER_NAME_REGEX ) ) ) , <EOL> DISABLED_REWRITERS : validation . Optional ( <EOL> validation . Repeated ( validation . Regex ( _REWRITER_NAME_REGEX ) ) ) , <EOL> DOMAINS_TO_REWRITE : validation . Optional ( <EOL> validation . Repeated ( validation . Regex ( _DOMAINS_TO_REWRITE_REGEX ) ) ) , <EOL> } <EOL> def LoadPagespeedEntry ( pagespeed_entry , open_fn = None ) : <EOL> """<STR_LIT>""" <EOL> builder = yaml_object . ObjectBuilder ( PagespeedEntry ) <EOL> handler = yaml_builder . BuilderHandler ( builder ) <EOL> listener = yaml_listener . EventListener ( handler ) <EOL> listener . Parse ( pagespeed_entry ) <EOL> parsed_yaml = handler . GetResults ( ) <EOL> if not parsed_yaml : <EOL> return PagespeedEntry ( ) <EOL> if len ( parsed_yaml ) > <NUM_LIT:1> : <EOL> raise MalformedPagespeedConfiguration ( <EOL> '<STR_LIT>' ) <EOL> return parsed_yaml [ <NUM_LIT:0> ] </s>

<s> """<STR_LIT>""" <EOL> from search import AtomField <EOL> from search import Cursor <EOL> from search import DateField <EOL> from search import DeleteError <EOL> from search import DeleteResult <EOL> from search import Document <EOL> from search import DOCUMENT_ID_FIELD_NAME <EOL> from search import Error <EOL> from search import ExpressionError <EOL> from search import Field <EOL> from search import FieldExpression <EOL> from search import GeoField <EOL> from search import GeoPoint <EOL> from search import get_indexes <EOL> from search import GetResponse <EOL> from search import HtmlField <EOL> from search import Index <EOL> from search import InternalError <EOL> from search import InvalidRequest <EOL> from search import LANGUAGE_FIELD_NAME <EOL> from search import MatchScorer <EOL> from search import MAXIMUM_DOCUMENT_ID_LENGTH <EOL> from search import MAXIMUM_DOCUMENTS_PER_PUT_REQUEST <EOL> from search import MAXIMUM_DOCUMENTS_RETURNED_PER_SEARCH <EOL> from search import MAXIMUM_EXPRESSION_LENGTH <EOL> from search import MAXIMUM_FIELD_ATOM_LENGTH <EOL> from search import MAXIMUM_FIELD_NAME_LENGTH <EOL> from search import MAXIMUM_FIELD_VALUE_LENGTH <EOL> from search import MAXIMUM_FIELDS_RETURNED_PER_SEARCH <EOL> from search import MAXIMUM_GET_INDEXES_OFFSET <EOL> from search import MAXIMUM_INDEX_NAME_LENGTH <EOL> from search import MAXIMUM_INDEXES_RETURNED_PER_GET_REQUEST <EOL> from search import MAXIMUM_NUMBER_FOUND_ACCURACY <EOL> from search import MAXIMUM_QUERY_LENGTH <EOL> from search import MAXIMUM_SEARCH_OFFSET <EOL> from search import MAXIMUM_SORTED_DOCUMENTS <EOL> from search import NumberField <EOL> from search import OperationResult <EOL> from search import PutError <EOL> from search import PutResult <EOL> from search import Query <EOL> from search import QueryError <EOL> from search import QueryOptions <EOL> from search import RANK_FIELD_NAME <EOL> from search import RescoringMatchScorer <EOL> from search import SCORE_FIELD_NAME <EOL> from search import ScoredDocument <EOL> from search import SearchResults <EOL> from search import SortExpression <EOL> from search import SortOptions <EOL> from search import TextField <EOL> from search import TIMESTAMP_FIELD_NAME <EOL> from search import TransientError </s>

<s> """<STR_LIT>""" <EOL> from __future__ import with_statement <EOL> __all__ = [ ] <EOL> import base64 <EOL> import bisect <EOL> import calendar <EOL> import datetime <EOL> import logging <EOL> import os <EOL> import random <EOL> import string <EOL> import threading <EOL> import time <EOL> import taskqueue_service_pb <EOL> import taskqueue <EOL> from google . appengine . api import api_base_pb <EOL> from google . appengine . api import apiproxy_stub <EOL> from google . appengine . api import apiproxy_stub_map <EOL> from google . appengine . api import queueinfo <EOL> from google . appengine . api import request_info <EOL> from google . appengine . api . taskqueue import taskqueue <EOL> from google . appengine . runtime import apiproxy_errors <EOL> DEFAULT_RATE = '<STR_LIT>' <EOL> DEFAULT_RATE_FLOAT = <NUM_LIT> <EOL> DEFAULT_BUCKET_SIZE = <NUM_LIT:5> <EOL> MAX_ETA = datetime . timedelta ( days = <NUM_LIT:30> ) <EOL> MAX_PULL_TASK_SIZE_BYTES = <NUM_LIT:2> ** <NUM_LIT:20> <EOL> MAX_PUSH_TASK_SIZE_BYTES = <NUM_LIT:100> * ( <NUM_LIT:2> ** <NUM_LIT:10> ) <EOL> MAX_TASK_SIZE = MAX_PUSH_TASK_SIZE_BYTES <EOL> MAX_REQUEST_SIZE = <NUM_LIT:32> << <NUM_LIT:20> <EOL> BUILT_IN_HEADERS = set ( [ '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' ] ) <EOL> DEFAULT_QUEUE_NAME = '<STR_LIT:default>' <EOL> INF = <NUM_LIT> <EOL> QUEUE_MODE = taskqueue_service_pb . TaskQueueMode <EOL> AUTOMATIC_QUEUES = { <EOL> DEFAULT_QUEUE_NAME : ( <NUM_LIT> , DEFAULT_BUCKET_SIZE , DEFAULT_RATE ) , <EOL> '<STR_LIT>' : ( <NUM_LIT:1> , <NUM_LIT:1> , '<STR_LIT>' ) } <EOL> def _GetAppId ( request ) : <EOL> """<STR_LIT>""" <EOL> if request . has_app_id ( ) : <EOL> return request . app_id ( ) <EOL> else : <EOL> return None <EOL> def _SecToUsec ( t ) : <EOL> """<STR_LIT>""" <EOL> return int ( t * <NUM_LIT> ) <EOL> def _UsecToSec ( t ) : <EOL> """<STR_LIT>""" <EOL> return t / <NUM_LIT> <EOL> def _FormatEta ( eta_usec ) : <EOL> """<STR_LIT>""" <EOL> eta = datetime . datetime . utcfromtimestamp ( _UsecToSec ( eta_usec ) ) <EOL> return eta . strftime ( '<STR_LIT>' ) <EOL> def _TruncDelta ( timedelta ) : <EOL> """<STR_LIT>""" <EOL> return datetime . timedelta ( days = timedelta . days , seconds = timedelta . seconds ) <EOL> def _EtaDelta ( eta_usec , now ) : <EOL> """<STR_LIT>""" <EOL> eta = datetime . datetime . utcfromtimestamp ( _UsecToSec ( eta_usec ) ) <EOL> if eta > now : <EOL> return '<STR_LIT>' % _TruncDelta ( eta - now ) <EOL> else : <EOL> return '<STR_LIT>' % _TruncDelta ( now - eta ) <EOL> def QueryTasksResponseToDict ( queue_name , task_response , now ) : <EOL> """<STR_LIT>""" <EOL> task = { } <EOL> task [ '<STR_LIT:name>' ] = task_response . task_name ( ) <EOL> task [ '<STR_LIT>' ] = queue_name <EOL> task [ '<STR_LIT:url>' ] = task_response . url ( ) <EOL> method = task_response . method ( ) <EOL> if method == taskqueue_service_pb . TaskQueueQueryTasksResponse_Task . GET : <EOL> task [ '<STR_LIT>' ] = '<STR_LIT:GET>' <EOL> elif method == taskqueue_service_pb . TaskQueueQueryTasksResponse_Task . POST : <EOL> task [ '<STR_LIT>' ] = '<STR_LIT:POST>' <EOL> elif method == taskqueue_service_pb . TaskQueueQueryTasksResponse_Task . HEAD : <EOL> task [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> elif method == taskqueue_service_pb . TaskQueueQueryTasksResponse_Task . PUT : <EOL> task [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> elif method == taskqueue_service_pb . TaskQueueQueryTasksResponse_Task . DELETE : <EOL> task [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> else : <EOL> raise ValueError ( '<STR_LIT>' % method ) <EOL> task [ '<STR_LIT>' ] = _FormatEta ( task_response . eta_usec ( ) ) <EOL> task [ '<STR_LIT>' ] = task_response . eta_usec ( ) <EOL> task [ '<STR_LIT>' ] = _EtaDelta ( task_response . eta_usec ( ) , now ) <EOL> task [ '<STR_LIT:body>' ] = base64 . b64encode ( task_response . body ( ) ) <EOL> headers = [ ( header . key ( ) , header . value ( ) ) <EOL> for header in task_response . header_list ( ) <EOL> if header . key ( ) . lower ( ) not in BUILT_IN_HEADERS ] <EOL> headers . append ( ( '<STR_LIT>' , queue_name ) ) <EOL> headers . append ( ( '<STR_LIT>' , task_response . task_name ( ) ) ) <EOL> headers . append ( ( '<STR_LIT>' , <EOL> str ( task_response . retry_count ( ) ) ) ) <EOL> headers . append ( ( '<STR_LIT>' , <EOL> str ( _UsecToSec ( task_response . eta_usec ( ) ) ) ) ) <EOL> headers . append ( ( '<STR_LIT>' , '<STR_LIT:1>' ) ) <EOL> headers . append ( ( '<STR_LIT>' , str ( len ( task [ '<STR_LIT:body>' ] ) ) ) ) <EOL> if '<STR_LIT>' not in frozenset ( key . lower ( ) for key , _ in headers ) : <EOL> headers . append ( ( '<STR_LIT:Content-Type>' , '<STR_LIT>' ) ) <EOL> headers . append ( ( '<STR_LIT>' , <EOL> str ( task_response . execution_count ( ) ) ) ) <EOL> if task_response . has_runlog ( ) and task_response . runlog ( ) . has_response_code ( ) : <EOL> headers . append ( ( '<STR_LIT>' , <EOL> str ( task_response . runlog ( ) . response_code ( ) ) ) ) <EOL> task [ '<STR_LIT>' ] = headers <EOL> return task <EOL> class _Group ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , queue_yaml_parser = None , app_id = None , <EOL> _all_queues_valid = False , _update_newest_eta = None , <EOL> _testing_validate_state = False ) : <EOL> """<STR_LIT>""" <EOL> self . _queues = { } <EOL> self . _queue_yaml_parser = queue_yaml_parser <EOL> self . _all_queues_valid = _all_queues_valid <EOL> self . _next_task_id = <NUM_LIT:1> <EOL> self . _app_id = app_id <EOL> if _update_newest_eta is None : <EOL> self . _update_newest_eta = lambda x : None <EOL> else : <EOL> self . _update_newest_eta = _update_newest_eta <EOL> self . _testing_validate_state = _testing_validate_state <EOL> def GetQueuesAsDicts ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _ReloadQueuesFromYaml ( ) <EOL> now = datetime . datetime . utcnow ( ) <EOL> queues = [ ] <EOL> for queue_name , queue in sorted ( self . _queues . items ( ) ) : <EOL> queue_dict = { } <EOL> queues . append ( queue_dict ) <EOL> queue_dict [ '<STR_LIT:name>' ] = queue_name <EOL> queue_dict [ '<STR_LIT>' ] = queue . bucket_capacity <EOL> if queue . user_specified_rate is not None : <EOL> queue_dict [ '<STR_LIT>' ] = queue . user_specified_rate <EOL> else : <EOL> queue_dict [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> if queue . queue_mode == QUEUE_MODE . PULL : <EOL> queue_dict [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> else : <EOL> queue_dict [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> queue_dict [ '<STR_LIT>' ] = queue . acl <EOL> if queue . Oldest ( ) : <EOL> queue_dict [ '<STR_LIT>' ] = _FormatEta ( queue . Oldest ( ) ) <EOL> queue_dict [ '<STR_LIT>' ] = _EtaDelta ( queue . Oldest ( ) , now ) <EOL> else : <EOL> queue_dict [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> queue_dict [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> queue_dict [ '<STR_LIT>' ] = queue . Count ( ) <EOL> if queue . retry_parameters : <EOL> retry_proto = queue . retry_parameters <EOL> retry_dict = { } <EOL> if retry_proto . has_retry_limit ( ) : <EOL> retry_dict [ '<STR_LIT>' ] = retry_proto . retry_limit ( ) <EOL> if retry_proto . has_age_limit_sec ( ) : <EOL> retry_dict [ '<STR_LIT>' ] = retry_proto . age_limit_sec ( ) <EOL> if retry_proto . has_min_backoff_sec ( ) : <EOL> retry_dict [ '<STR_LIT>' ] = retry_proto . min_backoff_sec ( ) <EOL> if retry_proto . has_max_backoff_sec ( ) : <EOL> retry_dict [ '<STR_LIT>' ] = retry_proto . max_backoff_sec ( ) <EOL> if retry_proto . has_max_doublings ( ) : <EOL> retry_dict [ '<STR_LIT>' ] = retry_proto . max_doublings ( ) <EOL> queue_dict [ '<STR_LIT>' ] = retry_dict <EOL> return queues <EOL> def HasQueue ( self , queue_name ) : <EOL> """<STR_LIT>""" <EOL> self . _ReloadQueuesFromYaml ( ) <EOL> return queue_name in self . _queues and ( <EOL> self . _queues [ queue_name ] is not None ) <EOL> def GetQueue ( self , queue_name ) : <EOL> """<STR_LIT>""" <EOL> self . _ReloadQueuesFromYaml ( ) <EOL> return self . _queues [ queue_name ] <EOL> def GetNextPushTask ( self ) : <EOL> """<STR_LIT>""" <EOL> min_eta = INF <EOL> result = None , None <EOL> for queue in self . _queues . itervalues ( ) : <EOL> if queue . queue_mode == QUEUE_MODE . PULL : <EOL> continue <EOL> task = queue . OldestTask ( ) <EOL> if not task : <EOL> continue <EOL> if task . eta_usec ( ) < min_eta : <EOL> result = queue , task <EOL> min_eta = task . eta_usec ( ) <EOL> return result <EOL> def _ConstructQueue ( self , queue_name , * args , ** kwargs ) : <EOL> if '<STR_LIT>' in kwargs : <EOL> raise TypeError ( <EOL> '<STR_LIT>' ) <EOL> kwargs [ '<STR_LIT>' ] = self . _testing_validate_state <EOL> self . _queues [ queue_name ] = _Queue ( queue_name , * args , ** kwargs ) <EOL> def _ConstructAutomaticQueue ( self , queue_name ) : <EOL> if queue_name in AUTOMATIC_QUEUES : <EOL> self . _ConstructQueue ( queue_name , * AUTOMATIC_QUEUES [ queue_name ] ) <EOL> else : <EOL> assert self . _all_queues_valid <EOL> self . _ConstructQueue ( queue_name ) <EOL> def _ReloadQueuesFromYaml ( self ) : <EOL> """<STR_LIT>""" <EOL> if not self . _queue_yaml_parser : <EOL> return <EOL> queue_info = self . _queue_yaml_parser ( ) <EOL> if queue_info and queue_info . queue : <EOL> queues = queue_info . queue <EOL> else : <EOL> queues = [ ] <EOL> old_queues = set ( self . _queues ) <EOL> new_queues = set ( ) <EOL> for entry in queues : <EOL> queue_name = entry . name <EOL> new_queues . add ( queue_name ) <EOL> retry_parameters = None <EOL> if entry . bucket_size : <EOL> bucket_size = entry . bucket_size <EOL> else : <EOL> bucket_size = DEFAULT_BUCKET_SIZE <EOL> if entry . retry_parameters : <EOL> retry_parameters = queueinfo . TranslateRetryParameters ( <EOL> entry . retry_parameters ) <EOL> if entry . mode == '<STR_LIT>' : <EOL> mode = QUEUE_MODE . PULL <EOL> if entry . rate is not None : <EOL> logging . warning ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> else : <EOL> mode = QUEUE_MODE . PUSH <EOL> if entry . rate is None : <EOL> logging . warning ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> max_rate = entry . rate <EOL> if entry . acl is not None : <EOL> acl = taskqueue_service_pb . TaskQueueAcl ( ) <EOL> for acl_entry in entry . acl : <EOL> acl . add_user_email ( acl_entry . user_email ) <EOL> else : <EOL> acl = None <EOL> if self . _queues . get ( queue_name ) is None : <EOL> self . _ConstructQueue ( queue_name , bucket_capacity = bucket_size , <EOL> user_specified_rate = max_rate , queue_mode = mode , <EOL> acl = acl , retry_parameters = retry_parameters ) <EOL> else : <EOL> queue = self . _queues [ queue_name ] <EOL> queue . bucket_size = bucket_size <EOL> queue . user_specified_rate = max_rate <EOL> queue . acl = acl <EOL> queue . queue_mode = mode <EOL> queue . retry_parameters = retry_parameters <EOL> if mode == QUEUE_MODE . PUSH : <EOL> eta = queue . Oldest ( ) <EOL> if eta : <EOL> self . _update_newest_eta ( _UsecToSec ( eta ) ) <EOL> if DEFAULT_QUEUE_NAME not in self . _queues : <EOL> self . _ConstructAutomaticQueue ( DEFAULT_QUEUE_NAME ) <EOL> new_queues . add ( DEFAULT_QUEUE_NAME ) <EOL> if not self . _all_queues_valid : <EOL> for queue_name in old_queues - new_queues : <EOL> del self . _queues [ queue_name ] <EOL> def _ValidateQueueName ( self , queue_name ) : <EOL> """<STR_LIT>""" <EOL> if not queue_name : <EOL> return taskqueue_service_pb . TaskQueueServiceError . INVALID_QUEUE_NAME <EOL> elif queue_name not in self . _queues : <EOL> if queue_name in AUTOMATIC_QUEUES or self . _all_queues_valid : <EOL> self . _ConstructAutomaticQueue ( queue_name ) <EOL> else : <EOL> return taskqueue_service_pb . TaskQueueServiceError . UNKNOWN_QUEUE <EOL> elif self . _queues [ queue_name ] is None : <EOL> return taskqueue_service_pb . TaskQueueServiceError . TOMBSTONED_QUEUE <EOL> return taskqueue_service_pb . TaskQueueServiceError . OK <EOL> def _CheckQueueForRpc ( self , queue_name ) : <EOL> """<STR_LIT>""" <EOL> self . _ReloadQueuesFromYaml ( ) <EOL> response = self . _ValidateQueueName ( queue_name ) <EOL> if response != taskqueue_service_pb . TaskQueueServiceError . OK : <EOL> raise apiproxy_errors . ApplicationError ( response ) <EOL> def _ChooseTaskName ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _next_task_id += <NUM_LIT:1> <EOL> return '<STR_LIT>' % ( self . _next_task_id - <NUM_LIT:1> ) <EOL> def _VerifyTaskQueueAddRequest ( self , request , now ) : <EOL> """<STR_LIT>""" <EOL> if request . eta_usec ( ) < <NUM_LIT:0> : <EOL> return taskqueue_service_pb . TaskQueueServiceError . INVALID_ETA <EOL> eta = datetime . datetime . utcfromtimestamp ( _UsecToSec ( request . eta_usec ( ) ) ) <EOL> max_eta = now + MAX_ETA <EOL> if eta > max_eta : <EOL> return taskqueue_service_pb . TaskQueueServiceError . INVALID_ETA <EOL> queue_name_response = self . _ValidateQueueName ( request . queue_name ( ) ) <EOL> if queue_name_response != taskqueue_service_pb . TaskQueueServiceError . OK : <EOL> return queue_name_response <EOL> if request . has_crontimetable ( ) and self . _app_id is None : <EOL> return taskqueue_service_pb . TaskQueueServiceError . PERMISSION_DENIED <EOL> if request . mode ( ) == QUEUE_MODE . PULL : <EOL> max_task_size_bytes = MAX_PULL_TASK_SIZE_BYTES <EOL> else : <EOL> max_task_size_bytes = MAX_PUSH_TASK_SIZE_BYTES <EOL> if request . ByteSize ( ) > max_task_size_bytes : <EOL> return taskqueue_service_pb . TaskQueueServiceError . TASK_TOO_LARGE <EOL> return taskqueue_service_pb . TaskQueueServiceError . OK <EOL> def BulkAdd_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> self . _ReloadQueuesFromYaml ( ) <EOL> if not request . add_request ( <NUM_LIT:0> ) . queue_name ( ) : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . UNKNOWN_QUEUE ) <EOL> error_found = False <EOL> task_results_with_chosen_names = set ( ) <EOL> now = datetime . datetime . utcfromtimestamp ( time . time ( ) ) <EOL> for add_request in request . add_request_list ( ) : <EOL> task_result = response . add_taskresult ( ) <EOL> result = self . _VerifyTaskQueueAddRequest ( add_request , now ) <EOL> if result == taskqueue_service_pb . TaskQueueServiceError . OK : <EOL> if not add_request . task_name ( ) : <EOL> chosen_name = self . _ChooseTaskName ( ) <EOL> add_request . set_task_name ( chosen_name ) <EOL> task_results_with_chosen_names . add ( id ( task_result ) ) <EOL> task_result . set_result ( <EOL> taskqueue_service_pb . TaskQueueServiceError . SKIPPED ) <EOL> else : <EOL> error_found = True <EOL> task_result . set_result ( result ) <EOL> if error_found : <EOL> return <EOL> if request . add_request ( <NUM_LIT:0> ) . has_transaction ( ) : <EOL> self . _TransactionalBulkAdd ( request ) <EOL> else : <EOL> self . _NonTransactionalBulkAdd ( request , response , now ) <EOL> for add_request , task_result in zip ( request . add_request_list ( ) , <EOL> response . taskresult_list ( ) ) : <EOL> if ( task_result . result ( ) == <EOL> taskqueue_service_pb . TaskQueueServiceError . SKIPPED ) : <EOL> task_result . set_result ( taskqueue_service_pb . TaskQueueServiceError . OK ) <EOL> if id ( task_result ) in task_results_with_chosen_names : <EOL> task_result . set_chosen_task_name ( add_request . task_name ( ) ) <EOL> def _TransactionalBulkAdd ( self , request ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> apiproxy_stub_map . MakeSyncCall ( <EOL> '<STR_LIT>' , '<STR_LIT>' , request , api_base_pb . VoidProto ( ) ) <EOL> except apiproxy_errors . ApplicationError , e : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> e . application_error + <EOL> taskqueue_service_pb . TaskQueueServiceError . DATASTORE_ERROR , <EOL> e . error_detail ) <EOL> def _NonTransactionalBulkAdd ( self , request , response , now ) : <EOL> """<STR_LIT>""" <EOL> queue_mode = request . add_request ( <NUM_LIT:0> ) . mode ( ) <EOL> queue_name = request . add_request ( <NUM_LIT:0> ) . queue_name ( ) <EOL> store = self . _queues [ queue_name ] <EOL> if store . queue_mode != queue_mode : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . INVALID_QUEUE_MODE ) <EOL> for add_request , task_result in zip ( request . add_request_list ( ) , <EOL> response . taskresult_list ( ) ) : <EOL> try : <EOL> store . Add ( add_request , now ) <EOL> except apiproxy_errors . ApplicationError , e : <EOL> task_result . set_result ( e . application_error ) <EOL> else : <EOL> task_result . set_result ( taskqueue_service_pb . TaskQueueServiceError . OK ) <EOL> if ( store . queue_mode == QUEUE_MODE . PUSH and <EOL> store . Oldest ( ) == add_request . eta_usec ( ) ) : <EOL> self . _update_newest_eta ( _UsecToSec ( add_request . eta_usec ( ) ) ) <EOL> def UpdateQueue_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> queue_name = request . queue_name ( ) <EOL> response = self . _ValidateQueueName ( queue_name ) <EOL> is_unknown_queue = ( <EOL> response == taskqueue_service_pb . TaskQueueServiceError . UNKNOWN_QUEUE ) <EOL> if response != taskqueue_service_pb . TaskQueueServiceError . OK and ( <EOL> not is_unknown_queue ) : <EOL> raise apiproxy_errors . ApplicationError ( response ) <EOL> if is_unknown_queue : <EOL> self . _queues [ queue_name ] = _Queue ( request . queue_name ( ) ) <EOL> if self . _app_id is not None : <EOL> self . _queues [ queue_name ] . Populate ( random . randint ( <NUM_LIT:10> , <NUM_LIT:100> ) ) <EOL> self . _queues [ queue_name ] . UpdateQueue_Rpc ( request , response ) <EOL> def FetchQueues_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> self . _ReloadQueuesFromYaml ( ) <EOL> for queue_name in sorted ( self . _queues ) : <EOL> if response . queue_size ( ) > request . max_rows ( ) : <EOL> break <EOL> if self . _queues [ queue_name ] is None : <EOL> continue <EOL> self . _queues [ queue_name ] . FetchQueues_Rpc ( request , response ) <EOL> def FetchQueueStats_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> for queue_name in request . queue_name_list ( ) : <EOL> stats = response . add_queuestats ( ) <EOL> if queue_name not in self . _queues : <EOL> stats . set_num_tasks ( <NUM_LIT:0> ) <EOL> stats . set_oldest_eta_usec ( - <NUM_LIT:1> ) <EOL> continue <EOL> store = self . _queues [ queue_name ] <EOL> stats . set_num_tasks ( store . Count ( ) ) <EOL> if stats . num_tasks ( ) == <NUM_LIT:0> : <EOL> stats . set_oldest_eta_usec ( - <NUM_LIT:1> ) <EOL> else : <EOL> stats . set_oldest_eta_usec ( store . Oldest ( ) ) <EOL> if random . randint ( <NUM_LIT:0> , <NUM_LIT:9> ) > <NUM_LIT:0> : <EOL> scanner_info = stats . mutable_scanner_info ( ) <EOL> scanner_info . set_executed_last_minute ( random . randint ( <NUM_LIT:0> , <NUM_LIT:10> ) ) <EOL> scanner_info . set_executed_last_hour ( scanner_info . executed_last_minute ( ) <EOL> + random . randint ( <NUM_LIT:0> , <NUM_LIT:100> ) ) <EOL> scanner_info . set_sampling_duration_seconds ( random . random ( ) * <NUM_LIT> ) <EOL> scanner_info . set_requests_in_flight ( random . randint ( <NUM_LIT:0> , <NUM_LIT:10> ) ) <EOL> def QueryTasks_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> self . _CheckQueueForRpc ( request . queue_name ( ) ) <EOL> self . _queues [ request . queue_name ( ) ] . QueryTasks_Rpc ( request , response ) <EOL> def FetchTask_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> self . _ReloadQueuesFromYaml ( ) <EOL> self . _CheckQueueForRpc ( request . queue_name ( ) ) <EOL> self . _queues [ request . queue_name ( ) ] . FetchTask_Rpc ( request , response ) <EOL> def Delete_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> self . _ReloadQueuesFromYaml ( ) <EOL> def _AddResultForAll ( result ) : <EOL> for _ in request . task_name_list ( ) : <EOL> response . add_result ( result ) <EOL> if request . queue_name ( ) not in self . _queues : <EOL> _AddResultForAll ( taskqueue_service_pb . TaskQueueServiceError . UNKNOWN_QUEUE ) <EOL> elif self . _queues [ request . queue_name ( ) ] is None : <EOL> _AddResultForAll ( <EOL> taskqueue_service_pb . TaskQueueServiceError . TOMBSTONED_QUEUE ) <EOL> else : <EOL> self . _queues [ request . queue_name ( ) ] . Delete_Rpc ( request , response ) <EOL> def DeleteQueue_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> self . _CheckQueueForRpc ( request . queue_name ( ) ) <EOL> self . _queues [ request . queue_name ( ) ] = None <EOL> def PauseQueue_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> self . _CheckQueueForRpc ( request . queue_name ( ) ) <EOL> self . _queues [ request . queue_name ( ) ] . paused = request . pause ( ) <EOL> def PurgeQueue_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> self . _CheckQueueForRpc ( request . queue_name ( ) ) <EOL> self . _queues [ request . queue_name ( ) ] . PurgeQueue ( ) <EOL> def QueryAndOwnTasks_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> self . _CheckQueueForRpc ( request . queue_name ( ) ) <EOL> self . _queues [ request . queue_name ( ) ] . QueryAndOwnTasks_Rpc ( request , response ) <EOL> def ModifyTaskLease_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> self . _CheckQueueForRpc ( request . queue_name ( ) ) <EOL> self . _queues [ request . queue_name ( ) ] . ModifyTaskLease_Rpc ( request , response ) <EOL> class Retry ( object ) : <EOL> """<STR_LIT>""" <EOL> _default_params = taskqueue_service_pb . TaskQueueRetryParameters ( ) <EOL> def __init__ ( self , task , queue ) : <EOL> """<STR_LIT>""" <EOL> if task is not None and task . has_retry_parameters ( ) : <EOL> self . _params = task . retry_parameters ( ) <EOL> elif queue is not None and queue . retry_parameters is not None : <EOL> self . _params = queue . retry_parameters <EOL> else : <EOL> self . _params = self . _default_params <EOL> def CanRetry ( self , retry_count , age_usec ) : <EOL> """<STR_LIT>""" <EOL> if self . _params . has_retry_limit ( ) and self . _params . has_age_limit_sec ( ) : <EOL> return ( self . _params . retry_limit ( ) >= retry_count or <EOL> self . _params . age_limit_sec ( ) >= _UsecToSec ( age_usec ) ) <EOL> if self . _params . has_retry_limit ( ) : <EOL> return self . _params . retry_limit ( ) >= retry_count <EOL> if self . _params . has_age_limit_sec ( ) : <EOL> return self . _params . age_limit_sec ( ) >= _UsecToSec ( age_usec ) <EOL> return True <EOL> def CalculateBackoffUsec ( self , retry_count ) : <EOL> """<STR_LIT>""" <EOL> exponent = min ( retry_count - <NUM_LIT:1> , self . _params . max_doublings ( ) ) <EOL> linear_steps = retry_count - exponent <EOL> min_backoff_usec = _SecToUsec ( self . _params . min_backoff_sec ( ) ) <EOL> max_backoff_usec = _SecToUsec ( self . _params . max_backoff_sec ( ) ) <EOL> backoff_usec = min_backoff_usec <EOL> if exponent > <NUM_LIT:0> : <EOL> backoff_usec *= ( <NUM_LIT:2> ** ( min ( <NUM_LIT> , exponent ) ) ) <EOL> if linear_steps > <NUM_LIT:1> : <EOL> backoff_usec *= linear_steps <EOL> return int ( min ( max_backoff_usec , backoff_usec ) ) <EOL> class _Queue ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , queue_name , bucket_refill_per_second = DEFAULT_RATE_FLOAT , <EOL> bucket_capacity = DEFAULT_BUCKET_SIZE , <EOL> user_specified_rate = DEFAULT_RATE , retry_parameters = None , <EOL> max_concurrent_requests = None , paused = False , <EOL> queue_mode = QUEUE_MODE . PUSH , acl = None , <EOL> _testing_validate_state = None ) : <EOL> self . queue_name = queue_name <EOL> self . bucket_refill_per_second = bucket_refill_per_second <EOL> self . bucket_capacity = bucket_capacity <EOL> self . user_specified_rate = user_specified_rate <EOL> self . retry_parameters = retry_parameters <EOL> self . max_concurrent_requests = max_concurrent_requests <EOL> self . paused = paused <EOL> self . queue_mode = queue_mode <EOL> self . acl = acl <EOL> self . _testing_validate_state = _testing_validate_state <EOL> self . task_name_archive = set ( ) <EOL> self . _sorted_by_name = [ ] <EOL> self . _sorted_by_eta = [ ] <EOL> self . _sorted_by_tag = [ ] <EOL> self . _lock = threading . Lock ( ) <EOL> def VerifyIndexes ( self ) : <EOL> """<STR_LIT>""" <EOL> assert self . _IsInOrder ( self . _sorted_by_name ) <EOL> assert self . _IsInOrder ( self . _sorted_by_eta ) <EOL> assert self . _IsInOrder ( self . _sorted_by_tag ) <EOL> tasks_by_name = set ( ) <EOL> tasks_with_tags = set ( ) <EOL> for name , task in self . _sorted_by_name : <EOL> assert name == task . task_name ( ) <EOL> assert name not in tasks_by_name <EOL> tasks_by_name . add ( name ) <EOL> if task . has_tag ( ) : <EOL> tasks_with_tags . add ( name ) <EOL> tasks_by_eta = set ( ) <EOL> for eta , name , task in self . _sorted_by_eta : <EOL> assert name == task . task_name ( ) <EOL> assert eta == task . eta_usec ( ) <EOL> assert name not in tasks_by_eta <EOL> tasks_by_eta . add ( name ) <EOL> assert tasks_by_eta == tasks_by_name <EOL> tasks_by_tag = set ( ) <EOL> for tag , eta , name , task in self . _sorted_by_tag : <EOL> assert name == task . task_name ( ) <EOL> assert eta == task . eta_usec ( ) <EOL> assert task . has_tag ( ) and task . tag ( ) <EOL> assert tag == task . tag ( ) <EOL> assert name not in tasks_by_tag <EOL> tasks_by_tag . add ( name ) <EOL> assert tasks_by_tag == tasks_with_tags <EOL> @ staticmethod <EOL> def _IsInOrder ( l ) : <EOL> """<STR_LIT>""" <EOL> sorted_list = sorted ( l ) <EOL> return l == sorted_list <EOL> def _WithLock ( f ) : <EOL> """<STR_LIT>""" <EOL> def _Inner ( self , * args , ** kwargs ) : <EOL> with self . _lock : <EOL> ret = f ( self , * args , ** kwargs ) <EOL> if self . _testing_validate_state : <EOL> self . VerifyIndexes ( ) <EOL> return ret <EOL> _Inner . __doc__ = f . __doc__ <EOL> return _Inner <EOL> @ _WithLock <EOL> def UpdateQueue_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> assert request . queue_name ( ) == self . queue_name <EOL> self . bucket_refill_per_second = request . bucket_refill_per_second ( ) <EOL> self . bucket_capacity = request . bucket_capacity ( ) <EOL> if request . has_user_specified_rate ( ) : <EOL> self . user_specified_rate = request . user_specified_rate ( ) <EOL> else : <EOL> self . user_specified_rate = None <EOL> if request . has_retry_parameters ( ) : <EOL> self . retry_parameters = request . retry_parameters ( ) <EOL> else : <EOL> self . retry_parameters = None <EOL> if request . has_max_concurrent_requests ( ) : <EOL> self . max_concurrent_requests = request . max_concurrent_requests ( ) <EOL> else : <EOL> self . max_concurrent_requests = None <EOL> self . queue_mode = request . mode ( ) <EOL> if request . has_acl ( ) : <EOL> self . acl = request . acl ( ) <EOL> else : <EOL> self . acl = None <EOL> @ _WithLock <EOL> def FetchQueues_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> response_queue = response . add_queue ( ) <EOL> response_queue . set_queue_name ( self . queue_name ) <EOL> response_queue . set_bucket_refill_per_second ( <EOL> self . bucket_refill_per_second ) <EOL> response_queue . set_bucket_capacity ( self . bucket_capacity ) <EOL> if self . user_specified_rate is not None : <EOL> response_queue . set_user_specified_rate ( self . user_specified_rate ) <EOL> if self . max_concurrent_requests is not None : <EOL> response_queue . set_max_concurrent_requests ( <EOL> self . max_concurrent_requests ) <EOL> if self . retry_parameters is not None : <EOL> response_queue . retry_parameters ( ) . CopyFrom ( self . retry_parameters ) <EOL> response_queue . set_paused ( self . paused ) <EOL> if self . queue_mode is not None : <EOL> response_queue . set_mode ( self . queue_mode ) <EOL> if self . acl is not None : <EOL> response_queue . mutable_acl ( ) . CopyFrom ( self . acl ) <EOL> @ _WithLock <EOL> def QueryTasks_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> assert not request . has_start_tag ( ) <EOL> if request . has_start_eta_usec ( ) : <EOL> tasks = self . _LookupNoAcquireLock ( request . max_rows ( ) , <EOL> name = request . start_task_name ( ) , <EOL> eta = request . start_eta_usec ( ) ) <EOL> else : <EOL> tasks = self . _LookupNoAcquireLock ( request . max_rows ( ) , <EOL> name = request . start_task_name ( ) ) <EOL> for task in tasks : <EOL> response . add_task ( ) . MergeFrom ( task ) <EOL> @ _WithLock <EOL> def FetchTask_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> task_name = request . task_name ( ) <EOL> pos = self . _LocateTaskByName ( task_name ) <EOL> if pos is None : <EOL> if task_name in self . task_name_archive : <EOL> error = taskqueue_service_pb . TaskQueueServiceError . TOMBSTONED_TASK <EOL> else : <EOL> error = taskqueue_service_pb . TaskQueueServiceError . UNKNOWN_TASK <EOL> raise apiproxy_errors . ApplicationError ( error ) <EOL> _ , task = self . _sorted_by_name [ pos ] <EOL> response . mutable_task ( ) . add_task ( ) . CopyFrom ( task ) <EOL> @ _WithLock <EOL> def Delete_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> for taskname in request . task_name_list ( ) : <EOL> if request . has_app_id ( ) and random . random ( ) <= <NUM_LIT> : <EOL> response . add_result ( <EOL> taskqueue_service_pb . TaskQueueServiceError . TRANSIENT_ERROR ) <EOL> else : <EOL> response . add_result ( self . _DeleteNoAcquireLock ( taskname ) ) <EOL> def _QueryAndOwnTasksGetTaskList ( self , max_rows , group_by_tag , now_eta_usec , <EOL> tag = None ) : <EOL> assert self . _lock . locked ( ) <EOL> if group_by_tag and tag : <EOL> return self . _IndexScan ( self . _sorted_by_tag , <EOL> start_key = ( tag , None , None , ) , <EOL> end_key = ( tag , now_eta_usec , None , ) , <EOL> max_rows = max_rows ) <EOL> elif group_by_tag : <EOL> tasks = self . _IndexScan ( self . _sorted_by_eta , <EOL> start_key = ( None , None , ) , <EOL> end_key = ( now_eta_usec , None , ) , <EOL> max_rows = max_rows ) <EOL> if not tasks : <EOL> return [ ] <EOL> if tasks [ <NUM_LIT:0> ] . has_tag ( ) : <EOL> tag = tasks [ <NUM_LIT:0> ] . tag ( ) <EOL> return self . _QueryAndOwnTasksGetTaskList ( <EOL> max_rows , True , now_eta_usec , tag ) <EOL> else : <EOL> return [ task for task in tasks if not task . has_tag ( ) ] <EOL> else : <EOL> return self . _IndexScan ( self . _sorted_by_eta , <EOL> start_key = ( None , None , ) , <EOL> end_key = ( now_eta_usec , None , ) , <EOL> max_rows = max_rows ) <EOL> @ _WithLock <EOL> def QueryAndOwnTasks_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> if self . queue_mode != QUEUE_MODE . PULL : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . INVALID_QUEUE_MODE ) <EOL> lease_seconds = request . lease_seconds ( ) <EOL> if lease_seconds < <NUM_LIT:0> : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . INVALID_REQUEST ) <EOL> max_tasks = request . max_tasks ( ) <EOL> if max_tasks <= <NUM_LIT:0> : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . INVALID_REQUEST ) <EOL> if request . has_tag ( ) and not request . group_by_tag ( ) : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . INVALID_REQUEST , <EOL> '<STR_LIT>' ) <EOL> now_eta_usec = _SecToUsec ( time . time ( ) ) <EOL> tasks = self . _QueryAndOwnTasksGetTaskList ( <EOL> max_tasks , request . group_by_tag ( ) , now_eta_usec , request . tag ( ) ) <EOL> tasks_to_delete = [ ] <EOL> for task in tasks : <EOL> retry = Retry ( task , self ) <EOL> if not retry . CanRetry ( task . retry_count ( ) + <NUM_LIT:1> , <NUM_LIT:0> ) : <EOL> logging . warning ( <EOL> '<STR_LIT>' , <EOL> task . task_name ( ) , self . queue_name , task . retry_count ( ) ) <EOL> tasks_to_delete . append ( task ) <EOL> continue <EOL> self . _PostponeTaskNoAcquireLock ( <EOL> task , now_eta_usec + _SecToUsec ( lease_seconds ) ) <EOL> task_response = response . add_task ( ) <EOL> task_response . set_task_name ( task . task_name ( ) ) <EOL> task_response . set_eta_usec ( task . eta_usec ( ) ) <EOL> task_response . set_retry_count ( task . retry_count ( ) ) <EOL> if task . has_tag ( ) : <EOL> task_response . set_tag ( task . tag ( ) ) <EOL> task_response . set_body ( task . body ( ) ) <EOL> for task in tasks_to_delete : <EOL> self . _DeleteNoAcquireLock ( task . task_name ( ) ) <EOL> @ _WithLock <EOL> def ModifyTaskLease_Rpc ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> if self . queue_mode != QUEUE_MODE . PULL : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . INVALID_QUEUE_MODE ) <EOL> if self . paused : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . QUEUE_PAUSED ) <EOL> lease_seconds = request . lease_seconds ( ) <EOL> if lease_seconds < <NUM_LIT:0> : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . INVALID_REQUEST ) <EOL> pos = self . _LocateTaskByName ( request . task_name ( ) ) <EOL> if pos is None : <EOL> if request . task_name ( ) in self . task_name_archive : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . TOMBSTONED_TASK ) <EOL> else : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . UNKNOWN_TASK ) <EOL> _ , task = self . _sorted_by_name [ pos ] <EOL> if task . eta_usec ( ) != request . eta_usec ( ) : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . TASK_LEASE_EXPIRED ) <EOL> now_usec = _SecToUsec ( time . time ( ) ) <EOL> if task . eta_usec ( ) < now_usec : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . TASK_LEASE_EXPIRED ) <EOL> future_eta_usec = now_usec + _SecToUsec ( lease_seconds ) <EOL> self . _PostponeTaskNoAcquireLock ( <EOL> task , future_eta_usec , increase_retries = False ) <EOL> response . set_updated_eta_usec ( future_eta_usec ) <EOL> @ _WithLock <EOL> def IncRetryCount ( self , task_name ) : <EOL> """<STR_LIT>""" <EOL> pos = self . _LocateTaskByName ( task_name ) <EOL> assert pos is not None , ( <EOL> '<STR_LIT>' ) <EOL> task = self . _sorted_by_name [ pos ] [ <NUM_LIT:1> ] <EOL> self . _IncRetryCount ( task ) <EOL> def _IncRetryCount ( self , task ) : <EOL> assert self . _lock . locked ( ) <EOL> retry_count = task . retry_count ( ) <EOL> task . set_retry_count ( retry_count + <NUM_LIT:1> ) <EOL> task . set_execution_count ( task . execution_count ( ) + <NUM_LIT:1> ) <EOL> @ _WithLock <EOL> def GetTasksAsDicts ( self ) : <EOL> """<STR_LIT>""" <EOL> tasks = [ ] <EOL> now = datetime . datetime . utcnow ( ) <EOL> for _ , _ , task_response in self . _sorted_by_eta : <EOL> tasks . append ( QueryTasksResponseToDict ( <EOL> self . queue_name , task_response , now ) ) <EOL> return tasks <EOL> @ _WithLock <EOL> def GetTaskAsDict ( self , task_name ) : <EOL> """<STR_LIT>""" <EOL> task_responses = self . _LookupNoAcquireLock ( maximum = <NUM_LIT:1> , name = task_name ) <EOL> if not task_responses : <EOL> return <EOL> task_response , = task_responses <EOL> if task_response . task_name ( ) != task_name : <EOL> return <EOL> now = datetime . datetime . utcnow ( ) <EOL> return QueryTasksResponseToDict ( self . queue_name , task_response , now ) <EOL> @ _WithLock <EOL> def PurgeQueue ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _sorted_by_name = [ ] <EOL> self . _sorted_by_eta = [ ] <EOL> self . _sorted_by_tag = [ ] <EOL> @ _WithLock <EOL> def _GetTasks ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _GetTasksNoAcquireLock ( ) <EOL> def _GetTasksNoAcquireLock ( self ) : <EOL> """<STR_LIT>""" <EOL> assert self . _lock . locked ( ) <EOL> tasks = [ ] <EOL> for eta , task_name , task in self . _sorted_by_eta : <EOL> tasks . append ( task ) <EOL> return tasks <EOL> def _InsertTask ( self , task ) : <EOL> """<STR_LIT>""" <EOL> assert self . _lock . locked ( ) <EOL> eta = task . eta_usec ( ) <EOL> name = task . task_name ( ) <EOL> bisect . insort_left ( self . _sorted_by_eta , ( eta , name , task ) ) <EOL> if task . has_tag ( ) : <EOL> bisect . insort_left ( self . _sorted_by_tag , ( task . tag ( ) , eta , name , task ) ) <EOL> bisect . insort_left ( self . _sorted_by_name , ( name , task ) ) <EOL> self . task_name_archive . add ( name ) <EOL> @ _WithLock <EOL> def RunTaskNow ( self , task ) : <EOL> """<STR_LIT>""" <EOL> self . _PostponeTaskNoAcquireLock ( task , <NUM_LIT:0> , increase_retries = False ) <EOL> @ _WithLock <EOL> def PostponeTask ( self , task , new_eta_usec ) : <EOL> """<STR_LIT>""" <EOL> assert new_eta_usec > task . eta_usec ( ) <EOL> self . _PostponeTaskNoAcquireLock ( task , new_eta_usec ) <EOL> def _PostponeTaskNoAcquireLock ( self , task , new_eta_usec , <EOL> increase_retries = True ) : <EOL> assert self . _lock . locked ( ) <EOL> if increase_retries : <EOL> self . _IncRetryCount ( task ) <EOL> name = task . task_name ( ) <EOL> eta = task . eta_usec ( ) <EOL> assert self . _RemoveTaskFromIndex ( <EOL> self . _sorted_by_eta , ( eta , name , None ) , task ) <EOL> if task . has_tag ( ) : <EOL> assert self . _RemoveTaskFromIndex ( <EOL> self . _sorted_by_tag , ( task . tag ( ) , eta , name , None ) , task ) <EOL> self . _PostponeTaskInsertOnly ( task , new_eta_usec ) <EOL> def _PostponeTaskInsertOnly ( self , task , new_eta_usec ) : <EOL> assert self . _lock . locked ( ) <EOL> task . set_eta_usec ( new_eta_usec ) <EOL> name = task . task_name ( ) <EOL> bisect . insort_left ( self . _sorted_by_eta , ( new_eta_usec , name , task ) ) <EOL> if task . has_tag ( ) : <EOL> tag = task . tag ( ) <EOL> bisect . insort_left ( self . _sorted_by_tag , ( tag , new_eta_usec , name , task ) ) <EOL> @ _WithLock <EOL> def Lookup ( self , maximum , name = None , eta = None ) : <EOL> """<STR_LIT>""" <EOL> return self . _LookupNoAcquireLock ( maximum , name , eta ) <EOL> def _IndexScan ( self , index , start_key , end_key = None , max_rows = None ) : <EOL> """<STR_LIT>""" <EOL> assert self . _lock . locked ( ) <EOL> start_pos = bisect . bisect_left ( index , start_key ) <EOL> end_pos = INF <EOL> if end_key is not None : <EOL> end_pos = bisect . bisect_left ( index , end_key ) <EOL> if max_rows is not None : <EOL> end_pos = min ( end_pos , start_pos + max_rows ) <EOL> end_pos = min ( end_pos , len ( index ) ) <EOL> tasks = [ ] <EOL> for pos in xrange ( start_pos , end_pos ) : <EOL> tasks . append ( index [ pos ] [ - <NUM_LIT:1> ] ) <EOL> return tasks <EOL> def _LookupNoAcquireLock ( self , maximum , name = None , eta = None , tag = None ) : <EOL> assert self . _lock . locked ( ) <EOL> if tag is not None : <EOL> return self . _IndexScan ( self . _sorted_by_tag , <EOL> start_key = ( tag , eta , name , ) , <EOL> end_key = ( '<STR_LIT>' % tag , None , None , ) , <EOL> max_rows = maximum ) <EOL> elif eta is not None : <EOL> return self . _IndexScan ( self . _sorted_by_eta , <EOL> start_key = ( eta , name , ) , <EOL> max_rows = maximum ) <EOL> else : <EOL> return self . _IndexScan ( self . _sorted_by_name , <EOL> start_key = ( name , ) , <EOL> max_rows = maximum ) <EOL> @ _WithLock <EOL> def Count ( self ) : <EOL> """<STR_LIT>""" <EOL> return len ( self . _sorted_by_name ) <EOL> @ _WithLock <EOL> def OldestTask ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _sorted_by_eta : <EOL> return self . _sorted_by_eta [ <NUM_LIT:0> ] [ <NUM_LIT:2> ] <EOL> return None <EOL> @ _WithLock <EOL> def Oldest ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _sorted_by_eta : <EOL> return self . _sorted_by_eta [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] <EOL> return None <EOL> def _LocateTaskByName ( self , task_name ) : <EOL> """<STR_LIT>""" <EOL> assert self . _lock . locked ( ) <EOL> pos = bisect . bisect_left ( self . _sorted_by_name , ( task_name , ) ) <EOL> if ( pos >= len ( self . _sorted_by_name ) or <EOL> self . _sorted_by_name [ pos ] [ <NUM_LIT:0> ] != task_name ) : <EOL> return None <EOL> return pos <EOL> @ _WithLock <EOL> def Add ( self , request , now ) : <EOL> """<STR_LIT>""" <EOL> if self . _LocateTaskByName ( request . task_name ( ) ) is not None : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . TASK_ALREADY_EXISTS ) <EOL> if request . task_name ( ) in self . task_name_archive : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . TOMBSTONED_TASK ) <EOL> now_sec = calendar . timegm ( now . utctimetuple ( ) ) <EOL> task = taskqueue_service_pb . TaskQueueQueryTasksResponse_Task ( ) <EOL> task . set_task_name ( request . task_name ( ) ) <EOL> task . set_eta_usec ( request . eta_usec ( ) ) <EOL> task . set_creation_time_usec ( _SecToUsec ( now_sec ) ) <EOL> task . set_retry_count ( <NUM_LIT:0> ) <EOL> task . set_method ( request . method ( ) ) <EOL> if request . has_url ( ) : <EOL> task . set_url ( request . url ( ) ) <EOL> for keyvalue in request . header_list ( ) : <EOL> header = task . add_header ( ) <EOL> header . set_key ( keyvalue . key ( ) ) <EOL> header . set_value ( keyvalue . value ( ) ) <EOL> if request . has_description ( ) : <EOL> task . set_description ( request . description ( ) ) <EOL> if request . has_body ( ) : <EOL> task . set_body ( request . body ( ) ) <EOL> if request . has_crontimetable ( ) : <EOL> task . mutable_crontimetable ( ) . set_schedule ( <EOL> request . crontimetable ( ) . schedule ( ) ) <EOL> task . mutable_crontimetable ( ) . set_timezone ( <EOL> request . crontimetable ( ) . timezone ( ) ) <EOL> if request . has_retry_parameters ( ) : <EOL> task . mutable_retry_parameters ( ) . CopyFrom ( request . retry_parameters ( ) ) <EOL> if request . has_tag ( ) : <EOL> task . set_tag ( request . tag ( ) ) <EOL> self . _InsertTask ( task ) <EOL> @ _WithLock <EOL> def Delete ( self , name ) : <EOL> """<STR_LIT>""" <EOL> return self . _DeleteNoAcquireLock ( name ) <EOL> def _RemoveTaskFromIndex ( self , index , index_tuple , task ) : <EOL> """<STR_LIT>""" <EOL> assert self . _lock . locked ( ) <EOL> pos = bisect . bisect_left ( index , index_tuple ) <EOL> if index [ pos ] [ - <NUM_LIT:1> ] is not task : <EOL> logging . debug ( '<STR_LIT>' , task , index [ pos ] [ - <NUM_LIT:1> ] ) <EOL> return False <EOL> index . pop ( pos ) <EOL> return True <EOL> def _DeleteNoAcquireLock ( self , name ) : <EOL> assert self . _lock . locked ( ) <EOL> pos = self . _LocateTaskByName ( name ) <EOL> if pos is None : <EOL> if name in self . task_name_archive : <EOL> return taskqueue_service_pb . TaskQueueServiceError . TOMBSTONED_TASK <EOL> else : <EOL> return taskqueue_service_pb . TaskQueueServiceError . UNKNOWN_TASK <EOL> old_task = self . _sorted_by_name . pop ( pos ) [ - <NUM_LIT:1> ] <EOL> eta = old_task . eta_usec ( ) <EOL> if not self . _RemoveTaskFromIndex ( <EOL> self . _sorted_by_eta , ( eta , name , None ) , old_task ) : <EOL> return taskqueue_service_pb . TaskQueueServiceError . INTERNAL_ERRROR <EOL> if old_task . has_tag ( ) : <EOL> tag = old_task . tag ( ) <EOL> if not self . _RemoveTaskFromIndex ( <EOL> self . _sorted_by_tag , ( tag , eta , name , None ) , old_task ) : <EOL> return taskqueue_service_pb . TaskQueueServiceError . INTERNAL_ERRROR <EOL> return taskqueue_service_pb . TaskQueueServiceError . OK <EOL> @ _WithLock <EOL> def Populate ( self , num_tasks ) : <EOL> """<STR_LIT>""" <EOL> def RandomTask ( ) : <EOL> """<STR_LIT>""" <EOL> assert self . _lock . locked ( ) <EOL> task = taskqueue_service_pb . TaskQueueQueryTasksResponse_Task ( ) <EOL> task . set_task_name ( '<STR_LIT>' . join ( random . choice ( string . ascii_lowercase ) <EOL> for x in range ( <NUM_LIT:20> ) ) ) <EOL> task . set_eta_usec ( now_usec + random . randint ( _SecToUsec ( - <NUM_LIT:10> ) , <EOL> _SecToUsec ( <NUM_LIT> ) ) ) <EOL> task . set_creation_time_usec ( min ( now_usec , task . eta_usec ( ) ) - <EOL> random . randint ( <NUM_LIT:0> , _SecToUsec ( <NUM_LIT:20> ) ) ) <EOL> task . set_url ( random . choice ( [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) ) <EOL> if random . random ( ) < <NUM_LIT> : <EOL> task . set_method ( <EOL> taskqueue_service_pb . TaskQueueQueryTasksResponse_Task . POST ) <EOL> task . set_body ( '<STR_LIT:A>' * <NUM_LIT> ) <EOL> else : <EOL> task . set_method ( <EOL> taskqueue_service_pb . TaskQueueQueryTasksResponse_Task . GET ) <EOL> retry_count = max ( <NUM_LIT:0> , random . randint ( - <NUM_LIT:10> , <NUM_LIT:5> ) ) <EOL> task . set_retry_count ( retry_count ) <EOL> task . set_execution_count ( retry_count ) <EOL> if random . random ( ) < <NUM_LIT> : <EOL> random_headers = [ ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( '<STR_LIT:foo>' , '<STR_LIT:bar>' ) , <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) ] <EOL> for _ in xrange ( random . randint ( <NUM_LIT:1> , <NUM_LIT:4> ) ) : <EOL> elem = random . randint ( <NUM_LIT:0> , len ( random_headers ) - <NUM_LIT:1> ) <EOL> key , value = random_headers . pop ( elem ) <EOL> header_proto = task . add_header ( ) <EOL> header_proto . set_key ( key ) <EOL> header_proto . set_value ( value ) <EOL> return task <EOL> now_usec = _SecToUsec ( time . time ( ) ) <EOL> for _ in range ( num_tasks ) : <EOL> self . _InsertTask ( RandomTask ( ) ) <EOL> class _TaskExecutor ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , default_host , request_data ) : <EOL> """<STR_LIT>""" <EOL> self . _default_host = default_host <EOL> self . _request_data = request_data <EOL> def _HeadersFromTask ( self , task , queue ) : <EOL> """<STR_LIT>""" <EOL> headers = [ ] <EOL> header_dict = { } <EOL> for header in task . header_list ( ) : <EOL> header_key_lower = header . key ( ) . lower ( ) <EOL> if header_key_lower not in BUILT_IN_HEADERS : <EOL> headers . append ( ( header . key ( ) , header . value ( ) ) ) <EOL> header_dict . setdefault ( header_key_lower , [ ] ) . append ( header . value ( ) ) <EOL> headers . append ( ( '<STR_LIT>' , queue . queue_name ) ) <EOL> headers . append ( ( '<STR_LIT>' , task . task_name ( ) ) ) <EOL> headers . append ( ( '<STR_LIT>' , str ( task . retry_count ( ) ) ) ) <EOL> headers . append ( ( '<STR_LIT>' , <EOL> str ( _UsecToSec ( task . eta_usec ( ) ) ) ) ) <EOL> headers . append ( ( '<STR_LIT>' , '<STR_LIT:1>' ) ) <EOL> headers . append ( ( '<STR_LIT>' , str ( len ( task . body ( ) ) ) ) ) <EOL> if '<STR_LIT>' not in header_dict : <EOL> headers . append ( ( '<STR_LIT:Content-Type>' , '<STR_LIT>' ) ) <EOL> headers . append ( ( '<STR_LIT>' , <EOL> str ( task . execution_count ( ) ) ) ) <EOL> if task . has_runlog ( ) and task . runlog ( ) . has_response_code ( ) : <EOL> headers . append ( ( '<STR_LIT>' , <EOL> str ( task . runlog ( ) . response_code ( ) ) ) ) <EOL> return header_dict , headers <EOL> def ExecuteTask ( self , task , queue ) : <EOL> """<STR_LIT>""" <EOL> method = task . RequestMethod_Name ( task . method ( ) ) <EOL> header_dict , headers = self . _HeadersFromTask ( task , queue ) <EOL> connection_host , = header_dict . get ( '<STR_LIT:host>' , [ self . _default_host ] ) <EOL> if connection_host is None : <EOL> logging . error ( '<STR_LIT>' <EOL> '<STR_LIT>' , <EOL> task . task_name ( ) , task . url ( ) , queue . queue_name ) <EOL> return False <EOL> else : <EOL> header_dict [ '<STR_LIT>' ] = connection_host <EOL> dispatcher = self . _request_data . get_dispatcher ( ) <EOL> try : <EOL> response = dispatcher . add_request ( method , task . url ( ) , headers , <EOL> task . body ( ) if task . has_body ( ) else '<STR_LIT>' , <EOL> '<STR_LIT>' ) <EOL> except request_info . ServerDoesNotExistError : <EOL> logging . exception ( '<STR_LIT>' ) <EOL> return <NUM_LIT:0> <EOL> return int ( response . status . split ( '<STR_LIT:U+0020>' , <NUM_LIT:1> ) [ <NUM_LIT:0> ] ) <EOL> class _BackgroundTaskScheduler ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , group , task_executor , retry_seconds , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> self . _group = group <EOL> self . _should_exit = False <EOL> self . _next_wakeup = INF <EOL> self . _event = threading . Event ( ) <EOL> self . _wakeup_lock = threading . Lock ( ) <EOL> self . task_executor = task_executor <EOL> self . default_retry_seconds = retry_seconds <EOL> self . _get_time = kwargs . pop ( '<STR_LIT>' , time . time ) <EOL> if kwargs : <EOL> raise TypeError ( '<STR_LIT>' % '<STR_LIT:U+002CU+0020>' . join ( kwargs ) ) <EOL> def UpdateNextEventTime ( self , next_event_time ) : <EOL> """<STR_LIT>""" <EOL> with self . _wakeup_lock : <EOL> if next_event_time < self . _next_wakeup : <EOL> self . _next_wakeup = next_event_time <EOL> self . _event . set ( ) <EOL> def Shutdown ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _should_exit = True <EOL> self . _event . set ( ) <EOL> def _ProcessQueues ( self ) : <EOL> with self . _wakeup_lock : <EOL> self . _next_wakeup = INF <EOL> now = self . _get_time ( ) <EOL> queue , task = self . _group . GetNextPushTask ( ) <EOL> while task and _UsecToSec ( task . eta_usec ( ) ) <= now : <EOL> if task . retry_count ( ) == <NUM_LIT:0> : <EOL> task . set_first_try_usec ( _SecToUsec ( now ) ) <EOL> response_code = self . task_executor . ExecuteTask ( task , queue ) <EOL> if response_code : <EOL> task . mutable_runlog ( ) . set_response_code ( response_code ) <EOL> else : <EOL> logging . error ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' , <EOL> task . task_name ( ) , task . url ( ) , queue . queue_name ) <EOL> now = self . _get_time ( ) <EOL> if <NUM_LIT:200> <= response_code < <NUM_LIT> : <EOL> queue . Delete ( task . task_name ( ) ) <EOL> else : <EOL> retry = Retry ( task , queue ) <EOL> age_usec = _SecToUsec ( now ) - task . first_try_usec ( ) <EOL> if retry . CanRetry ( task . retry_count ( ) + <NUM_LIT:1> , age_usec ) : <EOL> retry_usec = retry . CalculateBackoffUsec ( task . retry_count ( ) + <NUM_LIT:1> ) <EOL> logging . warning ( <EOL> '<STR_LIT>' , <EOL> task . task_name ( ) , _UsecToSec ( retry_usec ) ) <EOL> queue . PostponeTask ( task , _SecToUsec ( now ) + retry_usec ) <EOL> else : <EOL> logging . warning ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' , <EOL> task . task_name ( ) , task . retry_count ( ) , _UsecToSec ( age_usec ) ) <EOL> queue . Delete ( task . task_name ( ) ) <EOL> queue , task = self . _group . GetNextPushTask ( ) <EOL> if task : <EOL> with self . _wakeup_lock : <EOL> eta = _UsecToSec ( task . eta_usec ( ) ) <EOL> if eta < self . _next_wakeup : <EOL> self . _next_wakeup = eta <EOL> def _Wait ( self ) : <EOL> """<STR_LIT>""" <EOL> now = self . _get_time ( ) <EOL> while not self . _should_exit and self . _next_wakeup > now : <EOL> timeout = self . _next_wakeup - now <EOL> self . _event . wait ( timeout ) <EOL> self . _event . clear ( ) <EOL> now = self . _get_time ( ) <EOL> def MainLoop ( self ) : <EOL> """<STR_LIT>""" <EOL> while not self . _should_exit : <EOL> self . _ProcessQueues ( ) <EOL> self . _Wait ( ) <EOL> class TaskQueueServiceStub ( apiproxy_stub . APIProxyStub ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , <EOL> service_name = '<STR_LIT>' , <EOL> root_path = None , <EOL> auto_task_running = False , <EOL> task_retry_seconds = <NUM_LIT:30> , <EOL> _all_queues_valid = False , <EOL> default_http_server = None , <EOL> _testing_validate_state = False , <EOL> request_data = None ) : <EOL> """<STR_LIT>""" <EOL> super ( TaskQueueServiceStub , self ) . __init__ ( <EOL> service_name , max_request_size = MAX_REQUEST_SIZE , <EOL> request_data = request_data ) <EOL> self . _queues = { } <EOL> self . _all_queues_valid = _all_queues_valid <EOL> self . _root_path = root_path <EOL> self . _testing_validate_state = _testing_validate_state <EOL> self . _queues [ None ] = _Group ( <EOL> self . _ParseQueueYaml , app_id = None , <EOL> _all_queues_valid = _all_queues_valid , <EOL> _update_newest_eta = self . _UpdateNextEventTime , <EOL> _testing_validate_state = self . _testing_validate_state ) <EOL> self . _auto_task_running = auto_task_running <EOL> self . _started = False <EOL> self . _task_scheduler = _BackgroundTaskScheduler ( <EOL> self . _queues [ None ] , _TaskExecutor ( default_http_server , <EOL> self . request_data ) , <EOL> retry_seconds = task_retry_seconds ) <EOL> self . _yaml_last_modified = None <EOL> def StartBackgroundExecution ( self ) : <EOL> """<STR_LIT>""" <EOL> if not self . _started and self . _auto_task_running : <EOL> task_scheduler_thread = threading . Thread ( <EOL> target = self . _task_scheduler . MainLoop ) <EOL> task_scheduler_thread . setDaemon ( True ) <EOL> task_scheduler_thread . start ( ) <EOL> self . _started = True <EOL> def Shutdown ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _task_scheduler . Shutdown ( ) <EOL> def _ParseQueueYaml ( self ) : <EOL> """<STR_LIT>""" <EOL> if hasattr ( self , '<STR_LIT>' ) : <EOL> return self . queue_yaml_parser ( self . _root_path ) <EOL> if self . _root_path is None : <EOL> return None <EOL> for queueyaml in ( '<STR_LIT>' , '<STR_LIT>' ) : <EOL> try : <EOL> path = os . path . join ( self . _root_path , queueyaml ) <EOL> modified = os . stat ( path ) . st_mtime <EOL> if self . _yaml_last_modified and self . _yaml_last_modified == modified : <EOL> return self . _last_queue_info <EOL> fh = open ( path , '<STR_LIT:r>' ) <EOL> except ( IOError , OSError ) : <EOL> continue <EOL> try : <EOL> queue_info = queueinfo . LoadSingleQueue ( fh ) <EOL> self . _last_queue_info = queue_info <EOL> self . _yaml_last_modified = modified <EOL> return queue_info <EOL> finally : <EOL> fh . close ( ) <EOL> return None <EOL> def _UpdateNextEventTime ( self , callback_time ) : <EOL> """<STR_LIT>""" <EOL> self . _task_scheduler . UpdateNextEventTime ( callback_time ) <EOL> def _GetGroup ( self , app_id = None ) : <EOL> """<STR_LIT>""" <EOL> if app_id not in self . _queues : <EOL> self . _queues [ app_id ] = _Group ( <EOL> app_id = app_id , _all_queues_valid = self . _all_queues_valid , <EOL> _testing_validate_state = self . _testing_validate_state ) <EOL> return self . _queues [ app_id ] <EOL> def _Dynamic_Add ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> bulk_request = taskqueue_service_pb . TaskQueueBulkAddRequest ( ) <EOL> bulk_response = taskqueue_service_pb . TaskQueueBulkAddResponse ( ) <EOL> bulk_request . add_add_request ( ) . CopyFrom ( request ) <EOL> self . _Dynamic_BulkAdd ( bulk_request , bulk_response ) <EOL> assert bulk_response . taskresult_size ( ) == <NUM_LIT:1> <EOL> result = bulk_response . taskresult ( <NUM_LIT:0> ) . result ( ) <EOL> if result != taskqueue_service_pb . TaskQueueServiceError . OK : <EOL> raise apiproxy_errors . ApplicationError ( result ) <EOL> elif bulk_response . taskresult ( <NUM_LIT:0> ) . has_chosen_task_name ( ) : <EOL> response . set_chosen_task_name ( <EOL> bulk_response . taskresult ( <NUM_LIT:0> ) . chosen_task_name ( ) ) <EOL> def _Dynamic_BulkAdd ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> assert request . add_request_size ( ) , '<STR_LIT>' <EOL> self . _GetGroup ( _GetAppId ( request . add_request ( <NUM_LIT:0> ) ) ) . BulkAdd_Rpc ( <EOL> request , response ) <EOL> def GetQueues ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _GetGroup ( ) . GetQueuesAsDicts ( ) <EOL> def GetTasks ( self , queue_name ) : <EOL> """<STR_LIT>""" <EOL> return self . _GetGroup ( ) . GetQueue ( queue_name ) . GetTasksAsDicts ( ) <EOL> def DeleteTask ( self , queue_name , task_name ) : <EOL> """<STR_LIT>""" <EOL> if self . _GetGroup ( ) . HasQueue ( queue_name ) : <EOL> queue = self . _GetGroup ( ) . GetQueue ( queue_name ) <EOL> queue . Delete ( task_name ) <EOL> queue . task_name_archive . discard ( task_name ) <EOL> def FlushQueue ( self , queue_name ) : <EOL> """<STR_LIT>""" <EOL> if self . _GetGroup ( ) . HasQueue ( queue_name ) : <EOL> self . _GetGroup ( ) . GetQueue ( queue_name ) . PurgeQueue ( ) <EOL> self . _GetGroup ( ) . GetQueue ( queue_name ) . task_name_archive . clear ( ) <EOL> def _Dynamic_UpdateQueue ( self , request , unused_response ) : <EOL> """<STR_LIT>""" <EOL> self . _GetGroup ( _GetAppId ( request ) ) . UpdateQueue_Rpc ( request , unused_response ) <EOL> def _Dynamic_FetchQueues ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> self . _GetGroup ( _GetAppId ( request ) ) . FetchQueues_Rpc ( request , response ) <EOL> def _Dynamic_FetchQueueStats ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> self . _GetGroup ( _GetAppId ( request ) ) . FetchQueueStats_Rpc ( request , response ) <EOL> def _Dynamic_QueryTasks ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> self . _GetGroup ( _GetAppId ( request ) ) . QueryTasks_Rpc ( request , response ) <EOL> def _Dynamic_FetchTask ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> self . _GetGroup ( _GetAppId ( request ) ) . FetchTask_Rpc ( request , response ) <EOL> def _Dynamic_Delete ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> self . _GetGroup ( _GetAppId ( request ) ) . Delete_Rpc ( request , response ) <EOL> def _Dynamic_ForceRun ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> if _GetAppId ( request ) is not None : <EOL> if random . random ( ) <= <NUM_LIT> : <EOL> response . set_result ( <EOL> taskqueue_service_pb . TaskQueueServiceError . TRANSIENT_ERROR ) <EOL> elif random . random ( ) <= <NUM_LIT> : <EOL> response . set_result ( <EOL> taskqueue_service_pb . TaskQueueServiceError . INTERNAL_ERROR ) <EOL> else : <EOL> response . set_result ( <EOL> taskqueue_service_pb . TaskQueueServiceError . OK ) <EOL> else : <EOL> group = self . _GetGroup ( None ) <EOL> if not group . HasQueue ( request . queue_name ( ) ) : <EOL> response . set_result ( <EOL> taskqueue_service_pb . TaskQueueServiceError . UNKNOWN_QUEUE ) <EOL> return <EOL> queue = group . GetQueue ( request . queue_name ( ) ) <EOL> task = queue . Lookup ( <NUM_LIT:1> , name = request . task_name ( ) ) <EOL> if not task : <EOL> response . set_result ( <EOL> taskqueue_service_pb . TaskQueueServiceError . UNKNOWN_TASK ) <EOL> return <EOL> queue . RunTaskNow ( task [ <NUM_LIT:0> ] ) <EOL> self . _UpdateNextEventTime ( <NUM_LIT:0> ) <EOL> response . set_result ( <EOL> taskqueue_service_pb . TaskQueueServiceError . OK ) <EOL> def _Dynamic_DeleteQueue ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> app_id = _GetAppId ( request ) <EOL> if app_id is None : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . PERMISSION_DENIED ) <EOL> self . _GetGroup ( app_id ) . DeleteQueue_Rpc ( request , response ) <EOL> def _Dynamic_PauseQueue ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> app_id = _GetAppId ( request ) <EOL> if app_id is None : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . PERMISSION_DENIED ) <EOL> self . _GetGroup ( app_id ) . PauseQueue_Rpc ( request , response ) <EOL> def _Dynamic_PurgeQueue ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> self . _GetGroup ( _GetAppId ( request ) ) . PurgeQueue_Rpc ( request , response ) <EOL> def _Dynamic_DeleteGroup ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> app_id = _GetAppId ( request ) <EOL> if app_id is None : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . PERMISSION_DENIED ) <EOL> if app_id in self . _queues : <EOL> del self . _queues [ app_id ] <EOL> else : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . UNKNOWN_QUEUE ) <EOL> def _Dynamic_UpdateStorageLimit ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> if _GetAppId ( request ) is None : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . PERMISSION_DENIED ) <EOL> if request . limit ( ) < <NUM_LIT:0> or request . limit ( ) > <NUM_LIT:1000> * ( <NUM_LIT> ** <NUM_LIT:4> ) : <EOL> raise apiproxy_errors . ApplicationError ( <EOL> taskqueue_service_pb . TaskQueueServiceError . INVALID_REQUEST ) <EOL> response . set_new_limit ( request . limit ( ) ) <EOL> def _Dynamic_QueryAndOwnTasks ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> self . _GetGroup ( ) . QueryAndOwnTasks_Rpc ( request , response ) <EOL> def _Dynamic_ModifyTaskLease ( self , request , response ) : <EOL> """<STR_LIT>""" <EOL> self . _GetGroup ( ) . ModifyTaskLease_Rpc ( request , response ) <EOL> def get_filtered_tasks ( self , url = None , name = None , queue_names = None ) : <EOL> """<STR_LIT>""" <EOL> all_queue_names = [ queue [ '<STR_LIT:name>' ] for queue in self . GetQueues ( ) ] <EOL> if isinstance ( queue_names , basestring ) : <EOL> queue_names = [ queue_names ] <EOL> if queue_names is None : <EOL> queue_names = all_queue_names <EOL> task_dicts = [ ] <EOL> for queue_name in queue_names : <EOL> if queue_name in all_queue_names : <EOL> for task in self . GetTasks ( queue_name ) : <EOL> if url is not None and task [ '<STR_LIT:url>' ] != url : <EOL> continue <EOL> if name is not None and task [ '<STR_LIT:name>' ] != name : <EOL> continue <EOL> task_dicts . append ( task ) <EOL> tasks = [ ] <EOL> for task in task_dicts : <EOL> payload = base64 . b64decode ( task [ '<STR_LIT:body>' ] ) <EOL> headers = dict ( task [ '<STR_LIT>' ] ) <EOL> headers [ '<STR_LIT>' ] = str ( len ( payload ) ) <EOL> eta = datetime . datetime . strptime ( task [ '<STR_LIT>' ] , '<STR_LIT>' ) <EOL> eta = eta . replace ( tzinfo = taskqueue . _UTC ) <EOL> task_object = taskqueue . Task ( name = task [ '<STR_LIT:name>' ] , method = task [ '<STR_LIT>' ] , <EOL> url = task [ '<STR_LIT:url>' ] , headers = headers , <EOL> payload = payload , eta = eta ) <EOL> tasks . append ( task_object ) <EOL> return tasks </s>

<s> """<STR_LIT>""" <EOL> import calendar <EOL> import datetime <EOL> try : <EOL> import pytz <EOL> except ImportError : <EOL> pytz = None <EOL> import groc <EOL> HOURS = '<STR_LIT>' <EOL> MINUTES = '<STR_LIT>' <EOL> try : <EOL> from pytz import NonExistentTimeError <EOL> from pytz import AmbiguousTimeError <EOL> except ImportError : <EOL> class NonExistentTimeError ( Exception ) : <EOL> pass <EOL> class AmbiguousTimeError ( Exception ) : <EOL> pass <EOL> def GrocTimeSpecification ( schedule , timezone = None ) : <EOL> """<STR_LIT>""" <EOL> parser = groc . CreateParser ( schedule ) <EOL> parser . timespec ( ) <EOL> if parser . period_string : <EOL> return IntervalTimeSpecification ( parser . interval_mins , <EOL> parser . period_string , <EOL> parser . synchronized , <EOL> parser . start_time_string , <EOL> parser . end_time_string , <EOL> timezone ) <EOL> else : <EOL> return SpecificTimeSpecification ( parser . ordinal_set , parser . weekday_set , <EOL> parser . month_set , <EOL> parser . monthday_set , <EOL> parser . time_string , <EOL> timezone ) <EOL> class TimeSpecification ( object ) : <EOL> """<STR_LIT>""" <EOL> def GetMatches ( self , start , n ) : <EOL> """<STR_LIT>""" <EOL> out = [ ] <EOL> for _ in range ( n ) : <EOL> start = self . GetMatch ( start ) <EOL> out . append ( start ) <EOL> return out <EOL> def GetMatch ( self , start ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError <EOL> def _GetTimezone ( timezone_string ) : <EOL> """<STR_LIT>""" <EOL> if timezone_string : <EOL> if pytz is None : <EOL> raise ValueError ( '<STR_LIT>' ) <EOL> return pytz . timezone ( timezone_string ) <EOL> else : <EOL> return None <EOL> def _ToTimeZone ( t , tzinfo ) : <EOL> """<STR_LIT>""" <EOL> if pytz is None : <EOL> return t . replace ( tzinfo = tzinfo ) <EOL> elif tzinfo : <EOL> if not t . tzinfo : <EOL> t = pytz . utc . localize ( t ) <EOL> return tzinfo . normalize ( t . astimezone ( tzinfo ) ) <EOL> elif t . tzinfo : <EOL> return pytz . utc . normalize ( t . astimezone ( pytz . utc ) ) . replace ( tzinfo = None ) <EOL> else : <EOL> return t <EOL> def _GetTime ( time_string ) : <EOL> """<STR_LIT>""" <EOL> hourstr , minutestr = time_string . split ( '<STR_LIT::>' ) <EOL> return datetime . time ( int ( hourstr ) , int ( minutestr ) ) <EOL> class IntervalTimeSpecification ( TimeSpecification ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , interval , period , synchronized = False , <EOL> start_time_string = '<STR_LIT>' , end_time_string = '<STR_LIT>' , timezone = None ) : <EOL> super ( IntervalTimeSpecification , self ) . __init__ ( ) <EOL> if interval < <NUM_LIT:1> : <EOL> raise groc . GrocException ( '<STR_LIT>' ) <EOL> self . interval = interval <EOL> self . period = period <EOL> self . synchronized = synchronized <EOL> if self . period == HOURS : <EOL> self . seconds = self . interval * <NUM_LIT> <EOL> else : <EOL> self . seconds = self . interval * <NUM_LIT> <EOL> self . timezone = _GetTimezone ( timezone ) <EOL> if self . synchronized : <EOL> if start_time_string : <EOL> raise ValueError ( <EOL> '<STR_LIT>' ) <EOL> if end_time_string : <EOL> raise ValueError ( <EOL> '<STR_LIT>' ) <EOL> if ( self . seconds > <NUM_LIT> ) or ( ( <NUM_LIT> % self . seconds ) != <NUM_LIT:0> ) : <EOL> raise groc . GrocException ( '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> self . start_time = datetime . time ( <NUM_LIT:0> , <NUM_LIT:0> ) . replace ( tzinfo = self . timezone ) <EOL> self . end_time = datetime . time ( <NUM_LIT> , <NUM_LIT> ) . replace ( tzinfo = self . timezone ) <EOL> elif start_time_string : <EOL> if not end_time_string : <EOL> raise ValueError ( <EOL> '<STR_LIT>' ) <EOL> self . start_time = ( <EOL> _GetTime ( start_time_string ) . replace ( tzinfo = self . timezone ) ) <EOL> self . end_time = _GetTime ( end_time_string ) . replace ( tzinfo = self . timezone ) <EOL> else : <EOL> if end_time_string : <EOL> raise ValueError ( <EOL> '<STR_LIT>' ) <EOL> self . start_time = None <EOL> self . end_time = None <EOL> def GetMatch ( self , start ) : <EOL> """<STR_LIT>""" <EOL> if self . start_time is None : <EOL> return start + datetime . timedelta ( seconds = self . seconds ) <EOL> t = _ToTimeZone ( start , self . timezone ) <EOL> start_time = self . _GetPreviousDateTime ( t , self . start_time ) <EOL> t_delta = t - start_time <EOL> t_delta_seconds = ( t_delta . days * <NUM_LIT> * <NUM_LIT> + t_delta . seconds ) <EOL> num_intervals = ( t_delta_seconds + self . seconds ) / self . seconds <EOL> interval_time = ( <EOL> start_time + datetime . timedelta ( seconds = ( num_intervals * self . seconds ) ) ) <EOL> if self . timezone : <EOL> interval_time = self . timezone . normalize ( interval_time ) <EOL> next_start_time = self . _GetNextDateTime ( t , self . start_time ) <EOL> if ( self . _TimeIsInRange ( t ) and <EOL> self . _TimeIsInRange ( interval_time ) and <EOL> interval_time < next_start_time ) : <EOL> result = interval_time <EOL> else : <EOL> result = next_start_time <EOL> return _ToTimeZone ( result , start . tzinfo ) <EOL> def _TimeIsInRange ( self , t ) : <EOL> """<STR_LIT>""" <EOL> previous_start_time = self . _GetPreviousDateTime ( t , self . start_time ) <EOL> previous_end_time = self . _GetPreviousDateTime ( t , self . end_time ) <EOL> if previous_start_time > previous_end_time : <EOL> return True <EOL> else : <EOL> return t == previous_end_time <EOL> @ staticmethod <EOL> def _GetPreviousDateTime ( t , target_time ) : <EOL> """<STR_LIT>""" <EOL> date = t . date ( ) <EOL> while True : <EOL> result = IntervalTimeSpecification . _CombineDateAndTime ( date , target_time ) <EOL> if result <= t : <EOL> return result <EOL> date -= datetime . timedelta ( days = <NUM_LIT:1> ) <EOL> @ staticmethod <EOL> def _GetNextDateTime ( t , target_time ) : <EOL> """<STR_LIT>""" <EOL> date = t . date ( ) <EOL> while True : <EOL> result = IntervalTimeSpecification . _CombineDateAndTime ( date , target_time ) <EOL> if result > t : <EOL> return result <EOL> date += datetime . timedelta ( days = <NUM_LIT:1> ) <EOL> @ staticmethod <EOL> def _CombineDateAndTime ( date , time ) : <EOL> """<STR_LIT>""" <EOL> if time . tzinfo : <EOL> naive_result = datetime . datetime ( <EOL> date . year , date . month , date . day , time . hour , time . minute , time . second ) <EOL> try : <EOL> return time . tzinfo . localize ( naive_result , is_dst = None ) <EOL> except AmbiguousTimeError : <EOL> return min ( time . tzinfo . localize ( naive_result , is_dst = True ) , <EOL> time . tzinfo . localize ( naive_result , is_dst = False ) ) <EOL> except NonExistentTimeError : <EOL> while True : <EOL> naive_result += datetime . timedelta ( minutes = <NUM_LIT:1> ) <EOL> try : <EOL> return time . tzinfo . localize ( naive_result , is_dst = None ) <EOL> except NonExistentTimeError : <EOL> pass <EOL> else : <EOL> return datetime . datetime . combine ( date , time ) <EOL> class SpecificTimeSpecification ( TimeSpecification ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , ordinals = None , weekdays = None , months = None , monthdays = None , <EOL> timestr = '<STR_LIT>' , timezone = None ) : <EOL> super ( SpecificTimeSpecification , self ) . __init__ ( ) <EOL> if weekdays and monthdays : <EOL> raise ValueError ( '<STR_LIT>' ) <EOL> if ordinals is None : <EOL> self . ordinals = set ( range ( <NUM_LIT:1> , <NUM_LIT:6> ) ) <EOL> else : <EOL> self . ordinals = set ( ordinals ) <EOL> if self . ordinals and ( min ( self . ordinals ) < <NUM_LIT:1> or max ( self . ordinals ) > <NUM_LIT:5> ) : <EOL> raise ValueError ( '<STR_LIT>' <EOL> '<STR_LIT>' % ordinals ) <EOL> if weekdays is None : <EOL> self . weekdays = set ( range ( <NUM_LIT:7> ) ) <EOL> else : <EOL> self . weekdays = set ( weekdays ) <EOL> if self . weekdays and ( min ( self . weekdays ) < <NUM_LIT:0> or max ( self . weekdays ) > <NUM_LIT:6> ) : <EOL> raise ValueError ( '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' % weekdays ) <EOL> if months is None : <EOL> self . months = set ( range ( <NUM_LIT:1> , <NUM_LIT> ) ) <EOL> else : <EOL> self . months = set ( months ) <EOL> if self . months and ( min ( self . months ) < <NUM_LIT:1> or max ( self . months ) > <NUM_LIT:12> ) : <EOL> raise ValueError ( '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' % months ) <EOL> if not monthdays : <EOL> self . monthdays = set ( ) <EOL> else : <EOL> if min ( monthdays ) < <NUM_LIT:1> : <EOL> raise ValueError ( '<STR_LIT>' ) <EOL> if max ( monthdays ) > <NUM_LIT> : <EOL> raise ValueError ( '<STR_LIT>' ) <EOL> if self . months : <EOL> for month in self . months : <EOL> _ , ndays = calendar . monthrange ( <NUM_LIT:4> , month ) <EOL> if min ( monthdays ) <= ndays : <EOL> break <EOL> else : <EOL> raise ValueError ( '<STR_LIT>' <EOL> '<STR_LIT>' % ( max ( monthdays ) , month ) ) <EOL> self . monthdays = set ( monthdays ) <EOL> self . time = _GetTime ( timestr ) <EOL> self . timezone = _GetTimezone ( timezone ) <EOL> def _MatchingDays ( self , year , month ) : <EOL> """<STR_LIT>""" <EOL> start_day , last_day = calendar . monthrange ( year , month ) <EOL> if self . monthdays : <EOL> return sorted ( [ day for day in self . monthdays if day <= last_day ] ) <EOL> out_days = [ ] <EOL> start_day = ( start_day + <NUM_LIT:1> ) % <NUM_LIT:7> <EOL> for ordinal in self . ordinals : <EOL> for weekday in self . weekdays : <EOL> day = ( ( weekday - start_day ) % <NUM_LIT:7> ) + <NUM_LIT:1> <EOL> day += <NUM_LIT:7> * ( ordinal - <NUM_LIT:1> ) <EOL> if day <= last_day : <EOL> out_days . append ( day ) <EOL> return sorted ( out_days ) <EOL> def _NextMonthGenerator ( self , start , matches ) : <EOL> """<STR_LIT>""" <EOL> potential = matches = sorted ( matches ) <EOL> after = start - <NUM_LIT:1> <EOL> wrapcount = <NUM_LIT:0> <EOL> while True : <EOL> potential = [ x for x in potential if x > after ] <EOL> if not potential : <EOL> wrapcount += <NUM_LIT:1> <EOL> potential = matches <EOL> after = potential [ <NUM_LIT:0> ] <EOL> yield ( after , wrapcount ) <EOL> def GetMatch ( self , start ) : <EOL> """<STR_LIT>""" <EOL> start_time = _ToTimeZone ( start , self . timezone ) . replace ( tzinfo = None ) <EOL> if self . months : <EOL> months = self . _NextMonthGenerator ( start_time . month , self . months ) <EOL> while True : <EOL> month , yearwraps = months . next ( ) <EOL> candidate_month = start_time . replace ( day = <NUM_LIT:1> , month = month , <EOL> year = start_time . year + yearwraps ) <EOL> day_matches = self . _MatchingDays ( candidate_month . year , month ) <EOL> if ( ( candidate_month . year , candidate_month . month ) <EOL> == ( start_time . year , start_time . month ) ) : <EOL> day_matches = [ x for x in day_matches if x >= start_time . day ] <EOL> while ( day_matches and day_matches [ <NUM_LIT:0> ] == start_time . day <EOL> and start_time . time ( ) >= self . time ) : <EOL> day_matches . pop ( <NUM_LIT:0> ) <EOL> while day_matches : <EOL> out = candidate_month . replace ( day = day_matches [ <NUM_LIT:0> ] , hour = self . time . hour , <EOL> minute = self . time . minute , second = <NUM_LIT:0> , <EOL> microsecond = <NUM_LIT:0> ) <EOL> if self . timezone and pytz is not None : <EOL> try : <EOL> out = self . timezone . localize ( out , is_dst = None ) <EOL> except AmbiguousTimeError : <EOL> out = self . timezone . localize ( out ) <EOL> except NonExistentTimeError : <EOL> for _ in range ( <NUM_LIT> ) : <EOL> out += datetime . timedelta ( minutes = <NUM_LIT> ) <EOL> try : <EOL> out = self . timezone . localize ( out ) <EOL> except NonExistentTimeError : <EOL> continue <EOL> break <EOL> return _ToTimeZone ( out , start . tzinfo ) </s>

<s> """<STR_LIT>""" <EOL> from google . appengine . api . remote_socket . _remote_socket import select , error </s>

<s> """<STR_LIT>""" <EOL> import logging <EOL> import os <EOL> DEFAULT_DIR = os . path . join ( os . path . dirname ( __file__ ) ) <EOL> _handler_dir = None <EOL> _available_builtins = None <EOL> INCLUDE_FILENAME_TEMPLATE = '<STR_LIT>' <EOL> DEFAULT_INCLUDE_FILENAME = '<STR_LIT>' <EOL> class InvalidBuiltinName ( Exception ) : <EOL> """<STR_LIT>""" <EOL> def reset_builtins_dir ( ) : <EOL> """<STR_LIT>""" <EOL> set_builtins_dir ( DEFAULT_DIR ) <EOL> def set_builtins_dir ( path ) : <EOL> """<STR_LIT>""" <EOL> global _handler_dir , _available_builtins <EOL> _handler_dir = path <EOL> _available_builtins = [ ] <EOL> _initialize_builtins ( ) <EOL> def _initialize_builtins ( ) : <EOL> """<STR_LIT>""" <EOL> for filename in os . listdir ( _handler_dir ) : <EOL> if os . path . isfile ( _get_yaml_path ( filename , '<STR_LIT>' ) ) : <EOL> _available_builtins . append ( filename ) <EOL> def _get_yaml_path ( builtin_name , runtime ) : <EOL> """<STR_LIT>""" <EOL> runtime_specific = os . path . join ( _handler_dir , builtin_name , <EOL> INCLUDE_FILENAME_TEMPLATE % runtime ) <EOL> if runtime and os . path . exists ( runtime_specific ) : <EOL> return runtime_specific <EOL> return os . path . join ( _handler_dir , builtin_name , DEFAULT_INCLUDE_FILENAME ) <EOL> def get_yaml_path ( builtin_name , runtime = '<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> if _handler_dir is None : <EOL> set_builtins_dir ( DEFAULT_DIR ) <EOL> available_builtins = set ( _available_builtins ) <EOL> if builtin_name not in available_builtins : <EOL> raise InvalidBuiltinName ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' % ( <EOL> builtin_name , '<STR_LIT:U+002CU+0020>' . join ( sorted ( available_builtins ) ) ) ) <EOL> return _get_yaml_path ( builtin_name , runtime ) <EOL> def get_yaml_basepath ( ) : <EOL> """<STR_LIT>""" <EOL> if _handler_dir is None : <EOL> set_builtins_dir ( DEFAULT_DIR ) <EOL> return _handler_dir </s>

<s> """<STR_LIT>""" <EOL> import copy <EOL> import datetime <EOL> import logging <EOL> import re <EOL> import time <EOL> import urlparse <EOL> import warnings <EOL> from google . appengine . api import datastore <EOL> from google . appengine . api import datastore_errors <EOL> from google . appengine . api import datastore_types <EOL> from google . appengine . api import namespace_manager <EOL> from google . appengine . api import users <EOL> from google . appengine . datastore import datastore_rpc <EOL> from google . appengine . datastore import datastore_query <EOL> Error = datastore_errors . Error <EOL> BadValueError = datastore_errors . BadValueError <EOL> BadPropertyError = datastore_errors . BadPropertyError <EOL> BadRequestError = datastore_errors . BadRequestError <EOL> EntityNotFoundError = datastore_errors . EntityNotFoundError <EOL> BadArgumentError = datastore_errors . BadArgumentError <EOL> QueryNotFoundError = datastore_errors . QueryNotFoundError <EOL> TransactionNotFoundError = datastore_errors . TransactionNotFoundError <EOL> Rollback = datastore_errors . Rollback <EOL> TransactionFailedError = datastore_errors . TransactionFailedError <EOL> BadFilterError = datastore_errors . BadFilterError <EOL> BadQueryError = datastore_errors . BadQueryError <EOL> BadKeyError = datastore_errors . BadKeyError <EOL> InternalError = datastore_errors . InternalError <EOL> NeedIndexError = datastore_errors . NeedIndexError <EOL> ReferencePropertyResolveError = datastore_errors . ReferencePropertyResolveError <EOL> Timeout = datastore_errors . Timeout <EOL> CommittedButStillApplying = datastore_errors . CommittedButStillApplying <EOL> ValidationError = BadValueError <EOL> Key = datastore_types . Key <EOL> Category = datastore_types . Category <EOL> Link = datastore_types . Link <EOL> Email = datastore_types . Email <EOL> GeoPt = datastore_types . GeoPt <EOL> IM = datastore_types . IM <EOL> PhoneNumber = datastore_types . PhoneNumber <EOL> PostalAddress = datastore_types . PostalAddress <EOL> Rating = datastore_types . Rating <EOL> Text = datastore_types . Text <EOL> Blob = datastore_types . Blob <EOL> ByteString = datastore_types . ByteString <EOL> BlobKey = datastore_types . BlobKey <EOL> READ_CAPABILITY = datastore . READ_CAPABILITY <EOL> WRITE_CAPABILITY = datastore . WRITE_CAPABILITY <EOL> STRONG_CONSISTENCY = datastore . STRONG_CONSISTENCY <EOL> EVENTUAL_CONSISTENCY = datastore . EVENTUAL_CONSISTENCY <EOL> NESTED = datastore_rpc . TransactionOptions . NESTED <EOL> MANDATORY = datastore_rpc . TransactionOptions . MANDATORY <EOL> ALLOWED = datastore_rpc . TransactionOptions . ALLOWED <EOL> INDEPENDENT = datastore_rpc . TransactionOptions . INDEPENDENT <EOL> KEY_RANGE_EMPTY = "<STR_LIT>" <EOL> """<STR_LIT>""" <EOL> KEY_RANGE_CONTENTION = "<STR_LIT>" <EOL> """<STR_LIT>""" <EOL> KEY_RANGE_COLLISION = "<STR_LIT>" <EOL> """<STR_LIT>""" <EOL> _kind_map = { } <EOL> _SELF_REFERENCE = object ( ) <EOL> _RESERVED_WORDS = set ( [ '<STR_LIT>' ] ) <EOL> class NotSavedError ( Error ) : <EOL> """<STR_LIT>""" <EOL> class KindError ( BadValueError ) : <EOL> """<STR_LIT>""" <EOL> class PropertyError ( Error ) : <EOL> """<STR_LIT>""" <EOL> class DuplicatePropertyError ( Error ) : <EOL> """<STR_LIT>""" <EOL> class ConfigurationError ( Error ) : <EOL> """<STR_LIT>""" <EOL> class ReservedWordError ( Error ) : <EOL> """<STR_LIT>""" <EOL> class DerivedPropertyError ( Error ) : <EOL> """<STR_LIT>""" <EOL> _ALLOWED_PROPERTY_TYPES = set ( [ <EOL> basestring , <EOL> str , <EOL> unicode , <EOL> bool , <EOL> int , <EOL> long , <EOL> float , <EOL> Key , <EOL> datetime . datetime , <EOL> datetime . date , <EOL> datetime . time , <EOL> Blob , <EOL> datastore_types . EmbeddedEntity , <EOL> ByteString , <EOL> Text , <EOL> users . User , <EOL> Category , <EOL> Link , <EOL> Email , <EOL> GeoPt , <EOL> IM , <EOL> PhoneNumber , <EOL> PostalAddress , <EOL> Rating , <EOL> BlobKey , <EOL> ] ) <EOL> _ALLOWED_EXPANDO_PROPERTY_TYPES = set ( _ALLOWED_PROPERTY_TYPES ) <EOL> _ALLOWED_EXPANDO_PROPERTY_TYPES . update ( ( list , tuple , type ( None ) ) ) <EOL> _OPERATORS = [ '<STR_LIT:<>' , '<STR_LIT>' , '<STR_LIT:>>' , '<STR_LIT>' , '<STR_LIT:=>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> _FILTER_REGEX = re . compile ( <EOL> '<STR_LIT>' % '<STR_LIT:|>' . join ( _OPERATORS ) , <EOL> re . IGNORECASE | re . UNICODE ) <EOL> def class_for_kind ( kind ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> return _kind_map [ kind ] <EOL> except KeyError : <EOL> raise KindError ( '<STR_LIT>' % kind ) <EOL> def check_reserved_word ( attr_name ) : <EOL> """<STR_LIT>""" <EOL> if datastore_types . RESERVED_PROPERTY_NAME . match ( attr_name ) : <EOL> raise ReservedWordError ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> if attr_name in _RESERVED_WORDS or attr_name in dir ( Model ) : <EOL> raise ReservedWordError ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" % locals ( ) ) <EOL> def query_descendants ( model_instance ) : <EOL> """<STR_LIT>""" <EOL> result = Query ( ) . ancestor ( model_instance ) <EOL> result . filter ( datastore_types . KEY_SPECIAL_PROPERTY + '<STR_LIT>' , <EOL> model_instance . key ( ) ) <EOL> return result <EOL> def model_to_protobuf ( model_instance , _entity_class = datastore . Entity ) : <EOL> """<STR_LIT>""" <EOL> return model_instance . _populate_entity ( _entity_class ) . ToPb ( ) <EOL> def model_from_protobuf ( pb , _entity_class = datastore . Entity ) : <EOL> """<STR_LIT>""" <EOL> entity = _entity_class . FromPb ( pb , default_kind = Expando . kind ( ) ) <EOL> return class_for_kind ( entity . kind ( ) ) . from_entity ( entity ) <EOL> def model_is_projection ( model_instance ) : <EOL> """<STR_LIT>""" <EOL> return model_instance . _entity and model_instance . _entity . is_projection ( ) <EOL> def _initialize_properties ( model_class , name , bases , dct ) : <EOL> """<STR_LIT>""" <EOL> model_class . _properties = { } <EOL> property_source = { } <EOL> def get_attr_source ( name , cls ) : <EOL> for src_cls in cls . mro ( ) : <EOL> if name in src_cls . __dict__ : <EOL> return src_cls <EOL> defined = set ( ) <EOL> for base in bases : <EOL> if hasattr ( base , '<STR_LIT>' ) : <EOL> property_keys = set ( base . _properties . keys ( ) ) <EOL> duplicate_property_keys = defined & property_keys <EOL> for dupe_prop_name in duplicate_property_keys : <EOL> old_source = property_source [ dupe_prop_name ] = get_attr_source ( <EOL> dupe_prop_name , property_source [ dupe_prop_name ] ) <EOL> new_source = get_attr_source ( dupe_prop_name , base ) <EOL> if old_source != new_source : <EOL> raise DuplicatePropertyError ( <EOL> '<STR_LIT>' % <EOL> ( dupe_prop_name , old_source . __name__ , new_source . __name__ ) ) <EOL> property_keys -= duplicate_property_keys <EOL> if property_keys : <EOL> defined |= property_keys <EOL> property_source . update ( dict . fromkeys ( property_keys , base ) ) <EOL> model_class . _properties . update ( base . _properties ) <EOL> for attr_name in dct . keys ( ) : <EOL> attr = dct [ attr_name ] <EOL> if isinstance ( attr , Property ) : <EOL> check_reserved_word ( attr_name ) <EOL> if attr_name in defined : <EOL> raise DuplicatePropertyError ( '<STR_LIT>' % attr_name ) <EOL> defined . add ( attr_name ) <EOL> model_class . _properties [ attr_name ] = attr <EOL> attr . __property_config__ ( model_class , attr_name ) <EOL> model_class . _all_properties = frozenset ( <EOL> prop . name for name , prop in model_class . _properties . items ( ) ) <EOL> model_class . _unindexed_properties = frozenset ( <EOL> prop . name for name , prop in model_class . _properties . items ( ) <EOL> if not prop . indexed ) <EOL> def _coerce_to_key ( value ) : <EOL> """<STR_LIT>""" <EOL> if value is None : <EOL> return None <EOL> value , multiple = datastore . NormalizeAndTypeCheck ( <EOL> value , ( Model , Key , basestring ) ) <EOL> if len ( value ) > <NUM_LIT:1> : <EOL> raise datastore_errors . BadArgumentError ( '<STR_LIT>' ) <EOL> value = value [ <NUM_LIT:0> ] <EOL> if isinstance ( value , Model ) : <EOL> return value . key ( ) <EOL> elif isinstance ( value , basestring ) : <EOL> return Key ( value ) <EOL> else : <EOL> return value <EOL> class PropertiedClass ( type ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( cls , name , bases , dct , map_kind = True ) : <EOL> """<STR_LIT>""" <EOL> super ( PropertiedClass , cls ) . __init__ ( name , bases , dct ) <EOL> _initialize_properties ( cls , name , bases , dct ) <EOL> if map_kind : <EOL> _kind_map [ cls . kind ( ) ] = cls <EOL> AUTO_UPDATE_UNCHANGED = object ( ) <EOL> class Property ( object ) : <EOL> """<STR_LIT>""" <EOL> creation_counter = <NUM_LIT:0> <EOL> def __init__ ( self , <EOL> verbose_name = None , <EOL> name = None , <EOL> default = None , <EOL> required = False , <EOL> validator = None , <EOL> choices = None , <EOL> indexed = True ) : <EOL> """<STR_LIT>""" <EOL> self . verbose_name = verbose_name <EOL> self . name = name <EOL> self . default = default <EOL> self . required = required <EOL> self . validator = validator <EOL> self . choices = choices <EOL> self . indexed = indexed <EOL> self . creation_counter = Property . creation_counter <EOL> Property . creation_counter += <NUM_LIT:1> <EOL> def __property_config__ ( self , model_class , property_name ) : <EOL> """<STR_LIT>""" <EOL> self . model_class = model_class <EOL> if self . name is None : <EOL> self . name = property_name <EOL> def __get__ ( self , model_instance , model_class ) : <EOL> """<STR_LIT>""" <EOL> if model_instance is None : <EOL> return self <EOL> try : <EOL> return getattr ( model_instance , self . _attr_name ( ) ) <EOL> except AttributeError : <EOL> return None <EOL> def __set__ ( self , model_instance , value ) : <EOL> """<STR_LIT>""" <EOL> value = self . validate ( value ) <EOL> setattr ( model_instance , self . _attr_name ( ) , value ) <EOL> def default_value ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . default <EOL> def validate ( self , value ) : <EOL> """<STR_LIT>""" <EOL> if self . empty ( value ) : <EOL> if self . required : <EOL> raise BadValueError ( '<STR_LIT>' % self . name ) <EOL> else : <EOL> if self . choices : <EOL> if value not in self . choices : <EOL> raise BadValueError ( '<STR_LIT>' % <EOL> ( self . name , value , self . choices ) ) <EOL> if self . validator is not None : <EOL> self . validator ( value ) <EOL> return value <EOL> def empty ( self , value ) : <EOL> """<STR_LIT>""" <EOL> return not value <EOL> def get_value_for_datastore ( self , model_instance ) : <EOL> """<STR_LIT>""" <EOL> return self . __get__ ( model_instance , model_instance . __class__ ) <EOL> def get_updated_value_for_datastore ( self , model_instance ) : <EOL> """<STR_LIT>""" <EOL> return AUTO_UPDATE_UNCHANGED <EOL> def make_value_from_datastore_index_value ( self , index_value ) : <EOL> value = datastore_types . RestoreFromIndexValue ( index_value , self . data_type ) <EOL> return self . make_value_from_datastore ( value ) <EOL> def make_value_from_datastore ( self , value ) : <EOL> """<STR_LIT>""" <EOL> return value <EOL> def _require_parameter ( self , kwds , parameter , value ) : <EOL> """<STR_LIT>""" <EOL> if parameter in kwds and kwds [ parameter ] != value : <EOL> raise ConfigurationError ( '<STR_LIT>' % ( parameter , value ) ) <EOL> kwds [ parameter ] = value <EOL> def _attr_name ( self ) : <EOL> """<STR_LIT>""" <EOL> return '<STR_LIT:_>' + self . name <EOL> data_type = str <EOL> def datastore_type ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . data_type <EOL> class Index ( datastore . _BaseIndex ) : <EOL> """<STR_LIT>""" <EOL> id = datastore . _BaseIndex . _Id <EOL> kind = datastore . _BaseIndex . _Kind <EOL> has_ancestor = datastore . _BaseIndex . _HasAncestor <EOL> properties = datastore . _BaseIndex . _Properties <EOL> class Model ( object ) : <EOL> """<STR_LIT>""" <EOL> __metaclass__ = PropertiedClass <EOL> def __new__ ( * args , ** unused_kwds ) : <EOL> """<STR_LIT>""" <EOL> if args : <EOL> cls = args [ <NUM_LIT:0> ] <EOL> else : <EOL> raise TypeError ( '<STR_LIT>' ) <EOL> return super ( Model , cls ) . __new__ ( cls ) <EOL> def __init__ ( self , <EOL> parent = None , <EOL> key_name = None , <EOL> _app = None , <EOL> _from_entity = False , <EOL> ** kwds ) : <EOL> """<STR_LIT>""" <EOL> namespace = None <EOL> if isinstance ( _app , tuple ) : <EOL> if len ( _app ) != <NUM_LIT:2> : <EOL> raise BadArgumentError ( '<STR_LIT>' ) <EOL> _app , namespace = _app <EOL> key = kwds . get ( '<STR_LIT:key>' , None ) <EOL> if key is not None : <EOL> if isinstance ( key , ( tuple , list ) ) : <EOL> key = Key . from_path ( * key ) <EOL> if isinstance ( key , basestring ) : <EOL> key = Key ( encoded = key ) <EOL> if not isinstance ( key , Key ) : <EOL> raise TypeError ( '<STR_LIT>' % <EOL> ( key , key . __class__ . __name__ ) ) <EOL> if not key . has_id_or_name ( ) : <EOL> raise BadKeyError ( '<STR_LIT>' ) <EOL> if key . kind ( ) != self . kind ( ) : <EOL> raise BadKeyError ( '<STR_LIT>' % <EOL> ( self . kind ( ) , key . kind ( ) ) ) <EOL> if _app is not None and key . app ( ) != _app : <EOL> raise BadKeyError ( '<STR_LIT>' % <EOL> ( _app , key . app ( ) ) ) <EOL> if namespace is not None and key . namespace ( ) != namespace : <EOL> raise BadKeyError ( '<STR_LIT>' % <EOL> ( namespace , key . namespace ( ) ) ) <EOL> if key_name and key_name != key . name ( ) : <EOL> raise BadArgumentError ( '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> if parent and parent != key . parent ( ) : <EOL> raise BadArgumentError ( '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> namespace = key . namespace ( ) <EOL> self . _key = key <EOL> self . _key_name = None <EOL> self . _parent = None <EOL> self . _parent_key = None <EOL> else : <EOL> if key_name == '<STR_LIT>' : <EOL> raise BadKeyError ( '<STR_LIT>' ) <EOL> elif key_name is not None and not isinstance ( key_name , basestring ) : <EOL> raise BadKeyError ( '<STR_LIT>' % <EOL> key_name . __class__ . __name__ ) <EOL> if parent is not None : <EOL> if not isinstance ( parent , ( Model , Key ) ) : <EOL> raise TypeError ( '<STR_LIT>' % <EOL> ( parent , parent . __class__ . __name__ ) ) <EOL> if isinstance ( parent , Model ) and not parent . has_key ( ) : <EOL> raise BadValueError ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" % parent . kind ( ) ) <EOL> if isinstance ( parent , Key ) : <EOL> self . _parent_key = parent <EOL> self . _parent = None <EOL> else : <EOL> self . _parent_key = parent . key ( ) <EOL> self . _parent = parent <EOL> else : <EOL> self . _parent_key = None <EOL> self . _parent = None <EOL> self . _key_name = key_name <EOL> self . _key = None <EOL> if self . _parent_key is not None : <EOL> if namespace is not None and self . _parent_key . namespace ( ) != namespace : <EOL> raise BadArgumentError ( <EOL> '<STR_LIT>' % <EOL> ( namespace , self . _parent_key . namespace ( ) ) ) <EOL> namespace = self . _parent_key . namespace ( ) <EOL> self . _entity = None <EOL> if _app is not None and isinstance ( _app , Key ) : <EOL> raise BadArgumentError ( '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' % _app ) <EOL> if namespace is None : <EOL> namespace = namespace_manager . get_namespace ( ) <EOL> self . _app = _app <EOL> self . __namespace = namespace <EOL> is_projection = False <EOL> if isinstance ( _from_entity , datastore . Entity ) and _from_entity . is_saved ( ) : <EOL> self . _entity = _from_entity <EOL> is_projection = _from_entity . is_projection ( ) <EOL> del self . _key_name <EOL> del self . _key <EOL> for prop in self . properties ( ) . values ( ) : <EOL> if prop . name in kwds : <EOL> value = kwds [ prop . name ] <EOL> elif is_projection : <EOL> continue <EOL> else : <EOL> value = prop . default_value ( ) <EOL> try : <EOL> prop . __set__ ( self , value ) <EOL> except DerivedPropertyError : <EOL> if prop . name in kwds and not _from_entity : <EOL> raise <EOL> def key ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . is_saved ( ) : <EOL> return self . _entity . key ( ) <EOL> elif self . _key : <EOL> return self . _key <EOL> elif self . _key_name : <EOL> parent = self . _parent_key or ( self . _parent and self . _parent . key ( ) ) <EOL> self . _key = Key . from_path ( self . kind ( ) , self . _key_name , parent = parent , <EOL> _app = self . _app , namespace = self . __namespace ) <EOL> return self . _key <EOL> else : <EOL> raise NotSavedError ( ) <EOL> def __set_property ( self , entity , name , datastore_value ) : <EOL> if datastore_value == [ ] : <EOL> entity . pop ( name , None ) <EOL> else : <EOL> entity [ name ] = datastore_value <EOL> def _to_entity ( self , entity ) : <EOL> """<STR_LIT>""" <EOL> for prop in self . properties ( ) . values ( ) : <EOL> self . __set_property ( entity , prop . name , prop . get_value_for_datastore ( self ) ) <EOL> set_unindexed_properties = getattr ( entity , '<STR_LIT>' , None ) <EOL> if set_unindexed_properties : <EOL> set_unindexed_properties ( self . _unindexed_properties ) <EOL> def _populate_internal_entity ( self , _entity_class = datastore . Entity ) : <EOL> """<STR_LIT>""" <EOL> self . _entity = self . _populate_entity ( _entity_class = _entity_class ) <EOL> for prop in self . properties ( ) . values ( ) : <EOL> new_value = prop . get_updated_value_for_datastore ( self ) <EOL> if new_value is not AUTO_UPDATE_UNCHANGED : <EOL> self . __set_property ( self . _entity , prop . name , new_value ) <EOL> for attr in ( '<STR_LIT>' , '<STR_LIT>' ) : <EOL> try : <EOL> delattr ( self , attr ) <EOL> except AttributeError : <EOL> pass <EOL> return self . _entity <EOL> def put ( self , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> self . _populate_internal_entity ( ) <EOL> return datastore . Put ( self . _entity , ** kwargs ) <EOL> save = put <EOL> def _populate_entity ( self , _entity_class = datastore . Entity ) : <EOL> """<STR_LIT>""" <EOL> if self . is_saved ( ) : <EOL> entity = self . _entity <EOL> else : <EOL> kwds = { '<STR_LIT>' : self . _app , '<STR_LIT>' : self . __namespace , <EOL> '<STR_LIT>' : self . _unindexed_properties } <EOL> if self . _key is not None : <EOL> if self . _key . id ( ) : <EOL> kwds [ '<STR_LIT:id>' ] = self . _key . id ( ) <EOL> else : <EOL> kwds [ '<STR_LIT:name>' ] = self . _key . name ( ) <EOL> if self . _key . parent ( ) : <EOL> kwds [ '<STR_LIT>' ] = self . _key . parent ( ) <EOL> else : <EOL> if self . _key_name is not None : <EOL> kwds [ '<STR_LIT:name>' ] = self . _key_name <EOL> if self . _parent_key is not None : <EOL> kwds [ '<STR_LIT>' ] = self . _parent_key <EOL> elif self . _parent is not None : <EOL> kwds [ '<STR_LIT>' ] = self . _parent . _entity <EOL> entity = _entity_class ( self . kind ( ) , ** kwds ) <EOL> self . _to_entity ( entity ) <EOL> return entity <EOL> def delete ( self , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> datastore . Delete ( self . key ( ) , ** kwargs ) <EOL> self . _key = self . key ( ) <EOL> self . _key_name = None <EOL> self . _parent_key = None <EOL> self . _entity = None <EOL> def is_saved ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _entity is not None <EOL> def has_key ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . is_saved ( ) or self . _key or self . _key_name <EOL> def dynamic_properties ( self ) : <EOL> """<STR_LIT>""" <EOL> return [ ] <EOL> def instance_properties ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . dynamic_properties ( ) <EOL> def parent ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _parent is None : <EOL> parent_key = self . parent_key ( ) <EOL> if parent_key is not None : <EOL> self . _parent = get ( parent_key ) <EOL> return self . _parent <EOL> def parent_key ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _parent_key is not None : <EOL> return self . _parent_key <EOL> elif self . _parent is not None : <EOL> return self . _parent . key ( ) <EOL> elif self . _entity is not None : <EOL> return self . _entity . parent ( ) <EOL> elif self . _key is not None : <EOL> return self . _key . parent ( ) <EOL> else : <EOL> return None <EOL> def to_xml ( self , _entity_class = datastore . Entity ) : <EOL> """<STR_LIT>""" <EOL> entity = self . _populate_entity ( _entity_class ) <EOL> return entity . ToXml ( ) <EOL> @ classmethod <EOL> def get ( cls , keys , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> results = get ( keys , ** kwargs ) <EOL> if results is None : <EOL> return None <EOL> if isinstance ( results , Model ) : <EOL> instances = [ results ] <EOL> else : <EOL> instances = results <EOL> for instance in instances : <EOL> if not ( instance is None or isinstance ( instance , cls ) ) : <EOL> raise KindError ( '<STR_LIT>' % <EOL> ( instance . kind ( ) , cls . kind ( ) ) ) <EOL> return results <EOL> @ classmethod <EOL> def get_by_key_name ( cls , key_names , parent = None , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> parent = _coerce_to_key ( parent ) <EOL> except BadKeyError , e : <EOL> raise BadArgumentError ( str ( e ) ) <EOL> key_names , multiple = datastore . NormalizeAndTypeCheck ( key_names , basestring ) <EOL> keys = [ datastore . Key . from_path ( cls . kind ( ) , name , parent = parent ) <EOL> for name in key_names ] <EOL> if multiple : <EOL> return get ( keys , ** kwargs ) <EOL> else : <EOL> return get ( keys [ <NUM_LIT:0> ] , ** kwargs ) <EOL> @ classmethod <EOL> def get_by_id ( cls , ids , parent = None , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( parent , Model ) : <EOL> parent = parent . key ( ) <EOL> ids , multiple = datastore . NormalizeAndTypeCheck ( ids , ( int , long ) ) <EOL> keys = [ datastore . Key . from_path ( cls . kind ( ) , id , parent = parent ) <EOL> for id in ids ] <EOL> if multiple : <EOL> return get ( keys , ** kwargs ) <EOL> else : <EOL> return get ( keys [ <NUM_LIT:0> ] , ** kwargs ) <EOL> @ classmethod <EOL> def get_or_insert ( cls , key_name , ** kwds ) : <EOL> """<STR_LIT>""" <EOL> def txn ( ) : <EOL> entity = cls . get_by_key_name ( key_name , parent = kwds . get ( '<STR_LIT>' ) ) <EOL> if entity is None : <EOL> entity = cls ( key_name = key_name , ** kwds ) <EOL> entity . put ( ) <EOL> return entity <EOL> return run_in_transaction ( txn ) <EOL> @ classmethod <EOL> def all ( cls , ** kwds ) : <EOL> """<STR_LIT>""" <EOL> return Query ( cls , ** kwds ) <EOL> @ classmethod <EOL> def gql ( cls , query_string , * args , ** kwds ) : <EOL> """<STR_LIT>""" <EOL> return GqlQuery ( '<STR_LIT>' % ( cls . kind ( ) , query_string ) , <EOL> * args , ** kwds ) <EOL> @ classmethod <EOL> def _load_entity_values ( cls , entity ) : <EOL> """<STR_LIT>""" <EOL> entity_values = { } <EOL> for prop in cls . properties ( ) . values ( ) : <EOL> if prop . name in entity : <EOL> try : <EOL> value = entity [ prop . name ] <EOL> except KeyError : <EOL> entity_values [ prop . name ] = [ ] <EOL> else : <EOL> if entity . is_projection ( ) : <EOL> value = prop . make_value_from_datastore_index_value ( value ) <EOL> else : <EOL> value = prop . make_value_from_datastore ( value ) <EOL> entity_values [ prop . name ] = value <EOL> return entity_values <EOL> @ classmethod <EOL> def from_entity ( cls , entity ) : <EOL> """<STR_LIT>""" <EOL> if cls . kind ( ) != entity . kind ( ) : <EOL> raise KindError ( '<STR_LIT>' % <EOL> ( repr ( cls ) , entity . kind ( ) ) ) <EOL> entity_values = cls . _load_entity_values ( entity ) <EOL> if entity . key ( ) . has_id_or_name ( ) : <EOL> entity_values [ '<STR_LIT:key>' ] = entity . key ( ) <EOL> return cls ( None , _from_entity = entity , ** entity_values ) <EOL> @ classmethod <EOL> def kind ( cls ) : <EOL> """<STR_LIT>""" <EOL> return cls . __name__ <EOL> @ classmethod <EOL> def entity_type ( cls ) : <EOL> """<STR_LIT>""" <EOL> return cls . kind ( ) <EOL> @ classmethod <EOL> def properties ( cls ) : <EOL> """<STR_LIT>""" <EOL> return dict ( cls . _properties ) <EOL> @ classmethod <EOL> def fields ( cls ) : <EOL> """<STR_LIT>""" <EOL> return cls . properties ( ) <EOL> def create_rpc ( deadline = None , callback = None , read_policy = STRONG_CONSISTENCY ) : <EOL> """<STR_LIT>""" <EOL> return datastore . CreateRPC ( <EOL> deadline = deadline , callback = callback , read_policy = read_policy ) <EOL> def get_async ( keys , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> keys , multiple = datastore . NormalizeAndTypeCheckKeys ( keys ) <EOL> def extra_hook ( entities ) : <EOL> if not multiple and not entities : <EOL> return None <EOL> models = [ ] <EOL> for entity in entities : <EOL> if entity is None : <EOL> model = None <EOL> else : <EOL> cls1 = class_for_kind ( entity . kind ( ) ) <EOL> model = cls1 . from_entity ( entity ) <EOL> models . append ( model ) <EOL> if multiple : <EOL> return models <EOL> assert len ( models ) == <NUM_LIT:1> <EOL> return models [ <NUM_LIT:0> ] <EOL> return datastore . GetAsync ( keys , extra_hook = extra_hook , ** kwargs ) <EOL> def get ( keys , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return get_async ( keys , ** kwargs ) . get_result ( ) <EOL> def put_async ( models , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> models , multiple = datastore . NormalizeAndTypeCheck ( models , Model ) <EOL> entities = [ model . _populate_internal_entity ( ) for model in models ] <EOL> def extra_hook ( keys ) : <EOL> if multiple : <EOL> return keys <EOL> assert len ( keys ) == <NUM_LIT:1> <EOL> return keys [ <NUM_LIT:0> ] <EOL> return datastore . PutAsync ( entities , extra_hook = extra_hook , ** kwargs ) <EOL> def put ( models , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return put_async ( models , ** kwargs ) . get_result ( ) <EOL> save = put <EOL> def delete_async ( models , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( models , ( basestring , Model , Key ) ) : <EOL> models = [ models ] <EOL> else : <EOL> try : <EOL> models = iter ( models ) <EOL> except TypeError : <EOL> models = [ models ] <EOL> keys = [ _coerce_to_key ( v ) for v in models ] <EOL> return datastore . DeleteAsync ( keys , ** kwargs ) <EOL> def delete ( models , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> delete_async ( models , ** kwargs ) . get_result ( ) <EOL> def allocate_ids_async ( model , size , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return datastore . AllocateIdsAsync ( _coerce_to_key ( model ) , size = size , ** kwargs ) <EOL> def allocate_ids ( model , size , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return allocate_ids_async ( model , size , ** kwargs ) . get_result ( ) <EOL> def allocate_id_range ( model , start , end , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> key = _coerce_to_key ( model ) <EOL> datastore . NormalizeAndTypeCheck ( ( start , end ) , ( int , long ) ) <EOL> if start < <NUM_LIT:1> or end < <NUM_LIT:1> : <EOL> raise BadArgumentError ( '<STR_LIT>' % <EOL> ( start , end ) ) <EOL> if start > end : <EOL> raise BadArgumentError ( '<STR_LIT>' % <EOL> ( end , start ) ) <EOL> safe_start , _ = datastore . AllocateIds ( key , max = end , ** kwargs ) <EOL> race_condition = safe_start > start <EOL> start_key = Key . from_path ( key . kind ( ) , start , parent = key . parent ( ) , <EOL> _app = key . app ( ) , namespace = key . namespace ( ) ) <EOL> end_key = Key . from_path ( key . kind ( ) , end , parent = key . parent ( ) , <EOL> _app = key . app ( ) , namespace = key . namespace ( ) ) <EOL> collision = ( Query ( keys_only = True , namespace = key . namespace ( ) , _app = key . app ( ) ) <EOL> . filter ( '<STR_LIT>' , start_key ) <EOL> . filter ( '<STR_LIT>' , end_key ) . fetch ( <NUM_LIT:1> ) ) <EOL> if collision : <EOL> return KEY_RANGE_COLLISION <EOL> elif race_condition : <EOL> return KEY_RANGE_CONTENTION <EOL> else : <EOL> return KEY_RANGE_EMPTY <EOL> def _index_converter ( index ) : <EOL> return Index ( index . Id ( ) , <EOL> index . Kind ( ) , <EOL> index . HasAncestor ( ) , <EOL> index . Properties ( ) ) <EOL> def get_indexes_async ( ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> def extra_hook ( indexes ) : <EOL> return [ ( _index_converter ( index ) , state ) for index , state in indexes ] <EOL> return datastore . GetIndexesAsync ( extra_hook = extra_hook , ** kwargs ) <EOL> def get_indexes ( ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return get_indexes_async ( ** kwargs ) . get_result ( ) <EOL> class Expando ( Model ) : <EOL> """<STR_LIT>""" <EOL> _dynamic_properties = None <EOL> def __init__ ( self , parent = None , key_name = None , _app = None , ** kwds ) : <EOL> """<STR_LIT>""" <EOL> super ( Expando , self ) . __init__ ( parent , key_name , _app , ** kwds ) <EOL> self . _dynamic_properties = { } <EOL> for prop , value in kwds . iteritems ( ) : <EOL> if prop not in self . _all_properties and prop != '<STR_LIT:key>' : <EOL> if not ( hasattr ( getattr ( type ( self ) , prop , None ) , '<STR_LIT>' ) ) : <EOL> setattr ( self , prop , value ) <EOL> else : <EOL> check_reserved_word ( prop ) <EOL> def __setattr__ ( self , key , value ) : <EOL> """<STR_LIT>""" <EOL> check_reserved_word ( key ) <EOL> if ( key [ : <NUM_LIT:1> ] != '<STR_LIT:_>' and <EOL> not hasattr ( getattr ( type ( self ) , key , None ) , '<STR_LIT>' ) ) : <EOL> if value == [ ] : <EOL> raise ValueError ( '<STR_LIT>' % <EOL> key ) <EOL> if type ( value ) not in _ALLOWED_EXPANDO_PROPERTY_TYPES : <EOL> raise TypeError ( "<STR_LIT>" % <EOL> type ( value ) . __name__ ) <EOL> if self . _dynamic_properties is None : <EOL> self . _dynamic_properties = { } <EOL> self . _dynamic_properties [ key ] = value <EOL> else : <EOL> super ( Expando , self ) . __setattr__ ( key , value ) <EOL> def __getattribute__ ( self , key ) : <EOL> """<STR_LIT>""" <EOL> if not key . startswith ( '<STR_LIT:_>' ) : <EOL> dynamic_properties = self . _dynamic_properties <EOL> if dynamic_properties is not None and key in dynamic_properties : <EOL> return self . __getattr__ ( key ) <EOL> return super ( Expando , self ) . __getattribute__ ( key ) <EOL> def __getattr__ ( self , key ) : <EOL> """<STR_LIT>""" <EOL> _dynamic_properties = self . _dynamic_properties <EOL> if _dynamic_properties is not None and key in _dynamic_properties : <EOL> return _dynamic_properties [ key ] <EOL> else : <EOL> return getattr ( super ( Expando , self ) , key ) <EOL> def __delattr__ ( self , key ) : <EOL> """<STR_LIT>""" <EOL> if self . _dynamic_properties and key in self . _dynamic_properties : <EOL> del self . _dynamic_properties [ key ] <EOL> else : <EOL> object . __delattr__ ( self , key ) <EOL> def dynamic_properties ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _dynamic_properties is None : <EOL> return [ ] <EOL> return self . _dynamic_properties . keys ( ) <EOL> def _to_entity ( self , entity ) : <EOL> """<STR_LIT>""" <EOL> super ( Expando , self ) . _to_entity ( entity ) <EOL> if self . _dynamic_properties is None : <EOL> self . _dynamic_properties = { } <EOL> for key , value in self . _dynamic_properties . iteritems ( ) : <EOL> entity [ key ] = value <EOL> all_properties = set ( self . _dynamic_properties . iterkeys ( ) ) <EOL> all_properties . update ( self . _all_properties ) <EOL> for key in entity . keys ( ) : <EOL> if key not in all_properties : <EOL> del entity [ key ] <EOL> @ classmethod <EOL> def _load_entity_values ( cls , entity ) : <EOL> """<STR_LIT>""" <EOL> entity_values = super ( Expando , cls ) . _load_entity_values ( entity ) <EOL> for key , value in entity . iteritems ( ) : <EOL> if key not in entity_values : <EOL> entity_values [ str ( key ) ] = value <EOL> return entity_values <EOL> class _BaseQuery ( object ) : <EOL> """<STR_LIT>""" <EOL> _last_raw_query = None <EOL> _last_index_list = None <EOL> _cursor = None <EOL> _end_cursor = None <EOL> def __init__ ( self , model_class = None ) : <EOL> """<STR_LIT>""" <EOL> self . _model_class = model_class <EOL> def is_keys_only ( self ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError <EOL> def projection ( self ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError <EOL> def is_distinct ( self ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError <EOL> def _get_query ( self ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError <EOL> def run ( self , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> raw_query = self . _get_query ( ) <EOL> iterator = raw_query . Run ( ** kwargs ) <EOL> self . _last_raw_query = raw_query <EOL> keys_only = kwargs . get ( '<STR_LIT>' ) <EOL> if keys_only is None : <EOL> keys_only = self . is_keys_only ( ) <EOL> if keys_only : <EOL> return iterator <EOL> else : <EOL> return _QueryIterator ( self . _model_class , iter ( iterator ) ) <EOL> def __iter__ ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . run ( ) <EOL> def __getstate__ ( self ) : <EOL> state = self . __dict__ . copy ( ) <EOL> state [ '<STR_LIT>' ] = None <EOL> return state <EOL> def get ( self , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> results = self . run ( limit = <NUM_LIT:1> , ** kwargs ) <EOL> try : <EOL> return results . next ( ) <EOL> except StopIteration : <EOL> return None <EOL> def count ( self , limit = <NUM_LIT:1000> , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> raw_query = self . _get_query ( ) <EOL> result = raw_query . Count ( limit = limit , ** kwargs ) <EOL> self . _last_raw_query = raw_query <EOL> return result <EOL> def fetch ( self , limit , offset = <NUM_LIT:0> , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> if limit is None : <EOL> kwargs . setdefault ( '<STR_LIT>' , datastore . _MAX_INT_32 ) <EOL> return list ( self . run ( limit = limit , offset = offset , ** kwargs ) ) <EOL> def index_list ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _last_raw_query is None : <EOL> raise AssertionError ( '<STR_LIT>' ) <EOL> if self . _last_index_list is None : <EOL> raw_index_list = self . _last_raw_query . GetIndexList ( ) <EOL> self . _last_index_list = [ _index_converter ( raw_index ) <EOL> for raw_index in raw_index_list ] <EOL> return self . _last_index_list <EOL> def cursor ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _last_raw_query is None : <EOL> raise AssertionError ( '<STR_LIT>' ) <EOL> cursor = self . _last_raw_query . GetCursor ( ) <EOL> return websafe_encode_cursor ( cursor ) <EOL> def with_cursor ( self , start_cursor = None , end_cursor = None ) : <EOL> """<STR_LIT>""" <EOL> if start_cursor is None : <EOL> self . _cursor = None <EOL> else : <EOL> self . _cursor = websafe_decode_cursor ( start_cursor ) <EOL> if end_cursor is None : <EOL> self . _end_cursor = None <EOL> else : <EOL> self . _end_cursor = websafe_decode_cursor ( end_cursor ) <EOL> return self <EOL> def __getitem__ ( self , arg ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( arg , slice ) : <EOL> start , stop , step = arg . start , arg . stop , arg . step <EOL> if start is None : <EOL> start = <NUM_LIT:0> <EOL> if stop is None : <EOL> raise ValueError ( '<STR_LIT>' ) <EOL> if step is None : <EOL> step = <NUM_LIT:1> <EOL> if start < <NUM_LIT:0> or stop < <NUM_LIT:0> or step != <NUM_LIT:1> : <EOL> raise ValueError ( <EOL> '<STR_LIT>' ) <EOL> limit = stop - start <EOL> if limit < <NUM_LIT:0> : <EOL> return [ ] <EOL> return self . fetch ( limit , start ) <EOL> elif isinstance ( arg , ( int , long ) ) : <EOL> if arg < <NUM_LIT:0> : <EOL> raise ValueError ( '<STR_LIT>' ) <EOL> results = self . fetch ( <NUM_LIT:1> , arg ) <EOL> if results : <EOL> return results [ <NUM_LIT:0> ] <EOL> else : <EOL> raise IndexError ( '<STR_LIT>' % ( arg + <NUM_LIT:1> ) ) <EOL> else : <EOL> raise TypeError ( '<STR_LIT>' ) <EOL> class _QueryIterator ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , model_class , datastore_iterator ) : <EOL> """<STR_LIT>""" <EOL> self . __model_class = model_class <EOL> self . __iterator = datastore_iterator <EOL> def __iter__ ( self ) : <EOL> """<STR_LIT>""" <EOL> return self <EOL> def next ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . __model_class is not None : <EOL> return self . __model_class . from_entity ( self . __iterator . next ( ) ) <EOL> else : <EOL> while True : <EOL> entity = self . __iterator . next ( ) <EOL> try : <EOL> model_class = class_for_kind ( entity . kind ( ) ) <EOL> except KindError : <EOL> if datastore_types . RESERVED_PROPERTY_NAME . match ( entity . kind ( ) ) : <EOL> continue <EOL> raise <EOL> else : <EOL> return model_class . from_entity ( entity ) <EOL> def _normalize_query_parameter ( value ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( value , Model ) : <EOL> value = value . key ( ) <EOL> if ( isinstance ( value , datetime . date ) and <EOL> not isinstance ( value , datetime . datetime ) ) : <EOL> value = _date_to_datetime ( value ) <EOL> elif isinstance ( value , datetime . time ) : <EOL> value = _time_to_datetime ( value ) <EOL> return value <EOL> class Query ( _BaseQuery ) : <EOL> """<STR_LIT>""" <EOL> _keys_only = False <EOL> _distinct = False <EOL> _projection = None <EOL> _namespace = None <EOL> _app = None <EOL> __ancestor = None <EOL> def __init__ ( self , model_class = None , keys_only = False , cursor = None , <EOL> namespace = None , _app = None , distinct = False , projection = None ) : <EOL> """<STR_LIT>""" <EOL> super ( Query , self ) . __init__ ( model_class ) <EOL> if keys_only : <EOL> self . _keys_only = True <EOL> if projection : <EOL> self . _projection = projection <EOL> if namespace is not None : <EOL> self . _namespace = namespace <EOL> if _app is not None : <EOL> self . _app = _app <EOL> if distinct : <EOL> self . _distinct = True <EOL> self . __query_sets = [ { } ] <EOL> self . __orderings = [ ] <EOL> self . with_cursor ( cursor ) <EOL> def is_keys_only ( self ) : <EOL> return self . _keys_only <EOL> def projection ( self ) : <EOL> return self . _projection <EOL> def is_distinct ( self ) : <EOL> return self . _distinct <EOL> def _get_query ( self , <EOL> _query_class = datastore . Query , <EOL> _multi_query_class = datastore . MultiQuery ) : <EOL> queries = [ ] <EOL> for query_set in self . __query_sets : <EOL> if self . _model_class is not None : <EOL> kind = self . _model_class . kind ( ) <EOL> else : <EOL> kind = None <EOL> query = _query_class ( kind , <EOL> query_set , <EOL> keys_only = self . _keys_only , <EOL> projection = self . _projection , <EOL> distinct = self . _distinct , <EOL> compile = True , <EOL> cursor = self . _cursor , <EOL> end_cursor = self . _end_cursor , <EOL> namespace = self . _namespace , <EOL> _app = self . _app ) <EOL> query . Order ( * self . __orderings ) <EOL> if self . __ancestor is not None : <EOL> query . Ancestor ( self . __ancestor ) <EOL> queries . append ( query ) <EOL> if ( _query_class != datastore . Query and <EOL> _multi_query_class == datastore . MultiQuery ) : <EOL> warnings . warn ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' , RuntimeWarning ) <EOL> if len ( queries ) > <NUM_LIT:1> : <EOL> raise datastore_errors . BadArgumentError ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> elif ( _query_class == datastore . Query and <EOL> _multi_query_class != datastore . MultiQuery ) : <EOL> raise BadArgumentError ( '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> if len ( queries ) == <NUM_LIT:1> : <EOL> return queries [ <NUM_LIT:0> ] <EOL> else : <EOL> return _multi_query_class ( queries , self . __orderings ) <EOL> def __filter_disjunction ( self , operations , values ) : <EOL> """<STR_LIT>""" <EOL> if not isinstance ( operations , ( list , tuple ) ) : <EOL> operations = [ operations ] <EOL> if not isinstance ( values , ( list , tuple ) ) : <EOL> values = [ values ] <EOL> new_query_sets = [ ] <EOL> for operation in operations : <EOL> if operation . lower ( ) . endswith ( '<STR_LIT>' ) or operation . endswith ( '<STR_LIT>' ) : <EOL> raise BadQueryError ( '<STR_LIT>' ) <EOL> for query_set in self . __query_sets : <EOL> for value in values : <EOL> new_query_set = copy . deepcopy ( query_set ) <EOL> datastore . _AddOrAppend ( new_query_set , operation , value ) <EOL> new_query_sets . append ( new_query_set ) <EOL> self . __query_sets = new_query_sets <EOL> def filter ( self , property_operator , value ) : <EOL> """<STR_LIT>""" <EOL> match = _FILTER_REGEX . match ( property_operator ) <EOL> prop = match . group ( <NUM_LIT:1> ) <EOL> if match . group ( <NUM_LIT:3> ) is not None : <EOL> operator = match . group ( <NUM_LIT:3> ) <EOL> else : <EOL> operator = '<STR_LIT>' <EOL> if self . _model_class is None : <EOL> if prop != datastore_types . KEY_SPECIAL_PROPERTY : <EOL> raise BadQueryError ( <EOL> '<STR_LIT>' % <EOL> datastore_types . KEY_SPECIAL_PROPERTY ) <EOL> elif prop in self . _model_class . _unindexed_properties : <EOL> raise PropertyError ( '<STR_LIT>' % prop ) <EOL> if operator . lower ( ) == '<STR_LIT>' : <EOL> if self . _keys_only : <EOL> raise BadQueryError ( '<STR_LIT>' ) <EOL> elif not isinstance ( value , ( list , tuple ) ) : <EOL> raise BadValueError ( '<STR_LIT>' ) <EOL> values = [ _normalize_query_parameter ( v ) for v in value ] <EOL> self . __filter_disjunction ( prop + '<STR_LIT>' , values ) <EOL> else : <EOL> if isinstance ( value , ( list , tuple ) ) : <EOL> raise BadValueError ( '<STR_LIT>' ) <EOL> if operator == '<STR_LIT>' : <EOL> if self . _keys_only : <EOL> raise BadQueryError ( '<STR_LIT>' ) <EOL> self . __filter_disjunction ( [ prop + '<STR_LIT>' , prop + '<STR_LIT>' ] , <EOL> _normalize_query_parameter ( value ) ) <EOL> else : <EOL> value = _normalize_query_parameter ( value ) <EOL> for query_set in self . __query_sets : <EOL> datastore . _AddOrAppend ( query_set , property_operator , value ) <EOL> return self <EOL> def order ( self , property ) : <EOL> """<STR_LIT>""" <EOL> if property . startswith ( '<STR_LIT:->' ) : <EOL> property = property [ <NUM_LIT:1> : ] <EOL> order = datastore . Query . DESCENDING <EOL> else : <EOL> order = datastore . Query . ASCENDING <EOL> if self . _model_class is None : <EOL> if ( property != datastore_types . KEY_SPECIAL_PROPERTY or <EOL> order != datastore . Query . ASCENDING ) : <EOL> raise BadQueryError ( <EOL> '<STR_LIT>' % <EOL> datastore_types . KEY_SPECIAL_PROPERTY ) <EOL> else : <EOL> if not issubclass ( self . _model_class , Expando ) : <EOL> if ( property not in self . _model_class . _all_properties and <EOL> property not in datastore_types . _SPECIAL_PROPERTIES ) : <EOL> raise PropertyError ( '<STR_LIT>' % property ) <EOL> if property in self . _model_class . _unindexed_properties : <EOL> raise PropertyError ( '<STR_LIT>' % property ) <EOL> self . __orderings . append ( ( property , order ) ) <EOL> return self <EOL> def ancestor ( self , ancestor ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( ancestor , datastore . Key ) : <EOL> if ancestor . has_id_or_name ( ) : <EOL> self . __ancestor = ancestor <EOL> else : <EOL> raise NotSavedError ( ) <EOL> elif isinstance ( ancestor , Model ) : <EOL> if ancestor . has_key ( ) : <EOL> self . __ancestor = ancestor . key ( ) <EOL> else : <EOL> raise NotSavedError ( ) <EOL> else : <EOL> raise TypeError ( '<STR_LIT>' ) <EOL> return self <EOL> class GqlQuery ( _BaseQuery ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , query_string , * args , ** kwds ) : <EOL> """<STR_LIT>""" <EOL> from google . appengine . ext import gql <EOL> app = kwds . pop ( '<STR_LIT>' , None ) <EOL> namespace = None <EOL> if isinstance ( app , tuple ) : <EOL> if len ( app ) != <NUM_LIT:2> : <EOL> raise BadArgumentError ( '<STR_LIT>' ) <EOL> app , namespace = app <EOL> self . _proto_query = gql . GQL ( query_string , _app = app , namespace = namespace ) <EOL> if self . _proto_query . _kind is not None : <EOL> model_class = class_for_kind ( self . _proto_query . _kind ) <EOL> else : <EOL> model_class = None <EOL> super ( GqlQuery , self ) . __init__ ( model_class ) <EOL> if model_class is not None : <EOL> for property , unused in ( self . _proto_query . filters ( ) . keys ( ) + <EOL> self . _proto_query . orderings ( ) ) : <EOL> if property in model_class . _unindexed_properties : <EOL> raise PropertyError ( '<STR_LIT>' % property ) <EOL> self . bind ( * args , ** kwds ) <EOL> def is_keys_only ( self ) : <EOL> return self . _proto_query . _keys_only <EOL> def projection ( self ) : <EOL> return self . _proto_query . projection ( ) <EOL> def is_distinct ( self ) : <EOL> return self . _proto_query . is_distinct ( ) <EOL> def bind ( self , * args , ** kwds ) : <EOL> """<STR_LIT>""" <EOL> self . _args = [ ] <EOL> for arg in args : <EOL> self . _args . append ( _normalize_query_parameter ( arg ) ) <EOL> self . _kwds = { } <EOL> for name , arg in kwds . iteritems ( ) : <EOL> self . _kwds [ name ] = _normalize_query_parameter ( arg ) <EOL> def run ( self , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> if self . _proto_query . limit ( ) > <NUM_LIT:0> : <EOL> kwargs . setdefault ( '<STR_LIT>' , self . _proto_query . limit ( ) ) <EOL> kwargs . setdefault ( '<STR_LIT>' , self . _proto_query . offset ( ) ) <EOL> return _BaseQuery . run ( self , ** kwargs ) <EOL> def _get_query ( self ) : <EOL> return self . _proto_query . Bind ( self . _args , self . _kwds , <EOL> self . _cursor , self . _end_cursor ) <EOL> class UnindexedProperty ( Property ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , * args , ** kwds ) : <EOL> """<STR_LIT>""" <EOL> self . _require_parameter ( kwds , '<STR_LIT>' , False ) <EOL> kwds [ '<STR_LIT>' ] = True <EOL> super ( UnindexedProperty , self ) . __init__ ( * args , ** kwds ) <EOL> def validate ( self , value ) : <EOL> """<STR_LIT>""" <EOL> if value is not None and not isinstance ( value , self . data_type ) : <EOL> try : <EOL> value = self . data_type ( value ) <EOL> except TypeError , err : <EOL> raise BadValueError ( '<STR_LIT>' <EOL> '<STR_LIT>' % <EOL> ( self . name , self . data_type . __name__ , err ) ) <EOL> value = super ( UnindexedProperty , self ) . validate ( value ) <EOL> if value is not None and not isinstance ( value , self . data_type ) : <EOL> raise BadValueError ( '<STR_LIT>' % <EOL> ( self . name , self . data_type . __name__ ) ) <EOL> return value <EOL> class TextProperty ( UnindexedProperty ) : <EOL> """<STR_LIT>""" <EOL> data_type = Text <EOL> class StringProperty ( Property ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , verbose_name = None , multiline = False , ** kwds ) : <EOL> """<STR_LIT>""" <EOL> super ( StringProperty , self ) . __init__ ( verbose_name , ** kwds ) <EOL> self . multiline = multiline <EOL> def validate ( self , value ) : <EOL> """<STR_LIT>""" <EOL> value = super ( StringProperty , self ) . validate ( value ) <EOL> if value is not None and not isinstance ( value , basestring ) : <EOL> raise BadValueError ( <EOL> '<STR_LIT>' <EOL> % ( self . name , type ( value ) . __name__ ) ) <EOL> if not self . multiline and value and value . find ( '<STR_LIT:\n>' ) != - <NUM_LIT:1> : <EOL> raise BadValueError ( '<STR_LIT>' % self . name ) <EOL> if value is not None and len ( value ) > self . MAX_LENGTH : <EOL> raise BadValueError ( <EOL> '<STR_LIT>' <EOL> % ( self . name , len ( value ) , self . MAX_LENGTH ) ) <EOL> return value <EOL> MAX_LENGTH = <NUM_LIT> <EOL> data_type = basestring <EOL> class _CoercingProperty ( Property ) : <EOL> """<STR_LIT>""" <EOL> def validate ( self , value ) : <EOL> """<STR_LIT>""" <EOL> value = super ( _CoercingProperty , self ) . validate ( value ) <EOL> if value is not None and not isinstance ( value , self . data_type ) : <EOL> value = self . data_type ( value ) <EOL> return value <EOL> class CategoryProperty ( _CoercingProperty ) : <EOL> """<STR_LIT>""" <EOL> data_type = Category <EOL> class LinkProperty ( _CoercingProperty ) : <EOL> """<STR_LIT>""" <EOL> def validate ( self , value ) : <EOL> value = super ( LinkProperty , self ) . validate ( value ) <EOL> if value is not None : <EOL> scheme , netloc , path , query , fragment = urlparse . urlsplit ( value ) <EOL> if not scheme or not netloc : <EOL> raise BadValueError ( '<STR_LIT>' % <EOL> ( self . name , value ) ) <EOL> return value <EOL> data_type = Link <EOL> URLProperty = LinkProperty <EOL> class EmailProperty ( _CoercingProperty ) : <EOL> """<STR_LIT>""" <EOL> data_type = Email <EOL> class GeoPtProperty ( _CoercingProperty ) : <EOL> """<STR_LIT>""" <EOL> data_type = GeoPt <EOL> class IMProperty ( _CoercingProperty ) : <EOL> """<STR_LIT>""" <EOL> data_type = IM <EOL> class PhoneNumberProperty ( _CoercingProperty ) : <EOL> """<STR_LIT>""" <EOL> data_type = PhoneNumber <EOL> class PostalAddressProperty ( _CoercingProperty ) : <EOL> """<STR_LIT>""" <EOL> data_type = PostalAddress <EOL> class BlobProperty ( UnindexedProperty ) : <EOL> """<STR_LIT>""" <EOL> data_type = Blob <EOL> class ByteStringProperty ( Property ) : <EOL> """<STR_LIT>""" <EOL> def validate ( self , value ) : <EOL> """<STR_LIT>""" <EOL> if value is not None and not isinstance ( value , ByteString ) : <EOL> try : <EOL> value = ByteString ( value ) <EOL> except TypeError , err : <EOL> raise BadValueError ( '<STR_LIT>' <EOL> '<STR_LIT>' % ( self . name , err ) ) <EOL> value = super ( ByteStringProperty , self ) . validate ( value ) <EOL> if value is not None and not isinstance ( value , ByteString ) : <EOL> raise BadValueError ( '<STR_LIT>' <EOL> % self . name ) <EOL> if value is not None and len ( value ) > self . MAX_LENGTH : <EOL> raise BadValueError ( <EOL> '<STR_LIT>' <EOL> % ( self . name , len ( value ) , self . MAX_LENGTH ) ) <EOL> return value <EOL> MAX_LENGTH = <NUM_LIT> <EOL> data_type = ByteString <EOL> class DateTimeProperty ( Property ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , verbose_name = None , auto_now = False , auto_now_add = False , <EOL> ** kwds ) : <EOL> """<STR_LIT>""" <EOL> super ( DateTimeProperty , self ) . __init__ ( verbose_name , ** kwds ) <EOL> self . auto_now = auto_now <EOL> self . auto_now_add = auto_now_add <EOL> def validate ( self , value ) : <EOL> """<STR_LIT>""" <EOL> value = super ( DateTimeProperty , self ) . validate ( value ) <EOL> if value and not isinstance ( value , self . data_type ) : <EOL> raise BadValueError ( '<STR_LIT>' % <EOL> ( self . name , self . data_type . __name__ , value ) ) <EOL> return value <EOL> def default_value ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . auto_now or self . auto_now_add : <EOL> return self . now ( ) <EOL> return Property . default_value ( self ) <EOL> def get_updated_value_for_datastore ( self , model_instance ) : <EOL> """<STR_LIT>""" <EOL> if self . auto_now : <EOL> return self . now ( ) <EOL> return AUTO_UPDATE_UNCHANGED <EOL> data_type = datetime . datetime <EOL> @ staticmethod <EOL> def now ( ) : <EOL> """<STR_LIT>""" <EOL> return datetime . datetime . now ( ) <EOL> def _date_to_datetime ( value ) : <EOL> """<STR_LIT>""" <EOL> assert isinstance ( value , datetime . date ) <EOL> return datetime . datetime ( value . year , value . month , value . day ) <EOL> def _time_to_datetime ( value ) : <EOL> """<STR_LIT>""" <EOL> assert isinstance ( value , datetime . time ) <EOL> return datetime . datetime ( <NUM_LIT> , <NUM_LIT:1> , <NUM_LIT:1> , <EOL> value . hour , value . minute , value . second , <EOL> value . microsecond ) <EOL> class DateProperty ( DateTimeProperty ) : <EOL> """<STR_LIT>""" <EOL> @ staticmethod <EOL> def now ( ) : <EOL> """<STR_LIT>""" <EOL> return datetime . datetime . now ( ) . date ( ) <EOL> def validate ( self , value ) : <EOL> """<STR_LIT>""" <EOL> value = super ( DateProperty , self ) . validate ( value ) <EOL> if isinstance ( value , datetime . datetime ) : <EOL> raise BadValueError ( '<STR_LIT>' % <EOL> ( self . name , self . data_type . __name__ ) ) <EOL> return value <EOL> def get_updated_value_for_datastore ( self , model_instance ) : <EOL> """<STR_LIT>""" <EOL> if self . auto_now : <EOL> return _date_to_datetime ( self . now ( ) ) <EOL> return AUTO_UPDATE_UNCHANGED <EOL> def get_value_for_datastore ( self , model_instance ) : <EOL> """<STR_LIT>""" <EOL> value = super ( DateProperty , self ) . get_value_for_datastore ( model_instance ) <EOL> if value is not None : <EOL> assert isinstance ( value , datetime . date ) <EOL> value = _date_to_datetime ( value ) <EOL> return value <EOL> def make_value_from_datastore ( self , value ) : <EOL> """<STR_LIT>""" <EOL> if value is not None : <EOL> assert isinstance ( value , datetime . datetime ) <EOL> value = value . date ( ) <EOL> return value <EOL> data_type = datetime . date <EOL> class TimeProperty ( DateTimeProperty ) : <EOL> """<STR_LIT>""" <EOL> @ staticmethod <EOL> def now ( ) : <EOL> """<STR_LIT>""" <EOL> return datetime . datetime . now ( ) . time ( ) <EOL> def empty ( self , value ) : <EOL> """<STR_LIT>""" <EOL> return value is None <EOL> def get_updated_value_for_datastore ( self , model_instance ) : <EOL> """<STR_LIT>""" <EOL> if self . auto_now : <EOL> return _time_to_datetime ( self . now ( ) ) <EOL> return AUTO_UPDATE_UNCHANGED <EOL> def get_value_for_datastore ( self , model_instance ) : <EOL> """<STR_LIT>""" <EOL> value = super ( TimeProperty , self ) . get_value_for_datastore ( model_instance ) <EOL> if value is not None : <EOL> assert isinstance ( value , datetime . time ) , repr ( value ) <EOL> value = _time_to_datetime ( value ) <EOL> return value <EOL> def make_value_from_datastore ( self , value ) : <EOL> """<STR_LIT>""" <EOL> if value is not None : <EOL> assert isinstance ( value , datetime . datetime ) <EOL> value = value . time ( ) <EOL> return value <EOL> data_type = datetime . time <EOL> class IntegerProperty ( Property ) : <EOL> """<STR_LIT>""" <EOL> def validate ( self , value ) : <EOL> """<STR_LIT>""" <EOL> value = super ( IntegerProperty , self ) . validate ( value ) <EOL> if value is None : <EOL> return value <EOL> if not isinstance ( value , ( int , long ) ) or isinstance ( value , bool ) : <EOL> raise BadValueError ( '<STR_LIT>' <EOL> % ( self . name , type ( value ) . __name__ ) ) <EOL> if value < - <NUM_LIT> or value > <NUM_LIT> : <EOL> raise BadValueError ( '<STR_LIT>' % self . name ) <EOL> return value <EOL> data_type = int <EOL> def empty ( self , value ) : <EOL> """<STR_LIT>""" <EOL> return value is None <EOL> class RatingProperty ( _CoercingProperty , IntegerProperty ) : <EOL> """<STR_LIT>""" <EOL> data_type = Rating <EOL> class FloatProperty ( Property ) : <EOL> """<STR_LIT>""" <EOL> def validate ( self , value ) : <EOL> """<STR_LIT>""" <EOL> value = super ( FloatProperty , self ) . validate ( value ) <EOL> if value is not None and not isinstance ( value , float ) : <EOL> raise BadValueError ( '<STR_LIT>' % self . name ) <EOL> return value <EOL> data_type = float <EOL> def empty ( self , value ) : <EOL> """<STR_LIT>""" <EOL> return value is None <EOL> class BooleanProperty ( Property ) : <EOL> """<STR_LIT>""" <EOL> def validate ( self , value ) : <EOL> """<STR_LIT>""" <EOL> value = super ( BooleanProperty , self ) . validate ( value ) <EOL> if value is not None and not isinstance ( value , bool ) : <EOL> raise BadValueError ( '<STR_LIT>' % self . name ) <EOL> return value <EOL> data_type = bool <EOL> def empty ( self , value ) : <EOL> """<STR_LIT>""" <EOL> return value is None <EOL> class UserProperty ( Property ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , <EOL> verbose_name = None , <EOL> name = None , <EOL> required = False , <EOL> validator = None , <EOL> choices = None , <EOL> auto_current_user = False , <EOL> auto_current_user_add = False , <EOL> indexed = True ) : <EOL> """<STR_LIT>""" <EOL> super ( UserProperty , self ) . __init__ ( verbose_name , name , <EOL> required = required , <EOL> validator = validator , <EOL> choices = choices , <EOL> indexed = indexed ) <EOL> self . auto_current_user = auto_current_user <EOL> self . auto_current_user_add = auto_current_user_add <EOL> def validate ( self , value ) : <EOL> """<STR_LIT>""" <EOL> value = super ( UserProperty , self ) . validate ( value ) <EOL> if value is not None and not isinstance ( value , users . User ) : <EOL> raise BadValueError ( '<STR_LIT>' % self . name ) <EOL> return value <EOL> def default_value ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . auto_current_user or self . auto_current_user_add : <EOL> return users . get_current_user ( ) <EOL> return None <EOL> def get_updated_value_for_datastore ( self , model_instance ) : <EOL> """<STR_LIT>""" <EOL> if self . auto_current_user : <EOL> return users . get_current_user ( ) <EOL> return AUTO_UPDATE_UNCHANGED <EOL> data_type = users . User <EOL> class ListProperty ( Property ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , item_type , verbose_name = None , default = None , ** kwds ) : <EOL> """<STR_LIT>""" <EOL> if item_type is str : <EOL> item_type = basestring <EOL> if not isinstance ( item_type , type ) : <EOL> raise TypeError ( '<STR_LIT>' ) <EOL> if item_type not in _ALLOWED_PROPERTY_TYPES : <EOL> raise ValueError ( '<STR_LIT>' % item_type . __name__ ) <EOL> if issubclass ( item_type , ( Blob , Text ) ) : <EOL> self . _require_parameter ( kwds , '<STR_LIT>' , False ) <EOL> kwds [ '<STR_LIT>' ] = True <EOL> self . _require_parameter ( kwds , '<STR_LIT>' , True ) <EOL> if default is None : <EOL> default = [ ] <EOL> self . item_type = item_type <EOL> super ( ListProperty , self ) . __init__ ( verbose_name , <EOL> default = default , <EOL> ** kwds ) <EOL> def validate ( self , value ) : <EOL> """<STR_LIT>""" <EOL> value = super ( ListProperty , self ) . validate ( value ) <EOL> if value is not None : <EOL> if not isinstance ( value , list ) : <EOL> raise BadValueError ( '<STR_LIT>' % self . name ) <EOL> value = self . validate_list_contents ( value ) <EOL> return value <EOL> def _load ( self , model_instance , value ) : <EOL> if not isinstance ( value , list ) : <EOL> value = [ value ] <EOL> return super ( ListProperty , self ) . _load ( model_instance , value ) <EOL> def validate_list_contents ( self , value ) : <EOL> """<STR_LIT>""" <EOL> if self . item_type in ( int , long ) : <EOL> item_type = ( int , long ) <EOL> else : <EOL> item_type = self . item_type <EOL> for item in value : <EOL> if not isinstance ( item , item_type ) : <EOL> if item_type == ( int , long ) : <EOL> raise BadValueError ( '<STR_LIT>' % <EOL> self . name ) <EOL> else : <EOL> raise BadValueError ( <EOL> '<STR_LIT>' % <EOL> ( self . name , self . item_type . __name__ ) ) <EOL> return value <EOL> def empty ( self , value ) : <EOL> """<STR_LIT>""" <EOL> return value is None <EOL> data_type = list <EOL> def default_value ( self ) : <EOL> """<STR_LIT>""" <EOL> return list ( super ( ListProperty , self ) . default_value ( ) ) <EOL> def get_value_for_datastore ( self , model_instance ) : <EOL> """<STR_LIT>""" <EOL> value = super ( ListProperty , self ) . get_value_for_datastore ( model_instance ) <EOL> if not value : <EOL> return value <EOL> value = self . validate_list_contents ( value ) <EOL> if self . validator : <EOL> self . validator ( value ) <EOL> if self . item_type == datetime . date : <EOL> value = map ( _date_to_datetime , value ) <EOL> elif self . item_type == datetime . time : <EOL> value = map ( _time_to_datetime , value ) <EOL> return value <EOL> def make_value_from_datastore ( self , value ) : <EOL> """<STR_LIT>""" <EOL> if self . item_type == datetime . date : <EOL> for v in value : <EOL> assert isinstance ( v , datetime . datetime ) <EOL> value = map ( lambda x : x . date ( ) , value ) <EOL> elif self . item_type == datetime . time : <EOL> for v in value : <EOL> assert isinstance ( v , datetime . datetime ) <EOL> value = map ( lambda x : x . time ( ) , value ) <EOL> return value <EOL> def make_value_from_datastore_index_value ( self , index_value ) : <EOL> value = [ datastore_types . RestoreFromIndexValue ( index_value , self . item_type ) ] <EOL> return self . make_value_from_datastore ( value ) <EOL> class StringListProperty ( ListProperty ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , verbose_name = None , default = None , ** kwds ) : <EOL> """<STR_LIT>""" <EOL> super ( StringListProperty , self ) . __init__ ( basestring , <EOL> verbose_name = verbose_name , <EOL> default = default , <EOL> ** kwds ) <EOL> class ReferenceProperty ( Property ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , <EOL> reference_class = None , <EOL> verbose_name = None , <EOL> collection_name = None , <EOL> ** attrs ) : <EOL> """<STR_LIT>""" <EOL> super ( ReferenceProperty , self ) . __init__ ( verbose_name , ** attrs ) <EOL> self . collection_name = collection_name <EOL> if reference_class is None : <EOL> reference_class = Model <EOL> if not ( ( isinstance ( reference_class , type ) and <EOL> issubclass ( reference_class , Model ) ) or <EOL> reference_class is _SELF_REFERENCE ) : <EOL> raise KindError ( '<STR_LIT>' ) <EOL> self . reference_class = self . data_type = reference_class <EOL> def make_value_from_datastore_index_value ( self , index_value ) : <EOL> value = datastore_types . RestoreFromIndexValue ( index_value , Key ) <EOL> return self . make_value_from_datastore ( value ) <EOL> def __property_config__ ( self , model_class , property_name ) : <EOL> """<STR_LIT>""" <EOL> super ( ReferenceProperty , self ) . __property_config__ ( model_class , <EOL> property_name ) <EOL> if self . reference_class is _SELF_REFERENCE : <EOL> self . reference_class = self . data_type = model_class <EOL> if self . collection_name is None : <EOL> self . collection_name = '<STR_LIT>' % ( model_class . __name__ . lower ( ) ) <EOL> existing_prop = getattr ( self . reference_class , self . collection_name , None ) <EOL> if existing_prop is not None : <EOL> if not ( isinstance ( existing_prop , _ReverseReferenceProperty ) and <EOL> existing_prop . _prop_name == property_name and <EOL> existing_prop . _model . __name__ == model_class . __name__ and <EOL> existing_prop . _model . __module__ == model_class . __module__ ) : <EOL> raise DuplicatePropertyError ( '<STR_LIT>' <EOL> % ( self . reference_class . __name__ , <EOL> self . collection_name ) ) <EOL> setattr ( self . reference_class , <EOL> self . collection_name , <EOL> _ReverseReferenceProperty ( model_class , property_name ) ) <EOL> def __get__ ( self , model_instance , model_class ) : <EOL> """<STR_LIT>""" <EOL> if model_instance is None : <EOL> return self <EOL> if hasattr ( model_instance , self . __id_attr_name ( ) ) : <EOL> reference_id = getattr ( model_instance , self . __id_attr_name ( ) ) <EOL> else : <EOL> reference_id = None <EOL> if reference_id is not None : <EOL> resolved = getattr ( model_instance , self . __resolved_attr_name ( ) ) <EOL> if resolved is not None : <EOL> return resolved <EOL> else : <EOL> instance = get ( reference_id ) <EOL> if instance is None : <EOL> raise ReferencePropertyResolveError ( <EOL> '<STR_LIT>' % <EOL> reference_id . to_path ( ) ) <EOL> setattr ( model_instance , self . __resolved_attr_name ( ) , instance ) <EOL> return instance <EOL> else : <EOL> return None <EOL> def __set__ ( self , model_instance , value ) : <EOL> """<STR_LIT>""" <EOL> value = self . validate ( value ) <EOL> if value is not None : <EOL> if isinstance ( value , datastore . Key ) : <EOL> setattr ( model_instance , self . __id_attr_name ( ) , value ) <EOL> setattr ( model_instance , self . __resolved_attr_name ( ) , None ) <EOL> else : <EOL> setattr ( model_instance , self . __id_attr_name ( ) , value . key ( ) ) <EOL> setattr ( model_instance , self . __resolved_attr_name ( ) , value ) <EOL> else : <EOL> setattr ( model_instance , self . __id_attr_name ( ) , None ) <EOL> setattr ( model_instance , self . __resolved_attr_name ( ) , None ) <EOL> def get_value_for_datastore ( self , model_instance ) : <EOL> """<STR_LIT>""" <EOL> return getattr ( model_instance , self . __id_attr_name ( ) ) <EOL> def validate ( self , value ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( value , datastore . Key ) : <EOL> return value <EOL> if value is not None and not value . has_key ( ) : <EOL> raise BadValueError ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' % self . reference_class . kind ( ) ) <EOL> value = super ( ReferenceProperty , self ) . validate ( value ) <EOL> if value is not None and not isinstance ( value , self . reference_class ) : <EOL> raise KindError ( '<STR_LIT>' % <EOL> ( self . name , self . reference_class . kind ( ) ) ) <EOL> return value <EOL> def __id_attr_name ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _attr_name ( ) <EOL> def __resolved_attr_name ( self ) : <EOL> """<STR_LIT>""" <EOL> return '<STR_LIT>' + self . _attr_name ( ) <EOL> Reference = ReferenceProperty <EOL> def SelfReferenceProperty ( verbose_name = None , collection_name = None , ** attrs ) : <EOL> """<STR_LIT>""" <EOL> if '<STR_LIT>' in attrs : <EOL> raise ConfigurationError ( <EOL> '<STR_LIT>' ) <EOL> return ReferenceProperty ( _SELF_REFERENCE , <EOL> verbose_name , <EOL> collection_name , <EOL> ** attrs ) <EOL> SelfReference = SelfReferenceProperty <EOL> class _ReverseReferenceProperty ( Property ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , model , prop ) : <EOL> """<STR_LIT>""" <EOL> self . __model = model <EOL> self . __property = prop <EOL> @ property <EOL> def _model ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __model <EOL> @ property <EOL> def _prop_name ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . __property <EOL> def __get__ ( self , model_instance , model_class ) : <EOL> """<STR_LIT>""" <EOL> if model_instance is not None : <EOL> query = Query ( self . __model ) <EOL> return query . filter ( self . __property + '<STR_LIT>' , model_instance . key ( ) ) <EOL> else : <EOL> return self <EOL> def __set__ ( self , model_instance , value ) : <EOL> """<STR_LIT>""" <EOL> raise BadValueError ( '<STR_LIT>' ) <EOL> class ComputedProperty ( Property ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , value_function , indexed = True ) : <EOL> """<STR_LIT>""" <EOL> super ( ComputedProperty , self ) . __init__ ( indexed = indexed ) <EOL> self . __value_function = value_function <EOL> def __set__ ( self , * args ) : <EOL> """<STR_LIT>""" <EOL> raise DerivedPropertyError ( <EOL> '<STR_LIT>' % self . name ) <EOL> def __get__ ( self , model_instance , model_class ) : <EOL> """<STR_LIT>""" <EOL> if model_instance is None : <EOL> return self <EOL> return self . __value_function ( model_instance ) <EOL> def to_dict ( model_instance , dictionary = None ) : <EOL> """<STR_LIT>""" <EOL> if dictionary is None : <EOL> dictionary = { } <EOL> model_instance . _to_entity ( dictionary ) <EOL> return dictionary <EOL> run_in_transaction = datastore . RunInTransaction <EOL> run_in_transaction_custom_retries = datastore . RunInTransactionCustomRetries <EOL> run_in_transaction_options = datastore . RunInTransactionOptions <EOL> RunInTransaction = run_in_transaction <EOL> RunInTransactionCustomRetries = run_in_transaction_custom_retries <EOL> websafe_encode_cursor = datastore_query . Cursor . to_websafe_string <EOL> websafe_decode_cursor = datastore_query . Cursor . from_websafe_string <EOL> is_in_transaction = datastore . IsInTransaction <EOL> transactional = datastore . Transactional <EOL> non_transactional = datastore . NonTransactional <EOL> create_config = datastore . CreateConfig <EOL> create_transaction_options = datastore . CreateTransactionOptions </s>

<s> """<STR_LIT>""" <EOL> import os <EOL> import time <EOL> from google . appengine . api import validation <EOL> from google . appengine . api import yaml_builder <EOL> from google . appengine . api import yaml_errors <EOL> from google . appengine . api import yaml_listener <EOL> from google . appengine . api import yaml_object <EOL> from google . appengine . ext import db <EOL> from google . appengine . ext . mapreduce import base_handler <EOL> from google . appengine . ext . mapreduce import errors <EOL> from google . appengine . ext . mapreduce import model <EOL> MR_YAML_NAMES = [ "<STR_LIT>" , "<STR_LIT>" ] <EOL> class BadStatusParameterError ( Exception ) : <EOL> """<STR_LIT>""" <EOL> class UserParam ( validation . Validated ) : <EOL> """<STR_LIT>""" <EOL> ATTRIBUTES = { <EOL> "<STR_LIT:name>" : r"<STR_LIT>" , <EOL> "<STR_LIT:default>" : validation . Optional ( r"<STR_LIT>" ) , <EOL> "<STR_LIT:value>" : validation . Optional ( r"<STR_LIT>" ) , <EOL> } <EOL> class MapperInfo ( validation . Validated ) : <EOL> """<STR_LIT>""" <EOL> ATTRIBUTES = { <EOL> "<STR_LIT>" : r"<STR_LIT>" , <EOL> "<STR_LIT>" : r"<STR_LIT>" , <EOL> "<STR_LIT>" : validation . Optional ( r"<STR_LIT>" ) , <EOL> "<STR_LIT>" : validation . Optional ( validation . Repeated ( UserParam ) ) , <EOL> "<STR_LIT>" : validation . Optional ( r"<STR_LIT>" ) , <EOL> } <EOL> class MapreduceInfo ( validation . Validated ) : <EOL> """<STR_LIT>""" <EOL> ATTRIBUTES = { <EOL> "<STR_LIT:name>" : r"<STR_LIT>" , <EOL> "<STR_LIT>" : MapperInfo , <EOL> "<STR_LIT>" : validation . Optional ( validation . Repeated ( UserParam ) ) , <EOL> "<STR_LIT>" : validation . Optional ( r"<STR_LIT>" ) , <EOL> } <EOL> class MapReduceYaml ( validation . Validated ) : <EOL> """<STR_LIT>""" <EOL> ATTRIBUTES = { <EOL> "<STR_LIT>" : validation . Optional ( validation . Repeated ( MapreduceInfo ) ) <EOL> } <EOL> @ staticmethod <EOL> def to_dict ( mapreduce_yaml ) : <EOL> """<STR_LIT>""" <EOL> all_configs = [ ] <EOL> for config in mapreduce_yaml . mapreduce : <EOL> out = { <EOL> "<STR_LIT:name>" : config . name , <EOL> "<STR_LIT>" : config . mapper . input_reader , <EOL> "<STR_LIT>" : config . mapper . handler , <EOL> } <EOL> if config . mapper . params_validator : <EOL> out [ "<STR_LIT>" ] = config . mapper . params_validator <EOL> if config . mapper . params : <EOL> param_defaults = { } <EOL> for param in config . mapper . params : <EOL> param_defaults [ param . name ] = param . default or param . value <EOL> out [ "<STR_LIT>" ] = param_defaults <EOL> if config . params : <EOL> param_defaults = { } <EOL> for param in config . params : <EOL> param_defaults [ param . name ] = param . default or param . value <EOL> out [ "<STR_LIT>" ] = param_defaults <EOL> if config . mapper . output_writer : <EOL> out [ "<STR_LIT>" ] = config . mapper . output_writer <EOL> all_configs . append ( out ) <EOL> return all_configs <EOL> def find_mapreduce_yaml ( status_file = __file__ ) : <EOL> """<STR_LIT>""" <EOL> checked = set ( ) <EOL> yaml = _find_mapreduce_yaml ( os . path . dirname ( status_file ) , checked ) <EOL> if not yaml : <EOL> yaml = _find_mapreduce_yaml ( os . getcwd ( ) , checked ) <EOL> return yaml <EOL> def _find_mapreduce_yaml ( start , checked ) : <EOL> """<STR_LIT>""" <EOL> dir = start <EOL> while dir not in checked : <EOL> checked . add ( dir ) <EOL> for mr_yaml_name in MR_YAML_NAMES : <EOL> yaml_path = os . path . join ( dir , mr_yaml_name ) <EOL> if os . path . exists ( yaml_path ) : <EOL> return yaml_path <EOL> dir = os . path . dirname ( dir ) <EOL> return None <EOL> def parse_mapreduce_yaml ( contents ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> builder = yaml_object . ObjectBuilder ( MapReduceYaml ) <EOL> handler = yaml_builder . BuilderHandler ( builder ) <EOL> listener = yaml_listener . EventListener ( handler ) <EOL> listener . Parse ( contents ) <EOL> mr_info = handler . GetResults ( ) <EOL> except ( ValueError , yaml_errors . EventError ) , e : <EOL> raise errors . BadYamlError ( e ) <EOL> if len ( mr_info ) < <NUM_LIT:1> : <EOL> raise errors . BadYamlError ( "<STR_LIT>" ) <EOL> if len ( mr_info ) > <NUM_LIT:1> : <EOL> raise errors . MultipleDocumentsInMrYaml ( "<STR_LIT>" % <EOL> len ( mr_info ) ) <EOL> jobs = mr_info [ <NUM_LIT:0> ] <EOL> job_names = set ( j . name for j in jobs . mapreduce ) <EOL> if len ( jobs . mapreduce ) != len ( job_names ) : <EOL> raise errors . BadYamlError ( <EOL> "<STR_LIT>" ) <EOL> return jobs <EOL> def get_mapreduce_yaml ( parse = parse_mapreduce_yaml ) : <EOL> """<STR_LIT>""" <EOL> mr_yaml_path = find_mapreduce_yaml ( ) <EOL> if not mr_yaml_path : <EOL> raise errors . MissingYamlError ( ) <EOL> mr_yaml_file = open ( mr_yaml_path ) <EOL> try : <EOL> return parse ( mr_yaml_file . read ( ) ) <EOL> finally : <EOL> mr_yaml_file . close ( ) <EOL> class ResourceHandler ( base_handler . BaseHandler ) : <EOL> """<STR_LIT>""" <EOL> _RESOURCE_MAP = { <EOL> "<STR_LIT:status>" : ( "<STR_LIT>" , "<STR_LIT>" ) , <EOL> "<STR_LIT>" : ( "<STR_LIT>" , "<STR_LIT>" ) , <EOL> "<STR_LIT>" : ( "<STR_LIT>" , "<STR_LIT>" ) , <EOL> "<STR_LIT>" : ( "<STR_LIT>" , "<STR_LIT>" ) , <EOL> "<STR_LIT>" : ( "<STR_LIT>" , "<STR_LIT>" ) , <EOL> "<STR_LIT>" : ( "<STR_LIT>" , "<STR_LIT>" ) , <EOL> } <EOL> def get ( self , relative ) : <EOL> if relative not in self . _RESOURCE_MAP : <EOL> self . response . set_status ( <NUM_LIT> ) <EOL> self . response . out . write ( "<STR_LIT>" ) <EOL> return <EOL> real_path , content_type = self . _RESOURCE_MAP [ relative ] <EOL> path = os . path . join ( os . path . dirname ( __file__ ) , "<STR_LIT>" , real_path ) <EOL> self . response . headers [ "<STR_LIT>" ] = "<STR_LIT>" <EOL> self . response . headers [ "<STR_LIT:Content-Type>" ] = content_type <EOL> self . response . out . write ( open ( path ) . read ( ) ) <EOL> class ListConfigsHandler ( base_handler . GetJsonHandler ) : <EOL> """<STR_LIT>""" <EOL> def handle ( self ) : <EOL> self . json_response [ "<STR_LIT>" ] = MapReduceYaml . to_dict ( get_mapreduce_yaml ( ) ) <EOL> class ListJobsHandler ( base_handler . GetJsonHandler ) : <EOL> """<STR_LIT>""" <EOL> def handle ( self ) : <EOL> cursor = self . request . get ( "<STR_LIT>" ) <EOL> count = int ( self . request . get ( "<STR_LIT:count>" , "<STR_LIT>" ) ) <EOL> query = model . MapreduceState . all ( ) <EOL> if cursor : <EOL> query . filter ( "<STR_LIT>" , db . Key ( cursor ) ) <EOL> query . order ( "<STR_LIT>" ) <EOL> jobs_list = query . fetch ( count + <NUM_LIT:1> ) <EOL> if len ( jobs_list ) == ( count + <NUM_LIT:1> ) : <EOL> self . json_response [ "<STR_LIT>" ] = str ( jobs_list [ - <NUM_LIT:1> ] . key ( ) ) <EOL> jobs_list = jobs_list [ : - <NUM_LIT:1> ] <EOL> all_jobs = [ ] <EOL> for job in jobs_list : <EOL> out = { <EOL> "<STR_LIT:name>" : job . mapreduce_spec . name , <EOL> "<STR_LIT>" : job . mapreduce_spec . mapreduce_id , <EOL> "<STR_LIT>" : job . active , <EOL> "<STR_LIT>" : <EOL> int ( time . mktime ( job . start_time . utctimetuple ( ) ) * <NUM_LIT:1000> ) , <EOL> "<STR_LIT>" : <EOL> int ( time . mktime ( job . last_poll_time . utctimetuple ( ) ) * <NUM_LIT:1000> ) , <EOL> "<STR_LIT>" : job . sparkline_url , <EOL> "<STR_LIT>" : job . chart_width , <EOL> "<STR_LIT>" : job . active_shards , <EOL> "<STR_LIT>" : job . mapreduce_spec . mapper . shard_count , <EOL> } <EOL> if job . result_status : <EOL> out [ "<STR_LIT>" ] = job . result_status <EOL> all_jobs . append ( out ) <EOL> self . json_response [ "<STR_LIT>" ] = all_jobs <EOL> class GetJobDetailHandler ( base_handler . GetJsonHandler ) : <EOL> """<STR_LIT>""" <EOL> def handle ( self ) : <EOL> mapreduce_id = self . request . get ( "<STR_LIT>" ) <EOL> if not mapreduce_id : <EOL> raise BadStatusParameterError ( "<STR_LIT>" ) <EOL> job = model . MapreduceState . get_by_key_name ( mapreduce_id ) <EOL> if job is None : <EOL> raise KeyError ( "<STR_LIT>" % mapreduce_id ) <EOL> self . json_response . update ( job . mapreduce_spec . to_json ( ) ) <EOL> self . json_response . update ( job . counters_map . to_json ( ) ) <EOL> self . json_response . update ( { <EOL> "<STR_LIT>" : job . active , <EOL> "<STR_LIT>" : <EOL> int ( time . mktime ( job . start_time . utctimetuple ( ) ) * <NUM_LIT:1000> ) , <EOL> "<STR_LIT>" : <EOL> int ( time . mktime ( job . last_poll_time . utctimetuple ( ) ) * <NUM_LIT:1000> ) , <EOL> "<STR_LIT>" : job . chart_url , <EOL> "<STR_LIT>" : job . chart_width , <EOL> } ) <EOL> self . json_response [ "<STR_LIT>" ] = job . result_status <EOL> shards_list = model . ShardState . find_by_mapreduce_state ( job ) <EOL> all_shards = [ ] <EOL> shards_list . sort ( key = lambda x : x . shard_number ) <EOL> for shard in shards_list : <EOL> out = { <EOL> "<STR_LIT>" : shard . active , <EOL> "<STR_LIT>" : shard . result_status , <EOL> "<STR_LIT>" : shard . shard_number , <EOL> "<STR_LIT>" : shard . shard_id , <EOL> "<STR_LIT>" : <EOL> int ( time . mktime ( shard . update_time . utctimetuple ( ) ) * <NUM_LIT:1000> ) , <EOL> "<STR_LIT>" : shard . shard_description , <EOL> "<STR_LIT>" : shard . last_work_item , <EOL> } <EOL> out . update ( shard . counters_map . to_json ( ) ) <EOL> all_shards . append ( out ) <EOL> self . json_response [ "<STR_LIT>" ] = all_shards </s>

<s> """<STR_LIT>""" <EOL> import logging <EOL> import os <EOL> from google . appengine . api import lib_config <EOL> def __django_version_setup ( ) : <EOL> """<STR_LIT>""" <EOL> django_version = _config_handle . django_version <EOL> if django_version is not None : <EOL> from google . appengine . dist import use_library <EOL> use_library ( '<STR_LIT>' , str ( django_version ) ) <EOL> else : <EOL> from google . appengine . dist import _library <EOL> version , explicit = _library . installed . get ( '<STR_LIT>' , ( '<STR_LIT>' , False ) ) <EOL> if not explicit : <EOL> logging . warn ( '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' , <EOL> version , <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> try : <EOL> import django <EOL> if not hasattr ( django , '<STR_LIT>' ) : <EOL> from django import v0_96 <EOL> except ImportError : <EOL> pass <EOL> def _django_setup ( ) : <EOL> """<STR_LIT>""" <EOL> if os . environ . get ( '<STR_LIT>' ) != '<STR_LIT>' : <EOL> __django_version_setup ( ) <EOL> import django <EOL> import django . conf <EOL> try : <EOL> raise ImportError <EOL> except ( ImportError , EnvironmentError ) , e : <EOL> if os . getenv ( django . conf . ENVIRONMENT_VARIABLE ) : <EOL> logging . warning ( e ) <EOL> try : <EOL> django . conf . settings . configure ( <EOL> DEBUG = False , <EOL> TEMPLATE_DEBUG = False , <EOL> TEMPLATE_LOADERS = ( <EOL> '<STR_LIT>' , <EOL> ) , <EOL> ) <EOL> except ( EnvironmentError , RuntimeError ) : <EOL> pass <EOL> if os . environ . get ( '<STR_LIT>' ) == '<STR_LIT>' : <EOL> _config_handle = lib_config . register ( <EOL> '<STR_LIT>' , <EOL> { '<STR_LIT>' : lambda app : app , } ) <EOL> from webapp2 import * <EOL> else : <EOL> _config_handle = lib_config . register ( <EOL> '<STR_LIT>' , <EOL> { '<STR_LIT>' : _django_setup , <EOL> '<STR_LIT>' : None , <EOL> '<STR_LIT>' : lambda app : app , <EOL> } ) <EOL> from google . appengine . ext . webapp . _webapp25 import * <EOL> from google . appengine . ext . webapp . _webapp25 import __doc__ </s>