Datasets:

AISE-TUDelft

/

PY150k

like 0

"""<STR_LIT>""" <EOL> from itertools import islice <EOL> from . pgen2 import token <EOL> from . pytree import Leaf , Node <EOL> from . pygram import python_symbols as syms <EOL> from . import patcomp <EOL> def KeywordArg ( keyword , value ) : <EOL> return Node ( syms . argument , <EOL> [ keyword , Leaf ( token . EQUAL , u"<STR_LIT:=>" ) , value ] ) <EOL> def LParen ( ) : <EOL> return Leaf ( token . LPAR , u"<STR_LIT:(>" ) <EOL> def RParen ( ) : <EOL> return Leaf ( token . RPAR , u"<STR_LIT:)>" ) <EOL> def Assign ( target , source ) : <EOL> """<STR_LIT>""" <EOL> if not isinstance ( target , list ) : <EOL> target = [ target ] <EOL> if not isinstance ( source , list ) : <EOL> source . prefix = u"<STR_LIT:U+0020>" <EOL> source = [ source ] <EOL> return Node ( syms . atom , <EOL> target + [ Leaf ( token . EQUAL , u"<STR_LIT:=>" , prefix = u"<STR_LIT:U+0020>" ) ] + source ) <EOL> def Name ( name , prefix = None ) : <EOL> """<STR_LIT>""" <EOL> return Leaf ( token . NAME , name , prefix = prefix ) <EOL> def Attr ( obj , attr ) : <EOL> """<STR_LIT>""" <EOL> return [ obj , Node ( syms . trailer , [ Dot ( ) , attr ] ) ] <EOL> def Comma ( ) : <EOL> """<STR_LIT>""" <EOL> return Leaf ( token . COMMA , u"<STR_LIT:U+002C>" ) <EOL> def Dot ( ) : <EOL> """<STR_LIT>""" <EOL> return Leaf ( token . DOT , u"<STR_LIT:.>" ) <EOL> def ArgList ( args , lparen = LParen ( ) , rparen = RParen ( ) ) : <EOL> """<STR_LIT>""" <EOL> node = Node ( syms . trailer , [ lparen . clone ( ) , rparen . clone ( ) ] ) <EOL> if args : <EOL> node . insert_child ( <NUM_LIT:1> , Node ( syms . arglist , args ) ) <EOL> return node <EOL> def Call ( func_name , args = None , prefix = None ) : <EOL> """<STR_LIT>""" <EOL> node = Node ( syms . power , [ func_name , ArgList ( args ) ] ) <EOL> if prefix is not None : <EOL> node . prefix = prefix <EOL> return node <EOL> def Newline ( ) : <EOL> """<STR_LIT>""" <EOL> return Leaf ( token . NEWLINE , u"<STR_LIT:\n>" ) <EOL> def BlankLine ( ) : <EOL> """<STR_LIT>""" <EOL> return Leaf ( token . NEWLINE , u"<STR_LIT>" ) <EOL> def Number ( n , prefix = None ) : <EOL> return Leaf ( token . NUMBER , n , prefix = prefix ) <EOL> def Subscript ( index_node ) : <EOL> """<STR_LIT>""" <EOL> return Node ( syms . trailer , [ Leaf ( token . LBRACE , u"<STR_LIT:[>" ) , <EOL> index_node , <EOL> Leaf ( token . RBRACE , u"<STR_LIT:]>" ) ] ) <EOL> def String ( string , prefix = None ) : <EOL> """<STR_LIT>""" <EOL> return Leaf ( token . STRING , string , prefix = prefix ) <EOL> def ListComp ( xp , fp , it , test = None ) : <EOL> """<STR_LIT>""" <EOL> xp . prefix = u"<STR_LIT>" <EOL> fp . prefix = u"<STR_LIT:U+0020>" <EOL> it . prefix = u"<STR_LIT:U+0020>" <EOL> for_leaf = Leaf ( token . NAME , u"<STR_LIT>" ) <EOL> for_leaf . prefix = u"<STR_LIT:U+0020>" <EOL> in_leaf = Leaf ( token . NAME , u"<STR_LIT>" ) <EOL> in_leaf . prefix = u"<STR_LIT:U+0020>" <EOL> inner_args = [ for_leaf , fp , in_leaf , it ] <EOL> if test : <EOL> test . prefix = u"<STR_LIT:U+0020>" <EOL> if_leaf = Leaf ( token . NAME , u"<STR_LIT>" ) <EOL> if_leaf . prefix = u"<STR_LIT:U+0020>" <EOL> inner_args . append ( Node ( syms . comp_if , [ if_leaf , test ] ) ) <EOL> inner = Node ( syms . listmaker , [ xp , Node ( syms . comp_for , inner_args ) ] ) <EOL> return Node ( syms . atom , <EOL> [ Leaf ( token . LBRACE , u"<STR_LIT:[>" ) , <EOL> inner , <EOL> Leaf ( token . RBRACE , u"<STR_LIT:]>" ) ] ) <EOL> def FromImport ( package_name , name_leafs ) : <EOL> """<STR_LIT>""" <EOL> for leaf in name_leafs : <EOL> leaf . remove ( ) <EOL> children = [ Leaf ( token . NAME , u"<STR_LIT>" ) ,

Leaf ( token . NAME , package_name , prefix = u"<STR_LIT:U+0020>" ) ,

"""<STR_LIT>""" <EOL> from itertools import islice <EOL> from . pgen2 import token <EOL> from . pytree import Leaf , Node <EOL> from . pygram import python_symbols as syms <EOL> from . import patcomp <EOL> def KeywordArg ( keyword , value ) : <EOL> return Node ( syms . argument , <EOL> [ keyword , Leaf ( token . EQUAL , u"<STR_LIT:=>" ) , value ] ) <EOL> def LParen ( ) : <EOL> return Leaf ( token . LPAR , u"<STR_LIT:(>" ) <EOL> def RParen ( ) : <EOL> return Leaf ( token . RPAR , u"<STR_LIT:)>" ) <EOL> def Assign ( target , source ) : <EOL> """<STR_LIT>""" <EOL> if not isinstance ( target , list ) : <EOL> target = [ target ] <EOL> if not isinstance ( source , list ) : <EOL> source . prefix = u"<STR_LIT:U+0020>" <EOL> source = [ source ] <EOL> return Node ( syms . atom , <EOL> target + [ Leaf ( token . EQUAL , u"<STR_LIT:=>" , prefix = u"<STR_LIT:U+0020>" ) ] + source ) <EOL> def Name ( name , prefix = None ) : <EOL> """<STR_LIT>""" <EOL> return Leaf ( token . NAME , name , prefix = prefix ) <EOL> def Attr ( obj , attr ) : <EOL> """<STR_LIT>""" <EOL> return [ obj , Node ( syms . trailer , [ Dot ( ) , attr ] ) ] <EOL> def Comma ( ) : <EOL> """<STR_LIT>""" <EOL> return Leaf ( token . COMMA , u"<STR_LIT:U+002C>" ) <EOL> def Dot ( ) : <EOL> """<STR_LIT>""" <EOL> return Leaf ( token . DOT , u"<STR_LIT:.>" ) <EOL> def ArgList ( args , lparen = LParen ( ) , rparen = RParen ( ) ) : <EOL> """<STR_LIT>""" <EOL> node = Node ( syms . trailer , [ lparen . clone ( ) , rparen . clone ( ) ] ) <EOL> if args : <EOL> node . insert_child ( <NUM_LIT:1> , Node ( syms . arglist , args ) ) <EOL> return node <EOL> def Call ( func_name , args = None , prefix = None ) : <EOL> """<STR_LIT>""" <EOL> node = Node ( syms . power , [ func_name , ArgList ( args ) ] ) <EOL> if prefix is not None : <EOL> node . prefix = prefix <EOL> return node <EOL> def Newline ( ) : <EOL> """<STR_LIT>""" <EOL> return Leaf ( token . NEWLINE , u"<STR_LIT:\n>" ) <EOL> def BlankLine ( ) : <EOL> """<STR_LIT>""" <EOL> return Leaf ( token . NEWLINE , u"<STR_LIT>" ) <EOL> def Number ( n , prefix = None ) : <EOL> return Leaf ( token . NUMBER , n , prefix = prefix ) <EOL> def Subscript ( index_node ) : <EOL> """<STR_LIT>""" <EOL> return Node ( syms . trailer , [ Leaf ( token . LBRACE , u"<STR_LIT:[>" ) , <EOL> index_node , <EOL> Leaf ( token . RBRACE , u"<STR_LIT:]>" ) ] ) <EOL> def String ( string , prefix = None ) : <EOL> """<STR_LIT>""" <EOL> return Leaf ( token . STRING , string , prefix = prefix ) <EOL> def ListComp ( xp , fp , it , test = None ) : <EOL> """<STR_LIT>""" <EOL> xp . prefix = u"<STR_LIT>" <EOL> fp . prefix = u"<STR_LIT:U+0020>" <EOL> it . prefix = u"<STR_LIT:U+0020>" <EOL> for_leaf = Leaf ( token . NAME , u"<STR_LIT>" ) <EOL> for_leaf . prefix = u"<STR_LIT:U+0020>" <EOL> in_leaf = Leaf ( token . NAME , u"<STR_LIT>" ) <EOL> in_leaf . prefix = u"<STR_LIT:U+0020>" <EOL> inner_args = [ for_leaf , fp , in_leaf , it ] <EOL> if test : <EOL> test . prefix = u"<STR_LIT:U+0020>" <EOL> if_leaf = Leaf ( token . NAME , u"<STR_LIT>" ) <EOL> if_leaf . prefix = u"<STR_LIT:U+0020>" <EOL> inner_args . append ( Node ( syms . comp_if , [ if_leaf , test ] ) ) <EOL> inner = Node ( syms . listmaker , [ xp , Node ( syms . comp_for , inner_args ) ] ) <EOL> return Node ( syms . atom , <EOL> [ Leaf ( token . LBRACE , u"<STR_LIT:[>" ) , <EOL> inner , <EOL> Leaf ( token . RBRACE , u"<STR_LIT:]>" ) ] ) <EOL> def FromImport ( package_name , name_leafs ) : <EOL> """<STR_LIT>""" <EOL> for leaf in name_leafs : <EOL> leaf . remove ( ) <EOL> children = [ Leaf ( token . NAME , u"<STR_LIT>" ) , <EOL> Leaf ( token . NAME , package_name , prefix = u"<STR_LIT:U+0020>" ) , <EOL> Leaf ( token . NAME , u"<STR_LIT>" , prefix = u"<STR_LIT:U+0020>" ) , <EOL> Node ( syms . import_as_names , name_leafs ) ] <EOL> imp = Node ( syms . import_from , children ) <EOL> return imp <EOL> def is_tuple ( node ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( node , Node ) and node . children == [ LParen ( ) , RParen ( ) ] : <EOL> return True <EOL> return ( isinstance ( node , Node ) <EOL> and len ( node . children ) == <NUM_LIT:3> <EOL> and isinstance ( node . children [ <NUM_LIT:0> ] , Leaf ) <EOL> and isinstance ( node . children [ <NUM_LIT:1> ] , Node ) <EOL> and isinstance ( node . children [ <NUM_LIT:2> ] , Leaf ) <EOL> and node . children [ <NUM_LIT:0> ] . value == u"<STR_LIT:(>" <EOL> and node . children [ <NUM_LIT:2> ] . value == u"<STR_LIT:)>" ) <EOL> def is_list ( node ) : <EOL> """<STR_LIT>""" <EOL> return ( isinstance ( node , Node ) <EOL> and len ( node . children ) > <NUM_LIT:1> <EOL> and isinstance ( node . children [ <NUM_LIT:0> ] , Leaf ) <EOL> and isinstance ( node . children [ - <NUM_LIT:1> ] , Leaf ) <EOL> and node . children [ <NUM_LIT:0> ] . value == u"<STR_LIT:[>" <EOL> and node . children [ - <NUM_LIT:1> ] . value == u"<STR_LIT:]>" ) <EOL> def parenthesize ( node ) : <EOL> return Node ( syms . atom , [ LParen ( ) , node , RParen ( ) ] ) <EOL> consuming_calls = set ( [ "<STR_LIT>" , "<STR_LIT:list>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT:all>" , "<STR_LIT>" , "<STR_LIT>" , <EOL> "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ] ) <EOL> def attr_chain ( obj , attr ) : <EOL> """<STR_LIT>""" <EOL> next = getattr ( obj , attr ) <EOL> while next : <EOL> yield next <EOL> next = getattr ( next , attr ) <EOL> p0 = """<STR_LIT>""" <EOL> p1 = """<STR_LIT>""" <EOL> p2 = """<STR_LIT>""" <EOL> pats_built = False <EOL> def in_special_context ( node ) : <EOL> """<STR_LIT>""" <EOL> global p0 , p1 , p2 , pats_built <EOL> if not pats_built : <EOL> p0 = patcomp . compile_pattern ( p0 ) <EOL> p1 = patcomp . compile_pattern ( p1 ) <EOL> p2 = patcomp . compile_pattern ( p2 ) <EOL> pats_built = True <EOL> patterns = [ p0 , p1 , p2 ] <EOL> for pattern , parent in zip ( patterns , attr_chain ( node , "<STR_LIT>" ) ) : <EOL> results = { } <EOL> if pattern . match ( parent , results ) and results [ "<STR_LIT>" ] is node : <EOL> return True <EOL> return False <EOL> def is_probably_builtin ( node ) : <EOL> """<STR_LIT>""" <EOL> prev = node . prev_sibling <EOL> if prev is not None and prev . type == token . DOT : <EOL> return False <EOL> parent = node . parent <EOL> if parent . type in ( syms . funcdef , syms . classdef ) : <EOL> return False <EOL> if parent . type == syms . expr_stmt and parent . children [ <NUM_LIT:0> ] is node : <EOL> return False <EOL> if parent . type == syms . parameters or ( parent . type == syms . typedargslist and ( <EOL> ( prev is not None and prev . type == token . COMMA ) or <EOL> parent . children [ <NUM_LIT:0> ] is node <EOL> ) ) : <EOL> return False <EOL> return True <EOL> def find_indentation ( node ) : <EOL> """<STR_LIT>""" <EOL> while node is not None : <EOL> if node . type == syms . suite and len ( node . children ) > <NUM_LIT:2> : <EOL> indent = node . children [ <NUM_LIT:1> ] <EOL> if indent . type == token . INDENT : <EOL> return indent . value <EOL> node = node . parent <EOL> return u"<STR_LIT>" <EOL> def make_suite ( node ) : <EOL> if node . type == syms . suite : <EOL> return node <EOL> node = node . clone ( ) <EOL> parent , node . parent = node . parent , None <EOL> suite = Node ( syms . suite , [ node ] ) <EOL> suite . parent = parent <EOL> return suite <EOL> def find_root ( node ) : <EOL> """<STR_LIT>""" <EOL> while node . type != syms . file_input : <EOL> node = node . parent <EOL> if not node : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> return node <EOL> def does_tree_import ( package , name , node ) : <EOL> """<STR_LIT>""" <EOL> binding = find_binding ( name , find_root ( node ) , package ) <EOL> return bool ( binding ) <EOL> def is_import ( node ) : <EOL> """<STR_LIT>""" <EOL> return node . type in ( syms . import_name , syms . import_from ) <EOL> def touch_import ( package , name , node ) : <EOL> """<STR_LIT>""" <EOL> def is_import_stmt ( node ) : <EOL> return ( node . type == syms . simple_stmt and node . children and <EOL> is_import ( node . children [ <NUM_LIT:0> ] ) ) <EOL> root = find_root ( node ) <EOL> if does_tree_import ( package , name , root ) : <EOL> return <EOL> insert_pos = offset = <NUM_LIT:0> <EOL> for idx , node in enumerate ( root . children ) : <EOL> if not is_import_stmt ( node ) : <EOL> continue <EOL> for offset , node2 in enumerate ( root . children [ idx : ] ) : <EOL> if not is_import_stmt ( node2 ) : <EOL> break <EOL> insert_pos = idx + offset <EOL> break <EOL> if insert_pos == <NUM_LIT:0> : <EOL> for idx , node in enumerate ( root . children ) : <EOL> if ( node . type == syms . simple_stmt and node . children and <EOL> node . children [ <NUM_LIT:0> ] . type == token . STRING ) : <EOL> insert_pos = idx + <NUM_LIT:1> <EOL> break <EOL> if package is None : <EOL> import_ = Node ( syms . import_name , [ <EOL> Leaf ( token . NAME , u"<STR_LIT>" ) , <EOL> Leaf ( token . NAME , name , prefix = u"<STR_LIT:U+0020>" ) <EOL> ] ) <EOL> else : <EOL> import_ = FromImport ( package , [ Leaf ( token . NAME , name , prefix = u"<STR_LIT:U+0020>" ) ] ) <EOL> children = [ import_ , Newline ( ) ] <EOL> root . insert_child ( insert_pos , Node ( syms . simple_stmt , children ) ) <EOL> _def_syms = set ( [ syms . classdef , syms . funcdef ] ) <EOL> def find_binding ( name , node , package = None ) : <EOL> """<STR_LIT>""" <EOL> for child in node . children : <EOL> ret = None <EOL> if child . type == syms . for_stmt : <EOL> if _find ( name , child . children [ <NUM_LIT:1> ] ) : <EOL> return child <EOL> n = find_binding ( name , make_suite ( child . children [ - <NUM_LIT:1> ] ) , package ) <EOL> if n : ret = n <EOL> elif child . type in ( syms . if_stmt , syms . while_stmt ) : <EOL> n = find_binding ( name , make_suite ( child . children [ - <NUM_LIT:1> ] ) , package ) <EOL> if n : ret = n <EOL> elif child . type == syms . try_stmt : <EOL> n = find_binding ( name , make_suite ( child . children [ <NUM_LIT:2> ] ) , package ) <EOL> if n : <EOL> ret = n <EOL> else : <EOL> for i , kid in enumerate ( child . children [ <NUM_LIT:3> : ] ) : <EOL> if kid . type == token . COLON and kid . value == "<STR_LIT::>" : <EOL> n = find_binding ( name , make_suite ( child . children [ i + <NUM_LIT:4> ] ) , package ) <EOL> if n : ret = n <EOL> elif child . type in _def_syms and child . children [ <NUM_LIT:1> ] . value == name : <EOL> ret = child <EOL> elif _is_import_binding ( child , name , package ) : <EOL> ret = child <EOL> elif child . type == syms . simple_stmt : <EOL> ret = find_binding ( name , child , package ) <EOL> elif child . type == syms . expr_stmt : <EOL> if _find ( name , child . children [ <NUM_LIT:0> ] ) : <EOL> ret = child <EOL> if ret : <EOL> if not package : <EOL> return ret <EOL> if is_import ( ret ) : <EOL> return ret <EOL> return None <EOL> _block_syms = set ( [ syms . funcdef , syms . classdef , syms . trailer ] ) <EOL> def _find ( name , node ) : <EOL> nodes = [ node ] <EOL> while nodes : <EOL> node = nodes . pop ( ) <EOL> if node . type > <NUM_LIT> and node . type not in _block_syms : <EOL> nodes . extend ( node . children ) <EOL> elif node . type == token . NAME and node . value == name : <EOL> return node <EOL> return None <EOL> def _is_import_binding ( node , name , package = None ) : <EOL> """<STR_LIT>""" <EOL> if node . type == syms . import_name and not package : <EOL> imp = node . children [ <NUM_LIT:1> ] <EOL> if imp . type == syms . dotted_as_names : <EOL> for child in imp . children : <EOL> if child . type == syms . dotted_as_name : <EOL> if child . children [ <NUM_LIT:2> ] . value == name : <EOL> return node <EOL> elif child . type == token . NAME and child . value == name : <EOL> return node <EOL> elif imp . type == syms . dotted_as_name : <EOL> last = imp . children [ - <NUM_LIT:1> ] <EOL> if last . type == token . NAME and last . value == name : <EOL> return node <EOL> elif imp . type == token . NAME and imp . value == name : <EOL> return node <EOL> elif node . type == syms . import_from : <EOL> if package and unicode ( node . children [ <NUM_LIT:1> ] ) . strip ( ) != package : <EOL> return None <EOL> n = node . children [ <NUM_LIT:3> ] <EOL> if package and _find ( u"<STR_LIT>" , n ) : <EOL> return None <EOL> elif n . type == syms . import_as_names and _find ( name , n ) : <EOL> return node <EOL> elif n . type == syms . import_as_name : <EOL> child = n . children [ <NUM_LIT:2> ] <EOL> if child . type == token . NAME and child . value == name : <EOL> return node <EOL> elif n . type == token . NAME and n . value == name : <EOL> return node <EOL> elif package and n . type == token . STAR : <EOL> return node <EOL> return None </s>

"""<STR_LIT>""" <EOL> from . . import fixer_base <EOL> from . . fixer_util import Name <EOL> MAP = { <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" <EOL> } <EOL> class FixMethodattrs ( fixer_base . BaseFix ) : <EOL> BM_compatible = True <EOL> PATTERN = """<STR_LIT>""" <EOL> def transform ( self , node , results ) : <EOL> attr = results [ "<STR_LIT>" ] [ <NUM_LIT:0> ] <EOL> new = unicode ( MAP [ attr . value ] )

attr . replace ( Name ( new , prefix = attr . prefix ) ) </s>

"""<STR_LIT>""" <EOL> from . . import fixer_base <EOL> from . . fixer_util import Name <EOL> MAP = { <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" <EOL> } <EOL> class FixMethodattrs ( fixer_base . BaseFix ) : <EOL> BM_compatible = True <EOL> PATTERN = """<STR_LIT>""" <EOL> def transform ( self , node , results ) : <EOL> attr = results [ "<STR_LIT>" ] [ <NUM_LIT:0> ] <EOL> new = unicode ( MAP [ attr . value ] ) <EOL> attr . replace ( Name ( new , prefix = attr . prefix ) ) </s>

"""<STR_LIT>""" <EOL> import re <EOL> from pgen2 import grammar , token <EOL> class Converter ( grammar . Grammar ) : <EOL> """<STR_LIT>""" <EOL> def run ( self , graminit_h , graminit_c ) : <EOL> """<STR_LIT>""" <EOL> self . parse_graminit_h ( graminit_h ) <EOL> self . parse_graminit_c ( graminit_c ) <EOL> self . finish_off ( ) <EOL> def parse_graminit_h ( self , filename ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> f = open ( filename ) <EOL> except IOError , err : <EOL> print "<STR_LIT>" % ( filename , err ) <EOL> return False <EOL> self . symbol2number = { } <EOL> self . number2symbol = { } <EOL> lineno = <NUM_LIT:0> <EOL> for line in f : <EOL> lineno += <NUM_LIT:1> <EOL> mo = re . match ( r"<STR_LIT>" , line ) <EOL> if not mo and line . strip ( ) : <EOL> print "<STR_LIT>" % ( filename , lineno , <EOL> line . strip ( ) ) <EOL> else : <EOL> symbol , number = mo . groups ( ) <EOL> number = int ( number ) <EOL> assert symbol not in self . symbol2number <EOL> assert number not in self . number2symbol <EOL> self . symbol2number [ symbol ] = number <EOL> self . number2symbol [ number ] = symbol <EOL> return True <EOL> def parse_graminit_c ( self , filename ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> f = open ( filename ) <EOL> except IOError , err : <EOL> print "<STR_LIT>" % ( filename , err ) <EOL> return False <EOL> lineno = <NUM_LIT:0> <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> assert line == '<STR_LIT>' , ( lineno , line ) <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> assert line == '<STR_LIT>' , ( lineno , line ) <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> allarcs = { } <EOL> states = [ ] <EOL> while line . startswith ( "<STR_LIT>" ) : <EOL> while line . startswith ( "<STR_LIT>" ) : <EOL> mo = re . match ( r"<STR_LIT>" , <EOL> line ) <EOL> assert mo , ( lineno , line ) <EOL> n , m , k = map ( int , mo . groups ( ) ) <EOL> arcs = [ ] <EOL> for _ in range ( k ) : <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> mo = re . match ( r"<STR_LIT>" , line ) <EOL> assert mo , ( lineno , line ) <EOL> i , j = map ( int , mo . groups ( ) ) <EOL> arcs . append ( ( i , j ) ) <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> assert line == "<STR_LIT>" , ( lineno , line ) <EOL> allarcs [ ( n , m ) ] = arcs <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> mo = re . match ( r"<STR_LIT>" , line ) <EOL> assert mo , ( lineno , line ) <EOL> s , t = map ( int , mo . groups ( ) ) <EOL> assert s == len ( states ) , ( lineno , line ) <EOL> state = [ ] <EOL> for _ in range ( t ) : <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> mo = re . match ( r"<STR_LIT>" , line ) <EOL> assert mo , ( lineno , line )

k , n , m = map ( int , mo . groups ( ) )

"""<STR_LIT>""" <EOL> import re <EOL> from pgen2 import grammar , token <EOL> class Converter ( grammar . Grammar ) : <EOL> """<STR_LIT>""" <EOL> def run ( self , graminit_h , graminit_c ) : <EOL> """<STR_LIT>""" <EOL> self . parse_graminit_h ( graminit_h ) <EOL> self . parse_graminit_c ( graminit_c ) <EOL> self . finish_off ( ) <EOL> def parse_graminit_h ( self , filename ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> f = open ( filename ) <EOL> except IOError , err : <EOL> print "<STR_LIT>" % ( filename , err ) <EOL> return False <EOL> self . symbol2number = { } <EOL> self . number2symbol = { } <EOL> lineno = <NUM_LIT:0> <EOL> for line in f : <EOL> lineno += <NUM_LIT:1> <EOL> mo = re . match ( r"<STR_LIT>" , line ) <EOL> if not mo and line . strip ( ) : <EOL> print "<STR_LIT>" % ( filename , lineno , <EOL> line . strip ( ) ) <EOL> else : <EOL> symbol , number = mo . groups ( ) <EOL> number = int ( number ) <EOL> assert symbol not in self . symbol2number <EOL> assert number not in self . number2symbol <EOL> self . symbol2number [ symbol ] = number <EOL> self . number2symbol [ number ] = symbol <EOL> return True <EOL> def parse_graminit_c ( self , filename ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> f = open ( filename ) <EOL> except IOError , err : <EOL> print "<STR_LIT>" % ( filename , err ) <EOL> return False <EOL> lineno = <NUM_LIT:0> <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> assert line == '<STR_LIT>' , ( lineno , line ) <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> assert line == '<STR_LIT>' , ( lineno , line ) <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> allarcs = { } <EOL> states = [ ] <EOL> while line . startswith ( "<STR_LIT>" ) : <EOL> while line . startswith ( "<STR_LIT>" ) : <EOL> mo = re . match ( r"<STR_LIT>" , <EOL> line ) <EOL> assert mo , ( lineno , line ) <EOL> n , m , k = map ( int , mo . groups ( ) ) <EOL> arcs = [ ] <EOL> for _ in range ( k ) : <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> mo = re . match ( r"<STR_LIT>" , line ) <EOL> assert mo , ( lineno , line ) <EOL> i , j = map ( int , mo . groups ( ) ) <EOL> arcs . append ( ( i , j ) ) <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> assert line == "<STR_LIT>" , ( lineno , line ) <EOL> allarcs [ ( n , m ) ] = arcs <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> mo = re . match ( r"<STR_LIT>" , line ) <EOL> assert mo , ( lineno , line ) <EOL> s , t = map ( int , mo . groups ( ) ) <EOL> assert s == len ( states ) , ( lineno , line ) <EOL> state = [ ] <EOL> for _ in range ( t ) : <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> mo = re . match ( r"<STR_LIT>" , line ) <EOL> assert mo , ( lineno , line ) <EOL> k , n , m = map ( int , mo . groups ( ) ) <EOL> arcs = allarcs [ n , m ] <EOL> assert k == len ( arcs ) , ( lineno , line ) <EOL> state . append ( arcs ) <EOL> states . append ( state ) <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> assert line == "<STR_LIT>" , ( lineno , line ) <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> self . states = states <EOL> dfas = { } <EOL> mo = re . match ( r"<STR_LIT>" , line ) <EOL> assert mo , ( lineno , line ) <EOL> ndfas = int ( mo . group ( <NUM_LIT:1> ) ) <EOL> for i in range ( ndfas ) : <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> mo = re . match ( r'<STR_LIT>' , <EOL> line ) <EOL> assert mo , ( lineno , line ) <EOL> symbol = mo . group ( <NUM_LIT:2> ) <EOL> number , x , y , z = map ( int , mo . group ( <NUM_LIT:1> , <NUM_LIT:3> , <NUM_LIT:4> , <NUM_LIT:5> ) ) <EOL> assert self . symbol2number [ symbol ] == number , ( lineno , line ) <EOL> assert self . number2symbol [ number ] == symbol , ( lineno , line ) <EOL> assert x == <NUM_LIT:0> , ( lineno , line ) <EOL> state = states [ z ] <EOL> assert y == len ( state ) , ( lineno , line ) <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> mo = re . match ( r'<STR_LIT>' , line ) <EOL> assert mo , ( lineno , line ) <EOL> first = { } <EOL> rawbitset = eval ( mo . group ( <NUM_LIT:1> ) ) <EOL> for i , c in enumerate ( rawbitset ) : <EOL> byte = ord ( c ) <EOL> for j in range ( <NUM_LIT:8> ) : <EOL> if byte & ( <NUM_LIT:1> << j ) : <EOL> first [ i * <NUM_LIT:8> + j ] = <NUM_LIT:1> <EOL> dfas [ number ] = ( state , first ) <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> assert line == "<STR_LIT>" , ( lineno , line ) <EOL> self . dfas = dfas <EOL> labels = [ ] <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> mo = re . match ( r"<STR_LIT>" , line ) <EOL> assert mo , ( lineno , line ) <EOL> nlabels = int ( mo . group ( <NUM_LIT:1> ) ) <EOL> for i in range ( nlabels ) : <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> mo = re . match ( r'<STR_LIT>' , line ) <EOL> assert mo , ( lineno , line ) <EOL> x , y = mo . groups ( ) <EOL> x = int ( x ) <EOL> if y == "<STR_LIT:0>" : <EOL> y = None <EOL> else : <EOL> y = eval ( y ) <EOL> labels . append ( ( x , y ) ) <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> assert line == "<STR_LIT>" , ( lineno , line ) <EOL> self . labels = labels <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> assert line == "<STR_LIT>" , ( lineno , line ) <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> mo = re . match ( r"<STR_LIT>" , line ) <EOL> assert mo , ( lineno , line ) <EOL> ndfas = int ( mo . group ( <NUM_LIT:1> ) ) <EOL> assert ndfas == len ( self . dfas ) <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> assert line == "<STR_LIT>" , ( lineno , line ) <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> mo = re . match ( r"<STR_LIT>" , line ) <EOL> assert mo , ( lineno , line ) <EOL> nlabels = int ( mo . group ( <NUM_LIT:1> ) ) <EOL> assert nlabels == len ( self . labels ) , ( lineno , line ) <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> mo = re . match ( r"<STR_LIT>" , line ) <EOL> assert mo , ( lineno , line ) <EOL> start = int ( mo . group ( <NUM_LIT:1> ) ) <EOL> assert start in self . number2symbol , ( lineno , line ) <EOL> self . start = start <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> assert line == "<STR_LIT>" , ( lineno , line ) <EOL> try : <EOL> lineno , line = lineno + <NUM_LIT:1> , f . next ( ) <EOL> except StopIteration : <EOL> pass <EOL> else : <EOL> assert <NUM_LIT:0> , ( lineno , line ) <EOL> def finish_off ( self ) : <EOL> """<STR_LIT>""" <EOL> self . keywords = { } <EOL> self . tokens = { } <EOL> for ilabel , ( type , value ) in enumerate ( self . labels ) : <EOL> if type == token . NAME and value is not None : <EOL> self . keywords [ value ] = ilabel <EOL> elif value is None : <EOL> self . tokens [ type ] = ilabel </s>

"""<STR_LIT>""" <EOL> import re <EOL> _declname_match = re . compile ( r'<STR_LIT>' ) . match <EOL> _declstringlit_match = re . compile ( r'<STR_LIT>' ) . match <EOL> _commentclose = re . compile ( r'<STR_LIT>' ) <EOL> _markedsectionclose = re . compile ( r'<STR_LIT>' ) <EOL> _msmarkedsectionclose = re . compile ( r'<STR_LIT>' ) <EOL> del re <EOL> class ParserBase : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self ) : <EOL> if self . __class__ is ParserBase : <EOL> raise RuntimeError ( <EOL> "<STR_LIT>" ) <EOL> def error ( self , message ) : <EOL> raise NotImplementedError ( <EOL> "<STR_LIT>" ) <EOL> def reset ( self ) : <EOL> self . lineno = <NUM_LIT:1> <EOL> self . offset = <NUM_LIT:0> <EOL> def getpos ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . lineno , self . offset <EOL> def updatepos ( self , i , j ) : <EOL> if i >= j : <EOL> return j <EOL> rawdata = self . rawdata <EOL> nlines = rawdata . count ( "<STR_LIT:\n>" , i , j ) <EOL> if nlines : <EOL> self . lineno = self . lineno + nlines <EOL> pos = rawdata . rindex ( "<STR_LIT:\n>" , i , j ) <EOL> self . offset = j - ( pos + <NUM_LIT:1> ) <EOL> else : <EOL> self . offset = self . offset + j - i <EOL> return j <EOL> _decl_otherchars = '<STR_LIT>' <EOL> def parse_declaration ( self , i ) : <EOL> rawdata = self . rawdata <EOL> j = i + <NUM_LIT:2> <EOL> assert rawdata [ i : j ] == "<STR_LIT>" , "<STR_LIT>" <EOL> if rawdata [ j : j + <NUM_LIT:1> ] == "<STR_LIT:>>" : <EOL> return j + <NUM_LIT:1> <EOL> if rawdata [ j : j + <NUM_LIT:1> ] in ( "<STR_LIT:->" , "<STR_LIT>" ) : <EOL> return - <NUM_LIT:1> <EOL> n = len ( rawdata ) <EOL> if rawdata [ j : j + <NUM_LIT:2> ] == '<STR_LIT>' : <EOL> return self . parse_comment ( i ) <EOL> elif rawdata [ j ] == '<STR_LIT:[>' : <EOL> return self . parse_marked_section ( i ) <EOL> else : <EOL> decltype , j = self . _scan_name ( j , i ) <EOL> if j < <NUM_LIT:0> : <EOL> return j <EOL> if decltype == "<STR_LIT>" : <EOL> self . _decl_otherchars = '<STR_LIT>' <EOL> while j < n : <EOL> c = rawdata [ j ] <EOL> if c == "<STR_LIT:>>" : <EOL> data = rawdata [ i + <NUM_LIT:2> : j ] <EOL> if decltype == "<STR_LIT>" : <EOL> self . handle_decl ( data ) <EOL> else : <EOL> self . unknown_decl ( data ) <EOL> return j + <NUM_LIT:1> <EOL> if c in "<STR_LIT>" : <EOL> m = _declstringlit_match ( rawdata , j ) <EOL> if not m : <EOL> return - <NUM_LIT:1> <EOL> j = m . end ( ) <EOL> elif c in "<STR_LIT>" : <EOL> name , j = self . _scan_name ( j , i ) <EOL> elif c in self . _decl_otherchars : <EOL> j = j + <NUM_LIT:1> <EOL> elif c == "<STR_LIT:[>" : <EOL> if decltype == "<STR_LIT>" : <EOL> j = self . _parse_doctype_subset ( j + <NUM_LIT:1> , i ) <EOL> elif decltype in ( "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ) : <EOL> self . error ( "<STR_LIT>" % decltype ) <EOL> else : <EOL> self . error ( "<STR_LIT>" ) <EOL> else :

self . error (

"""<STR_LIT>""" <EOL> import re <EOL> _declname_match = re . compile ( r'<STR_LIT>' ) . match <EOL> _declstringlit_match = re . compile ( r'<STR_LIT>' ) . match <EOL> _commentclose = re . compile ( r'<STR_LIT>' ) <EOL> _markedsectionclose = re . compile ( r'<STR_LIT>' ) <EOL> _msmarkedsectionclose = re . compile ( r'<STR_LIT>' ) <EOL> del re <EOL> class ParserBase : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self ) : <EOL> if self . __class__ is ParserBase : <EOL> raise RuntimeError ( <EOL> "<STR_LIT>" ) <EOL> def error ( self , message ) : <EOL> raise NotImplementedError ( <EOL> "<STR_LIT>" ) <EOL> def reset ( self ) : <EOL> self . lineno = <NUM_LIT:1> <EOL> self . offset = <NUM_LIT:0> <EOL> def getpos ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . lineno , self . offset <EOL> def updatepos ( self , i , j ) : <EOL> if i >= j : <EOL> return j <EOL> rawdata = self . rawdata <EOL> nlines = rawdata . count ( "<STR_LIT:\n>" , i , j ) <EOL> if nlines : <EOL> self . lineno = self . lineno + nlines <EOL> pos = rawdata . rindex ( "<STR_LIT:\n>" , i , j ) <EOL> self . offset = j - ( pos + <NUM_LIT:1> ) <EOL> else : <EOL> self . offset = self . offset + j - i <EOL> return j <EOL> _decl_otherchars = '<STR_LIT>' <EOL> def parse_declaration ( self , i ) : <EOL> rawdata = self . rawdata <EOL> j = i + <NUM_LIT:2> <EOL> assert rawdata [ i : j ] == "<STR_LIT>" , "<STR_LIT>" <EOL> if rawdata [ j : j + <NUM_LIT:1> ] == "<STR_LIT:>>" : <EOL> return j + <NUM_LIT:1> <EOL> if rawdata [ j : j + <NUM_LIT:1> ] in ( "<STR_LIT:->" , "<STR_LIT>" ) : <EOL> return - <NUM_LIT:1> <EOL> n = len ( rawdata ) <EOL> if rawdata [ j : j + <NUM_LIT:2> ] == '<STR_LIT>' : <EOL> return self . parse_comment ( i ) <EOL> elif rawdata [ j ] == '<STR_LIT:[>' : <EOL> return self . parse_marked_section ( i ) <EOL> else : <EOL> decltype , j = self . _scan_name ( j , i ) <EOL> if j < <NUM_LIT:0> : <EOL> return j <EOL> if decltype == "<STR_LIT>" : <EOL> self . _decl_otherchars = '<STR_LIT>' <EOL> while j < n : <EOL> c = rawdata [ j ] <EOL> if c == "<STR_LIT:>>" : <EOL> data = rawdata [ i + <NUM_LIT:2> : j ] <EOL> if decltype == "<STR_LIT>" : <EOL> self . handle_decl ( data ) <EOL> else : <EOL> self . unknown_decl ( data ) <EOL> return j + <NUM_LIT:1> <EOL> if c in "<STR_LIT>" : <EOL> m = _declstringlit_match ( rawdata , j ) <EOL> if not m : <EOL> return - <NUM_LIT:1> <EOL> j = m . end ( ) <EOL> elif c in "<STR_LIT>" : <EOL> name , j = self . _scan_name ( j , i ) <EOL> elif c in self . _decl_otherchars : <EOL> j = j + <NUM_LIT:1> <EOL> elif c == "<STR_LIT:[>" : <EOL> if decltype == "<STR_LIT>" : <EOL> j = self . _parse_doctype_subset ( j + <NUM_LIT:1> , i ) <EOL> elif decltype in ( "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ) : <EOL> self . error ( "<STR_LIT>" % decltype ) <EOL> else : <EOL> self . error ( "<STR_LIT>" ) <EOL> else : <EOL> self . error ( <EOL> "<STR_LIT>" % rawdata [ j ] ) <EOL> if j < <NUM_LIT:0> : <EOL> return j <EOL> return - <NUM_LIT:1> <EOL> def parse_marked_section ( self , i , report = <NUM_LIT:1> ) : <EOL> rawdata = self . rawdata <EOL> assert rawdata [ i : i + <NUM_LIT:3> ] == '<STR_LIT>' , "<STR_LIT>" <EOL> sectName , j = self . _scan_name ( i + <NUM_LIT:3> , i ) <EOL> if j < <NUM_LIT:0> : <EOL> return j <EOL> if sectName in ( "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT:ignore>" , "<STR_LIT>" , "<STR_LIT>" ) : <EOL> match = _markedsectionclose . search ( rawdata , i + <NUM_LIT:3> ) <EOL> elif sectName in ( "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ) : <EOL> match = _msmarkedsectionclose . search ( rawdata , i + <NUM_LIT:3> ) <EOL> else : <EOL> self . error ( '<STR_LIT>' % rawdata [ i + <NUM_LIT:3> : j ] ) <EOL> if not match : <EOL> return - <NUM_LIT:1> <EOL> if report : <EOL> j = match . start ( <NUM_LIT:0> ) <EOL> self . unknown_decl ( rawdata [ i + <NUM_LIT:3> : j ] ) <EOL> return match . end ( <NUM_LIT:0> ) <EOL> def parse_comment ( self , i , report = <NUM_LIT:1> ) : <EOL> rawdata = self . rawdata <EOL> if rawdata [ i : i + <NUM_LIT:4> ] != '<STR_LIT>' : <EOL> self . error ( '<STR_LIT>' ) <EOL> match = _commentclose . search ( rawdata , i + <NUM_LIT:4> ) <EOL> if not match : <EOL> return - <NUM_LIT:1> <EOL> if report : <EOL> j = match . start ( <NUM_LIT:0> ) <EOL> self . handle_comment ( rawdata [ i + <NUM_LIT:4> : j ] ) <EOL> return match . end ( <NUM_LIT:0> ) <EOL> def _parse_doctype_subset ( self , i , declstartpos ) : <EOL> rawdata = self . rawdata <EOL> n = len ( rawdata ) <EOL> j = i <EOL> while j < n : <EOL> c = rawdata [ j ] <EOL> if c == "<STR_LIT:<>" : <EOL> s = rawdata [ j : j + <NUM_LIT:2> ] <EOL> if s == "<STR_LIT:<>" : <EOL> return - <NUM_LIT:1> <EOL> if s != "<STR_LIT>" : <EOL> self . updatepos ( declstartpos , j + <NUM_LIT:1> ) <EOL> self . error ( "<STR_LIT>" % s ) <EOL> if ( j + <NUM_LIT:2> ) == n : <EOL> return - <NUM_LIT:1> <EOL> if ( j + <NUM_LIT:4> ) > n : <EOL> return - <NUM_LIT:1> <EOL> if rawdata [ j : j + <NUM_LIT:4> ] == "<STR_LIT>" : <EOL> j = self . parse_comment ( j , report = <NUM_LIT:0> ) <EOL> if j < <NUM_LIT:0> : <EOL> return j <EOL> continue <EOL> name , j = self . _scan_name ( j + <NUM_LIT:2> , declstartpos ) <EOL> if j == - <NUM_LIT:1> : <EOL> return - <NUM_LIT:1> <EOL> if name not in ( "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ) : <EOL> self . updatepos ( declstartpos , j + <NUM_LIT:2> ) <EOL> self . error ( <EOL> "<STR_LIT>" % name ) <EOL> meth = getattr ( self , "<STR_LIT>" + name ) <EOL> j = meth ( j , declstartpos ) <EOL> if j < <NUM_LIT:0> : <EOL> return j <EOL> elif c == "<STR_LIT:%>" : <EOL> if ( j + <NUM_LIT:1> ) == n : <EOL> return - <NUM_LIT:1> <EOL> s , j = self . _scan_name ( j + <NUM_LIT:1> , declstartpos ) <EOL> if j < <NUM_LIT:0> : <EOL> return j <EOL> if rawdata [ j ] == "<STR_LIT:;>" : <EOL> j = j + <NUM_LIT:1> <EOL> elif c == "<STR_LIT:]>" : <EOL> j = j + <NUM_LIT:1> <EOL> while j < n and rawdata [ j ] . isspace ( ) : <EOL> j = j + <NUM_LIT:1> <EOL> if j < n : <EOL> if rawdata [ j ] == "<STR_LIT:>>" : <EOL> return j <EOL> self . updatepos ( declstartpos , j ) <EOL> self . error ( "<STR_LIT>" ) <EOL> else : <EOL> return - <NUM_LIT:1> <EOL> elif c . isspace ( ) : <EOL> j = j + <NUM_LIT:1> <EOL> else : <EOL> self . updatepos ( declstartpos , j ) <EOL> self . error ( "<STR_LIT>" % c ) <EOL> return - <NUM_LIT:1> <EOL> def _parse_doctype_element ( self , i , declstartpos ) : <EOL> name , j = self . _scan_name ( i , declstartpos ) <EOL> if j == - <NUM_LIT:1> : <EOL> return - <NUM_LIT:1> <EOL> rawdata = self . rawdata <EOL> if '<STR_LIT:>>' in rawdata [ j : ] : <EOL> return rawdata . find ( "<STR_LIT:>>" , j ) + <NUM_LIT:1> <EOL> return - <NUM_LIT:1> <EOL> def _parse_doctype_attlist ( self , i , declstartpos ) : <EOL> rawdata = self . rawdata <EOL> name , j = self . _scan_name ( i , declstartpos ) <EOL> c = rawdata [ j : j + <NUM_LIT:1> ] <EOL> if c == "<STR_LIT>" : <EOL> return - <NUM_LIT:1> <EOL> if c == "<STR_LIT:>>" : <EOL> return j + <NUM_LIT:1> <EOL> while <NUM_LIT:1> : <EOL> name , j = self . _scan_name ( j , declstartpos ) <EOL> if j < <NUM_LIT:0> : <EOL> return j <EOL> c = rawdata [ j : j + <NUM_LIT:1> ] <EOL> if c == "<STR_LIT>" : <EOL> return - <NUM_LIT:1> <EOL> if c == "<STR_LIT:(>" : <EOL> if "<STR_LIT:)>" in rawdata [ j : ] : <EOL> j = rawdata . find ( "<STR_LIT:)>" , j ) + <NUM_LIT:1> <EOL> else : <EOL> return - <NUM_LIT:1> <EOL> while rawdata [ j : j + <NUM_LIT:1> ] . isspace ( ) : <EOL> j = j + <NUM_LIT:1> <EOL> if not rawdata [ j : ] : <EOL> return - <NUM_LIT:1> <EOL> else : <EOL> name , j = self . _scan_name ( j , declstartpos ) <EOL> c = rawdata [ j : j + <NUM_LIT:1> ] <EOL> if not c : <EOL> return - <NUM_LIT:1> <EOL> if c in "<STR_LIT>" : <EOL> m = _declstringlit_match ( rawdata , j ) <EOL> if m : <EOL> j = m . end ( ) <EOL> else : <EOL> return - <NUM_LIT:1> <EOL> c = rawdata [ j : j + <NUM_LIT:1> ] <EOL> if not c : <EOL> return - <NUM_LIT:1> <EOL> if c == "<STR_LIT:#>" : <EOL> if rawdata [ j : ] == "<STR_LIT:#>" : <EOL> return - <NUM_LIT:1> <EOL> name , j = self . _scan_name ( j + <NUM_LIT:1> , declstartpos ) <EOL> if j < <NUM_LIT:0> : <EOL> return j <EOL> c = rawdata [ j : j + <NUM_LIT:1> ] <EOL> if not c : <EOL> return - <NUM_LIT:1> <EOL> if c == '<STR_LIT:>>' : <EOL> return j + <NUM_LIT:1> <EOL> def _parse_doctype_notation ( self , i , declstartpos ) : <EOL> name , j = self . _scan_name ( i , declstartpos ) <EOL> if j < <NUM_LIT:0> : <EOL> return j <EOL> rawdata = self . rawdata <EOL> while <NUM_LIT:1> : <EOL> c = rawdata [ j : j + <NUM_LIT:1> ] <EOL> if not c : <EOL> return - <NUM_LIT:1> <EOL> if c == '<STR_LIT:>>' : <EOL> return j + <NUM_LIT:1> <EOL> if c in "<STR_LIT>" : <EOL> m = _declstringlit_match ( rawdata , j ) <EOL> if not m : <EOL> return - <NUM_LIT:1> <EOL> j = m . end ( ) <EOL> else : <EOL> name , j = self . _scan_name ( j , declstartpos ) <EOL> if j < <NUM_LIT:0> : <EOL> return j <EOL> def _parse_doctype_entity ( self , i , declstartpos ) : <EOL> rawdata = self . rawdata <EOL> if rawdata [ i : i + <NUM_LIT:1> ] == "<STR_LIT:%>" : <EOL> j = i + <NUM_LIT:1> <EOL> while <NUM_LIT:1> : <EOL> c = rawdata [ j : j + <NUM_LIT:1> ] <EOL> if not c : <EOL> return - <NUM_LIT:1> <EOL> if c . isspace ( ) : <EOL> j = j + <NUM_LIT:1> <EOL> else : <EOL> break <EOL> else : <EOL> j = i <EOL> name , j = self . _scan_name ( j , declstartpos ) <EOL> if j < <NUM_LIT:0> : <EOL> return j <EOL> while <NUM_LIT:1> : <EOL> c = self . rawdata [ j : j + <NUM_LIT:1> ] <EOL> if not c : <EOL> return - <NUM_LIT:1> <EOL> if c in "<STR_LIT>" : <EOL> m = _declstringlit_match ( rawdata , j ) <EOL> if m : <EOL> j = m . end ( ) <EOL> else : <EOL> return - <NUM_LIT:1> <EOL> elif c == "<STR_LIT:>>" : <EOL> return j + <NUM_LIT:1> <EOL> else : <EOL> name , j = self . _scan_name ( j , declstartpos ) <EOL> if j < <NUM_LIT:0> : <EOL> return j <EOL> def _scan_name ( self , i , declstartpos ) : <EOL> rawdata = self . rawdata <EOL> n = len ( rawdata ) <EOL> if i == n : <EOL> return None , - <NUM_LIT:1> <EOL> m = _declname_match ( rawdata , i ) <EOL> if m : <EOL> s = m . group ( ) <EOL> name = s . strip ( ) <EOL> if ( i + len ( s ) ) == n : <EOL> return None , - <NUM_LIT:1> <EOL> return name . lower ( ) , m . end ( ) <EOL> else : <EOL> self . updatepos ( declstartpos , i ) <EOL> self . error ( "<STR_LIT>" <EOL> % rawdata [ declstartpos : declstartpos + <NUM_LIT:20> ] ) <EOL> def unknown_decl ( self , data ) : <EOL> pass </s>

"""<STR_LIT>""" <EOL> from warnings import warnpy3k <EOL> warnpy3k ( "<STR_LIT>" <EOL> "<STR_LIT>" , stacklevel = <NUM_LIT:2> ) <EOL> del warnpy3k <EOL> from types import ClassType as classobj

from types import FunctionType as function

"""<STR_LIT>""" <EOL> from warnings import warnpy3k <EOL> warnpy3k ( "<STR_LIT>" <EOL> "<STR_LIT>" , stacklevel = <NUM_LIT:2> ) <EOL> del warnpy3k <EOL> from types import ClassType as classobj <EOL> from types import FunctionType as function <EOL> from types import InstanceType as instance <EOL> from types import MethodType as instancemethod <EOL> from types import ModuleType as module <EOL> from types import CodeType as code </s>

"""<STR_LIT>""" <EOL> __all__ = [ "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ] <EOL> ESCAPE = '<STR_LIT:=>' <EOL> MAXLINESIZE = <NUM_LIT> <EOL> HEX = '<STR_LIT>'

EMPTYSTRING = '<STR_LIT>'

"""<STR_LIT>""" <EOL> __all__ = [ "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ] <EOL> ESCAPE = '<STR_LIT:=>' <EOL> MAXLINESIZE = <NUM_LIT> <EOL> HEX = '<STR_LIT>' <EOL> EMPTYSTRING = '<STR_LIT>' <EOL> try : <EOL> from binascii import a2b_qp , b2a_qp <EOL> except ImportError : <EOL> a2b_qp = None <EOL> b2a_qp = None <EOL> def needsquoting ( c , quotetabs , header ) : <EOL> """<STR_LIT>""" <EOL> if c in '<STR_LIT>' : <EOL> return quotetabs <EOL> if c == '<STR_LIT:_>' : <EOL> return header <EOL> return c == ESCAPE or not ( '<STR_LIT:U+0020>' <= c <= '<STR_LIT>' ) <EOL> def quote ( c ) : <EOL> """<STR_LIT>""" <EOL> i = ord ( c ) <EOL> return ESCAPE + HEX [ i // <NUM_LIT:16> ] + HEX [ i % <NUM_LIT:16> ] <EOL> def encode ( input , output , quotetabs , header = <NUM_LIT:0> ) : <EOL> """<STR_LIT>""" <EOL> if b2a_qp is not None : <EOL> data = input . read ( ) <EOL> odata = b2a_qp ( data , quotetabs = quotetabs , header = header ) <EOL> output . write ( odata ) <EOL> return <EOL> def write ( s , output = output , lineEnd = '<STR_LIT:\n>' ) : <EOL> if s and s [ - <NUM_LIT:1> : ] in '<STR_LIT>' : <EOL> output . write ( s [ : - <NUM_LIT:1> ] + quote ( s [ - <NUM_LIT:1> ] ) + lineEnd ) <EOL> elif s == '<STR_LIT:.>' : <EOL> output . write ( quote ( s ) + lineEnd ) <EOL> else : <EOL> output . write ( s + lineEnd ) <EOL> prevline = None <EOL> while <NUM_LIT:1> : <EOL> line = input . readline ( ) <EOL> if not line : <EOL> break <EOL> outline = [ ] <EOL> stripped = '<STR_LIT>' <EOL> if line [ - <NUM_LIT:1> : ] == '<STR_LIT:\n>' : <EOL> line = line [ : - <NUM_LIT:1> ] <EOL> stripped = '<STR_LIT:\n>' <EOL> for c in line : <EOL> if needsquoting ( c , quotetabs , header ) : <EOL> c = quote ( c ) <EOL> if header and c == '<STR_LIT:U+0020>' : <EOL> outline . append ( '<STR_LIT:_>' ) <EOL> else : <EOL> outline . append ( c ) <EOL> if prevline is not None : <EOL> write ( prevline ) <EOL> thisline = EMPTYSTRING . join ( outline ) <EOL> while len ( thisline ) > MAXLINESIZE : <EOL> write ( thisline [ : MAXLINESIZE - <NUM_LIT:1> ] , lineEnd = '<STR_LIT>' ) <EOL> thisline = thisline [ MAXLINESIZE - <NUM_LIT:1> : ] <EOL> prevline = thisline <EOL> if prevline is not None : <EOL> write ( prevline , lineEnd = stripped ) <EOL> def encodestring ( s , quotetabs = <NUM_LIT:0> , header = <NUM_LIT:0> ) : <EOL> if b2a_qp is not None : <EOL> return b2a_qp ( s , quotetabs = quotetabs , header = header ) <EOL> from cStringIO import StringIO <EOL> infp = StringIO ( s ) <EOL> outfp = StringIO ( ) <EOL> encode ( infp , outfp , quotetabs , header ) <EOL> return outfp . getvalue ( ) <EOL> def decode ( input , output , header = <NUM_LIT:0> ) : <EOL> """<STR_LIT>""" <EOL> if a2b_qp is not None : <EOL> data = input . read ( ) <EOL> odata = a2b_qp ( data , header = header ) <EOL> output . write ( odata ) <EOL> return <EOL> new = '<STR_LIT>' <EOL> while <NUM_LIT:1> : <EOL> line = input . readline ( ) <EOL> if not line : break <EOL> i , n = <NUM_LIT:0> , len ( line ) <EOL> if n > <NUM_LIT:0> and line [ n - <NUM_LIT:1> ] == '<STR_LIT:\n>' : <EOL> partial = <NUM_LIT:0> ; n = n - <NUM_LIT:1> <EOL> while n > <NUM_LIT:0> and line [ n - <NUM_LIT:1> ] in "<STR_LIT>" : <EOL> n = n - <NUM_LIT:1> <EOL> else : <EOL> partial = <NUM_LIT:1> <EOL> while i < n : <EOL> c = line [ i ] <EOL> if c == '<STR_LIT:_>' and header : <EOL> new = new + '<STR_LIT:U+0020>' ; i = i + <NUM_LIT:1> <EOL> elif c != ESCAPE : <EOL> new = new + c ; i = i + <NUM_LIT:1> <EOL> elif i + <NUM_LIT:1> == n and not partial : <EOL> partial = <NUM_LIT:1> ; break <EOL> elif i + <NUM_LIT:1> < n and line [ i + <NUM_LIT:1> ] == ESCAPE : <EOL> new = new + ESCAPE ; i = i + <NUM_LIT:2> <EOL> elif i + <NUM_LIT:2> < n and ishex ( line [ i + <NUM_LIT:1> ] ) and ishex ( line [ i + <NUM_LIT:2> ] ) : <EOL> new = new + chr ( unhex ( line [ i + <NUM_LIT:1> : i + <NUM_LIT:3> ] ) ) ; i = i + <NUM_LIT:3> <EOL> else : <EOL> new = new + c ; i = i + <NUM_LIT:1> <EOL> if not partial : <EOL> output . write ( new + '<STR_LIT:\n>' ) <EOL> new = '<STR_LIT>' <EOL> if new : <EOL> output . write ( new ) <EOL> def decodestring ( s , header = <NUM_LIT:0> ) : <EOL> if a2b_qp is not None : <EOL> return a2b_qp ( s , header = header ) <EOL> from cStringIO import StringIO <EOL> infp = StringIO ( s ) <EOL> outfp = StringIO ( ) <EOL> decode ( infp , outfp , header = header ) <EOL> return outfp . getvalue ( ) <EOL> def ishex ( c ) : <EOL> """<STR_LIT>""" <EOL> return '<STR_LIT:0>' <= c <= '<STR_LIT>' or '<STR_LIT:a>' <= c <= '<STR_LIT:f>' or '<STR_LIT:A>' <= c <= '<STR_LIT:F>' <EOL> def unhex ( s ) : <EOL> """<STR_LIT>""" <EOL> bits = <NUM_LIT:0> <EOL> for c in s : <EOL> if '<STR_LIT:0>' <= c <= '<STR_LIT>' : <EOL> i = ord ( '<STR_LIT:0>' ) <EOL> elif '<STR_LIT:a>' <= c <= '<STR_LIT:f>' : <EOL> i = ord ( '<STR_LIT:a>' ) - <NUM_LIT:10> <EOL> elif '<STR_LIT:A>' <= c <= '<STR_LIT:F>' : <EOL> i = ord ( '<STR_LIT:A>' ) - <NUM_LIT:10> <EOL> else : <EOL> break <EOL> bits = bits * <NUM_LIT:16> + ( ord ( c ) - i ) <EOL> return bits <EOL> def main ( ) : <EOL> import sys <EOL> import getopt <EOL> try : <EOL> opts , args = getopt . getopt ( sys . argv [ <NUM_LIT:1> : ] , '<STR_LIT>' ) <EOL> except getopt . error , msg : <EOL> sys . stdout = sys . stderr <EOL> print msg <EOL> print "<STR_LIT>" <EOL> print "<STR_LIT>" <EOL> print "<STR_LIT>" <EOL> sys . exit ( <NUM_LIT:2> ) <EOL> deco = <NUM_LIT:0> <EOL> tabs = <NUM_LIT:0> <EOL> for o , a in opts : <EOL> if o == '<STR_LIT>' : tabs = <NUM_LIT:1> <EOL> if o == '<STR_LIT>' : deco = <NUM_LIT:1> <EOL> if tabs and deco : <EOL> sys . stdout = sys . stderr <EOL> print "<STR_LIT>" <EOL> sys . exit ( <NUM_LIT:2> ) <EOL> if not args : args = [ '<STR_LIT:->' ] <EOL> sts = <NUM_LIT:0> <EOL> for file in args : <EOL> if file == '<STR_LIT:->' : <EOL> fp = sys . stdin <EOL> else : <EOL> try : <EOL> fp = open ( file ) <EOL> except IOError , msg : <EOL> sys . stderr . write ( "<STR_LIT>" % ( file , msg ) ) <EOL> sts = <NUM_LIT:1> <EOL> continue <EOL> if deco : <EOL> decode ( fp , sys . stdout ) <EOL> else : <EOL> encode ( fp , sys . stdout , tabs ) <EOL> if fp is not sys . stdin : <EOL> fp . close ( ) <EOL> if sts : <EOL> sys . exit ( sts ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> main ( ) </s>

import os <EOL> import Image <EOL> import marshal <EOL> try : <EOL> import zlib <EOL> except ImportError : <EOL> zlib = None <EOL> WIDTH = <NUM_LIT> <EOL> def puti16 ( fp , values ) : <EOL> for v in values : <EOL> if v < <NUM_LIT:0> : <EOL> v = v + <NUM_LIT> <EOL> fp . write ( chr ( v >> <NUM_LIT:8> & <NUM_LIT:255> ) + chr ( v & <NUM_LIT:255> ) ) <EOL> class FontFile : <EOL> bitmap = None <EOL> def __init__ ( self ) : <EOL> self . info = { } <EOL> self . glyph = [ None ] * <NUM_LIT> <EOL> def __getitem__ ( self , ix ) : <EOL> return self . glyph [ ix ] <EOL> def compile ( self ) : <EOL> "<STR_LIT>" <EOL> if self . bitmap : <EOL> return <EOL> h = w = maxwidth = <NUM_LIT:0> <EOL> lines = <NUM_LIT:1> <EOL> for glyph in self : <EOL> if glyph : <EOL> d , dst , src , im = glyph <EOL> h = max ( h , src [ <NUM_LIT:3> ] - src [ <NUM_LIT:1> ] ) <EOL> w = w + ( src [ <NUM_LIT:2> ] - src [ <NUM_LIT:0> ] ) <EOL> if w > WIDTH :

lines = lines + <NUM_LIT:1>

import os <EOL> import Image <EOL> import marshal <EOL> try : <EOL> import zlib <EOL> except ImportError : <EOL> zlib = None <EOL> WIDTH = <NUM_LIT> <EOL> def puti16 ( fp , values ) : <EOL> for v in values : <EOL> if v < <NUM_LIT:0> : <EOL> v = v + <NUM_LIT> <EOL> fp . write ( chr ( v >> <NUM_LIT:8> & <NUM_LIT:255> ) + chr ( v & <NUM_LIT:255> ) ) <EOL> class FontFile : <EOL> bitmap = None <EOL> def __init__ ( self ) : <EOL> self . info = { } <EOL> self . glyph = [ None ] * <NUM_LIT> <EOL> def __getitem__ ( self , ix ) : <EOL> return self . glyph [ ix ] <EOL> def compile ( self ) : <EOL> "<STR_LIT>" <EOL> if self . bitmap : <EOL> return <EOL> h = w = maxwidth = <NUM_LIT:0> <EOL> lines = <NUM_LIT:1> <EOL> for glyph in self : <EOL> if glyph : <EOL> d , dst , src , im = glyph <EOL> h = max ( h , src [ <NUM_LIT:3> ] - src [ <NUM_LIT:1> ] ) <EOL> w = w + ( src [ <NUM_LIT:2> ] - src [ <NUM_LIT:0> ] ) <EOL> if w > WIDTH : <EOL> lines = lines + <NUM_LIT:1> <EOL> w = ( src [ <NUM_LIT:2> ] - src [ <NUM_LIT:0> ] ) <EOL> maxwidth = max ( maxwidth , w ) <EOL> xsize = maxwidth <EOL> ysize = lines * h <EOL> if xsize == <NUM_LIT:0> and ysize == <NUM_LIT:0> : <EOL> return "<STR_LIT>" <EOL> self . ysize = h <EOL> self . bitmap = Image . new ( "<STR_LIT:1>" , ( xsize , ysize ) ) <EOL> self . metrics = [ None ] * <NUM_LIT> <EOL> x = y = <NUM_LIT:0> <EOL> for i in range ( <NUM_LIT> ) : <EOL> glyph = self [ i ] <EOL> if glyph : <EOL> d , dst , src , im = glyph <EOL> xx , yy = src [ <NUM_LIT:2> ] - src [ <NUM_LIT:0> ] , src [ <NUM_LIT:3> ] - src [ <NUM_LIT:1> ] <EOL> x0 , y0 = x , y <EOL> x = x + xx <EOL> if x > WIDTH : <EOL> x , y = <NUM_LIT:0> , y + h <EOL> x0 , y0 = x , y <EOL> x = xx <EOL> s = src [ <NUM_LIT:0> ] + x0 , src [ <NUM_LIT:1> ] + y0 , src [ <NUM_LIT:2> ] + x0 , src [ <NUM_LIT:3> ] + y0 <EOL> self . bitmap . paste ( im . crop ( src ) , s ) <EOL> self . metrics [ i ] = d , dst , s <EOL> def save1 ( self , filename ) : <EOL> "<STR_LIT>" <EOL> self . compile ( ) <EOL> self . bitmap . save ( os . path . splitext ( filename ) [ <NUM_LIT:0> ] + "<STR_LIT>" , "<STR_LIT>" ) <EOL> fp = open ( os . path . splitext ( filename ) [ <NUM_LIT:0> ] + "<STR_LIT>" , "<STR_LIT:wb>" ) <EOL> fp . write ( "<STR_LIT>" ) <EOL> fp . write ( "<STR_LIT>" % self . ysize ) <EOL> fp . write ( "<STR_LIT>" ) <EOL> for id in range ( <NUM_LIT> ) : <EOL> m = self . metrics [ id ] <EOL> if not m : <EOL> puti16 ( fp , [ <NUM_LIT:0> ] * <NUM_LIT:10> ) <EOL> else : <EOL> puti16 ( fp , m [ <NUM_LIT:0> ] + m [ <NUM_LIT:1> ] + m [ <NUM_LIT:2> ] ) <EOL> fp . close ( ) <EOL> def save2 ( self , filename ) : <EOL> "<STR_LIT>" <EOL> self . compile ( ) <EOL> data = marshal . dumps ( ( self . metrics , self . info ) ) <EOL> if zlib : <EOL> data = "<STR_LIT:z>" + zlib . compress ( data , <NUM_LIT:9> ) <EOL> else : <EOL> data = "<STR_LIT:u>" + data <EOL> fp = open ( os . path . splitext ( filename ) [ <NUM_LIT:0> ] + "<STR_LIT>" , "<STR_LIT:wb>" ) <EOL> fp . write ( "<STR_LIT>" + self . name + "<STR_LIT:\n>" + "<STR_LIT>" ) <EOL> fp . write ( data ) <EOL> self . bitmap . save ( fp , "<STR_LIT>" ) <EOL> fp . close ( ) <EOL> save = save1 </s>

import array <EOL> import Image , ImageColor <EOL> class ImagePalette : <EOL> "<STR_LIT>" <EOL> def __init__ ( self , mode = "<STR_LIT>" , palette = None ) : <EOL> self . mode = mode <EOL> self . rawmode = None <EOL> self . palette = palette or range ( <NUM_LIT> ) * len ( self . mode ) <EOL> self . colors = { } <EOL> self . dirty = None <EOL> if len ( self . mode ) * <NUM_LIT> != len ( self . palette ) : <EOL> raise ValueError , "<STR_LIT>" <EOL> def getdata ( self ) : <EOL> if self . rawmode : <EOL> return self . rawmode , self . palette <EOL> return self . mode + "<STR_LIT>" , self . tostring ( ) <EOL> def tostring ( self ) : <EOL> if self . rawmode :

raise ValueError ( "<STR_LIT>" )

import array <EOL> import Image , ImageColor <EOL> class ImagePalette : <EOL> "<STR_LIT>" <EOL> def __init__ ( self , mode = "<STR_LIT>" , palette = None ) : <EOL> self . mode = mode <EOL> self . rawmode = None <EOL> self . palette = palette or range ( <NUM_LIT> ) * len ( self . mode ) <EOL> self . colors = { } <EOL> self . dirty = None <EOL> if len ( self . mode ) * <NUM_LIT> != len ( self . palette ) : <EOL> raise ValueError , "<STR_LIT>" <EOL> def getdata ( self ) : <EOL> if self . rawmode : <EOL> return self . rawmode , self . palette <EOL> return self . mode + "<STR_LIT>" , self . tostring ( ) <EOL> def tostring ( self ) : <EOL> if self . rawmode : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> if Image . isStringType ( self . palette ) : <EOL> return self . palette <EOL> return array . array ( "<STR_LIT:B>" , self . palette ) . tostring ( ) <EOL> def getcolor ( self , color ) : <EOL> if self . rawmode : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> if Image . isTupleType ( color ) : <EOL> try : <EOL> return self . colors [ color ] <EOL> except KeyError : <EOL> if Image . isStringType ( self . palette ) : <EOL> self . palette = map ( int , self . palette ) <EOL> index = len ( self . colors ) <EOL> if index >= <NUM_LIT> : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> self . colors [ color ] = index <EOL> self . palette [ index ] = color [ <NUM_LIT:0> ] <EOL> self . palette [ index + <NUM_LIT> ] = color [ <NUM_LIT:1> ] <EOL> self . palette [ index + <NUM_LIT> ] = color [ <NUM_LIT:2> ] <EOL> self . dirty = <NUM_LIT:1> <EOL> return index <EOL> else : <EOL> raise ValueError ( "<STR_LIT>" % color ) <EOL> def save ( self , fp ) : <EOL> if self . rawmode : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> if type ( fp ) == type ( "<STR_LIT>" ) : <EOL> fp = open ( fp , "<STR_LIT:w>" ) <EOL> fp . write ( "<STR_LIT>" ) <EOL> fp . write ( "<STR_LIT>" % self . mode ) <EOL> for i in range ( <NUM_LIT> ) : <EOL> fp . write ( "<STR_LIT>" % i ) <EOL> for j in range ( i , len ( self . palette ) , <NUM_LIT> ) : <EOL> fp . write ( "<STR_LIT>" % self . palette [ j ] ) <EOL> fp . write ( "<STR_LIT:\n>" ) <EOL> fp . close ( ) <EOL> def raw ( rawmode , data ) : <EOL> palette = ImagePalette ( ) <EOL> palette . rawmode = rawmode <EOL> palette . palette = data <EOL> palette . dirty = <NUM_LIT:1> <EOL> return palette <EOL> def _make_linear_lut ( black , white ) : <EOL> lut = [ ] <EOL> if black == <NUM_LIT:0> : <EOL> for i in range ( <NUM_LIT> ) : <EOL> lut . append ( white * i / <NUM_LIT:255> ) <EOL> else : <EOL> raise NotImplementedError <EOL> return lut <EOL> def _make_gamma_lut ( exp , mode = "<STR_LIT>" ) : <EOL> lut = [ ] <EOL> for i in range ( <NUM_LIT> ) : <EOL> lut . append ( int ( ( ( i / <NUM_LIT> ) ** exp ) * <NUM_LIT> + <NUM_LIT:0.5> ) ) <EOL> return lut <EOL> def new ( mode , data ) : <EOL> return Image . core . new_palette ( mode , data ) <EOL> def negative ( mode = "<STR_LIT>" ) : <EOL> palette = range ( <NUM_LIT> ) <EOL> palette . reverse ( ) <EOL> return ImagePalette ( mode , palette * len ( mode ) ) <EOL> def random ( mode = "<STR_LIT>" ) : <EOL> from random import randint <EOL> palette = [ ] <EOL> for i in range ( <NUM_LIT> * len ( mode ) ) : <EOL> palette . append ( randint ( <NUM_LIT:0> , <NUM_LIT:255> ) ) <EOL> return ImagePalette ( mode , palette ) <EOL> def sepia ( white = "<STR_LIT>" ) : <EOL> r , g , b = ImageColor . getrgb ( white ) <EOL> r = _make_linear_lut ( <NUM_LIT:0> , r ) <EOL> g = _make_linear_lut ( <NUM_LIT:0> , g ) <EOL> b = _make_linear_lut ( <NUM_LIT:0> , b ) <EOL> return ImagePalette ( "<STR_LIT>" , r + g + b ) <EOL> def wedge ( mode = "<STR_LIT>" ) : <EOL> return ImagePalette ( mode , range ( <NUM_LIT> ) * len ( mode ) ) <EOL> def load ( filename ) : <EOL> fp = open ( filename , "<STR_LIT:rb>" ) <EOL> lut = None <EOL> if not lut : <EOL> try : <EOL> import GimpPaletteFile <EOL> fp . seek ( <NUM_LIT:0> ) <EOL> p = GimpPaletteFile . GimpPaletteFile ( fp ) <EOL> lut = p . getpalette ( ) <EOL> except ( SyntaxError , ValueError ) : <EOL> pass <EOL> if not lut : <EOL> try : <EOL> import GimpGradientFile <EOL> fp . seek ( <NUM_LIT:0> ) <EOL> p = GimpGradientFile . GimpGradientFile ( fp ) <EOL> lut = p . getpalette ( ) <EOL> except ( SyntaxError , ValueError ) : <EOL> pass <EOL> if not lut : <EOL> try : <EOL> import PaletteFile <EOL> fp . seek ( <NUM_LIT:0> ) <EOL> p = PaletteFile . PaletteFile ( fp ) <EOL> lut = p . getpalette ( ) <EOL> except ( SyntaxError , ValueError ) : <EOL> pass <EOL> if not lut : <EOL> raise IOError , "<STR_LIT>" <EOL> return lut </s>

__version__ = "<STR_LIT>" <EOL> import Image , ImageFile <EOL> def i16 ( c ) : <EOL> return ord ( c [ <NUM_LIT:1> ] ) + ( ord ( c [ <NUM_LIT:0> ] ) << <NUM_LIT:8> ) <EOL> def i32 ( c ) : <EOL> return ord ( c [ <NUM_LIT:3> ] ) + ( ord ( c [ <NUM_LIT:2> ] ) << <NUM_LIT:8> ) + ( ord ( c [ <NUM_LIT:1> ] ) << <NUM_LIT:16> ) + ( ord ( c [ <NUM_LIT:0> ] ) << <NUM_LIT> ) <EOL> def _accept ( prefix ) : <EOL> return i16 ( prefix ) == <NUM_LIT> <EOL> class SgiImageFile ( ImageFile . ImageFile ) : <EOL> format = "<STR_LIT>" <EOL> format_description = "<STR_LIT>" <EOL> def _open ( self ) : <EOL> s = self . fp . read ( <NUM_LIT> ) <EOL> if i16 ( s ) != <NUM_LIT> : <EOL> raise SyntaxError ( "<STR_LIT>" ) <EOL> compression = ord ( s [ <NUM_LIT:2> ] ) <EOL> layout = ord ( s [ <NUM_LIT:3> ] ) , i16 ( s [ <NUM_LIT:4> : ] ) , i16 ( s [ <NUM_LIT:10> : ] ) <EOL> if layout == ( <NUM_LIT:1> , <NUM_LIT:2> , <NUM_LIT:1> ) or layout == ( <NUM_LIT:1> , <NUM_LIT:1> , <NUM_LIT:1> ) : <EOL> self . mode = "<STR_LIT:L>" <EOL> elif layout == ( <NUM_LIT:1> , <NUM_LIT:3> , <NUM_LIT:3> ) : <EOL> self . mode = "<STR_LIT>" <EOL> elif layout == ( <NUM_LIT:1> , <NUM_LIT:3> , <NUM_LIT:4> ) : <EOL> self . mode = "<STR_LIT>" <EOL> else : <EOL> raise SyntaxError ( "<STR_LIT>" ) <EOL> self . size = i16 ( s [ <NUM_LIT:6> : ] ) , i16 ( s [ <NUM_LIT:8> : ] ) <EOL> if compression == <NUM_LIT:0> : <EOL> offset = <NUM_LIT> <EOL> pagesize = self . size [ <NUM_LIT:0> ] * self . size [ <NUM_LIT:1> ] * layout [ <NUM_LIT:0> ] <EOL> self . tile = [ ] <EOL> for layer in self . mode : <EOL> self . tile . append ( ( "<STR_LIT>" , ( <NUM_LIT:0> , <NUM_LIT:0> ) + self . size , offset , ( layer , <NUM_LIT:0> , - <NUM_LIT:1> ) ) )

offset = offset + pagesize

__version__ = "<STR_LIT>" <EOL> import Image , ImageFile <EOL> def i16 ( c ) : <EOL> return ord ( c [ <NUM_LIT:1> ] ) + ( ord ( c [ <NUM_LIT:0> ] ) << <NUM_LIT:8> ) <EOL> def i32 ( c ) : <EOL> return ord ( c [ <NUM_LIT:3> ] ) + ( ord ( c [ <NUM_LIT:2> ] ) << <NUM_LIT:8> ) + ( ord ( c [ <NUM_LIT:1> ] ) << <NUM_LIT:16> ) + ( ord ( c [ <NUM_LIT:0> ] ) << <NUM_LIT> ) <EOL> def _accept ( prefix ) : <EOL> return i16 ( prefix ) == <NUM_LIT> <EOL> class SgiImageFile ( ImageFile . ImageFile ) : <EOL> format = "<STR_LIT>" <EOL> format_description = "<STR_LIT>" <EOL> def _open ( self ) : <EOL> s = self . fp . read ( <NUM_LIT> ) <EOL> if i16 ( s ) != <NUM_LIT> : <EOL> raise SyntaxError ( "<STR_LIT>" ) <EOL> compression = ord ( s [ <NUM_LIT:2> ] ) <EOL> layout = ord ( s [ <NUM_LIT:3> ] ) , i16 ( s [ <NUM_LIT:4> : ] ) , i16 ( s [ <NUM_LIT:10> : ] ) <EOL> if layout == ( <NUM_LIT:1> , <NUM_LIT:2> , <NUM_LIT:1> ) or layout == ( <NUM_LIT:1> , <NUM_LIT:1> , <NUM_LIT:1> ) : <EOL> self . mode = "<STR_LIT:L>" <EOL> elif layout == ( <NUM_LIT:1> , <NUM_LIT:3> , <NUM_LIT:3> ) : <EOL> self . mode = "<STR_LIT>" <EOL> elif layout == ( <NUM_LIT:1> , <NUM_LIT:3> , <NUM_LIT:4> ) : <EOL> self . mode = "<STR_LIT>" <EOL> else : <EOL> raise SyntaxError ( "<STR_LIT>" ) <EOL> self . size = i16 ( s [ <NUM_LIT:6> : ] ) , i16 ( s [ <NUM_LIT:8> : ] ) <EOL> if compression == <NUM_LIT:0> : <EOL> offset = <NUM_LIT> <EOL> pagesize = self . size [ <NUM_LIT:0> ] * self . size [ <NUM_LIT:1> ] * layout [ <NUM_LIT:0> ] <EOL> self . tile = [ ] <EOL> for layer in self . mode : <EOL> self . tile . append ( ( "<STR_LIT>" , ( <NUM_LIT:0> , <NUM_LIT:0> ) + self . size , offset , ( layer , <NUM_LIT:0> , - <NUM_LIT:1> ) ) ) <EOL> offset = offset + pagesize <EOL> elif compression == <NUM_LIT:1> : <EOL> self . tile = [ ( "<STR_LIT>" , ( <NUM_LIT:0> , <NUM_LIT:0> ) + self . size , <NUM_LIT> , ( self . mode , <NUM_LIT:0> , - <NUM_LIT:1> ) ) ] <EOL> Image . register_open ( "<STR_LIT>" , SgiImageFile , _accept ) <EOL> Image . register_extension ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> Image . register_extension ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> Image . register_extension ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> Image . register_extension ( "<STR_LIT>" , "<STR_LIT>" ) </s>

"""<STR_LIT>""" <EOL> MAGIC = <NUM_LIT> <EOL> from _sre import MAXREPEAT <EOL> class error ( Exception ) : <EOL> pass <EOL> FAILURE = "<STR_LIT>" <EOL> SUCCESS = "<STR_LIT:success>" <EOL> ANY = "<STR_LIT>" <EOL> ANY_ALL = "<STR_LIT>" <EOL> ASSERT = "<STR_LIT>" <EOL> ASSERT_NOT = "<STR_LIT>" <EOL> AT = "<STR_LIT>" <EOL> BIGCHARSET = "<STR_LIT>" <EOL> BRANCH = "<STR_LIT>" <EOL> CALL = "<STR_LIT>" <EOL> CATEGORY = "<STR_LIT>" <EOL> CHARSET = "<STR_LIT>" <EOL> GROUPREF = "<STR_LIT>" <EOL> GROUPREF_IGNORE = "<STR_LIT>" <EOL> GROUPREF_EXISTS = "<STR_LIT>" <EOL> IN = "<STR_LIT>" <EOL> IN_IGNORE = "<STR_LIT>" <EOL> INFO = "<STR_LIT:info>" <EOL> JUMP = "<STR_LIT>" <EOL> LITERAL = "<STR_LIT>" <EOL> LITERAL_IGNORE = "<STR_LIT>" <EOL> MARK = "<STR_LIT>" <EOL> MAX_REPEAT = "<STR_LIT>" <EOL> MAX_UNTIL = "<STR_LIT>" <EOL> MIN_REPEAT = "<STR_LIT>" <EOL> MIN_UNTIL = "<STR_LIT>" <EOL> NEGATE = "<STR_LIT>" <EOL> NOT_LITERAL = "<STR_LIT>" <EOL> NOT_LITERAL_IGNORE = "<STR_LIT>" <EOL> RANGE = "<STR_LIT>" <EOL> REPEAT = "<STR_LIT>" <EOL> REPEAT_ONE = "<STR_LIT>" <EOL> SUBPATTERN = "<STR_LIT>" <EOL> MIN_REPEAT_ONE = "<STR_LIT>" <EOL> AT_BEGINNING = "<STR_LIT>" <EOL> AT_BEGINNING_LINE = "<STR_LIT>" <EOL> AT_BEGINNING_STRING = "<STR_LIT>" <EOL> AT_BOUNDARY = "<STR_LIT>" <EOL> AT_NON_BOUNDARY = "<STR_LIT>" <EOL> AT_END = "<STR_LIT>" <EOL> AT_END_LINE = "<STR_LIT>" <EOL> AT_END_STRING = "<STR_LIT>" <EOL> AT_LOC_BOUNDARY = "<STR_LIT>" <EOL> AT_LOC_NON_BOUNDARY = "<STR_LIT>" <EOL> AT_UNI_BOUNDARY = "<STR_LIT>" <EOL> AT_UNI_NON_BOUNDARY = "<STR_LIT>" <EOL> CATEGORY_DIGIT = "<STR_LIT>" <EOL> CATEGORY_NOT_DIGIT = "<STR_LIT>" <EOL> CATEGORY_SPACE = "<STR_LIT>" <EOL> CATEGORY_NOT_SPACE = "<STR_LIT>" <EOL> CATEGORY_WORD = "<STR_LIT>" <EOL> CATEGORY_NOT_WORD = "<STR_LIT>" <EOL> CATEGORY_LINEBREAK = "<STR_LIT>" <EOL> CATEGORY_NOT_LINEBREAK = "<STR_LIT>" <EOL> CATEGORY_LOC_WORD = "<STR_LIT>" <EOL> CATEGORY_LOC_NOT_WORD = "<STR_LIT>" <EOL> CATEGORY_UNI_DIGIT = "<STR_LIT>" <EOL> CATEGORY_UNI_NOT_DIGIT = "<STR_LIT>" <EOL> CATEGORY_UNI_SPACE = "<STR_LIT>" <EOL> CATEGORY_UNI_NOT_SPACE = "<STR_LIT>" <EOL> CATEGORY_UNI_WORD = "<STR_LIT>" <EOL> CATEGORY_UNI_NOT_WORD = "<STR_LIT>" <EOL> CATEGORY_UNI_LINEBREAK = "<STR_LIT>" <EOL> CATEGORY_UNI_NOT_LINEBREAK = "<STR_LIT>" <EOL> OPCODES = [ <EOL> FAILURE , SUCCESS , <EOL> ANY , ANY_ALL , <EOL> ASSERT , ASSERT_NOT , <EOL> AT , <EOL> BRANCH , <EOL> CALL , <EOL> CATEGORY , <EOL> CHARSET , BIGCHARSET , <EOL> GROUPREF , GROUPREF_EXISTS , GROUPREF_IGNORE , <EOL> IN , IN_IGNORE , <EOL> INFO , <EOL> JUMP , <EOL> LITERAL , LITERAL_IGNORE , <EOL> MARK , <EOL> MAX_UNTIL , <EOL> MIN_UNTIL , <EOL> NOT_LITERAL , NOT_LITERAL_IGNORE , <EOL> NEGATE , <EOL> RANGE , <EOL> REPEAT , <EOL> REPEAT_ONE , <EOL> SUBPATTERN , <EOL> MIN_REPEAT_ONE <EOL> ] <EOL> ATCODES = [ <EOL> AT_BEGINNING , AT_BEGINNING_LINE , AT_BEGINNING_STRING , AT_BOUNDARY , <EOL> AT_NON_BOUNDARY , AT_END , AT_END_LINE , AT_END_STRING , <EOL> AT_LOC_BOUNDARY , AT_LOC_NON_BOUNDARY , AT_UNI_BOUNDARY , <EOL> AT_UNI_NON_BOUNDARY <EOL> ] <EOL> CHCODES = [ <EOL> CATEGORY_DIGIT , CATEGORY_NOT_DIGIT , CATEGORY_SPACE , <EOL> CATEGORY_NOT_SPACE , CATEGORY_WORD , CATEGORY_NOT_WORD , <EOL> CATEGORY_LINEBREAK , CATEGORY_NOT_LINEBREAK , CATEGORY_LOC_WORD , <EOL> CATEGORY_LOC_NOT_WORD , CATEGORY_UNI_DIGIT , CATEGORY_UNI_NOT_DIGIT , <EOL> CATEGORY_UNI_SPACE , CATEGORY_UNI_NOT_SPACE , CATEGORY_UNI_WORD , <EOL> CATEGORY_UNI_NOT_WORD , CATEGORY_UNI_LINEBREAK , <EOL> CATEGORY_UNI_NOT_LINEBREAK <EOL> ] <EOL> def makedict ( list ) : <EOL> d = { } <EOL> i = <NUM_LIT:0> <EOL> for item in list : <EOL> d [ item ] = i <EOL> i = i + <NUM_LIT:1> <EOL> return d <EOL> OPCODES = makedict ( OPCODES ) <EOL> ATCODES = makedict ( ATCODES ) <EOL> CHCODES = makedict ( CHCODES ) <EOL> OP_IGNORE = { <EOL> GROUPREF : GROUPREF_IGNORE , <EOL> IN : IN_IGNORE , <EOL> LITERAL : LITERAL_IGNORE , <EOL> NOT_LITERAL : NOT_LITERAL_IGNORE <EOL> } <EOL> AT_MULTILINE = { <EOL> AT_BEGINNING : AT_BEGINNING_LINE , <EOL> AT_END : AT_END_LINE <EOL> } <EOL> AT_LOCALE = { <EOL> AT_BOUNDARY : AT_LOC_BOUNDARY , <EOL> AT_NON_BOUNDARY : AT_LOC_NON_BOUNDARY <EOL> } <EOL> AT_UNICODE = { <EOL> AT_BOUNDARY : AT_UNI_BOUNDARY , <EOL> AT_NON_BOUNDARY : AT_UNI_NON_BOUNDARY <EOL> } <EOL> CH_LOCALE = { <EOL> CATEGORY_DIGIT : CATEGORY_DIGIT , <EOL> CATEGORY_NOT_DIGIT : CATEGORY_NOT_DIGIT , <EOL> CATEGORY_SPACE : CATEGORY_SPACE ,

CATEGORY_NOT_SPACE : CATEGORY_NOT_SPACE ,

"""<STR_LIT>""" <EOL> MAGIC = <NUM_LIT> <EOL> from _sre import MAXREPEAT <EOL> class error ( Exception ) : <EOL> pass <EOL> FAILURE = "<STR_LIT>" <EOL> SUCCESS = "<STR_LIT:success>" <EOL> ANY = "<STR_LIT>" <EOL> ANY_ALL = "<STR_LIT>" <EOL> ASSERT = "<STR_LIT>" <EOL> ASSERT_NOT = "<STR_LIT>" <EOL> AT = "<STR_LIT>" <EOL> BIGCHARSET = "<STR_LIT>" <EOL> BRANCH = "<STR_LIT>" <EOL> CALL = "<STR_LIT>" <EOL> CATEGORY = "<STR_LIT>" <EOL> CHARSET = "<STR_LIT>" <EOL> GROUPREF = "<STR_LIT>" <EOL> GROUPREF_IGNORE = "<STR_LIT>" <EOL> GROUPREF_EXISTS = "<STR_LIT>" <EOL> IN = "<STR_LIT>" <EOL> IN_IGNORE = "<STR_LIT>" <EOL> INFO = "<STR_LIT:info>" <EOL> JUMP = "<STR_LIT>" <EOL> LITERAL = "<STR_LIT>" <EOL> LITERAL_IGNORE = "<STR_LIT>" <EOL> MARK = "<STR_LIT>" <EOL> MAX_REPEAT = "<STR_LIT>" <EOL> MAX_UNTIL = "<STR_LIT>" <EOL> MIN_REPEAT = "<STR_LIT>" <EOL> MIN_UNTIL = "<STR_LIT>" <EOL> NEGATE = "<STR_LIT>" <EOL> NOT_LITERAL = "<STR_LIT>" <EOL> NOT_LITERAL_IGNORE = "<STR_LIT>" <EOL> RANGE = "<STR_LIT>" <EOL> REPEAT = "<STR_LIT>" <EOL> REPEAT_ONE = "<STR_LIT>" <EOL> SUBPATTERN = "<STR_LIT>" <EOL> MIN_REPEAT_ONE = "<STR_LIT>" <EOL> AT_BEGINNING = "<STR_LIT>" <EOL> AT_BEGINNING_LINE = "<STR_LIT>" <EOL> AT_BEGINNING_STRING = "<STR_LIT>" <EOL> AT_BOUNDARY = "<STR_LIT>" <EOL> AT_NON_BOUNDARY = "<STR_LIT>" <EOL> AT_END = "<STR_LIT>" <EOL> AT_END_LINE = "<STR_LIT>" <EOL> AT_END_STRING = "<STR_LIT>" <EOL> AT_LOC_BOUNDARY = "<STR_LIT>" <EOL> AT_LOC_NON_BOUNDARY = "<STR_LIT>" <EOL> AT_UNI_BOUNDARY = "<STR_LIT>" <EOL> AT_UNI_NON_BOUNDARY = "<STR_LIT>" <EOL> CATEGORY_DIGIT = "<STR_LIT>" <EOL> CATEGORY_NOT_DIGIT = "<STR_LIT>" <EOL> CATEGORY_SPACE = "<STR_LIT>" <EOL> CATEGORY_NOT_SPACE = "<STR_LIT>" <EOL> CATEGORY_WORD = "<STR_LIT>" <EOL> CATEGORY_NOT_WORD = "<STR_LIT>" <EOL> CATEGORY_LINEBREAK = "<STR_LIT>" <EOL> CATEGORY_NOT_LINEBREAK = "<STR_LIT>" <EOL> CATEGORY_LOC_WORD = "<STR_LIT>" <EOL> CATEGORY_LOC_NOT_WORD = "<STR_LIT>" <EOL> CATEGORY_UNI_DIGIT = "<STR_LIT>" <EOL> CATEGORY_UNI_NOT_DIGIT = "<STR_LIT>" <EOL> CATEGORY_UNI_SPACE = "<STR_LIT>" <EOL> CATEGORY_UNI_NOT_SPACE = "<STR_LIT>" <EOL> CATEGORY_UNI_WORD = "<STR_LIT>" <EOL> CATEGORY_UNI_NOT_WORD = "<STR_LIT>" <EOL> CATEGORY_UNI_LINEBREAK = "<STR_LIT>" <EOL> CATEGORY_UNI_NOT_LINEBREAK = "<STR_LIT>" <EOL> OPCODES = [ <EOL> FAILURE , SUCCESS , <EOL> ANY , ANY_ALL , <EOL> ASSERT , ASSERT_NOT , <EOL> AT , <EOL> BRANCH , <EOL> CALL , <EOL> CATEGORY , <EOL> CHARSET , BIGCHARSET , <EOL> GROUPREF , GROUPREF_EXISTS , GROUPREF_IGNORE , <EOL> IN , IN_IGNORE , <EOL> INFO , <EOL> JUMP , <EOL> LITERAL , LITERAL_IGNORE , <EOL> MARK , <EOL> MAX_UNTIL , <EOL> MIN_UNTIL , <EOL> NOT_LITERAL , NOT_LITERAL_IGNORE , <EOL> NEGATE , <EOL> RANGE , <EOL> REPEAT , <EOL> REPEAT_ONE , <EOL> SUBPATTERN , <EOL> MIN_REPEAT_ONE <EOL> ] <EOL> ATCODES = [ <EOL> AT_BEGINNING , AT_BEGINNING_LINE , AT_BEGINNING_STRING , AT_BOUNDARY , <EOL> AT_NON_BOUNDARY , AT_END , AT_END_LINE , AT_END_STRING , <EOL> AT_LOC_BOUNDARY , AT_LOC_NON_BOUNDARY , AT_UNI_BOUNDARY , <EOL> AT_UNI_NON_BOUNDARY <EOL> ] <EOL> CHCODES = [ <EOL> CATEGORY_DIGIT , CATEGORY_NOT_DIGIT , CATEGORY_SPACE , <EOL> CATEGORY_NOT_SPACE , CATEGORY_WORD , CATEGORY_NOT_WORD , <EOL> CATEGORY_LINEBREAK , CATEGORY_NOT_LINEBREAK , CATEGORY_LOC_WORD , <EOL> CATEGORY_LOC_NOT_WORD , CATEGORY_UNI_DIGIT , CATEGORY_UNI_NOT_DIGIT , <EOL> CATEGORY_UNI_SPACE , CATEGORY_UNI_NOT_SPACE , CATEGORY_UNI_WORD , <EOL> CATEGORY_UNI_NOT_WORD , CATEGORY_UNI_LINEBREAK , <EOL> CATEGORY_UNI_NOT_LINEBREAK <EOL> ] <EOL> def makedict ( list ) : <EOL> d = { } <EOL> i = <NUM_LIT:0> <EOL> for item in list : <EOL> d [ item ] = i <EOL> i = i + <NUM_LIT:1> <EOL> return d <EOL> OPCODES = makedict ( OPCODES ) <EOL> ATCODES = makedict ( ATCODES ) <EOL> CHCODES = makedict ( CHCODES ) <EOL> OP_IGNORE = { <EOL> GROUPREF : GROUPREF_IGNORE , <EOL> IN : IN_IGNORE , <EOL> LITERAL : LITERAL_IGNORE , <EOL> NOT_LITERAL : NOT_LITERAL_IGNORE <EOL> } <EOL> AT_MULTILINE = { <EOL> AT_BEGINNING : AT_BEGINNING_LINE , <EOL> AT_END : AT_END_LINE <EOL> } <EOL> AT_LOCALE = { <EOL> AT_BOUNDARY : AT_LOC_BOUNDARY , <EOL> AT_NON_BOUNDARY : AT_LOC_NON_BOUNDARY <EOL> } <EOL> AT_UNICODE = { <EOL> AT_BOUNDARY : AT_UNI_BOUNDARY , <EOL> AT_NON_BOUNDARY : AT_UNI_NON_BOUNDARY <EOL> } <EOL> CH_LOCALE = { <EOL> CATEGORY_DIGIT : CATEGORY_DIGIT , <EOL> CATEGORY_NOT_DIGIT : CATEGORY_NOT_DIGIT , <EOL> CATEGORY_SPACE : CATEGORY_SPACE , <EOL> CATEGORY_NOT_SPACE : CATEGORY_NOT_SPACE , <EOL> CATEGORY_WORD : CATEGORY_LOC_WORD , <EOL> CATEGORY_NOT_WORD : CATEGORY_LOC_NOT_WORD , <EOL> CATEGORY_LINEBREAK : CATEGORY_LINEBREAK , <EOL> CATEGORY_NOT_LINEBREAK : CATEGORY_NOT_LINEBREAK <EOL> } <EOL> CH_UNICODE = { <EOL> CATEGORY_DIGIT : CATEGORY_UNI_DIGIT , <EOL> CATEGORY_NOT_DIGIT : CATEGORY_UNI_NOT_DIGIT , <EOL> CATEGORY_SPACE : CATEGORY_UNI_SPACE , <EOL> CATEGORY_NOT_SPACE : CATEGORY_UNI_NOT_SPACE , <EOL> CATEGORY_WORD : CATEGORY_UNI_WORD , <EOL> CATEGORY_NOT_WORD : CATEGORY_UNI_NOT_WORD , <EOL> CATEGORY_LINEBREAK : CATEGORY_UNI_LINEBREAK , <EOL> CATEGORY_NOT_LINEBREAK : CATEGORY_UNI_NOT_LINEBREAK <EOL> } <EOL> SRE_FLAG_TEMPLATE = <NUM_LIT:1> <EOL> SRE_FLAG_IGNORECASE = <NUM_LIT:2> <EOL> SRE_FLAG_LOCALE = <NUM_LIT:4> <EOL> SRE_FLAG_MULTILINE = <NUM_LIT:8> <EOL> SRE_FLAG_DOTALL = <NUM_LIT:16> <EOL> SRE_FLAG_UNICODE = <NUM_LIT:32> <EOL> SRE_FLAG_VERBOSE = <NUM_LIT:64> <EOL> SRE_FLAG_DEBUG = <NUM_LIT> <EOL> SRE_INFO_PREFIX = <NUM_LIT:1> <EOL> SRE_INFO_LITERAL = <NUM_LIT:2> <EOL> SRE_INFO_CHARSET = <NUM_LIT:4> <EOL> if __name__ == "<STR_LIT:__main__>" : <EOL> def dump ( f , d , prefix ) : <EOL> items = d . items ( ) <EOL> items . sort ( key = lambda a : a [ <NUM_LIT:1> ] ) <EOL> for k , v in items : <EOL> f . write ( "<STR_LIT>" % ( prefix , k . upper ( ) , v ) ) <EOL> f = open ( "<STR_LIT>" , "<STR_LIT:w>" ) <EOL> f . write ( """<STR_LIT>""" ) <EOL> f . write ( "<STR_LIT>" % MAGIC ) <EOL> dump ( f , OPCODES , "<STR_LIT>" ) <EOL> dump ( f , ATCODES , "<STR_LIT>" ) <EOL> dump ( f , CHCODES , "<STR_LIT>" ) <EOL> f . write ( "<STR_LIT>" % SRE_FLAG_TEMPLATE ) <EOL> f . write ( "<STR_LIT>" % SRE_FLAG_IGNORECASE ) <EOL> f . write ( "<STR_LIT>" % SRE_FLAG_LOCALE ) <EOL> f . write ( "<STR_LIT>" % SRE_FLAG_MULTILINE ) <EOL> f . write ( "<STR_LIT>" % SRE_FLAG_DOTALL ) <EOL> f . write ( "<STR_LIT>" % SRE_FLAG_UNICODE ) <EOL> f . write ( "<STR_LIT>" % SRE_FLAG_VERBOSE ) <EOL> f . write ( "<STR_LIT>" % SRE_INFO_PREFIX ) <EOL> f . write ( "<STR_LIT>" % SRE_INFO_LITERAL ) <EOL> f . write ( "<STR_LIT>" % SRE_INFO_CHARSET ) <EOL> f . close ( ) <EOL> print "<STR_LIT>" </s>

"""<STR_LIT>""" <EOL> import sys <EOL> NoneType = type ( None ) <EOL> TypeType = type <EOL> ObjectType = object <EOL> IntType = int <EOL> LongType = long <EOL> FloatType = float <EOL> BooleanType = bool <EOL> try : <EOL> ComplexType = complex <EOL> except NameError : <EOL> pass <EOL> StringType = str <EOL> try : <EOL> UnicodeType = unicode <EOL> StringTypes = ( StringType , UnicodeType ) <EOL> except NameError : <EOL> StringTypes = ( StringType , ) <EOL> BufferType = buffer <EOL> TupleType = tuple <EOL> ListType = list <EOL> DictType = DictionaryType = dict <EOL> def _f ( ) : pass <EOL> FunctionType = type ( _f ) <EOL> LambdaType = type ( lambda : None ) <EOL> CodeType = type ( _f . func_code ) <EOL> def _g ( ) : <EOL> yield <NUM_LIT:1> <EOL> GeneratorType = type ( _g ( ) ) <EOL> class _C : <EOL> def _m ( self ) : pass <EOL> ClassType = type ( _C ) <EOL> UnboundMethodType = type ( _C . _m ) <EOL> _x = _C ( )

InstanceType = type ( _x )

"""<STR_LIT>""" <EOL> import sys <EOL> NoneType = type ( None ) <EOL> TypeType = type <EOL> ObjectType = object <EOL> IntType = int <EOL> LongType = long <EOL> FloatType = float <EOL> BooleanType = bool <EOL> try : <EOL> ComplexType = complex <EOL> except NameError : <EOL> pass <EOL> StringType = str <EOL> try : <EOL> UnicodeType = unicode <EOL> StringTypes = ( StringType , UnicodeType ) <EOL> except NameError : <EOL> StringTypes = ( StringType , ) <EOL> BufferType = buffer <EOL> TupleType = tuple <EOL> ListType = list <EOL> DictType = DictionaryType = dict <EOL> def _f ( ) : pass <EOL> FunctionType = type ( _f ) <EOL> LambdaType = type ( lambda : None ) <EOL> CodeType = type ( _f . func_code ) <EOL> def _g ( ) : <EOL> yield <NUM_LIT:1> <EOL> GeneratorType = type ( _g ( ) ) <EOL> class _C : <EOL> def _m ( self ) : pass <EOL> ClassType = type ( _C ) <EOL> UnboundMethodType = type ( _C . _m ) <EOL> _x = _C ( ) <EOL> InstanceType = type ( _x ) <EOL> MethodType = type ( _x . _m ) <EOL> BuiltinFunctionType = type ( len ) <EOL> BuiltinMethodType = type ( [ ] . append ) <EOL> ModuleType = type ( sys ) <EOL> FileType = file <EOL> XRangeType = xrange <EOL> try : <EOL> raise TypeError <EOL> except TypeError : <EOL> tb = sys . exc_info ( ) [ <NUM_LIT:2> ] <EOL> TracebackType = type ( tb ) <EOL> FrameType = type ( tb . tb_frame ) <EOL> del tb <EOL> SliceType = slice <EOL> EllipsisType = type ( Ellipsis ) <EOL> DictProxyType = type ( TypeType . __dict__ ) <EOL> NotImplementedType = type ( NotImplemented ) <EOL> GetSetDescriptorType = type ( FunctionType . func_code ) <EOL> MemberDescriptorType = type ( FunctionType . func_globals ) <EOL> del sys , _f , _g , _C , _x </s>

"""<STR_LIT>""" <EOL> import struct <EOL> try : <EOL> from cStringIO import StringIO as _StringIO <EOL> except ImportError : <EOL> from StringIO import StringIO as _StringIO <EOL> __all__ = [ "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ] <EOL> class Error ( Exception ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , msg ) : <EOL> self . msg = msg <EOL> def __repr__ ( self ) : <EOL> return repr ( self . msg ) <EOL> def __str__ ( self ) : <EOL> return str ( self . msg ) <EOL> class ConversionError ( Error ) : <EOL> pass <EOL> class Packer : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self ) : <EOL> self . reset ( ) <EOL> def reset ( self ) : <EOL> self . __buf = _StringIO ( ) <EOL> def get_buffer ( self ) : <EOL> return self . __buf . getvalue ( ) <EOL> get_buf = get_buffer <EOL> def pack_uint ( self , x ) : <EOL> self . __buf . write ( struct . pack ( '<STR_LIT>' , x ) ) <EOL> def pack_int ( self , x ) : <EOL> self . __buf . write ( struct . pack ( '<STR_LIT>' , x ) ) <EOL> pack_enum = pack_int <EOL> def pack_bool ( self , x ) : <EOL> if x : self . __buf . write ( '<STR_LIT>' ) <EOL> else : self . __buf . write ( '<STR_LIT>' ) <EOL> def pack_uhyper ( self , x ) : <EOL> self . pack_uint ( x >> <NUM_LIT:32> & <NUM_LIT> L ) <EOL> self . pack_uint ( x & <NUM_LIT> L ) <EOL> pack_hyper = pack_uhyper <EOL> def pack_float ( self , x ) : <EOL> try : self . __buf . write ( struct . pack ( '<STR_LIT>' , x ) ) <EOL> except struct . error , msg : <EOL> raise ConversionError , msg <EOL> def pack_double ( self , x ) : <EOL> try : self . __buf . write ( struct . pack ( '<STR_LIT>' , x ) ) <EOL> except struct . error , msg : <EOL> raise ConversionError , msg <EOL> def pack_fstring ( self , n , s ) : <EOL> if n < <NUM_LIT:0> : <EOL> raise ValueError , '<STR_LIT>' <EOL> data = s [ : n ] <EOL> n = ( ( n + <NUM_LIT:3> ) // <NUM_LIT:4> ) * <NUM_LIT:4> <EOL> data = data + ( n - len ( data ) ) * '<STR_LIT>' <EOL> self . __buf . write ( data ) <EOL> pack_fopaque = pack_fstring <EOL> def pack_string ( self , s ) : <EOL> n = len ( s ) <EOL> self . pack_uint ( n ) <EOL> self . pack_fstring ( n , s ) <EOL> pack_opaque = pack_string <EOL> pack_bytes = pack_string <EOL> def pack_list ( self , list , pack_item ) : <EOL> for item in list : <EOL> self . pack_uint ( <NUM_LIT:1> ) <EOL> pack_item ( item ) <EOL> self . pack_uint ( <NUM_LIT:0> ) <EOL> def pack_farray ( self , n , list , pack_item ) : <EOL> if len ( list ) != n : <EOL> raise ValueError , '<STR_LIT>' <EOL> for item in list : <EOL> pack_item ( item ) <EOL> def pack_array ( self , list , pack_item ) : <EOL> n = len ( list ) <EOL> self . pack_uint ( n ) <EOL> self . pack_farray ( n , list , pack_item ) <EOL> class Unpacker : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , data ) : <EOL> self . reset ( data ) <EOL> def reset ( self , data ) : <EOL> self . __buf = data <EOL> self . __pos = <NUM_LIT:0> <EOL> def get_position ( self ) : <EOL> return self . __pos <EOL> def set_position ( self , position ) : <EOL> self . __pos = position <EOL> def get_buffer ( self ) : <EOL> return self . __buf <EOL> def done ( self ) : <EOL> if self . __pos < len ( self . __buf ) : <EOL> raise Error ( '<STR_LIT>' ) <EOL> def unpack_uint ( self ) : <EOL> i = self . __pos <EOL> self . __pos = j = i + <NUM_LIT:4> <EOL> data = self . __buf [ i : j ] <EOL> if len ( data ) < <NUM_LIT:4> : <EOL> raise EOFError <EOL> x = struct . unpack ( '<STR_LIT>' , data ) [ <NUM_LIT:0> ] <EOL> try : <EOL> return int ( x ) <EOL> except OverflowError : <EOL> return x <EOL> def unpack_int ( self ) : <EOL> i = self . __pos <EOL> self . __pos = j = i + <NUM_LIT:4> <EOL> data = self . __buf [ i : j ]

if len ( data ) < <NUM_LIT:4> :

"""<STR_LIT>""" <EOL> import struct <EOL> try : <EOL> from cStringIO import StringIO as _StringIO <EOL> except ImportError : <EOL> from StringIO import StringIO as _StringIO <EOL> __all__ = [ "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ] <EOL> class Error ( Exception ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , msg ) : <EOL> self . msg = msg <EOL> def __repr__ ( self ) : <EOL> return repr ( self . msg ) <EOL> def __str__ ( self ) : <EOL> return str ( self . msg ) <EOL> class ConversionError ( Error ) : <EOL> pass <EOL> class Packer : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self ) : <EOL> self . reset ( ) <EOL> def reset ( self ) : <EOL> self . __buf = _StringIO ( ) <EOL> def get_buffer ( self ) : <EOL> return self . __buf . getvalue ( ) <EOL> get_buf = get_buffer <EOL> def pack_uint ( self , x ) : <EOL> self . __buf . write ( struct . pack ( '<STR_LIT>' , x ) ) <EOL> def pack_int ( self , x ) : <EOL> self . __buf . write ( struct . pack ( '<STR_LIT>' , x ) ) <EOL> pack_enum = pack_int <EOL> def pack_bool ( self , x ) : <EOL> if x : self . __buf . write ( '<STR_LIT>' ) <EOL> else : self . __buf . write ( '<STR_LIT>' ) <EOL> def pack_uhyper ( self , x ) : <EOL> self . pack_uint ( x >> <NUM_LIT:32> & <NUM_LIT> L ) <EOL> self . pack_uint ( x & <NUM_LIT> L ) <EOL> pack_hyper = pack_uhyper <EOL> def pack_float ( self , x ) : <EOL> try : self . __buf . write ( struct . pack ( '<STR_LIT>' , x ) ) <EOL> except struct . error , msg : <EOL> raise ConversionError , msg <EOL> def pack_double ( self , x ) : <EOL> try : self . __buf . write ( struct . pack ( '<STR_LIT>' , x ) ) <EOL> except struct . error , msg : <EOL> raise ConversionError , msg <EOL> def pack_fstring ( self , n , s ) : <EOL> if n < <NUM_LIT:0> : <EOL> raise ValueError , '<STR_LIT>' <EOL> data = s [ : n ] <EOL> n = ( ( n + <NUM_LIT:3> ) // <NUM_LIT:4> ) * <NUM_LIT:4> <EOL> data = data + ( n - len ( data ) ) * '<STR_LIT>' <EOL> self . __buf . write ( data ) <EOL> pack_fopaque = pack_fstring <EOL> def pack_string ( self , s ) : <EOL> n = len ( s ) <EOL> self . pack_uint ( n ) <EOL> self . pack_fstring ( n , s ) <EOL> pack_opaque = pack_string <EOL> pack_bytes = pack_string <EOL> def pack_list ( self , list , pack_item ) : <EOL> for item in list : <EOL> self . pack_uint ( <NUM_LIT:1> ) <EOL> pack_item ( item ) <EOL> self . pack_uint ( <NUM_LIT:0> ) <EOL> def pack_farray ( self , n , list , pack_item ) : <EOL> if len ( list ) != n : <EOL> raise ValueError , '<STR_LIT>' <EOL> for item in list : <EOL> pack_item ( item ) <EOL> def pack_array ( self , list , pack_item ) : <EOL> n = len ( list ) <EOL> self . pack_uint ( n ) <EOL> self . pack_farray ( n , list , pack_item ) <EOL> class Unpacker : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , data ) : <EOL> self . reset ( data ) <EOL> def reset ( self , data ) : <EOL> self . __buf = data <EOL> self . __pos = <NUM_LIT:0> <EOL> def get_position ( self ) : <EOL> return self . __pos <EOL> def set_position ( self , position ) : <EOL> self . __pos = position <EOL> def get_buffer ( self ) : <EOL> return self . __buf <EOL> def done ( self ) : <EOL> if self . __pos < len ( self . __buf ) : <EOL> raise Error ( '<STR_LIT>' ) <EOL> def unpack_uint ( self ) : <EOL> i = self . __pos <EOL> self . __pos = j = i + <NUM_LIT:4> <EOL> data = self . __buf [ i : j ] <EOL> if len ( data ) < <NUM_LIT:4> : <EOL> raise EOFError <EOL> x = struct . unpack ( '<STR_LIT>' , data ) [ <NUM_LIT:0> ] <EOL> try : <EOL> return int ( x ) <EOL> except OverflowError : <EOL> return x <EOL> def unpack_int ( self ) : <EOL> i = self . __pos <EOL> self . __pos = j = i + <NUM_LIT:4> <EOL> data = self . __buf [ i : j ] <EOL> if len ( data ) < <NUM_LIT:4> : <EOL> raise EOFError <EOL> return struct . unpack ( '<STR_LIT>' , data ) [ <NUM_LIT:0> ] <EOL> unpack_enum = unpack_int <EOL> def unpack_bool ( self ) : <EOL> return bool ( self . unpack_int ( ) ) <EOL> def unpack_uhyper ( self ) : <EOL> hi = self . unpack_uint ( ) <EOL> lo = self . unpack_uint ( ) <EOL> return long ( hi ) << <NUM_LIT:32> | lo <EOL> def unpack_hyper ( self ) : <EOL> x = self . unpack_uhyper ( ) <EOL> if x >= <NUM_LIT> L : <EOL> x = x - <NUM_LIT> L <EOL> return x <EOL> def unpack_float ( self ) : <EOL> i = self . __pos <EOL> self . __pos = j = i + <NUM_LIT:4> <EOL> data = self . __buf [ i : j ] <EOL> if len ( data ) < <NUM_LIT:4> : <EOL> raise EOFError <EOL> return struct . unpack ( '<STR_LIT>' , data ) [ <NUM_LIT:0> ] <EOL> def unpack_double ( self ) : <EOL> i = self . __pos <EOL> self . __pos = j = i + <NUM_LIT:8> <EOL> data = self . __buf [ i : j ] <EOL> if len ( data ) < <NUM_LIT:8> : <EOL> raise EOFError <EOL> return struct . unpack ( '<STR_LIT>' , data ) [ <NUM_LIT:0> ] <EOL> def unpack_fstring ( self , n ) : <EOL> if n < <NUM_LIT:0> : <EOL> raise ValueError , '<STR_LIT>' <EOL> i = self . __pos <EOL> j = i + ( n + <NUM_LIT:3> ) // <NUM_LIT:4> * <NUM_LIT:4> <EOL> if j > len ( self . __buf ) : <EOL> raise EOFError <EOL> self . __pos = j <EOL> return self . __buf [ i : i + n ] <EOL> unpack_fopaque = unpack_fstring <EOL> def unpack_string ( self ) : <EOL> n = self . unpack_uint ( ) <EOL> return self . unpack_fstring ( n ) <EOL> unpack_opaque = unpack_string <EOL> unpack_bytes = unpack_string <EOL> def unpack_list ( self , unpack_item ) : <EOL> list = [ ] <EOL> while <NUM_LIT:1> : <EOL> x = self . unpack_uint ( ) <EOL> if x == <NUM_LIT:0> : break <EOL> if x != <NUM_LIT:1> : <EOL> raise ConversionError , '<STR_LIT>' % ( x , ) <EOL> item = unpack_item ( ) <EOL> list . append ( item ) <EOL> return list <EOL> def unpack_farray ( self , n , unpack_item ) : <EOL> list = [ ] <EOL> for i in range ( n ) : <EOL> list . append ( unpack_item ( ) ) <EOL> return list <EOL> def unpack_array ( self , unpack_item ) : <EOL> n = self . unpack_uint ( ) <EOL> return self . unpack_farray ( n , unpack_item ) </s>

import zipfile , sys , os , glob <EOL> import xml . etree . ElementTree as ET <EOL> from clint . textui import progress

from collections import defaultdict

import zipfile , sys , os , glob <EOL> import xml . etree . ElementTree as ET <EOL> from clint . textui import progress <EOL> from collections import defaultdict <EOL> anim_map = defaultdict ( list ) <EOL> for zipfilename in progress . bar ( glob . glob ( "<STR_LIT>" ) ) : <EOL> try : <EOL> with zipfile . ZipFile ( zipfilename , "<STR_LIT:r>" ) as zf : <EOL> root = ET . fromstring ( zf . read ( "<STR_LIT>" ) ) <EOL> for anim in root . findall ( "<STR_LIT>" ) : <EOL> animname = anim . attrib [ '<STR_LIT:name>' ] <EOL> rootname = anim . attrib [ '<STR_LIT:root>' ] <EOL> key = ( animname , rootname ) <EOL> anim_map [ key ] . append ( zipfilename ) <EOL> except : <EOL> pass <EOL> invalid = False <EOL> for key , datalist in anim_map . iteritems ( ) : <EOL> if len ( datalist ) > <NUM_LIT:1> : <EOL> print key <EOL> print datalist <EOL> print <EOL> invalid = True <EOL> if invalid : <EOL> sys . exit ( <NUM_LIT:255> ) </s>

from flask import Blueprint <EOL> from flask_login import LoginManager , login_required , logout_user , login_user , current_user <EOL> from flask_principal import Principal , identity_changed , Identity , AnonymousIdentity , identity_loaded , UserNeed , RoleNeed <EOL> from . . ext import db <EOL> from . models import User <EOL> class UserManager ( Blueprint ) : <EOL> def __init__ ( self , * args , ** kwargs ) : <EOL> self . _login_manager = None <EOL> self . _principal = None <EOL> self . app = None <EOL> super ( UserManager , self ) . __init__ ( * args , ** kwargs ) <EOL> def register ( self , app , * args , ** kwargs ) : <EOL> "<STR_LIT>" <EOL> if not self . _login_manager or self . app != app : <EOL> self . _login_manager = LoginManager ( ) <EOL> self . _login_manager . user_callback = self . user_loader <EOL> self . _login_manager . init_app ( app ) <EOL> self . _login_manager . login_view = app . config . get ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _login_manager . login_message = u'<STR_LIT>' <EOL> self . app = app <EOL> if not self . _principal : <EOL> self . _principal = Principal ( app ) <EOL> identity_loaded . connect ( self . identity_loaded ) <EOL> super ( UserManager , self ) . register ( app , * args , ** kwargs ) <EOL> @ staticmethod <EOL> def user_loader ( pk ) : <EOL> return User . query . options ( db . joinedload ( User . roles ) ) . get ( pk ) <EOL> @ staticmethod <EOL> def login_required ( fn ) : <EOL> return login_required ( fn ) <EOL> def logout ( self ) :

identity_changed . send ( self . app , identity = AnonymousIdentity ( ) )

from flask import Blueprint <EOL> from flask_login import LoginManager , login_required , logout_user , login_user , current_user <EOL> from flask_principal import Principal , identity_changed , Identity , AnonymousIdentity , identity_loaded , UserNeed , RoleNeed <EOL> from . . ext import db <EOL> from . models import User <EOL> class UserManager ( Blueprint ) : <EOL> def __init__ ( self , * args , ** kwargs ) : <EOL> self . _login_manager = None <EOL> self . _principal = None <EOL> self . app = None <EOL> super ( UserManager , self ) . __init__ ( * args , ** kwargs ) <EOL> def register ( self , app , * args , ** kwargs ) : <EOL> "<STR_LIT>" <EOL> if not self . _login_manager or self . app != app : <EOL> self . _login_manager = LoginManager ( ) <EOL> self . _login_manager . user_callback = self . user_loader <EOL> self . _login_manager . init_app ( app ) <EOL> self . _login_manager . login_view = app . config . get ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _login_manager . login_message = u'<STR_LIT>' <EOL> self . app = app <EOL> if not self . _principal : <EOL> self . _principal = Principal ( app ) <EOL> identity_loaded . connect ( self . identity_loaded ) <EOL> super ( UserManager , self ) . register ( app , * args , ** kwargs ) <EOL> @ staticmethod <EOL> def user_loader ( pk ) : <EOL> return User . query . options ( db . joinedload ( User . roles ) ) . get ( pk ) <EOL> @ staticmethod <EOL> def login_required ( fn ) : <EOL> return login_required ( fn ) <EOL> def logout ( self ) : <EOL> identity_changed . send ( self . app , identity = AnonymousIdentity ( ) ) <EOL> return logout_user ( ) <EOL> def login ( self , user ) : <EOL> identity_changed . send ( self . app , identity = Identity ( user . id ) ) <EOL> return login_user ( user ) <EOL> @ staticmethod <EOL> def identity_loaded ( sender , identity ) : <EOL> identity . user = current_user <EOL> if current_user . is_authenticated ( ) : <EOL> identity . provides . add ( UserNeed ( current_user . id ) ) <EOL> for role in current_user . roles : <EOL> identity . provides . add ( RoleNeed ( role . name ) ) </s>

import os . path as op <EOL> from tornado import template <EOL> LOADER = template . Loader ( op . join ( op . dirname ( op . abspath ( __file__ ) ) , '<STR_LIT>' ) , autoescape = None ) <EOL> TEMPLATES = { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:html>' : LOADER . load ( '<STR_LIT>' ) , <EOL> '<STR_LIT:text>' : LOADER . load ( '<STR_LIT>' ) , <EOL> '<STR_LIT>' : LOADER . load ( '<STR_LIT>' ) , <EOL> '<STR_LIT>' : LOADER . load ( '<STR_LIT>' ) , <EOL> '<STR_LIT>' : LOADER . load ( '<STR_LIT>' ) <EOL> } , <EOL> '<STR_LIT:url>' : {

'<STR_LIT:html>' : LOADER . load ( '<STR_LIT>' ) ,

import os . path as op <EOL> from tornado import template <EOL> LOADER = template . Loader ( op . join ( op . dirname ( op . abspath ( __file__ ) ) , '<STR_LIT>' ) , autoescape = None ) <EOL> TEMPLATES = { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:html>' : LOADER . load ( '<STR_LIT>' ) , <EOL> '<STR_LIT:text>' : LOADER . load ( '<STR_LIT>' ) , <EOL> '<STR_LIT>' : LOADER . load ( '<STR_LIT>' ) , <EOL> '<STR_LIT>' : LOADER . load ( '<STR_LIT>' ) , <EOL> '<STR_LIT>' : LOADER . load ( '<STR_LIT>' ) <EOL> } , <EOL> '<STR_LIT:url>' : { <EOL> '<STR_LIT:html>' : LOADER . load ( '<STR_LIT>' ) , <EOL> '<STR_LIT:text>' : LOADER . load ( '<STR_LIT>' ) , <EOL> '<STR_LIT>' : LOADER . load ( '<STR_LIT>' ) , <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:html>' : LOADER . load ( '<STR_LIT>' ) , <EOL> '<STR_LIT:text>' : LOADER . load ( '<STR_LIT>' ) , <EOL> '<STR_LIT>' : LOADER . load ( '<STR_LIT>' ) , <EOL> } , <EOL> } </s>

"""<STR_LIT>""" <EOL> import datetime <EOL> import pytest <EOL> from decimal import Decimal <EOL> from mixer . main import Mixer , TypeMixer <EOL> class Test : <EOL> """<STR_LIT>""" <EOL> one = int <EOL> two = int <EOL> name = str <EOL> title = str <EOL> body = str <EOL> price = Decimal <EOL> choices = list <EOL> parts = set <EOL> scheme = dict <EOL> def test_factory ( ) : <EOL> """<STR_LIT>""" <EOL> from mixer . main import GenFactory <EOL> g = GenFactory ( ) <EOL> test = g . get_fabric ( int ) <EOL> assert - <NUM_LIT> <= test ( ) < <NUM_LIT> <EOL> test = g . get_fabric ( bool ) <EOL> assert test ( ) in ( True , False ) <EOL> def test_typemixer_meta ( ) : <EOL> """<STR_LIT>""" <EOL> mixer1 = TypeMixer ( Test ) <EOL> mixer2 = TypeMixer ( Test , fake = False ) <EOL> mixer3 = TypeMixer ( Test , fake = False ) <EOL> assert mixer1 is not mixer2 <EOL> assert mixer2 is mixer3 <EOL> def test_typemixer ( ) : <EOL> class Scheme : <EOL> id = int <EOL> name = str <EOL> money = int <EOL> male = bool <EOL> prop = Test <EOL> mixer = TypeMixer ( Scheme ) <EOL> test = mixer . blend ( prop__two = <NUM_LIT:2> , prop__one = <NUM_LIT:1> , prop__name = '<STR_LIT>' , name = '<STR_LIT>' ) <EOL> assert test . male in ( True , False ) <EOL> assert test . name == '<STR_LIT>' <EOL> assert test . prop . two == <NUM_LIT:2> <EOL> assert test . prop . name == '<STR_LIT>' <EOL> test = mixer . blend ( prop__two = <NUM_LIT:4> , unknown = lambda : '<STR_LIT:?>' ) <EOL> assert test . prop . two == <NUM_LIT:4>

assert test . unknown == '<STR_LIT:?>'

"""<STR_LIT>""" <EOL> import datetime <EOL> import pytest <EOL> from decimal import Decimal <EOL> from mixer . main import Mixer , TypeMixer <EOL> class Test : <EOL> """<STR_LIT>""" <EOL> one = int <EOL> two = int <EOL> name = str <EOL> title = str <EOL> body = str <EOL> price = Decimal <EOL> choices = list <EOL> parts = set <EOL> scheme = dict <EOL> def test_factory ( ) : <EOL> """<STR_LIT>""" <EOL> from mixer . main import GenFactory <EOL> g = GenFactory ( ) <EOL> test = g . get_fabric ( int ) <EOL> assert - <NUM_LIT> <= test ( ) < <NUM_LIT> <EOL> test = g . get_fabric ( bool ) <EOL> assert test ( ) in ( True , False ) <EOL> def test_typemixer_meta ( ) : <EOL> """<STR_LIT>""" <EOL> mixer1 = TypeMixer ( Test ) <EOL> mixer2 = TypeMixer ( Test , fake = False ) <EOL> mixer3 = TypeMixer ( Test , fake = False ) <EOL> assert mixer1 is not mixer2 <EOL> assert mixer2 is mixer3 <EOL> def test_typemixer ( ) : <EOL> class Scheme : <EOL> id = int <EOL> name = str <EOL> money = int <EOL> male = bool <EOL> prop = Test <EOL> mixer = TypeMixer ( Scheme ) <EOL> test = mixer . blend ( prop__two = <NUM_LIT:2> , prop__one = <NUM_LIT:1> , prop__name = '<STR_LIT>' , name = '<STR_LIT>' ) <EOL> assert test . male in ( True , False ) <EOL> assert test . name == '<STR_LIT>' <EOL> assert test . prop . two == <NUM_LIT:2> <EOL> assert test . prop . name == '<STR_LIT>' <EOL> test = mixer . blend ( prop__two = <NUM_LIT:4> , unknown = lambda : '<STR_LIT:?>' ) <EOL> assert test . prop . two == <NUM_LIT:4> <EOL> assert test . unknown == '<STR_LIT:?>' <EOL> def test_fake ( ) : <EOL> from mixer . main import mixer <EOL> test = mixer . blend ( Test , name = mixer . FAKE , title = mixer . FAKE ) <EOL> assert '<STR_LIT:U+0020>' in test . name <EOL> assert '<STR_LIT:U+0020>' in test . title <EOL> test = mixer . blend ( Test , name = mixer . FAKE ( bool ) ) <EOL> assert test . name in ( True , False ) <EOL> def test_random ( ) : <EOL> from mixer . _compat import string_types <EOL> mixer = TypeMixer ( Test ) <EOL> test = mixer . blend ( name = mixer . RANDOM ) <EOL> assert isinstance ( test . name , string_types ) <EOL> test = mixer . blend ( name = mixer . RANDOM ( int ) ) <EOL> assert isinstance ( test . name , int ) <EOL> names = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> test = mixer . blend ( name = mixer . RANDOM ( * names ) ) <EOL> assert test . name in names <EOL> def test_mix ( ) : <EOL> from mixer . main import mixer <EOL> lama = type ( '<STR_LIT>' , tuple ( ) , dict ( <EOL> two = int , <EOL> one = type ( '<STR_LIT>' , tuple ( ) , dict ( two = <NUM_LIT> ) ) <EOL> ) ) <EOL> mix = mixer . MIX . one . two <EOL> assert mix & lama == <NUM_LIT> <EOL> test = mixer . blend ( lama , one__two = <NUM_LIT> ) <EOL> assert test . one . two == <NUM_LIT> <EOL> assert test . two != test . one . two <EOL> test = mixer . blend ( lama , one__two = <NUM_LIT> , two = mixer . MIX . one . two ) <EOL> assert test . two == test . one . two <EOL> def test_mixer ( ) : <EOL> mixer = Mixer ( ) <EOL> assert Mixer . SKIP == mixer . SKIP <EOL> try : <EOL> Mixer . SKIP = <NUM_LIT> <EOL> raise AssertionError ( '<STR_LIT>' ) <EOL> except AttributeError : <EOL> pass <EOL> try : <EOL> mixer . SKIP = <NUM_LIT> <EOL> raise AssertionError ( '<STR_LIT>' ) <EOL> except AttributeError : <EOL> pass <EOL> gen = ( '<STR_LIT>' . format ( i ) for i in range ( <NUM_LIT> ) ) <EOL> test = mixer . blend ( '<STR_LIT>' , name = gen ) <EOL> assert test . name == '<STR_LIT>' <EOL> name_gen = mixer . sequence ( lambda c : '<STR_LIT:test>' + str ( c ) ) <EOL> test = mixer . blend ( Test , name = name_gen ) <EOL> test = mixer . blend ( Test , name = name_gen ) <EOL> test = mixer . blend ( Test , name = name_gen ) <EOL> assert test . name == '<STR_LIT>' <EOL> name_gen = mixer . sequence ( '<STR_LIT>' ) <EOL> test = mixer . blend ( Test , name = name_gen ) <EOL> test = mixer . blend ( Test , name = name_gen ) <EOL> assert test . name == '<STR_LIT>' <EOL> name_gen = mixer . sequence ( ) <EOL> test = mixer . blend ( Test , name = name_gen ) <EOL> test = mixer . blend ( Test , name = name_gen ) <EOL> assert test . name == <NUM_LIT:1> <EOL> mixer . register ( '<STR_LIT>' , <EOL> name = '<STR_LIT>' , one = lambda : '<STR_LIT>' , unknown = "<STR_LIT>" ) <EOL> test = mixer . blend ( Test ) <EOL> assert test . one == '<STR_LIT>' <EOL> assert test . name == '<STR_LIT>' <EOL> def test_mixer_cycle ( ) : <EOL> mixer = Mixer ( ) <EOL> test = mixer . cycle ( <NUM_LIT:3> ) . blend ( Test ) <EOL> assert len ( test ) == <NUM_LIT:3> <EOL> assert test [ <NUM_LIT:0> ] . __class__ == Test <EOL> test = mixer . cycle ( <NUM_LIT:3> ) . blend ( Test , name = mixer . sequence ( '<STR_LIT>' ) ) <EOL> assert test [ <NUM_LIT:2> ] . name == '<STR_LIT>' <EOL> def test_mixer_default ( ) : <EOL> from mixer . main import mixer <EOL> test = mixer . blend ( Test ) <EOL> assert test . name <EOL> def test_invalid_scheme ( ) : <EOL> from mixer . main import mixer <EOL> with pytest . raises ( ValueError ) : <EOL> mixer . blend ( '<STR_LIT>' ) <EOL> def test_sequence ( ) : <EOL> from mixer . main import mixer <EOL> gen = mixer . sequence ( ) <EOL> assert next ( gen ) == <NUM_LIT:0> <EOL> assert next ( gen ) == <NUM_LIT:1> <EOL> gen = mixer . sequence ( '<STR_LIT>' ) <EOL> assert next ( gen ) == '<STR_LIT>' <EOL> assert next ( gen ) == '<STR_LIT>' <EOL> gen = mixer . sequence ( lambda c : c + <NUM_LIT:2> ) <EOL> assert next ( gen ) == <NUM_LIT:2> <EOL> assert next ( gen ) == <NUM_LIT:3> <EOL> gen = mixer . sequence ( <NUM_LIT:4> , <NUM_LIT:3> ) <EOL> assert next ( gen ) == <NUM_LIT:4> <EOL> assert next ( gen ) == <NUM_LIT:3> <EOL> assert next ( gen ) == <NUM_LIT:4> <EOL> def test_custom ( ) : <EOL> mixer = Mixer ( ) <EOL> @ mixer . middleware ( Test ) <EOL> def postprocess ( x ) : <EOL> x . name += '<STR_LIT>' <EOL> return x <EOL> mixer . register ( <EOL> Test , <EOL> name = '<STR_LIT>' , <EOL> one = mixer . faker . pyfloat , <EOL> body = lambda : mixer . faker . datetime ( '<STR_LIT>' ) , <EOL> ) <EOL> test = mixer . blend ( Test ) <EOL> assert test . name == '<STR_LIT>' <EOL> assert isinstance ( test . one , float ) <EOL> assert test . body >= datetime . datetime ( <NUM_LIT> , <NUM_LIT:1> , <NUM_LIT:1> ) <EOL> from mixer . main import GenFactory <EOL> class MyFactory ( GenFactory ) : <EOL> generators = { str : lambda : "<STR_LIT>" } <EOL> mixer = Mixer ( factory = MyFactory , fake = False ) <EOL> test = mixer . blend ( Test ) <EOL> assert test . name == "<STR_LIT>" <EOL> def test_ctx ( ) : <EOL> from mixer . main import LOGGER <EOL> mixer = Mixer ( ) <EOL> level = LOGGER . level <EOL> with mixer . ctx ( loglevel = '<STR_LIT>' ) : <EOL> mixer . blend ( Test ) <EOL> assert LOGGER . level != level <EOL> with mixer . ctx ( locale = '<STR_LIT>' ) : <EOL> phone = mixer . faker . phone_number ( ) <EOL> assert phone . startswith ( '<STR_LIT>' ) <EOL> assert LOGGER . level == level <EOL> def test_locale ( ) : <EOL> mixer = Mixer ( ) <EOL> mixer . faker . locale = '<STR_LIT>' <EOL> with mixer . ctx ( locale = '<STR_LIT>' ) : <EOL> mixer . faker . name ( ) <EOL> assert mixer . faker . locale == '<STR_LIT>' <EOL> with mixer . ctx ( loglevel = '<STR_LIT>' ) : <EOL> mixer . faker . name ( ) <EOL> assert mixer . faker . locale == '<STR_LIT>' <EOL> def test_silence ( ) : <EOL> mixer = Mixer ( ) <EOL> @ mixer . middleware ( Test ) <EOL> def falsed ( test ) : <EOL> raise Exception ( '<STR_LIT>' ) <EOL> with pytest . raises ( Exception ) : <EOL> mixer . blend ( Test ) <EOL> with mixer . ctx ( silence = True ) : <EOL> mixer . blend ( Test ) <EOL> def test_guard ( ) : <EOL> mixer = Mixer ( ) <EOL> test = mixer . guard ( ) . blend ( Test ) <EOL> assert test <EOL> def test_skip ( ) : <EOL> mixer = Mixer ( ) <EOL> test = mixer . blend ( Test , one = mixer . SKIP ) <EOL> assert test . one is not mixer . SKIP <EOL> assert test . one is int <EOL> def test_reload ( ) : <EOL> mixer = Mixer ( ) <EOL> test = mixer . blend ( Test ) <EOL> test2 = mixer . reload ( test ) <EOL> assert test is not test2 <EOL> assert test . name == test2 . name <EOL> test3 , test4 = mixer . reload ( test , test2 ) <EOL> assert test3 and test4 </s>

from dojango . util . config import Config <EOL> def config ( request ) : <EOL> '''<STR_LIT>''' <EOL> context_extras = { '<STR_LIT>' : { } } <EOL> config = Config ( ) <EOL> context_extras [ '<STR_LIT>' ] = config . get_context_dict ( )

return context_extras </s>

from dojango . util . config import Config <EOL> def config ( request ) : <EOL> '''<STR_LIT>''' <EOL> context_extras = { '<STR_LIT>' : { } } <EOL> config = Config ( ) <EOL> context_extras [ '<STR_LIT>' ] = config . get_context_dict ( ) <EOL> return context_extras </s>

from dojango . util import is_number <EOL> def get_combobox_data ( request ) : <EOL> """<STR_LIT>""" <EOL> if not request . method == '<STR_LIT:POST>' : <EOL> raise Exception ( '<STR_LIT>' ) <EOL> string = request . POST . get ( '<STR_LIT:name>' , '<STR_LIT>' ) <EOL> if string . endswith ( '<STR_LIT:*>' ) : <EOL> string = string [ : - <NUM_LIT:1> ] <EOL> start = int ( request . POST . get ( '<STR_LIT:start>' , <NUM_LIT:0> ) ) <EOL> end = request . POST . get ( '<STR_LIT:count>' , <NUM_LIT:10> ) <EOL> if not is_number ( end ) : <EOL> end = <NUM_LIT:10> <EOL> end = start + int ( end )

return string , start , end </s>

from dojango . util import is_number <EOL> def get_combobox_data ( request ) : <EOL> """<STR_LIT>""" <EOL> if not request . method == '<STR_LIT:POST>' : <EOL> raise Exception ( '<STR_LIT>' ) <EOL> string = request . POST . get ( '<STR_LIT:name>' , '<STR_LIT>' ) <EOL> if string . endswith ( '<STR_LIT:*>' ) : <EOL> string = string [ : - <NUM_LIT:1> ] <EOL> start = int ( request . POST . get ( '<STR_LIT:start>' , <NUM_LIT:0> ) ) <EOL> end = request . POST . get ( '<STR_LIT:count>' , <NUM_LIT:10> ) <EOL> if not is_number ( end ) : <EOL> end = <NUM_LIT:10> <EOL> end = start + int ( end ) <EOL> return string , start , end </s>

import brukva <EOL> import tornado . httpserver <EOL> import tornado . web <EOL> import tornado . websocket <EOL> import tornado . ioloop <EOL> from brukva import adisp <EOL> import logging <EOL> from functools import partial <EOL> logging . basicConfig ( level = logging . DEBUG ) <EOL> log = logging . getLogger ( '<STR_LIT>' ) <EOL> c = brukva . Client ( ) <EOL> c . connect ( )

def on_set ( result ) :

import brukva <EOL> import tornado . httpserver <EOL> import tornado . web <EOL> import tornado . websocket <EOL> import tornado . ioloop <EOL> from brukva import adisp <EOL> import logging <EOL> from functools import partial <EOL> logging . basicConfig ( level = logging . DEBUG ) <EOL> log = logging . getLogger ( '<STR_LIT>' ) <EOL> c = brukva . Client ( ) <EOL> c . connect ( ) <EOL> def on_set ( result ) : <EOL> ( error , data ) = result <EOL> log . debug ( "<STR_LIT>" % ( error or data , ) ) <EOL> async = partial ( adisp . async , cbname = '<STR_LIT>' ) <EOL> c . set ( '<STR_LIT:foo>' , '<STR_LIT>' , on_set ) <EOL> c . set ( '<STR_LIT:bar>' , '<STR_LIT>' , on_set ) <EOL> c . set ( '<STR_LIT>' , '<STR_LIT>' , on_set ) <EOL> class MainHandler ( tornado . web . RequestHandler ) : <EOL> @ tornado . web . asynchronous <EOL> @ adisp . process <EOL> def get ( self ) : <EOL> ( _ , foo ) = yield async ( c . get ) ( '<STR_LIT:foo>' ) <EOL> ( _ , bar ) = yield async ( c . get ) ( '<STR_LIT:bar>' ) <EOL> ( _ , zar ) = yield async ( c . get ) ( '<STR_LIT>' ) <EOL> self . set_header ( '<STR_LIT:Content-Type>' , '<STR_LIT>' ) <EOL> self . render ( "<STR_LIT>" , title = "<STR_LIT>" , foo = foo , bar = bar , zar = zar ) <EOL> application = tornado . web . Application ( [ <EOL> ( r'<STR_LIT:/>' , MainHandler ) , <EOL> ] ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> http_server = tornado . httpserver . HTTPServer ( application ) <EOL> http_server . listen ( <NUM_LIT> ) <EOL> tornado . ioloop . IOLoop . instance ( ) . start ( ) </s>

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

"""<STR_LIT>""" <EOL> import time <EOL> test_timestamp = time . strftime ( '<STR_LIT>' ) <EOL> TOP = """<STR_LIT>""" <EOL> CONTENT_HEADER = """<STR_LIT>""" <EOL> CONTENT_HEADER += "<STR_LIT>" % vars ( ) <EOL> CONTENT_HEADER += "<STR_LIT>" <EOL> CONTENT_BODY = """<STR_LIT>""" <EOL> EXCEPTION_LINE = "<STR_LIT>" <EOL> BOTTOM = """<STR_LIT>""" </s>

from __future__ import absolute_import , print_function , division <EOL> import codecs <EOL> from collections import namedtuple <EOL> import re <EOL> import xml . sax . saxutils <EOL> from . compat import ElementTree <EOL> Bounds = namedtuple ( '<STR_LIT>' , '<STR_LIT>' )

def iterparse ( source , tag , clear = False , events = None ) :

from __future__ import absolute_import , print_function , division <EOL> import codecs <EOL> from collections import namedtuple <EOL> import re <EOL> import xml . sax . saxutils <EOL> from . compat import ElementTree <EOL> Bounds = namedtuple ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> def iterparse ( source , tag , clear = False , events = None ) : <EOL> """<STR_LIT>""" <EOL> for event , elem in ElementTree . iterparse ( source , events = events ) : <EOL> if elem . tag == tag : <EOL> yield elem <EOL> if clear : <EOL> elem . clear ( ) <EOL> def unescape_attribute ( text ) : <EOL> return xml . sax . saxutils . unescape ( text , { '<STR_LIT>' : '<STR_LIT:">' } ) <EOL> def bounds ( filename , start_re , end_re , encoding = '<STR_LIT:utf8>' ) : <EOL> """<STR_LIT>""" <EOL> start_re , end_re = re . compile ( start_re ) , re . compile ( end_re ) <EOL> mo , line_start , line_end , byte_start , byte_end = [ None ] * <NUM_LIT:5> <EOL> offset = <NUM_LIT:0> <EOL> with open ( filename , '<STR_LIT:rb>' ) as f : <EOL> for index , line in enumerate ( f ) : <EOL> line_text = line . decode ( encoding ) <EOL> start_match = re . match ( start_re , line_text ) <EOL> if start_match : <EOL> mo , line_start , byte_start = start_match , index , offset <EOL> offset += len ( line ) <EOL> end_match = re . match ( end_re , line_text ) <EOL> if end_match : <EOL> yield mo , Bounds ( line_start , index , byte_start , offset ) <EOL> mo , line_start , line_end , byte_start , byte_end = [ None ] * <NUM_LIT:5> <EOL> def load_chunk ( filename , bounds , encoding = '<STR_LIT:utf8>' , slow = False ) : <EOL> """<STR_LIT>""" <EOL> if slow : <EOL> return _load_chunk_slow ( filename , bounds , encoding ) <EOL> with open ( filename , '<STR_LIT:rb>' ) as f : <EOL> f . seek ( bounds . byte_start ) <EOL> size = bounds . byte_end - bounds . byte_start <EOL> return f . read ( size ) . decode ( encoding ) <EOL> def _load_chunk_slow ( filename , bounds , encoding = '<STR_LIT:utf8>' ) : <EOL> lines = [ ] <EOL> with codecs . open ( filename , '<STR_LIT:rb>' , encoding ) as f : <EOL> for index , line in enumerate ( f ) : <EOL> if index >= bounds . line_start : <EOL> lines . append ( line ) <EOL> if index >= bounds . line_end : <EOL> break <EOL> return '<STR_LIT>' . join ( lines ) <EOL> def ET_to_lxml ( element ) : <EOL> import lxml . etree <EOL> return lxml . etree . fromstring ( ElementTree . tostring ( element ) ) </s>

try : <EOL> import cPickle as pickle <EOL> except ImportError : <EOL> import pickle <EOL> from tornado . httpclient import AsyncHTTPClient <EOL> from tornado . curl_httpclient import CurlAsyncHTTPClient <EOL> class HttpWorker ( object ) : <EOL> """<STR_LIT>""" <EOL> HTTPClient = AsyncHTTPClient <EOL> def __init__ ( self , server = '<STR_LIT>' , path = '<STR_LIT:/>' ) : <EOL> self . url = server + path <EOL> def proceed ( self , postponed , callback = None ) : <EOL> def on_response ( response ) : <EOL> if callback : <EOL> result = pickle . loads ( response . body ) <EOL> callback ( result ) <EOL> http = self . HTTPClient ( ) <EOL> http . fetch ( self . url , on_response , method = '<STR_LIT:POST>' , body = postponed . _pickled ) <EOL> class CurlHttpWorker ( HttpWorker ) : <EOL> """<STR_LIT>"""

HTTPClient = CurlAsyncHTTPClient </s>

try : <EOL> import cPickle as pickle <EOL> except ImportError : <EOL> import pickle <EOL> from tornado . httpclient import AsyncHTTPClient <EOL> from tornado . curl_httpclient import CurlAsyncHTTPClient <EOL> class HttpWorker ( object ) : <EOL> """<STR_LIT>""" <EOL> HTTPClient = AsyncHTTPClient <EOL> def __init__ ( self , server = '<STR_LIT>' , path = '<STR_LIT:/>' ) : <EOL> self . url = server + path <EOL> def proceed ( self , postponed , callback = None ) : <EOL> def on_response ( response ) : <EOL> if callback : <EOL> result = pickle . loads ( response . body ) <EOL> callback ( result ) <EOL> http = self . HTTPClient ( ) <EOL> http . fetch ( self . url , on_response , method = '<STR_LIT:POST>' , body = postponed . _pickled ) <EOL> class CurlHttpWorker ( HttpWorker ) : <EOL> """<STR_LIT>""" <EOL> HTTPClient = CurlAsyncHTTPClient </s>

"""<STR_LIT>""" <EOL> import re , os , random <EOL> from decimal import Decimal <EOL> from datetime import date , datetime , time <EOL> from string import ascii_letters , digits <EOL> from random import choice <EOL> from django . core . exceptions import ValidationError <EOL> from django . core import validators <EOL> from django . db import models , IntegrityError <EOL> from django . db . models import Q <EOL> from django . db . models . fields . files import FieldFile <EOL> from django . contrib . webdesign . lorem_ipsum import paragraphs <EOL> from django_any import xunit <EOL> from django_any . functions import valid_choices , split_model_kwargs , ExtensionMethod <EOL> any_field = ExtensionMethod ( ) <EOL> any_model = ExtensionMethod ( by_instance = True ) <EOL> @ any_field . decorator <EOL> def any_field_blank ( function ) : <EOL> """<STR_LIT>""" <EOL> def wrapper ( field , ** kwargs ) : <EOL> if kwargs . get ( '<STR_LIT>' , False ) : <EOL> return None <EOL> if field . blank and random . random < <NUM_LIT:0.1> : <EOL> return None <EOL> return function ( field , ** kwargs ) <EOL> return wrapper <EOL> @ any_field . decorator <EOL> def any_field_choices ( function ) : <EOL> """<STR_LIT>""" <EOL> def wrapper ( field , ** kwargs ) : <EOL> if field . choices : <EOL> return random . choice ( list ( valid_choices ( field . choices ) ) ) <EOL> return function ( field , ** kwargs ) <EOL> return wrapper <EOL> @ any_field . register ( models . BigIntegerField ) <EOL> def any_biginteger_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> min_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT:1> ) <EOL> max_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT:10> ** <NUM_LIT:10> ) <EOL> return long ( xunit . any_int ( min_value = min_value , max_value = max_value ) ) <EOL> @ any_field . register ( models . BooleanField ) <EOL> def any_boolean_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return xunit . any_boolean ( ) <EOL> @ any_field . register ( models . PositiveIntegerField ) <EOL> def any_positiveinteger_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> min_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT:1> ) <EOL> max_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT> ) <EOL> return xunit . any_int ( min_value = min_value , max_value = max_value ) <EOL> @ any_field . register ( models . CharField ) <EOL> def any_char_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> min_length = kwargs . get ( '<STR_LIT>' , <NUM_LIT:1> ) <EOL> max_length = kwargs . get ( '<STR_LIT:max_length>' , field . max_length ) <EOL> return xunit . any_string ( min_length = min_length , max_length = max_length ) <EOL> @ any_field . register ( models . CommaSeparatedIntegerField ) <EOL> def any_commaseparatedinteger_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> nums_count = field . max_length / <NUM_LIT:2> <EOL> nums = [ str ( xunit . any_int ( min_value = <NUM_LIT:0> , max_value = <NUM_LIT:9> ) ) for _ in xrange ( <NUM_LIT:0> , nums_count ) ] <EOL> return "<STR_LIT:U+002C>" . join ( nums ) <EOL> @ any_field . register ( models . DateField ) <EOL> def any_date_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> if field . auto_now or field . auto_now_add : <EOL> return None <EOL> from_date = kwargs . get ( '<STR_LIT>' , date ( <NUM_LIT> , <NUM_LIT:1> , <NUM_LIT:1> ) ) <EOL> to_date = kwargs . get ( '<STR_LIT>' , date . today ( ) ) <EOL> return xunit . any_date ( from_date = from_date , to_date = to_date ) <EOL> @ any_field . register ( models . DateTimeField ) <EOL> def any_datetime_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> from_date = kwargs . get ( '<STR_LIT>' , datetime ( <NUM_LIT> , <NUM_LIT:1> , <NUM_LIT:1> ) ) <EOL> to_date = kwargs . get ( '<STR_LIT>' , datetime . today ( ) ) <EOL> return xunit . any_datetime ( from_date = from_date , to_date = to_date ) <EOL> @ any_field . register ( models . DecimalField ) <EOL> def any_decimal_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> min_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT:0> ) <EOL> max_value = kwargs . get ( '<STR_LIT>' , <EOL> Decimal ( '<STR_LIT>' % ( '<STR_LIT>' * ( field . max_digits - field . decimal_places ) , <EOL> '<STR_LIT>' * field . decimal_places ) ) ) <EOL> decimal_places = kwargs . get ( '<STR_LIT>' , field . decimal_places ) <EOL> return xunit . any_decimal ( min_value = min_value , max_value = max_value , <EOL> decimal_places = decimal_places ) <EOL> @ any_field . register ( models . EmailField ) <EOL> def any_email_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return "<STR_LIT>" % ( xunit . any_string ( max_length = <NUM_LIT:10> ) , <EOL> xunit . any_string ( max_length = <NUM_LIT:10> ) , <EOL> xunit . any_string ( min_length = <NUM_LIT:2> , max_length = <NUM_LIT:3> ) ) <EOL> @ any_field . register ( models . FloatField ) <EOL> def any_float_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> min_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT:1> ) <EOL> max_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT:100> ) <EOL> precision = kwargs . get ( '<STR_LIT>' , <NUM_LIT:3> ) <EOL> return xunit . any_float ( min_value = min_value , max_value = max_value , precision = precision ) <EOL> @ any_field . register ( models . FileField ) <EOL> def any_file_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> def get_some_file ( path ) : <EOL> subdirs , files = field . storage . listdir ( path ) <EOL> if files : <EOL> result_file = random . choice ( files ) <EOL> instance = field . storage . open ( "<STR_LIT>" % ( path , result_file ) ) . file <EOL> return FieldFile ( instance , field , result_file ) <EOL> for subdir in subdirs : <EOL> result = get_some_file ( "<STR_LIT>" % ( path , subdir ) ) <EOL> if result : <EOL> return result <EOL> result = get_some_file ( field . upload_to ) <EOL> if result is None and not field . null : <EOL> raise TypeError ( "<STR_LIT>" % field . upload_to ) <EOL> return result <EOL> @ any_field . register ( models . FilePathField ) <EOL> def any_filepath_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> def get_some_file ( path ) : <EOL> subdirs , files = [ ] , [ ] <EOL> for entry in os . listdir ( path ) : <EOL> entry_path = os . path . join ( path , entry ) <EOL> if os . path . isdir ( entry_path ) : <EOL> subdirs . append ( entry_path ) <EOL> else : <EOL> if not field . match or re . match ( field . match , entry ) : <EOL> files . append ( entry_path ) <EOL> if files : <EOL> return random . choice ( files ) <EOL> if field . recursive : <EOL> for subdir in subdirs : <EOL> result = get_some_file ( subdir ) <EOL> if result : <EOL> return result <EOL> result = get_some_file ( field . path ) <EOL> if result is None and not field . null : <EOL> raise TypeError ( "<STR_LIT>" % field . path ) <EOL> return result <EOL> @ any_field . register ( models . IPAddressField ) <EOL> def any_ipaddress_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> nums = [ str ( xunit . any_int ( min_value = <NUM_LIT:0> , max_value = <NUM_LIT:255> ) ) for _ in xrange ( <NUM_LIT:0> , <NUM_LIT:4> ) ] <EOL> return "<STR_LIT:.>" . join ( nums ) <EOL> @ any_field . register ( models . NullBooleanField ) <EOL> def any_nullboolean_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return random . choice ( [ None , True , False ] ) <EOL> @ any_field . register ( models . PositiveSmallIntegerField ) <EOL> def any_positivesmallinteger_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> min_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT:1> ) <EOL> max_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT:255> ) <EOL> return xunit . any_int ( min_value = min_value , max_value = max_value ) <EOL> @ any_field . register ( models . SlugField ) <EOL> def any_slug_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> letters = ascii_letters + digits + '<STR_LIT>' <EOL> return xunit . any_string ( letters = letters , max_length = field . max_length ) <EOL> @ any_field . register ( models . SmallIntegerField ) <EOL> def any_smallinteger_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> min_value = kwargs . get ( '<STR_LIT>' , - <NUM_LIT:255> ) <EOL> max_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT:255> ) <EOL> return xunit . any_int ( min_value = min_value , max_value = max_value ) <EOL> @ any_field . register ( models . IntegerField ) <EOL> def any_integer_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> min_value = kwargs . get ( '<STR_LIT>' , - <NUM_LIT> ) <EOL> max_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT> )

return xunit . any_int ( min_value = min_value , max_value = max_value )

"""<STR_LIT>""" <EOL> import re , os , random <EOL> from decimal import Decimal <EOL> from datetime import date , datetime , time <EOL> from string import ascii_letters , digits <EOL> from random import choice <EOL> from django . core . exceptions import ValidationError <EOL> from django . core import validators <EOL> from django . db import models , IntegrityError <EOL> from django . db . models import Q <EOL> from django . db . models . fields . files import FieldFile <EOL> from django . contrib . webdesign . lorem_ipsum import paragraphs <EOL> from django_any import xunit <EOL> from django_any . functions import valid_choices , split_model_kwargs , ExtensionMethod <EOL> any_field = ExtensionMethod ( ) <EOL> any_model = ExtensionMethod ( by_instance = True ) <EOL> @ any_field . decorator <EOL> def any_field_blank ( function ) : <EOL> """<STR_LIT>""" <EOL> def wrapper ( field , ** kwargs ) : <EOL> if kwargs . get ( '<STR_LIT>' , False ) : <EOL> return None <EOL> if field . blank and random . random < <NUM_LIT:0.1> : <EOL> return None <EOL> return function ( field , ** kwargs ) <EOL> return wrapper <EOL> @ any_field . decorator <EOL> def any_field_choices ( function ) : <EOL> """<STR_LIT>""" <EOL> def wrapper ( field , ** kwargs ) : <EOL> if field . choices : <EOL> return random . choice ( list ( valid_choices ( field . choices ) ) ) <EOL> return function ( field , ** kwargs ) <EOL> return wrapper <EOL> @ any_field . register ( models . BigIntegerField ) <EOL> def any_biginteger_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> min_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT:1> ) <EOL> max_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT:10> ** <NUM_LIT:10> ) <EOL> return long ( xunit . any_int ( min_value = min_value , max_value = max_value ) ) <EOL> @ any_field . register ( models . BooleanField ) <EOL> def any_boolean_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return xunit . any_boolean ( ) <EOL> @ any_field . register ( models . PositiveIntegerField ) <EOL> def any_positiveinteger_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> min_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT:1> ) <EOL> max_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT> ) <EOL> return xunit . any_int ( min_value = min_value , max_value = max_value ) <EOL> @ any_field . register ( models . CharField ) <EOL> def any_char_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> min_length = kwargs . get ( '<STR_LIT>' , <NUM_LIT:1> ) <EOL> max_length = kwargs . get ( '<STR_LIT:max_length>' , field . max_length ) <EOL> return xunit . any_string ( min_length = min_length , max_length = max_length ) <EOL> @ any_field . register ( models . CommaSeparatedIntegerField ) <EOL> def any_commaseparatedinteger_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> nums_count = field . max_length / <NUM_LIT:2> <EOL> nums = [ str ( xunit . any_int ( min_value = <NUM_LIT:0> , max_value = <NUM_LIT:9> ) ) for _ in xrange ( <NUM_LIT:0> , nums_count ) ] <EOL> return "<STR_LIT:U+002C>" . join ( nums ) <EOL> @ any_field . register ( models . DateField ) <EOL> def any_date_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> if field . auto_now or field . auto_now_add : <EOL> return None <EOL> from_date = kwargs . get ( '<STR_LIT>' , date ( <NUM_LIT> , <NUM_LIT:1> , <NUM_LIT:1> ) ) <EOL> to_date = kwargs . get ( '<STR_LIT>' , date . today ( ) ) <EOL> return xunit . any_date ( from_date = from_date , to_date = to_date ) <EOL> @ any_field . register ( models . DateTimeField ) <EOL> def any_datetime_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> from_date = kwargs . get ( '<STR_LIT>' , datetime ( <NUM_LIT> , <NUM_LIT:1> , <NUM_LIT:1> ) ) <EOL> to_date = kwargs . get ( '<STR_LIT>' , datetime . today ( ) ) <EOL> return xunit . any_datetime ( from_date = from_date , to_date = to_date ) <EOL> @ any_field . register ( models . DecimalField ) <EOL> def any_decimal_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> min_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT:0> ) <EOL> max_value = kwargs . get ( '<STR_LIT>' , <EOL> Decimal ( '<STR_LIT>' % ( '<STR_LIT>' * ( field . max_digits - field . decimal_places ) , <EOL> '<STR_LIT>' * field . decimal_places ) ) ) <EOL> decimal_places = kwargs . get ( '<STR_LIT>' , field . decimal_places ) <EOL> return xunit . any_decimal ( min_value = min_value , max_value = max_value , <EOL> decimal_places = decimal_places ) <EOL> @ any_field . register ( models . EmailField ) <EOL> def any_email_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return "<STR_LIT>" % ( xunit . any_string ( max_length = <NUM_LIT:10> ) , <EOL> xunit . any_string ( max_length = <NUM_LIT:10> ) , <EOL> xunit . any_string ( min_length = <NUM_LIT:2> , max_length = <NUM_LIT:3> ) ) <EOL> @ any_field . register ( models . FloatField ) <EOL> def any_float_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> min_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT:1> ) <EOL> max_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT:100> ) <EOL> precision = kwargs . get ( '<STR_LIT>' , <NUM_LIT:3> ) <EOL> return xunit . any_float ( min_value = min_value , max_value = max_value , precision = precision ) <EOL> @ any_field . register ( models . FileField ) <EOL> def any_file_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> def get_some_file ( path ) : <EOL> subdirs , files = field . storage . listdir ( path ) <EOL> if files : <EOL> result_file = random . choice ( files ) <EOL> instance = field . storage . open ( "<STR_LIT>" % ( path , result_file ) ) . file <EOL> return FieldFile ( instance , field , result_file ) <EOL> for subdir in subdirs : <EOL> result = get_some_file ( "<STR_LIT>" % ( path , subdir ) ) <EOL> if result : <EOL> return result <EOL> result = get_some_file ( field . upload_to ) <EOL> if result is None and not field . null : <EOL> raise TypeError ( "<STR_LIT>" % field . upload_to ) <EOL> return result <EOL> @ any_field . register ( models . FilePathField ) <EOL> def any_filepath_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> def get_some_file ( path ) : <EOL> subdirs , files = [ ] , [ ] <EOL> for entry in os . listdir ( path ) : <EOL> entry_path = os . path . join ( path , entry ) <EOL> if os . path . isdir ( entry_path ) : <EOL> subdirs . append ( entry_path ) <EOL> else : <EOL> if not field . match or re . match ( field . match , entry ) : <EOL> files . append ( entry_path ) <EOL> if files : <EOL> return random . choice ( files ) <EOL> if field . recursive : <EOL> for subdir in subdirs : <EOL> result = get_some_file ( subdir ) <EOL> if result : <EOL> return result <EOL> result = get_some_file ( field . path ) <EOL> if result is None and not field . null : <EOL> raise TypeError ( "<STR_LIT>" % field . path ) <EOL> return result <EOL> @ any_field . register ( models . IPAddressField ) <EOL> def any_ipaddress_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> nums = [ str ( xunit . any_int ( min_value = <NUM_LIT:0> , max_value = <NUM_LIT:255> ) ) for _ in xrange ( <NUM_LIT:0> , <NUM_LIT:4> ) ] <EOL> return "<STR_LIT:.>" . join ( nums ) <EOL> @ any_field . register ( models . NullBooleanField ) <EOL> def any_nullboolean_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return random . choice ( [ None , True , False ] ) <EOL> @ any_field . register ( models . PositiveSmallIntegerField ) <EOL> def any_positivesmallinteger_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> min_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT:1> ) <EOL> max_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT:255> ) <EOL> return xunit . any_int ( min_value = min_value , max_value = max_value ) <EOL> @ any_field . register ( models . SlugField ) <EOL> def any_slug_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> letters = ascii_letters + digits + '<STR_LIT>' <EOL> return xunit . any_string ( letters = letters , max_length = field . max_length ) <EOL> @ any_field . register ( models . SmallIntegerField ) <EOL> def any_smallinteger_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> min_value = kwargs . get ( '<STR_LIT>' , - <NUM_LIT:255> ) <EOL> max_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT:255> ) <EOL> return xunit . any_int ( min_value = min_value , max_value = max_value ) <EOL> @ any_field . register ( models . IntegerField ) <EOL> def any_integer_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> min_value = kwargs . get ( '<STR_LIT>' , - <NUM_LIT> ) <EOL> max_value = kwargs . get ( '<STR_LIT>' , <NUM_LIT> ) <EOL> return xunit . any_int ( min_value = min_value , max_value = max_value ) <EOL> @ any_field . register ( models . TextField ) <EOL> def any_text_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return paragraphs ( <NUM_LIT:10> ) <EOL> @ any_field . register ( models . URLField ) <EOL> def any_url_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> url = kwargs . get ( '<STR_LIT:url>' ) <EOL> if not url : <EOL> verified = [ validator for validator in field . validators if isinstance ( validator , validators . URLValidator ) and validator . verify_exists == True ] <EOL> if verified : <EOL> url = choice ( [ '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' ] ) <EOL> else : <EOL> url = "<STR_LIT>" % ( <EOL> xunit . any_string ( max_length = <NUM_LIT:10> ) , <EOL> xunit . any_string ( min_length = <NUM_LIT:2> , max_length = <NUM_LIT:3> ) , <EOL> xunit . any_string ( max_length = <NUM_LIT:20> ) ) <EOL> return url <EOL> @ any_field . register ( models . TimeField ) <EOL> def any_time_field ( field , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> return time ( <EOL> xunit . any_int ( min_value = <NUM_LIT:0> , max_value = <NUM_LIT> ) , <EOL> xunit . any_int ( min_value = <NUM_LIT:0> , max_value = <NUM_LIT> ) , <EOL> xunit . any_int ( min_value = <NUM_LIT:0> , max_value = <NUM_LIT> ) ) <EOL> @ any_field . register ( models . ForeignKey ) <EOL> def any_foreignkey_field ( field , ** kwargs ) : <EOL> return any_model ( field . rel . to , ** kwargs ) <EOL> @ any_field . register ( models . OneToOneField ) <EOL> def any_onetoone_field ( field , ** kwargs ) : <EOL> return any_model ( field . rel . to , ** kwargs ) <EOL> def _fill_model_fields ( model , ** kwargs ) : <EOL> model_fields , fields_args = split_model_kwargs ( kwargs ) <EOL> for field in model . _meta . fields : <EOL> if field . name in model_fields : <EOL> if isinstance ( kwargs [ field . name ] , Q ) : <EOL> """<STR_LIT>""" <EOL> key_field = model . _meta . get_field ( field . name ) <EOL> value = key_field . rel . to . objects . get ( kwargs [ field . name ] ) <EOL> setattr ( model , field . name , value ) <EOL> else : <EOL> setattr ( model , field . name , kwargs [ field . name ] ) <EOL> elif isinstance ( field , models . OneToOneField ) and field . rel . parent_link : <EOL> """<STR_LIT>""" <EOL> elif isinstance ( field , models . fields . AutoField ) : <EOL> """<STR_LIT>""" <EOL> else : <EOL> setattr ( model , field . name , any_field ( field , ** fields_args [ field . name ] ) ) <EOL> onetoone = [ ( relation . var_name , relation . field ) for relation in model . _meta . get_all_related_objects ( ) if relation . field . unique ] <EOL> for field_name , field in onetoone : <EOL> if field_name in model_fields : <EOL> setattr ( model , field_name , kwargs [ field_name ] ) <EOL> @ any_model . register_default <EOL> def any_model_default ( model_cls , ** kwargs ) : <EOL> result = model_cls ( ) <EOL> attempts = <NUM_LIT:10> <EOL> while True : <EOL> try : <EOL> _fill_model_fields ( result , ** kwargs ) <EOL> result . full_clean ( ) <EOL> result . save ( ) <EOL> return result <EOL> except ( IntegrityError , ValidationError ) : <EOL> attempts -= <NUM_LIT:1> <EOL> if not attempts : <EOL> raise </s>

from setuptools import setup <EOL> try : <EOL> long_description = open ( '<STR_LIT>' ) . read ( ) <EOL> except IOError : <EOL> long_description = '<STR_LIT>' <EOL> setup ( <EOL> name = '<STR_LIT>' , <EOL> version = '<STR_LIT>' , <EOL> description = '<STR_LIT>' , <EOL> author = '<STR_LIT>' , <EOL> author_email = '<STR_LIT>' , <EOL> url = '<STR_LIT>' , <EOL> keywords = "<STR_LIT>" , <EOL> packages = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] , <EOL> include_package_data = True , <EOL> zip_safe = False , <EOL> license = '<STR_LIT>' , <EOL> platforms = [ '<STR_LIT>' ] , <EOL> classifiers = [ <EOL> '<STR_LIT>' ,

'<STR_LIT>' ,

from setuptools import setup <EOL> try : <EOL> long_description = open ( '<STR_LIT>' ) . read ( ) <EOL> except IOError : <EOL> long_description = '<STR_LIT>' <EOL> setup ( <EOL> name = '<STR_LIT>' , <EOL> version = '<STR_LIT>' , <EOL> description = '<STR_LIT>' , <EOL> author = '<STR_LIT>' , <EOL> author_email = '<STR_LIT>' , <EOL> url = '<STR_LIT>' , <EOL> keywords = "<STR_LIT>" , <EOL> packages = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] , <EOL> include_package_data = True , <EOL> zip_safe = False , <EOL> license = '<STR_LIT>' , <EOL> platforms = [ '<STR_LIT>' ] , <EOL> classifiers = [ <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> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ] <EOL> ) </s>

try : <EOL> import cmemcache as memcache <EOL> except ImportError : <EOL> import memcache <EOL> class CacheClass ( object ) : <EOL> def __init__ ( self ) : <EOL> self . client = memcache . Client ( [ '<STR_LIT>' ] , debug = <NUM_LIT:0> ) <EOL> def get ( self , key , default = None ) : <EOL> cache_value = self . client . get ( fixkey ( key ) ) <EOL> if cache_value : return cache_value <EOL> return default <EOL> def set ( self , key , value , time = <NUM_LIT:0> ) : <EOL> return self . client . set ( fixkey ( key ) , value , time )

def fixkey ( key ) :

try : <EOL> import cmemcache as memcache <EOL> except ImportError : <EOL> import memcache <EOL> class CacheClass ( object ) : <EOL> def __init__ ( self ) : <EOL> self . client = memcache . Client ( [ '<STR_LIT>' ] , debug = <NUM_LIT:0> ) <EOL> def get ( self , key , default = None ) : <EOL> cache_value = self . client . get ( fixkey ( key ) ) <EOL> if cache_value : return cache_value <EOL> return default <EOL> def set ( self , key , value , time = <NUM_LIT:0> ) : <EOL> return self . client . set ( fixkey ( key ) , value , time ) <EOL> def fixkey ( key ) : <EOL> return key . replace ( "<STR_LIT:U+0020>" , "<STR_LIT:_>" ) </s>

import slack <EOL> import slack . http_client <EOL> def history ( channel , ** kwargs ) : <EOL> """<STR_LIT>"""

params = {

import slack <EOL> import slack . http_client <EOL> def history ( channel , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> params = { <EOL> '<STR_LIT>' : slack . api_token , <EOL> '<STR_LIT>' : channel , <EOL> } <EOL> for key , value in kwargs . items ( ) : <EOL> params [ key ] = value <EOL> return slack . http_client . get ( '<STR_LIT>' , params ) <EOL> def list ( ) : <EOL> """<STR_LIT>""" <EOL> params = { '<STR_LIT>' : slack . api_token } <EOL> return slack . http_client . get ( '<STR_LIT>' , params ) </s>

from mock import patch

import unittest

from mock import patch <EOL> import unittest <EOL> import slack <EOL> import slack . users <EOL> import slack . http_client <EOL> slack . api_token = '<STR_LIT>' <EOL> class TestUsersList ( unittest . TestCase ) : <EOL> @ patch . object ( slack . http_client , '<STR_LIT>' ) <EOL> def test_list ( self , http_get_mock ) : <EOL> slack . users . list ( ) <EOL> http_get_mock . assert_called_with ( '<STR_LIT>' , { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> } ) </s>

import os <EOL> import sys <EOL> import unittest <EOL> sys . path . insert ( <NUM_LIT:0> , os . path . abspath ( '<STR_LIT:..>' ) ) <EOL> import polymaze as pmz <EOL> from polymaze import polygrid as _polygrid_module <EOL> try : <EOL> _assertCountEqual = unittest . TestCase . assertCountEqual <EOL> from unittest import mock <EOL> except ( AttributeError , ImportError ) : <EOL> _assertCountEqual = unittest . TestCase . assertItemsEqual <EOL> import mock <EOL> class TestPolyGrid_Creation ( unittest . TestCase ) : <EOL> @ mock . patch . object ( _polygrid_module . PolyGrid , '<STR_LIT>' ) <EOL> @ mock . patch . object ( _polygrid_module , '<STR_LIT>' ) <EOL> def test_create_string_converts_to_image_then_uses_create_image ( self , <EOL> m_s_img , <EOL> m_crt_im ) : <EOL> grid = generic_grid ( ) <EOL> source_string_spec = '<STR_LIT>' <EOL> grid . create_string ( source_string_spec ) <EOL> m_s_img_args = m_s_img . call_args [ <NUM_LIT:0> ] <EOL> self . assertIn ( source_string_spec , m_s_img_args ) <EOL> m_crt_im_args = m_crt_im . call_args [ <NUM_LIT:0> ] <EOL> self . assertIn ( m_s_img . return_value , m_crt_im_args ) <EOL> def test_string_image_returns_a_PIL_image ( self ) : <EOL> some_string = '<STR_LIT>' <EOL> image = _polygrid_module . _string_image ( some_string ) <EOL> self . assertTrue ( hasattr ( image , '<STR_LIT>' ) ) <EOL> @ mock . patch ( '<STR_LIT>' ) <EOL> def test_string_image_uses_bundled_font_when_none_provided ( self , m_tt ) : <EOL> some_string = '<STR_LIT>' <EOL> bundled_font_name = '<STR_LIT>' <EOL> try : <EOL> _polygrid_module . _string_image ( some_string ) <EOL> except Exception : <EOL> pass <EOL> m_truetype_args = m_tt . call_args [ <NUM_LIT:0> ] <EOL> m_truetype_arg = m_truetype_args [ <NUM_LIT:0> ] <EOL> self . assertIn ( bundled_font_name , m_truetype_arg ) <EOL> @ mock . patch ( '<STR_LIT>' ) <EOL> def test_string_image_tries_provided_font_path ( self , m_truetype ) : <EOL> some_string = '<STR_LIT>' <EOL> some_font = '<STR_LIT>' <EOL> try : <EOL> _polygrid_module . _string_image ( some_string , font_path = some_font ) <EOL> except Exception : <EOL> pass <EOL> m_truetype_args = m_truetype . call_args [ <NUM_LIT:0> ] <EOL> self . assertIn ( some_font , m_truetype_args ) <EOL> def test_string_image_raises_ValueError_if_provided_font_fails ( self ) : <EOL> nonexistent_font_path = '<STR_LIT>' <EOL> some_string = '<STR_LIT>' <EOL> self . assertRaises ( ValueError , _polygrid_module . _string_image , some_string , font_path = nonexistent_font_path ) <EOL> def test_create_from_image_looks_like_provided_image ( self ) : <EOL> pass <EOL> def test_string_image_is_about_double_height_with_newline ( self ) : <EOL> char = '<STR_LIT:a>' <EOL> image_without_newline = _polygrid_module . _string_image ( char ) <EOL> char_with_newline = char + '<STR_LIT>' + char <EOL> image_with_newline = _polygrid_module . _string_image ( char_with_newline ) <EOL> h_single_line = image_without_newline . size [ <NUM_LIT:1> ] <EOL> h_min_spec = <NUM_LIT:2> * h_single_line <EOL> h_max_spec = <NUM_LIT> * h_single_line <EOL> h_double = image_with_newline . size [ <NUM_LIT:1> ] <EOL> self . assertTrue ( h_min_spec <= h_double <= h_max_spec , <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' . format ( h_min_spec , h_max_spec , h_double ) ) <EOL> def test_sized_grid_is_under_single_target_size_by_less_than_4_side_lengths ( self ) : <EOL> single_dimension_size_spec = { <NUM_LIT:0> : ( '<STR_LIT>' , <NUM_LIT:15> ) , <EOL> <NUM_LIT:1> : ( '<STR_LIT:width>' , <NUM_LIT:20> ) } <EOL> for dimension , ( kw , dimension_limit ) in single_dimension_size_spec . items ( ) : <EOL> sized_grid = generic_grid ( ) <EOL> sized_grid . create_string ( '<STR_LIT:?>' , ** { kw : dimension_limit } ) <EOL> dimension_min = <NUM_LIT> <EOL> dimension_max = - <NUM_LIT> <EOL> for edge in sized_grid . edges ( ) : <EOL> for yx_units in edge . endpoints ( ) : <EOL> dimension_value = yx_units [ dimension ] <EOL> dimension_min = min ( dimension_value , dimension_min ) <EOL> dimension_max = max ( dimension_value , dimension_max ) <EOL> size = dimension_max - dimension_min <EOL> max_delta_spec = <NUM_LIT:4> * sized_grid . _supershape . _reference_length <EOL> size_max_spec = single_dimension_size_spec [ dimension ] [ <NUM_LIT:1> ] <EOL> size_min_spec = size_max_spec - max_delta_spec <EOL> self . assertGreaterEqual ( size , size_min_spec ) <EOL> self . assertLessEqual ( size , size_max_spec ) <EOL> def test_sized_grid_is_under_double_target_size_by_less_than_4_side_lengths ( self ) : <EOL> dimensions_data = { <NUM_LIT:0> : { '<STR_LIT>' : <NUM_LIT:15> , <EOL> '<STR_LIT>' : - <NUM_LIT> , <EOL> '<STR_LIT>' : <NUM_LIT> } , <EOL> <NUM_LIT:1> : { '<STR_LIT>' : <NUM_LIT:20> , <EOL> '<STR_LIT>' : - <NUM_LIT> , <EOL> '<STR_LIT>' : <NUM_LIT> } } <EOL> sized_grid = generic_grid ( ) <EOL> sized_grid . create_string ( '<STR_LIT:?>' , height = dimensions_data [ <NUM_LIT:0> ] [ '<STR_LIT>' ] , <EOL> width = dimensions_data [ <NUM_LIT:1> ] [ '<STR_LIT>' ] ) <EOL> for edge in sized_grid . edges ( ) : <EOL> for yx_point in edge . endpoints ( ) : <EOL> for dimension in ( <NUM_LIT:0> , <NUM_LIT:1> ) : <EOL> dimension_value = yx_point [ dimension ] <EOL> dimension_min = dimensions_data [ dimension ] [ '<STR_LIT>' ] <EOL> dimensions_data [ dimension ] [ '<STR_LIT>' ] = min ( dimension_value , dimension_min ) <EOL> dimension_max = dimensions_data [ dimension ] [ '<STR_LIT>' ] <EOL> dimensions_data [ dimension ] [ '<STR_LIT>' ] = max ( dimension_value , dimension_max ) <EOL> for dimension in ( <NUM_LIT:0> , <NUM_LIT:1> ) : <EOL> size = dimensions_data [ dimension ] [ '<STR_LIT>' ] - dimensions_data [ dimension ] [ '<STR_LIT>' ] <EOL> max_delta_spec = <NUM_LIT:4> * sized_grid . _supershape . _reference_length <EOL> size_max_spec = dimensions_data [ dimension ] [ '<STR_LIT>' ] <EOL> size_min_spec = size_max_spec - max_delta_spec <EOL> self . assertGreaterEqual ( size , size_min_spec ) <EOL> self . assertLessEqual ( size , size_max_spec ) <EOL> class TestShapeGrid ( unittest . TestCase ) : <EOL> def test_produces_an_empty_grid ( self ) : <EOL> grid = pmz . PolyGrid ( ) <EOL> self . assertEqual ( len ( tuple ( grid . shapes ( ) ) ) , <NUM_LIT:0> ) <EOL> def test_create_rectangle_produces_a_rectangular_graph ( self ) : <EOL> grid = generic_grid ( ) <EOL> grid . create_rectangle ( complexity = <NUM_LIT:3> ) <EOL> all_vertexes = list ( ) <EOL> for edge in grid . edges ( ) : <EOL> all_vertexes . extend ( edge . endpoints ( ) ) <EOL> y_all , x_all = zip ( * all_vertexes ) <EOL> top , bottom = min ( y_all ) , max ( y_all ) <EOL> left , right = min ( x_all ) , max ( x_all ) <EOL> rectangular_area = ( bottom - top ) * ( right - left ) <EOL> shape_count = len ( tuple ( s for s in grid . shapes ( ) ) ) <EOL> rectangular_shape_area_spec = shape_count * grid . _supershape . avg_area ( ) <EOL> tolerance = <NUM_LIT:0.1> * rectangular_shape_area_spec <EOL> self . assertAlmostEqual ( rectangular_area , rectangular_shape_area_spec , <EOL> delta = tolerance ) <EOL> def test_get_returns_shape_created_with_same_index ( self ) :

grid = generic_grid ( )

import os <EOL> import sys <EOL> import unittest <EOL> sys . path . insert ( <NUM_LIT:0> , os . path . abspath ( '<STR_LIT:..>' ) ) <EOL> import polymaze as pmz <EOL> from polymaze import polygrid as _polygrid_module <EOL> try : <EOL> _assertCountEqual = unittest . TestCase . assertCountEqual <EOL> from unittest import mock <EOL> except ( AttributeError , ImportError ) : <EOL> _assertCountEqual = unittest . TestCase . assertItemsEqual <EOL> import mock <EOL> class TestPolyGrid_Creation ( unittest . TestCase ) : <EOL> @ mock . patch . object ( _polygrid_module . PolyGrid , '<STR_LIT>' ) <EOL> @ mock . patch . object ( _polygrid_module , '<STR_LIT>' ) <EOL> def test_create_string_converts_to_image_then_uses_create_image ( self , <EOL> m_s_img , <EOL> m_crt_im ) : <EOL> grid = generic_grid ( ) <EOL> source_string_spec = '<STR_LIT>' <EOL> grid . create_string ( source_string_spec ) <EOL> m_s_img_args = m_s_img . call_args [ <NUM_LIT:0> ] <EOL> self . assertIn ( source_string_spec , m_s_img_args ) <EOL> m_crt_im_args = m_crt_im . call_args [ <NUM_LIT:0> ] <EOL> self . assertIn ( m_s_img . return_value , m_crt_im_args ) <EOL> def test_string_image_returns_a_PIL_image ( self ) : <EOL> some_string = '<STR_LIT>' <EOL> image = _polygrid_module . _string_image ( some_string ) <EOL> self . assertTrue ( hasattr ( image , '<STR_LIT>' ) ) <EOL> @ mock . patch ( '<STR_LIT>' ) <EOL> def test_string_image_uses_bundled_font_when_none_provided ( self , m_tt ) : <EOL> some_string = '<STR_LIT>' <EOL> bundled_font_name = '<STR_LIT>' <EOL> try : <EOL> _polygrid_module . _string_image ( some_string ) <EOL> except Exception : <EOL> pass <EOL> m_truetype_args = m_tt . call_args [ <NUM_LIT:0> ] <EOL> m_truetype_arg = m_truetype_args [ <NUM_LIT:0> ] <EOL> self . assertIn ( bundled_font_name , m_truetype_arg ) <EOL> @ mock . patch ( '<STR_LIT>' ) <EOL> def test_string_image_tries_provided_font_path ( self , m_truetype ) : <EOL> some_string = '<STR_LIT>' <EOL> some_font = '<STR_LIT>' <EOL> try : <EOL> _polygrid_module . _string_image ( some_string , font_path = some_font ) <EOL> except Exception : <EOL> pass <EOL> m_truetype_args = m_truetype . call_args [ <NUM_LIT:0> ] <EOL> self . assertIn ( some_font , m_truetype_args ) <EOL> def test_string_image_raises_ValueError_if_provided_font_fails ( self ) : <EOL> nonexistent_font_path = '<STR_LIT>' <EOL> some_string = '<STR_LIT>' <EOL> self . assertRaises ( ValueError , _polygrid_module . _string_image , some_string , font_path = nonexistent_font_path ) <EOL> def test_create_from_image_looks_like_provided_image ( self ) : <EOL> pass <EOL> def test_string_image_is_about_double_height_with_newline ( self ) : <EOL> char = '<STR_LIT:a>' <EOL> image_without_newline = _polygrid_module . _string_image ( char ) <EOL> char_with_newline = char + '<STR_LIT>' + char <EOL> image_with_newline = _polygrid_module . _string_image ( char_with_newline ) <EOL> h_single_line = image_without_newline . size [ <NUM_LIT:1> ] <EOL> h_min_spec = <NUM_LIT:2> * h_single_line <EOL> h_max_spec = <NUM_LIT> * h_single_line <EOL> h_double = image_with_newline . size [ <NUM_LIT:1> ] <EOL> self . assertTrue ( h_min_spec <= h_double <= h_max_spec , <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' . format ( h_min_spec , h_max_spec , h_double ) ) <EOL> def test_sized_grid_is_under_single_target_size_by_less_than_4_side_lengths ( self ) : <EOL> single_dimension_size_spec = { <NUM_LIT:0> : ( '<STR_LIT>' , <NUM_LIT:15> ) , <EOL> <NUM_LIT:1> : ( '<STR_LIT:width>' , <NUM_LIT:20> ) } <EOL> for dimension , ( kw , dimension_limit ) in single_dimension_size_spec . items ( ) : <EOL> sized_grid = generic_grid ( ) <EOL> sized_grid . create_string ( '<STR_LIT:?>' , ** { kw : dimension_limit } ) <EOL> dimension_min = <NUM_LIT> <EOL> dimension_max = - <NUM_LIT> <EOL> for edge in sized_grid . edges ( ) : <EOL> for yx_units in edge . endpoints ( ) : <EOL> dimension_value = yx_units [ dimension ] <EOL> dimension_min = min ( dimension_value , dimension_min ) <EOL> dimension_max = max ( dimension_value , dimension_max ) <EOL> size = dimension_max - dimension_min <EOL> max_delta_spec = <NUM_LIT:4> * sized_grid . _supershape . _reference_length <EOL> size_max_spec = single_dimension_size_spec [ dimension ] [ <NUM_LIT:1> ] <EOL> size_min_spec = size_max_spec - max_delta_spec <EOL> self . assertGreaterEqual ( size , size_min_spec ) <EOL> self . assertLessEqual ( size , size_max_spec ) <EOL> def test_sized_grid_is_under_double_target_size_by_less_than_4_side_lengths ( self ) : <EOL> dimensions_data = { <NUM_LIT:0> : { '<STR_LIT>' : <NUM_LIT:15> , <EOL> '<STR_LIT>' : - <NUM_LIT> , <EOL> '<STR_LIT>' : <NUM_LIT> } , <EOL> <NUM_LIT:1> : { '<STR_LIT>' : <NUM_LIT:20> , <EOL> '<STR_LIT>' : - <NUM_LIT> , <EOL> '<STR_LIT>' : <NUM_LIT> } } <EOL> sized_grid = generic_grid ( ) <EOL> sized_grid . create_string ( '<STR_LIT:?>' , height = dimensions_data [ <NUM_LIT:0> ] [ '<STR_LIT>' ] , <EOL> width = dimensions_data [ <NUM_LIT:1> ] [ '<STR_LIT>' ] ) <EOL> for edge in sized_grid . edges ( ) : <EOL> for yx_point in edge . endpoints ( ) : <EOL> for dimension in ( <NUM_LIT:0> , <NUM_LIT:1> ) : <EOL> dimension_value = yx_point [ dimension ] <EOL> dimension_min = dimensions_data [ dimension ] [ '<STR_LIT>' ] <EOL> dimensions_data [ dimension ] [ '<STR_LIT>' ] = min ( dimension_value , dimension_min ) <EOL> dimension_max = dimensions_data [ dimension ] [ '<STR_LIT>' ] <EOL> dimensions_data [ dimension ] [ '<STR_LIT>' ] = max ( dimension_value , dimension_max ) <EOL> for dimension in ( <NUM_LIT:0> , <NUM_LIT:1> ) : <EOL> size = dimensions_data [ dimension ] [ '<STR_LIT>' ] - dimensions_data [ dimension ] [ '<STR_LIT>' ] <EOL> max_delta_spec = <NUM_LIT:4> * sized_grid . _supershape . _reference_length <EOL> size_max_spec = dimensions_data [ dimension ] [ '<STR_LIT>' ] <EOL> size_min_spec = size_max_spec - max_delta_spec <EOL> self . assertGreaterEqual ( size , size_min_spec ) <EOL> self . assertLessEqual ( size , size_max_spec ) <EOL> class TestShapeGrid ( unittest . TestCase ) : <EOL> def test_produces_an_empty_grid ( self ) : <EOL> grid = pmz . PolyGrid ( ) <EOL> self . assertEqual ( len ( tuple ( grid . shapes ( ) ) ) , <NUM_LIT:0> ) <EOL> def test_create_rectangle_produces_a_rectangular_graph ( self ) : <EOL> grid = generic_grid ( ) <EOL> grid . create_rectangle ( complexity = <NUM_LIT:3> ) <EOL> all_vertexes = list ( ) <EOL> for edge in grid . edges ( ) : <EOL> all_vertexes . extend ( edge . endpoints ( ) ) <EOL> y_all , x_all = zip ( * all_vertexes ) <EOL> top , bottom = min ( y_all ) , max ( y_all ) <EOL> left , right = min ( x_all ) , max ( x_all ) <EOL> rectangular_area = ( bottom - top ) * ( right - left ) <EOL> shape_count = len ( tuple ( s for s in grid . shapes ( ) ) ) <EOL> rectangular_shape_area_spec = shape_count * grid . _supershape . avg_area ( ) <EOL> tolerance = <NUM_LIT:0.1> * rectangular_shape_area_spec <EOL> self . assertAlmostEqual ( rectangular_area , rectangular_shape_area_spec , <EOL> delta = tolerance ) <EOL> def test_get_returns_shape_created_with_same_index ( self ) : <EOL> grid = generic_grid ( ) <EOL> some_index = ( <NUM_LIT:1> , <NUM_LIT:2> ) <EOL> shape_spec = grid . create ( some_index ) <EOL> shape = grid . get ( some_index ) <EOL> self . assertIs ( shape , shape_spec ) <EOL> def test_get_returns_None_for_nonexistent_indexes ( self ) : <EOL> grid = generic_grid ( ) <EOL> unused_index = ( <NUM_LIT:1> , <NUM_LIT:2> ) <EOL> self . assertIsNone ( grid . get ( unused_index ) ) <EOL> def test_shapes_generates_each_shape_exactly_once ( self ) : <EOL> known_creator = pmz . SUPERSHAPES_DICT [ '<STR_LIT>' ] <EOL> some_index = ( <NUM_LIT:1> , <NUM_LIT:2> ) <EOL> grid = generic_grid ( supershape = known_creator , <EOL> neighborhood_center_index = some_index ) <EOL> all_shapes_spec = grid . _shapes . values ( ) <EOL> shape_count_spec = <NUM_LIT:5> <EOL> self . assertEqual ( len ( all_shapes_spec ) , shape_count_spec ) <EOL> all_shapes = tuple ( grid . shapes ( ) ) <EOL> _assertCountEqual ( self , all_shapes , all_shapes_spec ) <EOL> def test_edges_generates_each_edge_exactly_once ( self ) : <EOL> known_creator = pmz . SUPERSHAPES_DICT [ '<STR_LIT>' ] <EOL> some_index = ( <NUM_LIT:1> , <NUM_LIT:2> ) <EOL> grid = generic_grid ( supershape = known_creator , <EOL> neighborhood_center_index = some_index ) <EOL> edges_spec = list ( ) <EOL> for shape in grid . shapes ( ) : <EOL> for n_index , edge in shape . edges ( ) : <EOL> if edge not in edges_spec : <EOL> edges_spec . append ( edge ) <EOL> edge_count_spec = <NUM_LIT:16> <EOL> self . assertEqual ( len ( edges_spec ) , edge_count_spec ) <EOL> edges = tuple ( grid . edges ( ) ) <EOL> _assertCountEqual ( self , edges , edges_spec ) <EOL> def test_border_shapes_generates_all_shapes_with_any_empty_neighbors ( self ) : <EOL> center_index = ( <NUM_LIT:1> , <NUM_LIT:1> ) <EOL> grid = generic_grid ( neighborhood_center_index = center_index ) <EOL> center = grid . get ( center_index ) <EOL> n_indexes = tuple ( center . n_indexes ( ) ) <EOL> border_shapes_spec = ( grid . get ( n_index ) for n_index in n_indexes ) <EOL> border_shapes = tuple ( grid . border_shapes ( ) ) <EOL> _assertCountEqual ( self , border_shapes , border_shapes_spec ) <EOL> def test_remove_removes_shape_from_the_grid ( self ) : <EOL> grid = generic_grid ( ) <EOL> some_index = ( <NUM_LIT:1> , <NUM_LIT:2> ) <EOL> grid . create ( some_index ) <EOL> shape_before_remove = grid . get ( some_index ) <EOL> self . assertIsNotNone ( shape_before_remove ) <EOL> grid . remove ( some_index ) <EOL> center_shape_after_remove = grid . get ( some_index ) <EOL> self . assertIsNone ( center_shape_after_remove ) <EOL> def test_remove_removes_the_grid_from_the_shape ( self ) : <EOL> grid = generic_grid ( ) <EOL> some_index = ( <NUM_LIT:1> , <NUM_LIT:2> ) <EOL> grid . create ( some_index ) <EOL> removed_shape = grid . get ( some_index ) <EOL> self . assertIs ( removed_shape . _grid , grid ) <EOL> grid . remove ( some_index ) <EOL> self . assertIsNone ( removed_shape . _grid ) <EOL> def test_remove_for_nonexistent_key_simply_returns ( self ) : <EOL> grid = generic_grid ( ) <EOL> some_index = ( <NUM_LIT:1> , <NUM_LIT:2> ) <EOL> self . assertIsNone ( grid . get ( some_index ) ) <EOL> self . assertIsNone ( grid . remove ( some_index ) ) <EOL> def test_remove_causes_unshared_edges_of_removed_shape_to_be_delisted ( self ) : <EOL> grid = generic_grid ( ) <EOL> some_index = ( <NUM_LIT:1> , <NUM_LIT:2> ) <EOL> grid . create ( some_index ) <EOL> edges_before_remove = tuple ( grid . edges ( ) ) <EOL> self . assertNotEqual ( len ( edges_before_remove ) , <NUM_LIT:0> ) <EOL> grid . remove ( some_index ) <EOL> edges_after_remove = tuple ( grid . edges ( ) ) <EOL> self . assertEqual ( len ( edges_after_remove ) , <NUM_LIT:0> ) <EOL> def test_remove_pushes_shared_edges_of_removed_shape_to_neighbors ( self ) : <EOL> center_index = ( <NUM_LIT:1> , <NUM_LIT:2> ) <EOL> grid = generic_grid ( neighborhood_center_index = center_index ) <EOL> center_shape = grid . get ( center_index ) <EOL> center_neighbor_edge_combos = list ( ) <EOL> for n_index , neighbor in center_shape . neighbors ( ) : <EOL> self . assertTrue ( n_index in center_shape . _owned_edges ) <EOL> edge = center_shape . edge ( n_index ) <EOL> center_neighbor_edge_combos . append ( ( neighbor , edge ) ) <EOL> grid . remove ( center_index ) <EOL> for neighbor , previously_unowned_edge in center_neighbor_edge_combos : <EOL> owned_edges = neighbor . _owned_edges . values ( ) <EOL> self . assertIn ( previously_unowned_edge , owned_edges ) <EOL> def generic_grid ( supershape = None , neighborhood_center_index = None ) : <EOL> grid = pmz . PolyGrid ( supershape = supershape ) <EOL> if neighborhood_center_index : <EOL> center_shape = grid . create ( neighborhood_center_index ) <EOL> for n_index in center_shape . n_indexes ( ) : <EOL> grid . create ( n_index ) <EOL> return grid <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> unittest . main ( ) </s>

import json <EOL> import os <EOL> from django . conf import settings <EOL> from django_digest . test import DigestAuth <EOL> from rest_framework . renderers import JSONRenderer <EOL> from onadata . apps . api . tests . viewsets . test_abstract_viewset import TestAbstractViewSet <EOL> from onadata . apps . api . viewsets . data_viewset import DataViewSet <EOL> from onadata . apps . api . viewsets . xform_viewset import XFormViewSet <EOL> from onadata . apps . api . viewsets . project_viewset import ProjectViewSet <EOL> from onadata . libs import permissions as role <EOL> from onadata . libs . serializers . xform_serializer import XFormSerializer <EOL> class TestUserPermissions ( TestAbstractViewSet ) : <EOL> def setUp ( self ) : <EOL> super ( self . __class__ , self ) . setUp ( ) <EOL> def test_can_add_xform_to_other_account ( self ) : <EOL> view = XFormViewSet . as_view ( { <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } ) <EOL> data = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : False , <EOL> '<STR_LIT>' : False , <EOL> '<STR_LIT:description>' : u'<STR_LIT>' , <EOL> '<STR_LIT>' : True , <EOL> '<STR_LIT>' : False , <EOL> '<STR_LIT>' : False , <EOL> '<STR_LIT>' : u'<STR_LIT>' , <EOL> '<STR_LIT>' : u'<STR_LIT>' , <EOL> '<STR_LIT:title>' : u'<STR_LIT>' , <EOL> '<STR_LIT>' : u'<STR_LIT>' <EOL> } <EOL> path = os . path . join ( <EOL> settings . ONADATA_DIR , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , <EOL> "<STR_LIT>" , "<STR_LIT>" ) <EOL> bob = self . user <EOL> alice_data = { '<STR_LIT:username>' : '<STR_LIT>' , '<STR_LIT:email>' : '<STR_LIT>' } <EOL> self . _login_user_and_profile ( extra_post_data = alice_data ) <EOL> with open ( path ) as xls_file : <EOL> post_data = { '<STR_LIT>' : xls_file , '<STR_LIT>' : '<STR_LIT>' } <EOL> request = self . factory . post ( '<STR_LIT:/>' , data = post_data , ** self . extra ) <EOL> response = view ( request ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> role . ManagerRole . add ( self . user , bob . profile ) <EOL> xls_file . seek ( <NUM_LIT:0> ) <EOL> request = self . factory . post ( '<STR_LIT:/>' , data = post_data , ** self . extra ) <EOL> response = view ( request ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> xform = bob . xforms . all ( ) [ <NUM_LIT:0> ] <EOL> data . update ( { <EOL> '<STR_LIT:url>' : <EOL> '<STR_LIT>' % xform . pk <EOL> } ) <EOL> self . assertDictContainsSubset ( data , response . data ) <EOL> def test_manager_can_update_xform ( self ) : <EOL> self . _publish_xls_form_to_project ( ) <EOL> alice_data = { '<STR_LIT:username>' : '<STR_LIT>' , '<STR_LIT:email>' : '<STR_LIT>' } <EOL> self . _login_user_and_profile ( extra_post_data = alice_data ) <EOL> view = XFormViewSet . as_view ( { <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } ) <EOL> description = '<STR_LIT>'

request = self . factory . get ( '<STR_LIT:/>' , ** self . extra )

import json <EOL> import os <EOL> from django . conf import settings <EOL> from django_digest . test import DigestAuth <EOL> from rest_framework . renderers import JSONRenderer <EOL> from onadata . apps . api . tests . viewsets . test_abstract_viewset import TestAbstractViewSet <EOL> from onadata . apps . api . viewsets . data_viewset import DataViewSet <EOL> from onadata . apps . api . viewsets . xform_viewset import XFormViewSet <EOL> from onadata . apps . api . viewsets . project_viewset import ProjectViewSet <EOL> from onadata . libs import permissions as role <EOL> from onadata . libs . serializers . xform_serializer import XFormSerializer <EOL> class TestUserPermissions ( TestAbstractViewSet ) : <EOL> def setUp ( self ) : <EOL> super ( self . __class__ , self ) . setUp ( ) <EOL> def test_can_add_xform_to_other_account ( self ) : <EOL> view = XFormViewSet . as_view ( { <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } ) <EOL> data = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : False , <EOL> '<STR_LIT>' : False , <EOL> '<STR_LIT:description>' : u'<STR_LIT>' , <EOL> '<STR_LIT>' : True , <EOL> '<STR_LIT>' : False , <EOL> '<STR_LIT>' : False , <EOL> '<STR_LIT>' : u'<STR_LIT>' , <EOL> '<STR_LIT>' : u'<STR_LIT>' , <EOL> '<STR_LIT:title>' : u'<STR_LIT>' , <EOL> '<STR_LIT>' : u'<STR_LIT>' <EOL> } <EOL> path = os . path . join ( <EOL> settings . ONADATA_DIR , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , <EOL> "<STR_LIT>" , "<STR_LIT>" ) <EOL> bob = self . user <EOL> alice_data = { '<STR_LIT:username>' : '<STR_LIT>' , '<STR_LIT:email>' : '<STR_LIT>' } <EOL> self . _login_user_and_profile ( extra_post_data = alice_data ) <EOL> with open ( path ) as xls_file : <EOL> post_data = { '<STR_LIT>' : xls_file , '<STR_LIT>' : '<STR_LIT>' } <EOL> request = self . factory . post ( '<STR_LIT:/>' , data = post_data , ** self . extra ) <EOL> response = view ( request ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> role . ManagerRole . add ( self . user , bob . profile ) <EOL> xls_file . seek ( <NUM_LIT:0> ) <EOL> request = self . factory . post ( '<STR_LIT:/>' , data = post_data , ** self . extra ) <EOL> response = view ( request ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> xform = bob . xforms . all ( ) [ <NUM_LIT:0> ] <EOL> data . update ( { <EOL> '<STR_LIT:url>' : <EOL> '<STR_LIT>' % xform . pk <EOL> } ) <EOL> self . assertDictContainsSubset ( data , response . data ) <EOL> def test_manager_can_update_xform ( self ) : <EOL> self . _publish_xls_form_to_project ( ) <EOL> alice_data = { '<STR_LIT:username>' : '<STR_LIT>' , '<STR_LIT:email>' : '<STR_LIT>' } <EOL> self . _login_user_and_profile ( extra_post_data = alice_data ) <EOL> view = XFormViewSet . as_view ( { <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } ) <EOL> description = '<STR_LIT>' <EOL> request = self . factory . get ( '<STR_LIT:/>' , ** self . extra ) <EOL> xfs = XFormSerializer ( instance = self . xform , <EOL> context = { '<STR_LIT>' : request } ) <EOL> data = json . loads ( JSONRenderer ( ) . render ( xfs . data ) ) <EOL> data . update ( { '<STR_LIT>' : True , '<STR_LIT:description>' : description } ) <EOL> self . assertFalse ( self . xform . shared ) <EOL> request = self . factory . put ( '<STR_LIT:/>' , data = data , ** self . extra ) <EOL> response = view ( request , pk = self . xform . id ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> self . assertFalse ( self . xform . shared ) <EOL> role . ManagerRole . add ( self . user , self . xform ) <EOL> request = self . factory . put ( '<STR_LIT:/>' , data = data , ** self . extra ) <EOL> response = view ( request , pk = self . xform . id ) <EOL> self . xform . reload ( ) <EOL> self . assertTrue ( self . xform . shared ) <EOL> self . assertEqual ( self . xform . description , description ) <EOL> self . assertEqual ( response . data [ '<STR_LIT>' ] , True ) <EOL> self . assertEqual ( response . data [ '<STR_LIT:description>' ] , description ) <EOL> def test_manager_can_update_xform_tags ( self ) : <EOL> self . _publish_xls_form_to_project ( ) <EOL> alice_data = { '<STR_LIT:username>' : '<STR_LIT>' , '<STR_LIT:email>' : '<STR_LIT>' } <EOL> self . _login_user_and_profile ( extra_post_data = alice_data ) <EOL> view = XFormViewSet . as_view ( { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } ) <EOL> formid = self . xform . pk <EOL> request = self . factory . get ( '<STR_LIT:/>' , ** self . extra ) <EOL> response = view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> role . ManagerRole . add ( self . user , self . xform ) <EOL> response = view ( request , pk = formid ) <EOL> self . assertEqual ( response . data , [ ] ) <EOL> request = self . factory . post ( '<STR_LIT:/>' , data = { "<STR_LIT>" : "<STR_LIT:hello>" } , ** self . extra ) <EOL> response = view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> self . assertEqual ( response . data , [ u'<STR_LIT:hello>' ] ) <EOL> request = self . factory . delete ( '<STR_LIT:/>' , data = { "<STR_LIT>" : "<STR_LIT:hello>" } , <EOL> ** self . extra ) <EOL> response = view ( request , pk = formid , label = '<STR_LIT:hello>' ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> self . assertEqual ( response . data , [ ] ) <EOL> def test_readonly_role ( self ) : <EOL> self . _publish_xls_form_to_project ( ) <EOL> self . _make_submissions ( ) <EOL> view = XFormViewSet . as_view ( { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } ) <EOL> data_view = DataViewSet . as_view ( { '<STR_LIT>' : '<STR_LIT:list>' } ) <EOL> alice_data = { '<STR_LIT:username>' : '<STR_LIT>' , '<STR_LIT:email>' : '<STR_LIT>' } <EOL> self . _login_user_and_profile ( extra_post_data = alice_data ) <EOL> formid = self . xform . pk <EOL> request = self . factory . get ( '<STR_LIT:/>' , ** self . extra ) <EOL> response = view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> response = data_view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> role . ReadOnlyRole . add ( self . user , self . xform ) <EOL> response = view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> response = data_view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> data = { '<STR_LIT>' : True , '<STR_LIT:description>' : "<STR_LIT>" } <EOL> request = self . factory . put ( '<STR_LIT:/>' , data = data , ** self . extra ) <EOL> response = view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> def test_readonly_role_submission_when_requires_auth ( self ) : <EOL> self . _publish_xls_form_to_project ( ) <EOL> self . user . profile . require_auth = True <EOL> self . user . profile . save ( ) <EOL> alice_data = { '<STR_LIT:username>' : '<STR_LIT>' , '<STR_LIT:email>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , '<STR_LIT>' : '<STR_LIT>' } <EOL> self . _login_user_and_profile ( extra_post_data = alice_data ) <EOL> role . ReadOnlyRole . add ( self . user , self . xform ) <EOL> paths = [ os . path . join ( <EOL> self . main_directory , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , s , s + '<STR_LIT>' ) for s in self . surveys ] <EOL> auth = DigestAuth ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _make_submission ( paths [ <NUM_LIT:0> ] , username = '<STR_LIT>' , auth = auth ) <EOL> self . assertEqual ( self . response . status_code , <NUM_LIT> ) <EOL> def test_data_entry_role ( self ) : <EOL> self . _publish_xls_form_to_project ( ) <EOL> self . _make_submissions ( ) <EOL> view = XFormViewSet . as_view ( { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } ) <EOL> data_view = DataViewSet . as_view ( { '<STR_LIT>' : '<STR_LIT:list>' } ) <EOL> alice_data = { '<STR_LIT:username>' : '<STR_LIT>' , '<STR_LIT:email>' : '<STR_LIT>' } <EOL> self . _login_user_and_profile ( extra_post_data = alice_data ) <EOL> formid = self . xform . pk <EOL> request = self . factory . get ( '<STR_LIT:/>' , ** self . extra ) <EOL> response = view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> response = data_view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> role . DataEntryRole . add ( self . user , self . xform ) <EOL> response = view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> response = data_view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> data = { '<STR_LIT>' : True , '<STR_LIT:description>' : "<STR_LIT>" } <EOL> request = self . factory . put ( '<STR_LIT:/>' , data = data , ** self . extra ) <EOL> response = view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> def test_data_entry_role_submission_when_requires_auth ( self ) : <EOL> self . _publish_xls_form_to_project ( ) <EOL> self . user . profile . require_auth = True <EOL> self . user . profile . save ( ) <EOL> alice_data = { '<STR_LIT:username>' : '<STR_LIT>' , '<STR_LIT:email>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , '<STR_LIT>' : '<STR_LIT>' } <EOL> self . _login_user_and_profile ( extra_post_data = alice_data ) <EOL> role . DataEntryRole . add ( self . user , self . xform ) <EOL> paths = [ os . path . join ( <EOL> self . main_directory , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , s , s + '<STR_LIT>' ) for s in self . surveys ] <EOL> auth = DigestAuth ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _make_submission ( paths [ <NUM_LIT:0> ] , username = '<STR_LIT>' , auth = auth ) <EOL> self . assertEqual ( self . response . status_code , <NUM_LIT> ) <EOL> def test_editor_role ( self ) : <EOL> self . _publish_xls_form_to_project ( ) <EOL> self . _make_submissions ( ) <EOL> view = XFormViewSet . as_view ( { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } ) <EOL> data_view = DataViewSet . as_view ( { '<STR_LIT>' : '<STR_LIT:list>' } ) <EOL> alice_data = { '<STR_LIT:username>' : '<STR_LIT>' , '<STR_LIT:email>' : '<STR_LIT>' } <EOL> self . _login_user_and_profile ( extra_post_data = alice_data ) <EOL> formid = self . xform . pk <EOL> request = self . factory . get ( '<STR_LIT:/>' , ** self . extra ) <EOL> response = view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> response = data_view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> role . EditorRole . add ( self . user , self . xform ) <EOL> response = view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> response = data_view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> def test_editor_role_submission_when_requires_auth ( self ) : <EOL> self . _publish_xls_form_to_project ( ) <EOL> paths = [ os . path . join ( <EOL> self . main_directory , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , s , s + '<STR_LIT>' ) for s in [ <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' ] ] <EOL> self . _make_submission ( paths [ <NUM_LIT:0> ] ) <EOL> self . user . profile . require_auth = True <EOL> self . user . profile . save ( ) <EOL> alice_data = { '<STR_LIT:username>' : '<STR_LIT>' , '<STR_LIT:email>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , '<STR_LIT>' : '<STR_LIT>' } <EOL> self . _login_user_and_profile ( extra_post_data = alice_data ) <EOL> auth = DigestAuth ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . _make_submission ( paths [ <NUM_LIT:1> ] , username = '<STR_LIT>' , auth = auth ) <EOL> self . assertEqual ( self . response . status_code , <NUM_LIT> ) <EOL> role . EditorRole . add ( self . user , self . xform ) <EOL> self . _make_submission ( paths [ <NUM_LIT:1> ] , username = '<STR_LIT>' , auth = auth ) <EOL> self . assertEqual ( self . response . status_code , <NUM_LIT> ) <EOL> def test_owner_role ( self ) : <EOL> self . _publish_xls_form_to_project ( ) <EOL> self . _make_submissions ( ) <EOL> view = XFormViewSet . as_view ( { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } ) <EOL> data_view = DataViewSet . as_view ( { '<STR_LIT>' : '<STR_LIT:list>' } ) <EOL> alice_data = { '<STR_LIT:username>' : '<STR_LIT>' , '<STR_LIT:email>' : '<STR_LIT>' } <EOL> self . _login_user_and_profile ( extra_post_data = alice_data ) <EOL> formid = self . xform . pk <EOL> request = self . factory . get ( '<STR_LIT:/>' , ** self . extra ) <EOL> response = view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> response = data_view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> role . OwnerRole . add ( self . user , self . xform ) <EOL> response = view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> response = data_view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> xfs = XFormSerializer ( instance = self . xform , <EOL> context = { '<STR_LIT>' : request } ) <EOL> data = json . loads ( JSONRenderer ( ) . render ( xfs . data ) ) <EOL> data . update ( { '<STR_LIT>' : True , '<STR_LIT:description>' : "<STR_LIT>" } ) <EOL> request = self . factory . put ( '<STR_LIT:/>' , data = data , ** self . extra ) <EOL> response = view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> request = self . factory . delete ( '<STR_LIT:/>' , ** self . extra ) <EOL> response = view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> def test_org_creator_permissions ( self ) : <EOL> self . _org_create ( ) <EOL> self . assertTrue ( role . OwnerRole . user_has_role ( <EOL> self . user , self . organization ) ) <EOL> def test_form_inherits_permision_from_project ( self ) : <EOL> self . _publish_xls_form_to_project ( ) <EOL> self . _make_submissions ( ) <EOL> project_view = ProjectViewSet . as_view ( { <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } ) <EOL> xform_view = XFormViewSet . as_view ( { <EOL> '<STR_LIT>' : '<STR_LIT>' <EOL> } ) <EOL> data_view = DataViewSet . as_view ( { '<STR_LIT>' : '<STR_LIT:list>' } ) <EOL> alice_data = { '<STR_LIT:username>' : '<STR_LIT>' , '<STR_LIT:email>' : '<STR_LIT>' } <EOL> self . _login_user_and_profile ( extra_post_data = alice_data ) <EOL> formid = self . xform . pk <EOL> project_id = self . project . pk <EOL> request = self . factory . get ( '<STR_LIT:/>' , ** self . extra ) <EOL> response = xform_view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> response = data_view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT> ) <EOL> role . OwnerRole . add ( self . user , self . project ) <EOL> response = project_view ( request , pk = project_id ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> response = xform_view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) <EOL> response = data_view ( request , pk = formid ) <EOL> self . assertEqual ( response . status_code , <NUM_LIT:200> ) </s>

from django . contrib . auth . models import User <EOL> from django . utils . translation import ugettext as _ <EOL> from rest_framework import status <EOL> from rest_framework . viewsets import ModelViewSet <EOL> from rest_framework . decorators import detail_route <EOL> from rest_framework . response import Response <EOL> from onadata . apps . api . models . organization_profile import OrganizationProfile <EOL> from onadata . apps . api . tools import ( get_organization_members , <EOL> add_user_to_organization , <EOL> remove_user_from_organization ) <EOL> from onadata . apps . api import permissions <EOL> from onadata . libs . filters import OrganizationPermissionFilter <EOL> from onadata . libs . mixins . object_lookup_mixin import ObjectLookupMixin <EOL> from onadata . libs . permissions import ROLES <EOL> from onadata . libs . serializers . organization_serializer import ( <EOL> OrganizationSerializer ) <EOL> def _try_function_org_username ( f , organization , username , args = None ) : <EOL> data = [ ] <EOL> try : <EOL> user = User . objects . get ( username = username ) <EOL> except User . DoesNotExist : <EOL> status_code = status . HTTP_400_BAD_REQUEST <EOL> data = { '<STR_LIT:username>' : <EOL> [ _ ( u"<STR_LIT>" <EOL> % { '<STR_LIT:username>' : username } ) ] } <EOL> else : <EOL> if args : <EOL> f ( organization , user , * args )

else :

from django . contrib . auth . models import User <EOL> from django . utils . translation import ugettext as _ <EOL> from rest_framework import status <EOL> from rest_framework . viewsets import ModelViewSet <EOL> from rest_framework . decorators import detail_route <EOL> from rest_framework . response import Response <EOL> from onadata . apps . api . models . organization_profile import OrganizationProfile <EOL> from onadata . apps . api . tools import ( get_organization_members , <EOL> add_user_to_organization , <EOL> remove_user_from_organization ) <EOL> from onadata . apps . api import permissions <EOL> from onadata . libs . filters import OrganizationPermissionFilter <EOL> from onadata . libs . mixins . object_lookup_mixin import ObjectLookupMixin <EOL> from onadata . libs . permissions import ROLES <EOL> from onadata . libs . serializers . organization_serializer import ( <EOL> OrganizationSerializer ) <EOL> def _try_function_org_username ( f , organization , username , args = None ) : <EOL> data = [ ] <EOL> try : <EOL> user = User . objects . get ( username = username ) <EOL> except User . DoesNotExist : <EOL> status_code = status . HTTP_400_BAD_REQUEST <EOL> data = { '<STR_LIT:username>' : <EOL> [ _ ( u"<STR_LIT>" <EOL> % { '<STR_LIT:username>' : username } ) ] } <EOL> else : <EOL> if args : <EOL> f ( organization , user , * args ) <EOL> else : <EOL> f ( organization , user ) <EOL> status_code = status . HTTP_201_CREATED <EOL> return [ data , status_code ] <EOL> def _update_username_role ( organization , username , role_cls ) : <EOL> f = lambda org , user , role_cls : role_cls . add ( user , organization ) <EOL> return _try_function_org_username ( f , <EOL> organization , <EOL> username , <EOL> [ role_cls ] ) <EOL> def _add_username_to_organization ( organization , username ) : <EOL> return _try_function_org_username ( add_user_to_organization , <EOL> organization , <EOL> username ) <EOL> def _remove_username_to_organization ( organization , username ) : <EOL> return _try_function_org_username ( remove_user_from_organization , <EOL> organization , <EOL> username ) <EOL> class OrganizationProfileViewSet ( ObjectLookupMixin , ModelViewSet ) : <EOL> """<STR_LIT>""" <EOL> queryset = OrganizationProfile . objects . all ( ) <EOL> serializer_class = OrganizationSerializer <EOL> permission_classes = [ permissions . DjangoObjectPermissions ] <EOL> filter_backends = ( OrganizationPermissionFilter , ) <EOL> lookup_field = '<STR_LIT:user>' <EOL> @ detail_route ( methods = [ '<STR_LIT>' , '<STR_LIT:GET>' , '<STR_LIT:POST>' , '<STR_LIT>' ] ) <EOL> def members ( self , request , * args , ** kwargs ) : <EOL> organization = self . get_object ( ) <EOL> status_code = status . HTTP_200_OK <EOL> data = [ ] <EOL> username = request . data . get ( '<STR_LIT:username>' ) or request . query_params . get ( <EOL> '<STR_LIT:username>' ) <EOL> if request . method in [ '<STR_LIT>' , '<STR_LIT:POST>' , '<STR_LIT>' ] and not username : <EOL> status_code = status . HTTP_400_BAD_REQUEST <EOL> data = { '<STR_LIT:username>' : [ _ ( u"<STR_LIT>" ) ] } <EOL> elif request . method == '<STR_LIT:POST>' : <EOL> data , status_code = _add_username_to_organization ( <EOL> organization , username ) <EOL> elif request . method == '<STR_LIT>' : <EOL> role = request . data . get ( '<STR_LIT>' ) <EOL> role_cls = ROLES . get ( role ) <EOL> if not role or not role_cls : <EOL> status_code = status . HTTP_400_BAD_REQUEST <EOL> message = ( _ ( u"<STR_LIT>" % role ) if role <EOL> else _ ( u"<STR_LIT>" ) ) <EOL> data = { '<STR_LIT>' : [ message ] } <EOL> else : <EOL> _update_username_role ( organization , username , role_cls ) <EOL> elif request . method == '<STR_LIT>' : <EOL> data , status_code = _remove_username_to_organization ( <EOL> organization , username ) <EOL> if status_code in [ status . HTTP_200_OK , status . HTTP_201_CREATED ] : <EOL> members = get_organization_members ( organization ) <EOL> data = [ u . username for u in members ] <EOL> return Response ( data , status = status_code ) </s>

import json <EOL> from django . conf import settings <EOL> from django . core . management import BaseCommand <EOL> from django . utils import timezone <EOL> from django . utils . dateparse import parse_datetime <EOL> from django . utils . translation import ugettext_lazy <EOL> from onadata . apps . logger . models import Instance <EOL> class Command ( BaseCommand ) : <EOL> help = ugettext_lazy ( "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> def handle ( self , * args , ** kwargs ) : <EOL> Instance . objects . exclude ( <EOL> deleted_at = None , xform__downloadable = True ) . update ( deleted_at = None ) <EOL> query = '<STR_LIT>' '<STR_LIT>' <EOL> query = json . loads ( query )

xform_instances = settings . MONGO_DB . instances

import json <EOL> from django . conf import settings <EOL> from django . core . management import BaseCommand <EOL> from django . utils import timezone <EOL> from django . utils . dateparse import parse_datetime <EOL> from django . utils . translation import ugettext_lazy <EOL> from onadata . apps . logger . models import Instance <EOL> class Command ( BaseCommand ) : <EOL> help = ugettext_lazy ( "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> def handle ( self , * args , ** kwargs ) : <EOL> Instance . objects . exclude ( <EOL> deleted_at = None , xform__downloadable = True ) . update ( deleted_at = None ) <EOL> query = '<STR_LIT>' '<STR_LIT>' <EOL> query = json . loads ( query ) <EOL> xform_instances = settings . MONGO_DB . instances <EOL> cursor = xform_instances . find ( query ) <EOL> for record in cursor : <EOL> try : <EOL> i = Instance . objects . get ( <EOL> uuid = record [ "<STR_LIT>" ] , xform__downloadable = True ) <EOL> except Instance . DoesNotExist : <EOL> continue <EOL> else : <EOL> deleted_at = parse_datetime ( record [ "<STR_LIT>" ] ) <EOL> if not timezone . is_aware ( deleted_at ) : <EOL> deleted_at = timezone . make_aware ( <EOL> deleted_at , timezone . utc ) <EOL> i . set_deleted ( deleted_at ) </s>

import datetime <EOL> from south . db import db <EOL> from south . v2 import SchemaMigration <EOL> from django . db import models <EOL> class Migration ( SchemaMigration ) : <EOL> def forwards ( self , orm ) : <EOL> db . alter_column ( '<STR_LIT>' , '<STR_LIT>' , self . gf ( '<STR_LIT>' ) ( max_length = <NUM_LIT> ) ) <EOL> def backwards ( self , orm ) : <EOL> db . alter_column ( '<STR_LIT>' , '<STR_LIT>' , self . gf ( '<STR_LIT>' ) ( max_length = <NUM_LIT:32> ) ) <EOL> models = { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : "<STR_LIT>" , '<STR_LIT>' : '<STR_LIT:False>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT:email>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : "<STR_LIT>" , '<STR_LIT>' : '<STR_LIT:False>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) ,

'<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT>' } ) ,

import datetime <EOL> from south . db import db <EOL> from south . v2 import SchemaMigration <EOL> from django . db import models <EOL> class Migration ( SchemaMigration ) : <EOL> def forwards ( self , orm ) : <EOL> db . alter_column ( '<STR_LIT>' , '<STR_LIT>' , self . gf ( '<STR_LIT>' ) ( max_length = <NUM_LIT> ) ) <EOL> def backwards ( self , orm ) : <EOL> db . alter_column ( '<STR_LIT>' , '<STR_LIT>' , self . gf ( '<STR_LIT>' ) ( max_length = <NUM_LIT:32> ) ) <EOL> models = { <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : "<STR_LIT>" , '<STR_LIT>' : '<STR_LIT:False>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT:email>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : "<STR_LIT>" , '<STR_LIT>' : '<STR_LIT:False>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:password>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : "<STR_LIT>" , '<STR_LIT>' : '<STR_LIT:False>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:username>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:max_length>' : '<STR_LIT>' } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT:object_name>' : '<STR_LIT>' , '<STR_LIT>' : "<STR_LIT>" } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:to>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT:date>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:None>' , '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:status>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT:user>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:null>' : '<STR_LIT:True>' , '<STR_LIT:to>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:null>' : '<STR_LIT:True>' , '<STR_LIT:to>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:to>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:description>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT:title>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT:user>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:null>' : '<STR_LIT:True>' , '<STR_LIT:to>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' , '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { } ) <EOL> } <EOL> } <EOL> complete_apps = [ '<STR_LIT>' ] </s>

import datetime <EOL> from south . db import db <EOL> from south . v2 import SchemaMigration <EOL> from django . db import models <EOL> class Migration ( SchemaMigration ) : <EOL> def forwards ( self , orm ) : <EOL> db . add_column ( u'<STR_LIT>' , '<STR_LIT>' , <EOL> self . gf ( '<STR_LIT>' ) ( null = True ) , <EOL> keep_default = False ) <EOL> def backwards ( self , orm ) : <EOL> db . delete_column ( u'<STR_LIT>' , '<STR_LIT>' ) <EOL> models = { <EOL> u'<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : u"<STR_LIT>" , '<STR_LIT>' : '<STR_LIT:False>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) <EOL> } , <EOL> u'<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : u"<STR_LIT>" } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) <EOL> } , <EOL> u'<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT:email>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : u"<STR_LIT>" , '<STR_LIT>' : '<STR_LIT:False>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:password>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : u"<STR_LIT>" , '<STR_LIT>' : '<STR_LIT:False>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:username>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:max_length>' : '<STR_LIT>' } ) <EOL> } , <EOL> u'<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT:object_name>' : '<STR_LIT>' , '<STR_LIT>' : "<STR_LIT>" } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:to>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:None>' , '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:{}>' } ) , <EOL> '<STR_LIT:status>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT:user>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:null>' : '<STR_LIT:True>' , '<STR_LIT:to>' : u"<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:null>' : '<STR_LIT:True>' , '<STR_LIT:to>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:to>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:to>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:description>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:null>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) ,

'<STR_LIT:title>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) ,

import datetime <EOL> from south . db import db <EOL> from south . v2 import SchemaMigration <EOL> from django . db import models <EOL> class Migration ( SchemaMigration ) : <EOL> def forwards ( self , orm ) : <EOL> db . add_column ( u'<STR_LIT>' , '<STR_LIT>' , <EOL> self . gf ( '<STR_LIT>' ) ( null = True ) , <EOL> keep_default = False ) <EOL> def backwards ( self , orm ) : <EOL> db . delete_column ( u'<STR_LIT>' , '<STR_LIT>' ) <EOL> models = { <EOL> u'<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : u"<STR_LIT>" , '<STR_LIT>' : '<STR_LIT:False>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) <EOL> } , <EOL> u'<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : u"<STR_LIT>" } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) <EOL> } , <EOL> u'<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT:email>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : u"<STR_LIT>" , '<STR_LIT>' : '<STR_LIT:False>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:password>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : u"<STR_LIT>" , '<STR_LIT>' : '<STR_LIT:False>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:username>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:max_length>' : '<STR_LIT>' } ) <EOL> } , <EOL> u'<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT:object_name>' : '<STR_LIT>' , '<STR_LIT>' : "<STR_LIT>" } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:to>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:None>' , '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:{}>' } ) , <EOL> '<STR_LIT:status>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT:user>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:null>' : '<STR_LIT:True>' , '<STR_LIT:to>' : u"<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:null>' : '<STR_LIT:True>' , '<STR_LIT:to>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:to>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:to>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:description>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:null>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT:title>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT:user>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:null>' : '<STR_LIT:True>' , '<STR_LIT:to>' : u"<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' , '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:None>' , '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:None>' , '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:to>' : u"<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:null>' : '<STR_LIT:True>' , '<STR_LIT:to>' : "<STR_LIT>" } ) <EOL> } , <EOL> u'<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) <EOL> } , <EOL> u'<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:to>' : u"<STR_LIT>" } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:to>' : u"<STR_LIT>" } ) <EOL> } <EOL> } <EOL> complete_apps = [ '<STR_LIT>' ] </s>

from django . contrib . auth . models import User <EOL> from django . contrib . auth . backends import ModelBackend as DjangoModelBackend <EOL> class ModelBackend ( DjangoModelBackend ) :

def authenticate ( self , username = None , password = None ) :

from django . contrib . auth . models import User <EOL> from django . contrib . auth . backends import ModelBackend as DjangoModelBackend <EOL> class ModelBackend ( DjangoModelBackend ) : <EOL> def authenticate ( self , username = None , password = None ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> user = User . objects . get ( username__iexact = username ) <EOL> if user . check_password ( password ) : <EOL> return user <EOL> except User . DoesNotExist : <EOL> return None </s>

import datetime <EOL> from south . db import db <EOL> from south . v2 import SchemaMigration <EOL> from django . db import models <EOL> class Migration ( SchemaMigration ) : <EOL> def forwards ( self , orm ) : <EOL> db . add_column ( u'<STR_LIT>' , '<STR_LIT>' , <EOL> self . gf ( '<STR_LIT>' ) ( to = orm [ '<STR_LIT>' ] , null = True ) , <EOL> keep_default = False ) <EOL> def backwards ( self , orm ) : <EOL> db . delete_column ( u'<STR_LIT>' , '<STR_LIT>' ) <EOL> models = { <EOL> u'<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : u"<STR_LIT>" , '<STR_LIT>' : '<STR_LIT:False>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) <EOL> } , <EOL> u'<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : u"<STR_LIT>" } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) <EOL> } , <EOL> u'<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT:email>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : u"<STR_LIT>" , '<STR_LIT>' : '<STR_LIT:False>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:password>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : u"<STR_LIT>" , '<STR_LIT>' : '<STR_LIT:False>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:username>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:max_length>' : '<STR_LIT>' } ) <EOL> } , <EOL> u'<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT:object_name>' : '<STR_LIT>' , '<STR_LIT>' : "<STR_LIT>" } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) <EOL> } ,

'<STR_LIT>' : {

import datetime <EOL> from south . db import db <EOL> from south . v2 import SchemaMigration <EOL> from django . db import models <EOL> class Migration ( SchemaMigration ) : <EOL> def forwards ( self , orm ) : <EOL> db . add_column ( u'<STR_LIT>' , '<STR_LIT>' , <EOL> self . gf ( '<STR_LIT>' ) ( to = orm [ '<STR_LIT>' ] , null = True ) , <EOL> keep_default = False ) <EOL> def backwards ( self , orm ) : <EOL> db . delete_column ( u'<STR_LIT>' , '<STR_LIT>' ) <EOL> models = { <EOL> u'<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : u"<STR_LIT>" , '<STR_LIT>' : '<STR_LIT:False>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) <EOL> } , <EOL> u'<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : u"<STR_LIT>" } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) <EOL> } , <EOL> u'<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT:email>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : u"<STR_LIT>" , '<STR_LIT>' : '<STR_LIT:False>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:password>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : u"<STR_LIT>" , '<STR_LIT>' : '<STR_LIT:False>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:username>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:max_length>' : '<STR_LIT>' } ) <EOL> } , <EOL> u'<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT:object_name>' : '<STR_LIT>' , '<STR_LIT>' : "<STR_LIT>" } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' , '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : "<STR_LIT>" } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:primary_key>' : '<STR_LIT:True>' , '<STR_LIT:to>' : u"<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT:address>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:2>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:to>' : u"<STR_LIT>" , '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:description>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:name>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:user>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:to>' : u"<STR_LIT>" } ) <EOL> } , <EOL> '<STR_LIT>' : { <EOL> '<STR_LIT:Meta>' : { '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT>' : "<STR_LIT>" , '<STR_LIT:object_name>' : '<STR_LIT>' } , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT>' : '<STR_LIT:True>' , '<STR_LIT:blank>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT:description>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> u'<STR_LIT:id>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:primary_key>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : '<STR_LIT:False>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT:title>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT:user>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:related_name>' : "<STR_LIT>" , '<STR_LIT:null>' : '<STR_LIT:True>' , '<STR_LIT:to>' : u"<STR_LIT>" } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:default>' : "<STR_LIT>" , '<STR_LIT:max_length>' : '<STR_LIT>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { '<STR_LIT:max_length>' : '<STR_LIT:100>' , '<STR_LIT:null>' : '<STR_LIT:True>' } ) , <EOL> '<STR_LIT>' : ( '<STR_LIT>' , [ ] , { } ) <EOL> } <EOL> } <EOL> complete_apps = [ '<STR_LIT>' ] </s>

from subprocess import call

import unittest

from subprocess import call <EOL> import unittest <EOL> from django . test import TestCase <EOL> class TestStyle ( TestCase ) : <EOL> @ unittest . skip ( '<STR_LIT>' ) <EOL> def test_flake8 ( self ) : <EOL> result = call ( [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:.>' ] ) <EOL> self . assertEqual ( result , <NUM_LIT:0> , "<STR_LIT>" ) </s>

"""<STR_LIT>""" <EOL> import datetime <EOL> from dict2xml import dict2xml <EOL> from django . http import HttpResponse <EOL> from django . core . urlresolvers import reverse <EOL> from django . views . decorators . http import require_POST <EOL> from django . views . decorators . csrf import csrf_exempt <EOL> from django . utils . translation import ugettext as _ <EOL> from onadata . apps . sms_support . tools import SMS_API_ERROR , SMS_SUBMISSION_ACCEPTED <EOL> from onadata . apps . sms_support . parser import process_incoming_smses <EOL> def autodoc ( url_root , username , id_string ) : <EOL> urla = url_root + reverse ( '<STR_LIT>' , <EOL> kwargs = { '<STR_LIT:username>' : username , <EOL> '<STR_LIT>' : '<STR_LIT>' } ) <EOL> urlb = url_root + reverse ( '<STR_LIT>' , <EOL> kwargs = { '<STR_LIT:username>' : username , <EOL> '<STR_LIT>' : id_string , <EOL> '<STR_LIT>' : '<STR_LIT>' } ) <EOL> doc = ( u'<STR_LIT>' + <EOL> _ ( u"<STR_LIT>" ) <EOL> % { '<STR_LIT>' : u'<STR_LIT>' <EOL> u'<STR_LIT>' } <EOL> + u'<STR_LIT>' + <EOL> _ ( u"<STR_LIT>" ) <EOL> + u'<STR_LIT>' + <EOL> _ ( u"<STR_LIT>" <EOL> u"<STR_LIT>" ) <EOL> + u'<STR_LIT>' <EOL> + u'<STR_LIT>' <EOL> + u'<STR_LIT>' + <EOL> _ ( u"<STR_LIT>" <EOL> u"<STR_LIT>" ) <EOL> + u'<STR_LIT>' ) % { '<STR_LIT>' : urla , '<STR_LIT>' : urlb } <EOL> return doc <EOL> def get_response ( data ) : <EOL> xml_head = u'<STR_LIT>' <EOL> response_dict = { '<STR_LIT>' : { } } <EOL> message = data . get ( '<STR_LIT:text>' ) <EOL> if data . get ( '<STR_LIT:code>' ) == SMS_API_ERROR : <EOL> message = None <EOL> elif data . get ( '<STR_LIT:code>' ) != SMS_SUBMISSION_ACCEPTED : <EOL> message = _ ( u"<STR_LIT>" ) % message <EOL> if message : <EOL> messages = [ message , ] <EOL> sendouts = data . get ( '<STR_LIT>' , [ ] ) <EOL> if len ( sendouts ) : <EOL> messages += sendouts <EOL> response_dict . update ( { "<STR_LIT>" : { '<STR_LIT>' : messages } } ) <EOL> response = xml_head + dict2xml ( response_dict ) <EOL> return HttpResponse ( response , content_type = '<STR_LIT>' ) <EOL> @ require_POST <EOL> @ csrf_exempt <EOL> def import_submission ( request , username ) : <EOL> """<STR_LIT>""" <EOL> return import_submission_for_form ( request , username , None ) <EOL> @ require_POST <EOL> @ csrf_exempt <EOL> def import_submission_for_form ( request , username , id_string ) : <EOL> """<STR_LIT>""" <EOL> sms_identity = request . POST . get ( '<STR_LIT>' , '<STR_LIT>' ) . strip ( ) <EOL> sms_text = request . POST . get ( '<STR_LIT>' , '<STR_LIT>' ) . strip ( ) <EOL> now_timestamp = datetime . datetime . now ( ) . strftime ( '<STR_LIT:%s>' ) <EOL> sent_timestamp = request . POST . get ( '<STR_LIT>' , now_timestamp ) . strip ( ) <EOL> try : <EOL> sms_time = datetime . datetime . fromtimestamp ( float ( sent_timestamp ) ) <EOL> except ValueError : <EOL> sms_time = datetime . datetime . now ( ) <EOL> return process_message_for_twilio ( username = username , <EOL> sms_identity = sms_identity , <EOL> sms_text = sms_text , <EOL> sms_time = sms_time , <EOL> id_string = id_string ) <EOL> def process_message_for_twilio ( username ,

sms_identity , sms_text , sms_time , id_string ) :

"""<STR_LIT>""" <EOL> import datetime <EOL> from dict2xml import dict2xml <EOL> from django . http import HttpResponse <EOL> from django . core . urlresolvers import reverse <EOL> from django . views . decorators . http import require_POST <EOL> from django . views . decorators . csrf import csrf_exempt <EOL> from django . utils . translation import ugettext as _ <EOL> from onadata . apps . sms_support . tools import SMS_API_ERROR , SMS_SUBMISSION_ACCEPTED <EOL> from onadata . apps . sms_support . parser import process_incoming_smses <EOL> def autodoc ( url_root , username , id_string ) : <EOL> urla = url_root + reverse ( '<STR_LIT>' , <EOL> kwargs = { '<STR_LIT:username>' : username , <EOL> '<STR_LIT>' : '<STR_LIT>' } ) <EOL> urlb = url_root + reverse ( '<STR_LIT>' , <EOL> kwargs = { '<STR_LIT:username>' : username , <EOL> '<STR_LIT>' : id_string , <EOL> '<STR_LIT>' : '<STR_LIT>' } ) <EOL> doc = ( u'<STR_LIT>' + <EOL> _ ( u"<STR_LIT>" ) <EOL> % { '<STR_LIT>' : u'<STR_LIT>' <EOL> u'<STR_LIT>' } <EOL> + u'<STR_LIT>' + <EOL> _ ( u"<STR_LIT>" ) <EOL> + u'<STR_LIT>' + <EOL> _ ( u"<STR_LIT>" <EOL> u"<STR_LIT>" ) <EOL> + u'<STR_LIT>' <EOL> + u'<STR_LIT>' <EOL> + u'<STR_LIT>' + <EOL> _ ( u"<STR_LIT>" <EOL> u"<STR_LIT>" ) <EOL> + u'<STR_LIT>' ) % { '<STR_LIT>' : urla , '<STR_LIT>' : urlb } <EOL> return doc <EOL> def get_response ( data ) : <EOL> xml_head = u'<STR_LIT>' <EOL> response_dict = { '<STR_LIT>' : { } } <EOL> message = data . get ( '<STR_LIT:text>' ) <EOL> if data . get ( '<STR_LIT:code>' ) == SMS_API_ERROR : <EOL> message = None <EOL> elif data . get ( '<STR_LIT:code>' ) != SMS_SUBMISSION_ACCEPTED : <EOL> message = _ ( u"<STR_LIT>" ) % message <EOL> if message : <EOL> messages = [ message , ] <EOL> sendouts = data . get ( '<STR_LIT>' , [ ] ) <EOL> if len ( sendouts ) : <EOL> messages += sendouts <EOL> response_dict . update ( { "<STR_LIT>" : { '<STR_LIT>' : messages } } ) <EOL> response = xml_head + dict2xml ( response_dict ) <EOL> return HttpResponse ( response , content_type = '<STR_LIT>' ) <EOL> @ require_POST <EOL> @ csrf_exempt <EOL> def import_submission ( request , username ) : <EOL> """<STR_LIT>""" <EOL> return import_submission_for_form ( request , username , None ) <EOL> @ require_POST <EOL> @ csrf_exempt <EOL> def import_submission_for_form ( request , username , id_string ) : <EOL> """<STR_LIT>""" <EOL> sms_identity = request . POST . get ( '<STR_LIT>' , '<STR_LIT>' ) . strip ( ) <EOL> sms_text = request . POST . get ( '<STR_LIT>' , '<STR_LIT>' ) . strip ( ) <EOL> now_timestamp = datetime . datetime . now ( ) . strftime ( '<STR_LIT:%s>' ) <EOL> sent_timestamp = request . POST . get ( '<STR_LIT>' , now_timestamp ) . strip ( ) <EOL> try : <EOL> sms_time = datetime . datetime . fromtimestamp ( float ( sent_timestamp ) ) <EOL> except ValueError : <EOL> sms_time = datetime . datetime . now ( ) <EOL> return process_message_for_twilio ( username = username , <EOL> sms_identity = sms_identity , <EOL> sms_text = sms_text , <EOL> sms_time = sms_time , <EOL> id_string = id_string ) <EOL> def process_message_for_twilio ( username , <EOL> sms_identity , sms_text , sms_time , id_string ) : <EOL> """<STR_LIT>""" <EOL> if not sms_identity or not sms_text : <EOL> return get_response ( { '<STR_LIT:code>' : SMS_API_ERROR , <EOL> '<STR_LIT:text>' : _ ( u"<STR_LIT>" <EOL> u"<STR_LIT>" <EOL> u"<STR_LIT>" ) } ) <EOL> incomings = [ ( sms_identity , sms_text ) ] <EOL> response = process_incoming_smses ( username , incomings , id_string ) [ - <NUM_LIT:1> ] <EOL> return get_response ( response ) </s>

import base64 <EOL> import datetime <EOL> import json <EOL> import re <EOL> from bson import json_util , ObjectId <EOL> from celery import task <EOL> from dateutil import parser <EOL> from django . conf import settings <EOL> from django . db import models <EOL> from django . db . models . signals import post_save , pre_delete <EOL> from django . utils . translation import ugettext as _ <EOL> from onadata . apps . logger . models import Instance <EOL> from onadata . apps . logger . models import Note <EOL> from onadata . apps . restservice . utils import call_service <EOL> from onadata . libs . utils . common_tags import ID , UUID , ATTACHMENTS , GEOLOCATION , SUBMISSION_TIME , MONGO_STRFTIME , BAMBOO_DATASET_ID , DELETEDAT , TAGS , NOTES , SUBMITTED_BY <EOL> from onadata . libs . utils . decorators import apply_form_field_names <EOL> from onadata . libs . utils . model_tools import queryset_iterator <EOL> xform_instances = settings . MONGO_DB . instances <EOL> key_whitelist = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> DATETIME_FORMAT = '<STR_LIT>' <EOL> class ParseError ( Exception ) : <EOL> pass <EOL> def datetime_from_str ( text ) : <EOL> if text is None : <EOL> return None <EOL> dt = None <EOL> try : <EOL> dt = parser . parse ( text ) <EOL> except Exception : <EOL> return None <EOL> return dt <EOL> def dict_for_mongo ( d ) : <EOL> for key , value in d . items ( ) : <EOL> if type ( value ) == list : <EOL> value = [ dict_for_mongo ( e ) <EOL> if type ( e ) == dict else e for e in value ] <EOL> elif type ( value ) == dict : <EOL> value = dict_for_mongo ( value ) <EOL> elif key == '<STR_LIT>' : <EOL> try : <EOL> d [ key ] = int ( value ) <EOL> except ValueError : <EOL> pass <EOL> if _is_invalid_for_mongo ( key ) : <EOL> del d [ key ] <EOL> d [ _encode_for_mongo ( key ) ] = value <EOL> return d <EOL> def _encode_for_mongo ( key ) : <EOL> return reduce ( lambda s , c : re . sub ( c [ <NUM_LIT:0> ] , base64 . b64encode ( c [ <NUM_LIT:1> ] ) , s ) , <EOL> [ ( r'<STR_LIT>' , '<STR_LIT:$>' ) , ( r'<STR_LIT>' , '<STR_LIT:.>' ) ] , key ) <EOL> def _decode_from_mongo ( key ) : <EOL> re_dollar = re . compile ( r"<STR_LIT>" % base64 . b64encode ( "<STR_LIT:$>" ) ) <EOL> re_dot = re . compile ( r"<STR_LIT>" % base64 . b64encode ( "<STR_LIT:.>" ) ) <EOL> return reduce ( lambda s , c : c [ <NUM_LIT:0> ] . sub ( c [ <NUM_LIT:1> ] , s ) , <EOL> [ ( re_dollar , '<STR_LIT:$>' ) , ( re_dot , '<STR_LIT:.>' ) ] , key ) <EOL> def _is_invalid_for_mongo ( key ) : <EOL> return key not in key_whitelist and ( key . startswith ( '<STR_LIT:$>' ) or key . count ( '<STR_LIT:.>' ) > <NUM_LIT:0> ) <EOL> @ task <EOL> def update_mongo_instance ( record ) : <EOL> try : <EOL> return xform_instances . save ( record ) <EOL> except Exception : <EOL> pass <EOL> class ParsedInstance ( models . Model ) : <EOL> USERFORM_ID = u'<STR_LIT>' <EOL> STATUS = u'<STR_LIT>' <EOL> DEFAULT_LIMIT = <NUM_LIT> <EOL> DEFAULT_BATCHSIZE = <NUM_LIT:1000> <EOL> instance = models . OneToOneField ( Instance , related_name = "<STR_LIT>" ) <EOL> start_time = models . DateTimeField ( null = True ) <EOL> end_time = models . DateTimeField ( null = True ) <EOL> lat = models . FloatField ( null = True ) <EOL> lng = models . FloatField ( null = True ) <EOL> class Meta : <EOL> app_label = "<STR_LIT>" <EOL> @ classmethod <EOL> @ apply_form_field_names <EOL> def query_mongo ( cls , username , id_string , query , fields , sort , start = <NUM_LIT:0> , <EOL> limit = DEFAULT_LIMIT , count = False , hide_deleted = True ) : <EOL> fields_to_select = { cls . USERFORM_ID : <NUM_LIT:0> } <EOL> if isinstance ( query , basestring ) : <EOL> query = json . loads ( query , object_hook = json_util . object_hook ) <EOL> query = query if query else { } <EOL> query = dict_for_mongo ( query ) <EOL> query [ cls . USERFORM_ID ] = u'<STR_LIT>' % ( username , id_string ) <EOL> if '<STR_LIT>' in query and ObjectId . is_valid ( query [ '<STR_LIT>' ] ) : <EOL> query [ '<STR_LIT>' ] = ObjectId ( query [ '<STR_LIT>' ] ) <EOL> if hide_deleted : <EOL> query = { "<STR_LIT>" : [ query , { "<STR_LIT>" : None } ] } <EOL> if isinstance ( fields , basestring ) : <EOL> fields = json . loads ( fields , object_hook = json_util . object_hook ) <EOL> fields = fields if fields else [ ] <EOL> if type ( fields ) == list and len ( fields ) > <NUM_LIT:0> : <EOL> fields_to_select = dict ( <EOL> [ ( _encode_for_mongo ( field ) , <NUM_LIT:1> ) for field in fields ] ) <EOL> if isinstance ( sort , basestring ) : <EOL> sort = json . loads ( sort , object_hook = json_util . object_hook ) <EOL> sort = sort if sort else { } <EOL> cursor = xform_instances . find ( query , fields_to_select ) <EOL> if count : <EOL> return [ { "<STR_LIT:count>" : cursor . count ( ) } ] <EOL> if start < <NUM_LIT:0> or limit < <NUM_LIT:0> : <EOL> raise ValueError ( _ ( "<STR_LIT>" ) ) <EOL> cursor . skip ( start ) . limit ( limit ) <EOL> if type ( sort ) == dict and len ( sort ) == <NUM_LIT:1> : <EOL> sort_key = sort . keys ( ) [ <NUM_LIT:0> ] <EOL> sort_dir = int ( sort [ sort_key ] ) <EOL> cursor . sort ( _encode_for_mongo ( sort_key ) , sort_dir ) <EOL> cursor . batch_size = cls . DEFAULT_BATCHSIZE <EOL> return cursor <EOL> @ classmethod <EOL> @ apply_form_field_names <EOL> def mongo_aggregate ( cls , query , pipeline , hide_deleted = True ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( query , basestring ) : <EOL> query = json . loads ( <EOL> query , object_hook = json_util . object_hook ) if query else { } <EOL> if not ( isinstance ( pipeline , dict ) or isinstance ( pipeline , list ) ) : <EOL> raise Exception ( _ ( u"<STR_LIT>" % pipeline ) ) <EOL> if not isinstance ( query , dict ) : <EOL> raise Exception ( _ ( u"<STR_LIT>" % query ) ) <EOL> query = dict_for_mongo ( query ) <EOL> if hide_deleted : <EOL> deleted_at_query = { <EOL> "<STR_LIT>" : [ { "<STR_LIT>" : { "<STR_LIT>" : False } } , <EOL> { "<STR_LIT>" : None } ] } <EOL> query = { "<STR_LIT>" : [ query , deleted_at_query ] } <EOL> k = [ { '<STR_LIT>' : query } ] <EOL> if isinstance ( pipeline , list ) : <EOL> k . extend ( pipeline ) <EOL> else : <EOL> k . append ( pipeline ) <EOL> results = xform_instances . aggregate ( k ) <EOL> return results [ '<STR_LIT:result>' ] <EOL> @ classmethod <EOL> @ apply_form_field_names <EOL> def query_mongo_minimal ( <EOL> cls , query , fields , sort , start = <NUM_LIT:0> , limit = DEFAULT_LIMIT , <EOL> count = False , hide_deleted = True ) : <EOL> fields_to_select = { cls . USERFORM_ID : <NUM_LIT:0> } <EOL> query = json . loads ( <EOL> query , object_hook = json_util . object_hook ) if query else { } <EOL> query = dict_for_mongo ( query ) <EOL> if hide_deleted : <EOL> query = { "<STR_LIT>" : [ query , { "<STR_LIT>" : None } ] } <EOL> fields = json . loads ( <EOL> fields , object_hook = json_util . object_hook ) if fields else [ ] <EOL> if type ( fields ) == list and len ( fields ) > <NUM_LIT:0> : <EOL> fields_to_select = dict ( <EOL> [ ( _encode_for_mongo ( field ) , <NUM_LIT:1> ) for field in fields ] ) <EOL> sort = json . loads ( <EOL> sort , object_hook = json_util . object_hook ) if sort else { } <EOL> cursor = xform_instances . find ( query , fields_to_select ) <EOL> if count : <EOL> return [ { "<STR_LIT:count>" : cursor . count ( ) } ] <EOL> if start < <NUM_LIT:0> or limit < <NUM_LIT:0> : <EOL> raise ValueError ( _ ( "<STR_LIT>" ) ) <EOL> cursor . skip ( start ) . limit ( limit ) <EOL> if type ( sort ) == dict and len ( sort ) == <NUM_LIT:1> : <EOL> sort_key = sort . keys ( ) [ <NUM_LIT:0> ] <EOL> sort_dir = int ( sort [ sort_key ] ) <EOL> cursor . sort ( _encode_for_mongo ( sort_key ) , sort_dir ) <EOL> cursor . batch_size = cls . DEFAULT_BATCHSIZE <EOL> return cursor <EOL> def to_dict_for_mongo ( self ) : <EOL> d = self . to_dict ( ) <EOL> data = { <EOL> UUID : self . instance . uuid , <EOL> ID : self . instance . id , <EOL> BAMBOO_DATASET_ID : self . instance . xform . bamboo_dataset , <EOL> self . USERFORM_ID : u'<STR_LIT>' % ( <EOL> self . instance . xform . user . username , <EOL> self . instance . xform . id_string ) , <EOL> ATTACHMENTS : _get_attachments_from_instance ( self . instance ) , <EOL> self . STATUS : self . instance . status , <EOL> GEOLOCATION : [ self . lat , self . lng ] , <EOL> SUBMISSION_TIME : self . instance . date_created . strftime ( <EOL> MONGO_STRFTIME ) , <EOL> TAGS : list ( self . instance . tags . names ( ) ) , <EOL> NOTES : self . get_notes ( ) , <EOL> SUBMITTED_BY : self . instance . user . username <EOL> if self . instance . user else None <EOL> } <EOL> if isinstance ( self . instance . deleted_at , datetime . datetime ) : <EOL> data [ DELETEDAT ] = self . instance . deleted_at . strftime ( MONGO_STRFTIME ) <EOL> d . update ( data ) <EOL> return dict_for_mongo ( d ) <EOL> def update_mongo ( self , async = True ) : <EOL> d = self . to_dict_for_mongo ( ) <EOL> if async : <EOL> update_mongo_instance . apply_async ( ( ) , { "<STR_LIT>" : d } ) <EOL> else : <EOL> update_mongo_instance ( d ) <EOL> def to_dict ( self ) : <EOL> if not hasattr ( self , "<STR_LIT>" ) : <EOL> self . _dict_cache = self . instance . get_dict ( ) <EOL> return self . _dict_cache <EOL> @ classmethod <EOL> def dicts ( cls , xform ) : <EOL> qs = cls . objects . filter ( instance__xform = xform ) <EOL> for parsed_instance in queryset_iterator ( qs ) : <EOL> yield parsed_instance . to_dict ( ) <EOL> def _get_name_for_type ( self , type_value ) : <EOL> """<STR_LIT>""" <EOL> datadict = json . loads ( self . instance . xform . json ) <EOL> for item in datadict [ '<STR_LIT>' ] : <EOL> if type ( item ) == dict and item . get ( u'<STR_LIT:type>' ) == type_value : <EOL> return item [ '<STR_LIT:name>' ] <EOL> def get_data_dictionary ( self ) : <EOL> from onadata . apps . viewer . models . data_dictionary import DataDictionary <EOL> return DataDictionary . objects . get ( <EOL> user = self . instance . xform . user , <EOL> id_string = self . instance . xform . id_string <EOL> ) <EOL> data_dictionary = property ( get_data_dictionary ) <EOL> def _set_geopoint ( self ) : <EOL> if self . instance . point : <EOL> self . lat = self . instance . point . y <EOL> self . lng = self . instance . point . x <EOL> def save ( self , async = False , * args , ** kwargs ) : <EOL> self . start_time = None <EOL> self . end_time = None <EOL> self . _set_geopoint ( ) <EOL> super ( ParsedInstance , self ) . save ( * args , ** kwargs ) <EOL> self . update_mongo ( async ) <EOL> def add_note ( self , note ) : <EOL> note = Note ( instance = self . instance , note = note ) <EOL> note . save ( ) <EOL> def remove_note ( self , pk ) : <EOL> note = self . instance . notes . get ( pk = pk ) <EOL> note . delete ( ) <EOL> def get_notes ( self ) : <EOL> notes = [ ] <EOL> note_qs = self . instance . notes . values ( <EOL> '<STR_LIT:id>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> for note in note_qs : <EOL> note [ '<STR_LIT>' ] = note [ '<STR_LIT>' ] . strftime ( MONGO_STRFTIME ) <EOL> note [ '<STR_LIT>' ] = note [ '<STR_LIT>' ] . strftime ( MONGO_STRFTIME ) <EOL> notes . append ( note ) <EOL> return notes <EOL> def _get_attachments_from_instance ( instance ) : <EOL> attachments = [ ] <EOL> for a in instance . attachments . all ( ) : <EOL> attachment = dict ( )

attachment [ '<STR_LIT>' ] = a . media_file . url

import base64 <EOL> import datetime <EOL> import json <EOL> import re <EOL> from bson import json_util , ObjectId <EOL> from celery import task <EOL> from dateutil import parser <EOL> from django . conf import settings <EOL> from django . db import models <EOL> from django . db . models . signals import post_save , pre_delete <EOL> from django . utils . translation import ugettext as _ <EOL> from onadata . apps . logger . models import Instance <EOL> from onadata . apps . logger . models import Note <EOL> from onadata . apps . restservice . utils import call_service <EOL> from onadata . libs . utils . common_tags import ID , UUID , ATTACHMENTS , GEOLOCATION , SUBMISSION_TIME , MONGO_STRFTIME , BAMBOO_DATASET_ID , DELETEDAT , TAGS , NOTES , SUBMITTED_BY <EOL> from onadata . libs . utils . decorators import apply_form_field_names <EOL> from onadata . libs . utils . model_tools import queryset_iterator <EOL> xform_instances = settings . MONGO_DB . instances <EOL> key_whitelist = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> DATETIME_FORMAT = '<STR_LIT>' <EOL> class ParseError ( Exception ) : <EOL> pass <EOL> def datetime_from_str ( text ) : <EOL> if text is None : <EOL> return None <EOL> dt = None <EOL> try : <EOL> dt = parser . parse ( text ) <EOL> except Exception : <EOL> return None <EOL> return dt <EOL> def dict_for_mongo ( d ) : <EOL> for key , value in d . items ( ) : <EOL> if type ( value ) == list : <EOL> value = [ dict_for_mongo ( e ) <EOL> if type ( e ) == dict else e for e in value ] <EOL> elif type ( value ) == dict : <EOL> value = dict_for_mongo ( value ) <EOL> elif key == '<STR_LIT>' : <EOL> try : <EOL> d [ key ] = int ( value ) <EOL> except ValueError : <EOL> pass <EOL> if _is_invalid_for_mongo ( key ) : <EOL> del d [ key ] <EOL> d [ _encode_for_mongo ( key ) ] = value <EOL> return d <EOL> def _encode_for_mongo ( key ) : <EOL> return reduce ( lambda s , c : re . sub ( c [ <NUM_LIT:0> ] , base64 . b64encode ( c [ <NUM_LIT:1> ] ) , s ) , <EOL> [ ( r'<STR_LIT>' , '<STR_LIT:$>' ) , ( r'<STR_LIT>' , '<STR_LIT:.>' ) ] , key ) <EOL> def _decode_from_mongo ( key ) : <EOL> re_dollar = re . compile ( r"<STR_LIT>" % base64 . b64encode ( "<STR_LIT:$>" ) ) <EOL> re_dot = re . compile ( r"<STR_LIT>" % base64 . b64encode ( "<STR_LIT:.>" ) ) <EOL> return reduce ( lambda s , c : c [ <NUM_LIT:0> ] . sub ( c [ <NUM_LIT:1> ] , s ) , <EOL> [ ( re_dollar , '<STR_LIT:$>' ) , ( re_dot , '<STR_LIT:.>' ) ] , key ) <EOL> def _is_invalid_for_mongo ( key ) : <EOL> return key not in key_whitelist and ( key . startswith ( '<STR_LIT:$>' ) or key . count ( '<STR_LIT:.>' ) > <NUM_LIT:0> ) <EOL> @ task <EOL> def update_mongo_instance ( record ) : <EOL> try : <EOL> return xform_instances . save ( record ) <EOL> except Exception : <EOL> pass <EOL> class ParsedInstance ( models . Model ) : <EOL> USERFORM_ID = u'<STR_LIT>' <EOL> STATUS = u'<STR_LIT>' <EOL> DEFAULT_LIMIT = <NUM_LIT> <EOL> DEFAULT_BATCHSIZE = <NUM_LIT:1000> <EOL> instance = models . OneToOneField ( Instance , related_name = "<STR_LIT>" ) <EOL> start_time = models . DateTimeField ( null = True ) <EOL> end_time = models . DateTimeField ( null = True ) <EOL> lat = models . FloatField ( null = True ) <EOL> lng = models . FloatField ( null = True ) <EOL> class Meta : <EOL> app_label = "<STR_LIT>" <EOL> @ classmethod <EOL> @ apply_form_field_names <EOL> def query_mongo ( cls , username , id_string , query , fields , sort , start = <NUM_LIT:0> , <EOL> limit = DEFAULT_LIMIT , count = False , hide_deleted = True ) : <EOL> fields_to_select = { cls . USERFORM_ID : <NUM_LIT:0> } <EOL> if isinstance ( query , basestring ) : <EOL> query = json . loads ( query , object_hook = json_util . object_hook ) <EOL> query = query if query else { } <EOL> query = dict_for_mongo ( query ) <EOL> query [ cls . USERFORM_ID ] = u'<STR_LIT>' % ( username , id_string ) <EOL> if '<STR_LIT>' in query and ObjectId . is_valid ( query [ '<STR_LIT>' ] ) : <EOL> query [ '<STR_LIT>' ] = ObjectId ( query [ '<STR_LIT>' ] ) <EOL> if hide_deleted : <EOL> query = { "<STR_LIT>" : [ query , { "<STR_LIT>" : None } ] } <EOL> if isinstance ( fields , basestring ) : <EOL> fields = json . loads ( fields , object_hook = json_util . object_hook ) <EOL> fields = fields if fields else [ ] <EOL> if type ( fields ) == list and len ( fields ) > <NUM_LIT:0> : <EOL> fields_to_select = dict ( <EOL> [ ( _encode_for_mongo ( field ) , <NUM_LIT:1> ) for field in fields ] ) <EOL> if isinstance ( sort , basestring ) : <EOL> sort = json . loads ( sort , object_hook = json_util . object_hook ) <EOL> sort = sort if sort else { } <EOL> cursor = xform_instances . find ( query , fields_to_select ) <EOL> if count : <EOL> return [ { "<STR_LIT:count>" : cursor . count ( ) } ] <EOL> if start < <NUM_LIT:0> or limit < <NUM_LIT:0> : <EOL> raise ValueError ( _ ( "<STR_LIT>" ) ) <EOL> cursor . skip ( start ) . limit ( limit ) <EOL> if type ( sort ) == dict and len ( sort ) == <NUM_LIT:1> : <EOL> sort_key = sort . keys ( ) [ <NUM_LIT:0> ] <EOL> sort_dir = int ( sort [ sort_key ] ) <EOL> cursor . sort ( _encode_for_mongo ( sort_key ) , sort_dir ) <EOL> cursor . batch_size = cls . DEFAULT_BATCHSIZE <EOL> return cursor <EOL> @ classmethod <EOL> @ apply_form_field_names <EOL> def mongo_aggregate ( cls , query , pipeline , hide_deleted = True ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( query , basestring ) : <EOL> query = json . loads ( <EOL> query , object_hook = json_util . object_hook ) if query else { } <EOL> if not ( isinstance ( pipeline , dict ) or isinstance ( pipeline , list ) ) : <EOL> raise Exception ( _ ( u"<STR_LIT>" % pipeline ) ) <EOL> if not isinstance ( query , dict ) : <EOL> raise Exception ( _ ( u"<STR_LIT>" % query ) ) <EOL> query = dict_for_mongo ( query ) <EOL> if hide_deleted : <EOL> deleted_at_query = { <EOL> "<STR_LIT>" : [ { "<STR_LIT>" : { "<STR_LIT>" : False } } , <EOL> { "<STR_LIT>" : None } ] } <EOL> query = { "<STR_LIT>" : [ query , deleted_at_query ] } <EOL> k = [ { '<STR_LIT>' : query } ] <EOL> if isinstance ( pipeline , list ) : <EOL> k . extend ( pipeline ) <EOL> else : <EOL> k . append ( pipeline ) <EOL> results = xform_instances . aggregate ( k ) <EOL> return results [ '<STR_LIT:result>' ] <EOL> @ classmethod <EOL> @ apply_form_field_names <EOL> def query_mongo_minimal ( <EOL> cls , query , fields , sort , start = <NUM_LIT:0> , limit = DEFAULT_LIMIT , <EOL> count = False , hide_deleted = True ) : <EOL> fields_to_select = { cls . USERFORM_ID : <NUM_LIT:0> } <EOL> query = json . loads ( <EOL> query , object_hook = json_util . object_hook ) if query else { } <EOL> query = dict_for_mongo ( query ) <EOL> if hide_deleted : <EOL> query = { "<STR_LIT>" : [ query , { "<STR_LIT>" : None } ] } <EOL> fields = json . loads ( <EOL> fields , object_hook = json_util . object_hook ) if fields else [ ] <EOL> if type ( fields ) == list and len ( fields ) > <NUM_LIT:0> : <EOL> fields_to_select = dict ( <EOL> [ ( _encode_for_mongo ( field ) , <NUM_LIT:1> ) for field in fields ] ) <EOL> sort = json . loads ( <EOL> sort , object_hook = json_util . object_hook ) if sort else { } <EOL> cursor = xform_instances . find ( query , fields_to_select ) <EOL> if count : <EOL> return [ { "<STR_LIT:count>" : cursor . count ( ) } ] <EOL> if start < <NUM_LIT:0> or limit < <NUM_LIT:0> : <EOL> raise ValueError ( _ ( "<STR_LIT>" ) ) <EOL> cursor . skip ( start ) . limit ( limit ) <EOL> if type ( sort ) == dict and len ( sort ) == <NUM_LIT:1> : <EOL> sort_key = sort . keys ( ) [ <NUM_LIT:0> ] <EOL> sort_dir = int ( sort [ sort_key ] ) <EOL> cursor . sort ( _encode_for_mongo ( sort_key ) , sort_dir ) <EOL> cursor . batch_size = cls . DEFAULT_BATCHSIZE <EOL> return cursor <EOL> def to_dict_for_mongo ( self ) : <EOL> d = self . to_dict ( ) <EOL> data = { <EOL> UUID : self . instance . uuid , <EOL> ID : self . instance . id , <EOL> BAMBOO_DATASET_ID : self . instance . xform . bamboo_dataset , <EOL> self . USERFORM_ID : u'<STR_LIT>' % ( <EOL> self . instance . xform . user . username , <EOL> self . instance . xform . id_string ) , <EOL> ATTACHMENTS : _get_attachments_from_instance ( self . instance ) , <EOL> self . STATUS : self . instance . status , <EOL> GEOLOCATION : [ self . lat , self . lng ] , <EOL> SUBMISSION_TIME : self . instance . date_created . strftime ( <EOL> MONGO_STRFTIME ) , <EOL> TAGS : list ( self . instance . tags . names ( ) ) , <EOL> NOTES : self . get_notes ( ) , <EOL> SUBMITTED_BY : self . instance . user . username <EOL> if self . instance . user else None <EOL> } <EOL> if isinstance ( self . instance . deleted_at , datetime . datetime ) : <EOL> data [ DELETEDAT ] = self . instance . deleted_at . strftime ( MONGO_STRFTIME ) <EOL> d . update ( data ) <EOL> return dict_for_mongo ( d ) <EOL> def update_mongo ( self , async = True ) : <EOL> d = self . to_dict_for_mongo ( ) <EOL> if async : <EOL> update_mongo_instance . apply_async ( ( ) , { "<STR_LIT>" : d } ) <EOL> else : <EOL> update_mongo_instance ( d ) <EOL> def to_dict ( self ) : <EOL> if not hasattr ( self , "<STR_LIT>" ) : <EOL> self . _dict_cache = self . instance . get_dict ( ) <EOL> return self . _dict_cache <EOL> @ classmethod <EOL> def dicts ( cls , xform ) : <EOL> qs = cls . objects . filter ( instance__xform = xform ) <EOL> for parsed_instance in queryset_iterator ( qs ) : <EOL> yield parsed_instance . to_dict ( ) <EOL> def _get_name_for_type ( self , type_value ) : <EOL> """<STR_LIT>""" <EOL> datadict = json . loads ( self . instance . xform . json ) <EOL> for item in datadict [ '<STR_LIT>' ] : <EOL> if type ( item ) == dict and item . get ( u'<STR_LIT:type>' ) == type_value : <EOL> return item [ '<STR_LIT:name>' ] <EOL> def get_data_dictionary ( self ) : <EOL> from onadata . apps . viewer . models . data_dictionary import DataDictionary <EOL> return DataDictionary . objects . get ( <EOL> user = self . instance . xform . user , <EOL> id_string = self . instance . xform . id_string <EOL> ) <EOL> data_dictionary = property ( get_data_dictionary ) <EOL> def _set_geopoint ( self ) : <EOL> if self . instance . point : <EOL> self . lat = self . instance . point . y <EOL> self . lng = self . instance . point . x <EOL> def save ( self , async = False , * args , ** kwargs ) : <EOL> self . start_time = None <EOL> self . end_time = None <EOL> self . _set_geopoint ( ) <EOL> super ( ParsedInstance , self ) . save ( * args , ** kwargs ) <EOL> self . update_mongo ( async ) <EOL> def add_note ( self , note ) : <EOL> note = Note ( instance = self . instance , note = note ) <EOL> note . save ( ) <EOL> def remove_note ( self , pk ) : <EOL> note = self . instance . notes . get ( pk = pk ) <EOL> note . delete ( ) <EOL> def get_notes ( self ) : <EOL> notes = [ ] <EOL> note_qs = self . instance . notes . values ( <EOL> '<STR_LIT:id>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> for note in note_qs : <EOL> note [ '<STR_LIT>' ] = note [ '<STR_LIT>' ] . strftime ( MONGO_STRFTIME ) <EOL> note [ '<STR_LIT>' ] = note [ '<STR_LIT>' ] . strftime ( MONGO_STRFTIME ) <EOL> notes . append ( note ) <EOL> return notes <EOL> def _get_attachments_from_instance ( instance ) : <EOL> attachments = [ ] <EOL> for a in instance . attachments . all ( ) : <EOL> attachment = dict ( ) <EOL> attachment [ '<STR_LIT>' ] = a . media_file . url <EOL> attachment [ '<STR_LIT>' ] = a . mimetype <EOL> attachment [ '<STR_LIT:filename>' ] = a . media_file . name <EOL> attachment [ '<STR_LIT>' ] = a . instance . pk <EOL> attachment [ '<STR_LIT>' ] = instance . xform . id <EOL> attachment [ '<STR_LIT:id>' ] = a . id <EOL> attachments . append ( attachment ) <EOL> return attachments <EOL> def _remove_from_mongo ( sender , ** kwargs ) : <EOL> instance_id = kwargs . get ( '<STR_LIT>' ) . instance . id <EOL> xform_instances . remove ( instance_id ) <EOL> pre_delete . connect ( _remove_from_mongo , sender = ParsedInstance ) <EOL> def rest_service_form_submission ( sender , ** kwargs ) : <EOL> parsed_instance = kwargs . get ( '<STR_LIT>' ) <EOL> created = kwargs . get ( '<STR_LIT>' ) <EOL> if created : <EOL> call_service ( parsed_instance ) <EOL> post_save . connect ( rest_service_form_submission , sender = ParsedInstance ) </s>

from rest_framework import serializers , mixins <EOL> from rest_framework . exceptions import ParseError <EOL> from rest_framework . generics import get_object_or_404 <EOL> class ObjectLookupMixin ( object ) : <EOL> def get_object ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . kwargs . get ( self . lookup_field , None ) is None : <EOL> raise ParseError ( <EOL> '<STR_LIT>' % self . lookup_field <EOL> ) <EOL> queryset = self . filter_queryset ( self . get_queryset ( ) ) <EOL> filter_kwargs = { } <EOL> serializer = self . get_serializer ( ) <EOL> lookup_field = self . lookup_field <EOL> if self . lookup_field in serializer . get_fields ( ) : <EOL> k = serializer . get_fields ( ) [ self . lookup_field ] <EOL> if isinstance ( k , serializers . HyperlinkedRelatedField ) : <EOL> lookup_field = '<STR_LIT>' % ( self . lookup_field , k . lookup_field ) <EOL> filter_kwargs [ lookup_field ] = self . kwargs [ self . lookup_field ] <EOL> obj = get_object_or_404 ( queryset , ** filter_kwargs ) <EOL> self . check_object_permissions ( self . request , obj ) <EOL> return obj <EOL> def pre_save ( self , obj ) : <EOL> """<STR_LIT>""" <EOL> lookup = self . kwargs . get ( self . lookup_field , None ) <EOL> pk = self . kwargs . get ( self . pk_url_kwarg , None ) <EOL> slug = self . kwargs . get ( self . slug_url_kwarg , None ) <EOL> slug_field = slug and self . slug_field or None <EOL> if lookup : <EOL> serializer = self . get_serializer ( ) <EOL> k = serializer . get_fields ( ) [ self . lookup_field ] <EOL> queryset = self . get_queryset ( )

queryset = self . filter_queryset ( queryset )

from rest_framework import serializers , mixins <EOL> from rest_framework . exceptions import ParseError <EOL> from rest_framework . generics import get_object_or_404 <EOL> class ObjectLookupMixin ( object ) : <EOL> def get_object ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . kwargs . get ( self . lookup_field , None ) is None : <EOL> raise ParseError ( <EOL> '<STR_LIT>' % self . lookup_field <EOL> ) <EOL> queryset = self . filter_queryset ( self . get_queryset ( ) ) <EOL> filter_kwargs = { } <EOL> serializer = self . get_serializer ( ) <EOL> lookup_field = self . lookup_field <EOL> if self . lookup_field in serializer . get_fields ( ) : <EOL> k = serializer . get_fields ( ) [ self . lookup_field ] <EOL> if isinstance ( k , serializers . HyperlinkedRelatedField ) : <EOL> lookup_field = '<STR_LIT>' % ( self . lookup_field , k . lookup_field ) <EOL> filter_kwargs [ lookup_field ] = self . kwargs [ self . lookup_field ] <EOL> obj = get_object_or_404 ( queryset , ** filter_kwargs ) <EOL> self . check_object_permissions ( self . request , obj ) <EOL> return obj <EOL> def pre_save ( self , obj ) : <EOL> """<STR_LIT>""" <EOL> lookup = self . kwargs . get ( self . lookup_field , None ) <EOL> pk = self . kwargs . get ( self . pk_url_kwarg , None ) <EOL> slug = self . kwargs . get ( self . slug_url_kwarg , None ) <EOL> slug_field = slug and self . slug_field or None <EOL> if lookup : <EOL> serializer = self . get_serializer ( ) <EOL> k = serializer . get_fields ( ) [ self . lookup_field ] <EOL> queryset = self . get_queryset ( ) <EOL> queryset = self . filter_queryset ( queryset ) <EOL> if isinstance ( k , serializers . HyperlinkedRelatedField ) : <EOL> filter = { } <EOL> lookup_field = '<STR_LIT>' % ( self . lookup_field , k . lookup_field ) <EOL> filter [ lookup_field ] = lookup <EOL> k_obj = get_object_or_404 ( queryset , ** filter ) <EOL> lookup = getattr ( k_obj , self . lookup_field ) <EOL> setattr ( obj , self . lookup_field , lookup ) <EOL> if pk : <EOL> setattr ( obj , '<STR_LIT>' , pk ) <EOL> if slug : <EOL> setattr ( obj , slug_field , slug ) <EOL> if hasattr ( obj , '<STR_LIT>' ) : <EOL> exclude = mixins . _get_validation_exclusions ( <EOL> obj , pk , slug_field , self . lookup_field ) <EOL> obj . full_clean ( exclude ) </s>

from django . utils . translation import ugettext as _ <EOL> from rest_framework import exceptions <EOL> from rest_framework import serializers <EOL> from onadata . apps . api . tools import ( <EOL> get_all_stats , <EOL> get_mode_for_numeric_fields_in_form , <EOL> get_mean_for_numeric_fields_in_form , <EOL> get_median_for_numeric_fields_in_form , get_min_max_range <EOL> ) <EOL> from onadata . apps . logger . models . xform import XForm <EOL> from onadata . libs . data . query import get_form_submissions_grouped_by_field <EOL> SELECT_FIELDS = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> STATS_FUNCTIONS = { <EOL> '<STR_LIT>' : get_mean_for_numeric_fields_in_form , <EOL> '<STR_LIT>' : get_median_for_numeric_fields_in_form , <EOL> '<STR_LIT>' : get_mode_for_numeric_fields_in_form , <EOL> '<STR_LIT>' : get_min_max_range <EOL> } <EOL> class SubmissionStatsSerializer ( serializers . HyperlinkedModelSerializer ) : <EOL> url = serializers . HyperlinkedIdentityField ( <EOL> view_name = '<STR_LIT>' , lookup_field = '<STR_LIT>' ) <EOL> class Meta : <EOL> model = XForm <EOL> fields = ( '<STR_LIT:id>' , '<STR_LIT>' , '<STR_LIT:url>' ) <EOL> lookup_field = '<STR_LIT>' <EOL> class SubmissionStatsInstanceSerializer ( serializers . Serializer ) : <EOL> @ property <EOL> def data ( self ) : <EOL> return super ( serializers . Serializer , self ) . data <EOL> def to_representation ( self , obj ) : <EOL> if obj is None : <EOL> return super ( SubmissionStatsInstanceSerializer , self ) . to_representation ( obj ) <EOL> request = self . context . get ( '<STR_LIT>' ) <EOL> field = request . query_params . get ( '<STR_LIT>' ) <EOL> name = request . query_params . get ( '<STR_LIT:name>' , field ) <EOL> if field is None : <EOL> raise exceptions . ParseError ( _ ( u"<STR_LIT>" <EOL> u"<STR_LIT>" ) ) <EOL> try : <EOL> data = get_form_submissions_grouped_by_field ( <EOL> obj , field , name ) <EOL> except ValueError as e : <EOL> raise exceptions . ParseError ( detail = e . message ) <EOL> else : <EOL> if data : <EOL> dd = obj . data_dictionary ( ) <EOL> element = dd . get_survey_element ( field ) <EOL> if element and element . type in SELECT_FIELDS : <EOL> for record in data : <EOL> label = dd . get_choice_label ( element , record [ name ] ) <EOL> record [ name ] = label <EOL> return data <EOL> class StatsSerializer ( serializers . HyperlinkedModelSerializer ) : <EOL> url = serializers . HyperlinkedIdentityField (

view_name = '<STR_LIT>' , lookup_field = '<STR_LIT>' )

from django . utils . translation import ugettext as _ <EOL> from rest_framework import exceptions <EOL> from rest_framework import serializers <EOL> from onadata . apps . api . tools import ( <EOL> get_all_stats , <EOL> get_mode_for_numeric_fields_in_form , <EOL> get_mean_for_numeric_fields_in_form , <EOL> get_median_for_numeric_fields_in_form , get_min_max_range <EOL> ) <EOL> from onadata . apps . logger . models . xform import XForm <EOL> from onadata . libs . data . query import get_form_submissions_grouped_by_field <EOL> SELECT_FIELDS = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> STATS_FUNCTIONS = { <EOL> '<STR_LIT>' : get_mean_for_numeric_fields_in_form , <EOL> '<STR_LIT>' : get_median_for_numeric_fields_in_form , <EOL> '<STR_LIT>' : get_mode_for_numeric_fields_in_form , <EOL> '<STR_LIT>' : get_min_max_range <EOL> } <EOL> class SubmissionStatsSerializer ( serializers . HyperlinkedModelSerializer ) : <EOL> url = serializers . HyperlinkedIdentityField ( <EOL> view_name = '<STR_LIT>' , lookup_field = '<STR_LIT>' ) <EOL> class Meta : <EOL> model = XForm <EOL> fields = ( '<STR_LIT:id>' , '<STR_LIT>' , '<STR_LIT:url>' ) <EOL> lookup_field = '<STR_LIT>' <EOL> class SubmissionStatsInstanceSerializer ( serializers . Serializer ) : <EOL> @ property <EOL> def data ( self ) : <EOL> return super ( serializers . Serializer , self ) . data <EOL> def to_representation ( self , obj ) : <EOL> if obj is None : <EOL> return super ( SubmissionStatsInstanceSerializer , self ) . to_representation ( obj ) <EOL> request = self . context . get ( '<STR_LIT>' ) <EOL> field = request . query_params . get ( '<STR_LIT>' ) <EOL> name = request . query_params . get ( '<STR_LIT:name>' , field ) <EOL> if field is None : <EOL> raise exceptions . ParseError ( _ ( u"<STR_LIT>" <EOL> u"<STR_LIT>" ) ) <EOL> try : <EOL> data = get_form_submissions_grouped_by_field ( <EOL> obj , field , name ) <EOL> except ValueError as e : <EOL> raise exceptions . ParseError ( detail = e . message ) <EOL> else : <EOL> if data : <EOL> dd = obj . data_dictionary ( ) <EOL> element = dd . get_survey_element ( field ) <EOL> if element and element . type in SELECT_FIELDS : <EOL> for record in data : <EOL> label = dd . get_choice_label ( element , record [ name ] ) <EOL> record [ name ] = label <EOL> return data <EOL> class StatsSerializer ( serializers . HyperlinkedModelSerializer ) : <EOL> url = serializers . HyperlinkedIdentityField ( <EOL> view_name = '<STR_LIT>' , lookup_field = '<STR_LIT>' ) <EOL> class Meta : <EOL> model = XForm <EOL> fields = ( '<STR_LIT:id>' , '<STR_LIT>' , '<STR_LIT:url>' ) <EOL> lookup_field = '<STR_LIT>' <EOL> class StatsInstanceSerializer ( serializers . Serializer ) : <EOL> def to_representation ( self , obj ) : <EOL> if obj is None : <EOL> return super ( StatsInstanceSerializer , self ) . to_representation ( obj ) <EOL> request = self . context . get ( '<STR_LIT>' ) <EOL> method = request . query_params . get ( '<STR_LIT>' , None ) <EOL> field = request . query_params . get ( '<STR_LIT>' , None ) <EOL> if field and field not in obj . data_dictionary ( ) . get_keys ( ) : <EOL> raise exceptions . ParseError ( detail = _ ( "<STR_LIT>" ) ) <EOL> stats_function = STATS_FUNCTIONS . get ( method and method . lower ( ) , <EOL> get_all_stats ) <EOL> try : <EOL> data = stats_function ( obj , field ) <EOL> except ValueError as e : <EOL> raise exceptions . ParseError ( detail = e . message ) <EOL> return data </s>

import logging <EOL> from datetime import datetime <EOL> from onadata . libs . utils . viewer_tools import get_client_ip <EOL> class Enum ( object ) : <EOL> __name__ = "<STR_LIT>" <EOL> def __init__ ( self , ** enums ) : <EOL> self . enums = enums <EOL> def __getattr__ ( self , item ) : <EOL> return self . enums [ item ] <EOL> def __getitem__ ( self , item ) : <EOL> return self . __getattr__ ( item ) <EOL> def __iter__ ( self ) : <EOL> return self . enums . itervalues ( ) <EOL> Actions = Enum ( <EOL> PROFILE_ACCESSED = "<STR_LIT>" , <EOL> PUBLIC_PROFILE_ACCESSED = "<STR_LIT>" , <EOL> PROFILE_SETTINGS_UPDATED = "<STR_LIT>" , <EOL> USER_LOGIN = "<STR_LIT>" , <EOL> USER_LOGOUT = "<STR_LIT>" , <EOL> USER_BULK_SUBMISSION = "<STR_LIT>" , <EOL> USER_FORMLIST_REQUESTED = "<STR_LIT>" , <EOL> FORM_ACCESSED = "<STR_LIT>" , <EOL> FORM_PUBLISHED = "<STR_LIT>" , <EOL> FORM_UPDATED = "<STR_LIT>" , <EOL> FORM_XLS_DOWNLOADED = "<STR_LIT>" , <EOL> FORM_XLS_UPDATED = "<STR_LIT>" , <EOL> FORM_DELETED = "<STR_LIT>" , <EOL> FORM_CLONED = "<STR_LIT>" , <EOL> FORM_XML_DOWNLOADED = "<STR_LIT>" , <EOL> FORM_JSON_DOWNLOADED = "<STR_LIT>" , <EOL> FORM_PERMISSIONS_UPDATED = "<STR_LIT>" , <EOL> FORM_ENTER_DATA_REQUESTED = "<STR_LIT>" , <EOL> FORM_MAP_VIEWED = "<STR_LIT>" , <EOL> FORM_DATA_VIEWED = "<STR_LIT>" , <EOL> EXPORT_CREATED = "<STR_LIT>" , <EOL> EXPORT_DOWNLOADED = "<STR_LIT>" , <EOL> EXPORT_DELETED = "<STR_LIT>" , <EOL> EXPORT_LIST_REQUESTED = "<STR_LIT>" , <EOL> SUBMISSION_CREATED = "<STR_LIT>" , <EOL> SUBMISSION_UPDATED = "<STR_LIT>" , <EOL> SUBMISSION_DELETED = "<STR_LIT>" , <EOL> SUBMISSION_ACCESSED = "<STR_LIT>" , <EOL> SUBMISSION_EDIT_REQUESTED = "<STR_LIT>" , <EOL> BAMBOO_LINK_CREATED = "<STR_LIT>" , <EOL> BAMBOO_LINK_DELETED = "<STR_LIT>" , <EOL> SMS_SUPPORT_ACTIVATED = "<STR_LIT>" , <EOL> SMS_SUPPORT_DEACTIVATED = "<STR_LIT>" , <EOL> ) <EOL> class AuditLogHandler ( logging . Handler ) : <EOL> def __init__ ( self , model = "<STR_LIT>" ) : <EOL> super ( AuditLogHandler , self ) . __init__ ( ) <EOL> self . model_name = model <EOL> def _format ( self , record ) : <EOL> data = { <EOL> '<STR_LIT:action>' : record . formhub_action , <EOL> '<STR_LIT:user>' : record . request_username , <EOL> '<STR_LIT>' : record . account_username , <EOL> '<STR_LIT>' : { } , <EOL> '<STR_LIT>' : record . msg , <EOL> '<STR_LIT>' : datetime . utcfromtimestamp ( record . created ) , <EOL> '<STR_LIT>' : record . levelno , <EOL> '<STR_LIT>' : record . levelname , <EOL> '<STR_LIT:args>' : record . args , <EOL> '<STR_LIT>' : record . funcName , <EOL> '<STR_LIT>' : record . msecs , <EOL> '<STR_LIT>' : record . relativeCreated , <EOL> '<STR_LIT>' : record . thread , <EOL> '<STR_LIT:name>' : record . name , <EOL> '<STR_LIT>' : record . threadName , <EOL> '<STR_LIT>' : record . exc_info , <EOL> '<STR_LIT>' : record . pathname , <EOL> '<STR_LIT>' : record . exc_text , <EOL> '<STR_LIT>' : record . lineno , <EOL> '<STR_LIT>' : record . process , <EOL> '<STR_LIT:filename>' : record . filename , <EOL> '<STR_LIT>' : record . module , <EOL> '<STR_LIT>' : record . processName <EOL> } <EOL> if hasattr ( record , '<STR_LIT>' ) and isinstance ( record . audit , dict ) : <EOL> data [ '<STR_LIT>' ] = record . audit <EOL> return data <EOL> def emit ( self , record ) : <EOL> data = self . _format ( record ) <EOL> try : <EOL> model = self . get_model ( self . model_name ) <EOL> except : <EOL> pass <EOL> else : <EOL> log_entry = model ( data ) <EOL> log_entry . save ( ) <EOL> def get_model ( self , name ) : <EOL> names = name . split ( '<STR_LIT:.>' ) <EOL> mod = __import__ ( '<STR_LIT:.>' . join ( names [ : - <NUM_LIT:1> ] ) , fromlist = names [ - <NUM_LIT:1> : ] ) <EOL> return getattr ( mod , names [ - <NUM_LIT:1> ] ) <EOL> def audit_log ( action , request_user , account_user , message , audit , request , <EOL> level = logging . DEBUG ) : <EOL> """<STR_LIT>""" <EOL> logger = logging . getLogger ( "<STR_LIT>" ) <EOL> extra = { <EOL> '<STR_LIT>' : action , <EOL> '<STR_LIT>' : <EOL> request_user . username if request_user . username else str ( request_user ) , <EOL> '<STR_LIT>' : <EOL> account_user . username if account_user . username else str ( account_user ) , <EOL> '<STR_LIT>' : get_client_ip ( request ) , <EOL> '<STR_LIT>' : audit

}

import logging <EOL> from datetime import datetime <EOL> from onadata . libs . utils . viewer_tools import get_client_ip <EOL> class Enum ( object ) : <EOL> __name__ = "<STR_LIT>" <EOL> def __init__ ( self , ** enums ) : <EOL> self . enums = enums <EOL> def __getattr__ ( self , item ) : <EOL> return self . enums [ item ] <EOL> def __getitem__ ( self , item ) : <EOL> return self . __getattr__ ( item ) <EOL> def __iter__ ( self ) : <EOL> return self . enums . itervalues ( ) <EOL> Actions = Enum ( <EOL> PROFILE_ACCESSED = "<STR_LIT>" , <EOL> PUBLIC_PROFILE_ACCESSED = "<STR_LIT>" , <EOL> PROFILE_SETTINGS_UPDATED = "<STR_LIT>" , <EOL> USER_LOGIN = "<STR_LIT>" , <EOL> USER_LOGOUT = "<STR_LIT>" , <EOL> USER_BULK_SUBMISSION = "<STR_LIT>" , <EOL> USER_FORMLIST_REQUESTED = "<STR_LIT>" , <EOL> FORM_ACCESSED = "<STR_LIT>" , <EOL> FORM_PUBLISHED = "<STR_LIT>" , <EOL> FORM_UPDATED = "<STR_LIT>" , <EOL> FORM_XLS_DOWNLOADED = "<STR_LIT>" , <EOL> FORM_XLS_UPDATED = "<STR_LIT>" , <EOL> FORM_DELETED = "<STR_LIT>" , <EOL> FORM_CLONED = "<STR_LIT>" , <EOL> FORM_XML_DOWNLOADED = "<STR_LIT>" , <EOL> FORM_JSON_DOWNLOADED = "<STR_LIT>" , <EOL> FORM_PERMISSIONS_UPDATED = "<STR_LIT>" , <EOL> FORM_ENTER_DATA_REQUESTED = "<STR_LIT>" , <EOL> FORM_MAP_VIEWED = "<STR_LIT>" , <EOL> FORM_DATA_VIEWED = "<STR_LIT>" , <EOL> EXPORT_CREATED = "<STR_LIT>" , <EOL> EXPORT_DOWNLOADED = "<STR_LIT>" , <EOL> EXPORT_DELETED = "<STR_LIT>" , <EOL> EXPORT_LIST_REQUESTED = "<STR_LIT>" , <EOL> SUBMISSION_CREATED = "<STR_LIT>" , <EOL> SUBMISSION_UPDATED = "<STR_LIT>" , <EOL> SUBMISSION_DELETED = "<STR_LIT>" , <EOL> SUBMISSION_ACCESSED = "<STR_LIT>" , <EOL> SUBMISSION_EDIT_REQUESTED = "<STR_LIT>" , <EOL> BAMBOO_LINK_CREATED = "<STR_LIT>" , <EOL> BAMBOO_LINK_DELETED = "<STR_LIT>" , <EOL> SMS_SUPPORT_ACTIVATED = "<STR_LIT>" , <EOL> SMS_SUPPORT_DEACTIVATED = "<STR_LIT>" , <EOL> ) <EOL> class AuditLogHandler ( logging . Handler ) : <EOL> def __init__ ( self , model = "<STR_LIT>" ) : <EOL> super ( AuditLogHandler , self ) . __init__ ( ) <EOL> self . model_name = model <EOL> def _format ( self , record ) : <EOL> data = { <EOL> '<STR_LIT:action>' : record . formhub_action , <EOL> '<STR_LIT:user>' : record . request_username , <EOL> '<STR_LIT>' : record . account_username , <EOL> '<STR_LIT>' : { } , <EOL> '<STR_LIT>' : record . msg , <EOL> '<STR_LIT>' : datetime . utcfromtimestamp ( record . created ) , <EOL> '<STR_LIT>' : record . levelno , <EOL> '<STR_LIT>' : record . levelname , <EOL> '<STR_LIT:args>' : record . args , <EOL> '<STR_LIT>' : record . funcName , <EOL> '<STR_LIT>' : record . msecs , <EOL> '<STR_LIT>' : record . relativeCreated , <EOL> '<STR_LIT>' : record . thread , <EOL> '<STR_LIT:name>' : record . name , <EOL> '<STR_LIT>' : record . threadName , <EOL> '<STR_LIT>' : record . exc_info , <EOL> '<STR_LIT>' : record . pathname , <EOL> '<STR_LIT>' : record . exc_text , <EOL> '<STR_LIT>' : record . lineno , <EOL> '<STR_LIT>' : record . process , <EOL> '<STR_LIT:filename>' : record . filename , <EOL> '<STR_LIT>' : record . module , <EOL> '<STR_LIT>' : record . processName <EOL> } <EOL> if hasattr ( record , '<STR_LIT>' ) and isinstance ( record . audit , dict ) : <EOL> data [ '<STR_LIT>' ] = record . audit <EOL> return data <EOL> def emit ( self , record ) : <EOL> data = self . _format ( record ) <EOL> try : <EOL> model = self . get_model ( self . model_name ) <EOL> except : <EOL> pass <EOL> else : <EOL> log_entry = model ( data ) <EOL> log_entry . save ( ) <EOL> def get_model ( self , name ) : <EOL> names = name . split ( '<STR_LIT:.>' ) <EOL> mod = __import__ ( '<STR_LIT:.>' . join ( names [ : - <NUM_LIT:1> ] ) , fromlist = names [ - <NUM_LIT:1> : ] ) <EOL> return getattr ( mod , names [ - <NUM_LIT:1> ] ) <EOL> def audit_log ( action , request_user , account_user , message , audit , request , <EOL> level = logging . DEBUG ) : <EOL> """<STR_LIT>""" <EOL> logger = logging . getLogger ( "<STR_LIT>" ) <EOL> extra = { <EOL> '<STR_LIT>' : action , <EOL> '<STR_LIT>' : <EOL> request_user . username if request_user . username else str ( request_user ) , <EOL> '<STR_LIT>' : <EOL> account_user . username if account_user . username else str ( account_user ) , <EOL> '<STR_LIT>' : get_client_ip ( request ) , <EOL> '<STR_LIT>' : audit <EOL> } <EOL> logger . log ( level , message , extra = extra ) </s>

import os <EOL> import shutil <EOL> import tarfile <EOL> import zipfile <EOL> from six . moves import urllib <EOL> class Folder ( object ) : <EOL> def __init__ ( self , from_path ) : <EOL> self . from_path = from_path <EOL> def extractall ( self , path ) : <EOL> os . rmdir ( path ) <EOL> shutil . copytree ( self . from_path , path ) <EOL> def close ( self ) :

pass

import os <EOL> import shutil <EOL> import tarfile <EOL> import zipfile <EOL> from six . moves import urllib <EOL> class Folder ( object ) : <EOL> def __init__ ( self , from_path ) : <EOL> self . from_path = from_path <EOL> def extractall ( self , path ) : <EOL> os . rmdir ( path ) <EOL> shutil . copytree ( self . from_path , path ) <EOL> def close ( self ) : <EOL> pass <EOL> def open_zipfile ( archive ) : <EOL> return zipfile . ZipFile ( archive ) <EOL> def open_tarfile ( archive ) : <EOL> return tarfile . open ( name = archive , mode = '<STR_LIT:r>' ) <EOL> SUPPORTED_ARCHIVES = [ <EOL> ( open_tarfile , tarfile . is_tarfile ) , <EOL> ( open_zipfile , zipfile . is_zipfile ) , <EOL> ( Folder , os . path . isdir ) , <EOL> ] <EOL> def bootstrap_from_archive ( path , skeleton ) : <EOL> if os . path . isfile ( skeleton ) or os . path . isdir ( skeleton ) : <EOL> skeleton_file = skeleton <EOL> else : <EOL> skeleton_file , headers = urllib . request . urlretrieve ( skeleton ) <EOL> for opener , test in SUPPORTED_ARCHIVES : <EOL> try : <EOL> if test ( skeleton_file ) : <EOL> archive = opener ( skeleton_file ) <EOL> break <EOL> except IOError : <EOL> pass <EOL> else : <EOL> raise Exception ( "<STR_LIT>" ) <EOL> os . mkdir ( path ) <EOL> archive . extractall ( path = path ) <EOL> archive . close ( ) </s>

from django . core . management . commands . makemessages import Command as MakeMessagesCommand <EOL> from django . core . management . commands . compilemessages import Command as CompileMessagesCommand <EOL> from cactus . utils . filesystem import chdir <EOL> DEFAULT_COMMAND_KWARGS = { <EOL> "<STR_LIT>" : <NUM_LIT:3> , <EOL> "<STR_LIT>" : None , <EOL> "<STR_LIT>" : None , <EOL> "<STR_LIT>" : True , <EOL> "<STR_LIT:all>" : False , <EOL> } <EOL> DEFAULT_MAKEMESSAGES_KWARGS = { <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : [ ] , <EOL> "<STR_LIT>" : [ ] , <EOL> "<STR_LIT>" : False , <EOL> "<STR_LIT>" : True , <EOL> "<STR_LIT>" : False , <EOL> "<STR_LIT>" : False , <EOL> "<STR_LIT>" : False , <EOL> "<STR_LIT>" : False <EOL> } <EOL> def WrappedCommandFactory ( wrapped , default_kwargs = None ) : <EOL> base_kwargs = { } <EOL> base_kwargs . update ( DEFAULT_COMMAND_KWARGS ) <EOL> if default_kwargs is not None : <EOL> base_kwargs . update ( default_kwargs ) <EOL> class WrappedCommand ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , site ) : <EOL> self . site = site <EOL> def execute ( self ) : <EOL> kwargs = { "<STR_LIT>" : self . site . locale } <EOL> kwargs . update ( base_kwargs )

cmd = wrapped ( )

from django . core . management . commands . makemessages import Command as MakeMessagesCommand <EOL> from django . core . management . commands . compilemessages import Command as CompileMessagesCommand <EOL> from cactus . utils . filesystem import chdir <EOL> DEFAULT_COMMAND_KWARGS = { <EOL> "<STR_LIT>" : <NUM_LIT:3> , <EOL> "<STR_LIT>" : None , <EOL> "<STR_LIT>" : None , <EOL> "<STR_LIT>" : True , <EOL> "<STR_LIT:all>" : False , <EOL> } <EOL> DEFAULT_MAKEMESSAGES_KWARGS = { <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : [ ] , <EOL> "<STR_LIT>" : [ ] , <EOL> "<STR_LIT>" : False , <EOL> "<STR_LIT>" : True , <EOL> "<STR_LIT>" : False , <EOL> "<STR_LIT>" : False , <EOL> "<STR_LIT>" : False , <EOL> "<STR_LIT>" : False <EOL> } <EOL> def WrappedCommandFactory ( wrapped , default_kwargs = None ) : <EOL> base_kwargs = { } <EOL> base_kwargs . update ( DEFAULT_COMMAND_KWARGS ) <EOL> if default_kwargs is not None : <EOL> base_kwargs . update ( default_kwargs ) <EOL> class WrappedCommand ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , site ) : <EOL> self . site = site <EOL> def execute ( self ) : <EOL> kwargs = { "<STR_LIT>" : self . site . locale } <EOL> kwargs . update ( base_kwargs ) <EOL> cmd = wrapped ( ) <EOL> with chdir ( self . site . path ) : <EOL> cmd . execute ( ** kwargs ) <EOL> return WrappedCommand <EOL> MessageMaker = WrappedCommandFactory ( MakeMessagesCommand , DEFAULT_MAKEMESSAGES_KWARGS ) <EOL> MessageCompiler = WrappedCommandFactory ( CompileMessagesCommand ) </s>

import os <EOL> import tempfile <EOL> import shutil <EOL> import unittest2 as unittest <EOL> import django . conf <EOL> from cactus . site import Site <EOL> from cactus . bootstrap import bootstrap <EOL> from cactus . config . router import ConfigRouter <EOL> from cactus . utils . parallel import PARALLEL_DISABLED <EOL> class BaseTestCase ( unittest . TestCase ) : <EOL> def setUp ( self ) : <EOL> self . test_dir = tempfile . mkdtemp ( ) <EOL> self . path = os . path . join ( self . test_dir , '<STR_LIT:test>' ) <EOL> self . clear_django_settings ( ) <EOL> def tearDown ( self ) : <EOL> shutil . rmtree ( self . test_dir ) <EOL> def clear_django_settings ( self ) : <EOL> django . conf . settings . _wrapped = django . conf . empty <EOL> def assertFileExists ( self , path ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> open ( path ) <EOL> except IOError : <EOL> path_dir = os . path . dirname ( path ) <EOL> msg = [ <EOL> "<STR_LIT>" . format ( path ) , <EOL> "<STR_LIT>" . format ( path_dir , os . listdir ( path_dir ) ) <EOL> ] <EOL> self . fail ( "<STR_LIT:\n>" . join ( msg ) ) <EOL> def assertFileDoesNotExist ( self , path ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> open ( path ) <EOL> except IOError : <EOL> pass <EOL> else : <EOL> self . fail ( "<STR_LIT>" . format ( path ) ) <EOL> class BaseBootstrappedTestCase ( BaseTestCase ) : <EOL> def setUp ( self ) : <EOL> super ( BaseBootstrappedTestCase , self ) . setUp ( ) <EOL> bootstrap ( self . path , os . path . join ( "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT:data>" , "<STR_LIT>" ) )

class SiteTestCase ( BaseBootstrappedTestCase ) :

import os <EOL> import tempfile <EOL> import shutil <EOL> import unittest2 as unittest <EOL> import django . conf <EOL> from cactus . site import Site <EOL> from cactus . bootstrap import bootstrap <EOL> from cactus . config . router import ConfigRouter <EOL> from cactus . utils . parallel import PARALLEL_DISABLED <EOL> class BaseTestCase ( unittest . TestCase ) : <EOL> def setUp ( self ) : <EOL> self . test_dir = tempfile . mkdtemp ( ) <EOL> self . path = os . path . join ( self . test_dir , '<STR_LIT:test>' ) <EOL> self . clear_django_settings ( ) <EOL> def tearDown ( self ) : <EOL> shutil . rmtree ( self . test_dir ) <EOL> def clear_django_settings ( self ) : <EOL> django . conf . settings . _wrapped = django . conf . empty <EOL> def assertFileExists ( self , path ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> open ( path ) <EOL> except IOError : <EOL> path_dir = os . path . dirname ( path ) <EOL> msg = [ <EOL> "<STR_LIT>" . format ( path ) , <EOL> "<STR_LIT>" . format ( path_dir , os . listdir ( path_dir ) ) <EOL> ] <EOL> self . fail ( "<STR_LIT:\n>" . join ( msg ) ) <EOL> def assertFileDoesNotExist ( self , path ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> open ( path ) <EOL> except IOError : <EOL> pass <EOL> else : <EOL> self . fail ( "<STR_LIT>" . format ( path ) ) <EOL> class BaseBootstrappedTestCase ( BaseTestCase ) : <EOL> def setUp ( self ) : <EOL> super ( BaseBootstrappedTestCase , self ) . setUp ( ) <EOL> bootstrap ( self . path , os . path . join ( "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT:data>" , "<STR_LIT>" ) ) <EOL> class SiteTestCase ( BaseBootstrappedTestCase ) : <EOL> def setUp ( self ) : <EOL> super ( SiteTestCase , self ) . setUp ( ) <EOL> self . config_path = os . path . join ( self . path , '<STR_LIT>' ) <EOL> self . conf = ConfigRouter ( [ self . config_path ] ) <EOL> self . conf . set ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> for k , v in self . get_config_for_test ( ) . items ( ) : <EOL> self . conf . set ( k , v ) <EOL> self . conf . write ( ) <EOL> self . site = Site ( self . path , [ self . config_path ] ) <EOL> self . site . _parallel = PARALLEL_DISABLED <EOL> def get_config_for_test ( self ) : <EOL> """<STR_LIT>""" <EOL> return { } </s>

import os <EOL> from cactus . tests import SiteTestCase <EOL> class TestIgnore ( SiteTestCase ) : <EOL> def test_ignore_static ( self ) :

with open ( os . path . join ( self . site . static_path , "<STR_LIT>" ) , "<STR_LIT:w>" ) as f :

import os <EOL> from cactus . tests import SiteTestCase <EOL> class TestIgnore ( SiteTestCase ) : <EOL> def test_ignore_static ( self ) : <EOL> with open ( os . path . join ( self . site . static_path , "<STR_LIT>" ) , "<STR_LIT:w>" ) as f : <EOL> f . write ( "<STR_LIT>" ) <EOL> with open ( os . path . join ( self . site . static_path , "<STR_LIT>" ) , "<STR_LIT:w>" ) as f : <EOL> f . write ( "<STR_LIT>" ) <EOL> self . site . config . set ( "<STR_LIT:ignore>" , [ "<STR_LIT>" ] ) <EOL> self . site . build ( ) <EOL> self . assertFileDoesNotExist ( os . path . join ( self . site . build_path , "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> self . assertFileExists ( os . path . join ( self . site . build_path , "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> def test_ignore_pages ( self ) : <EOL> with open ( os . path . join ( self . site . page_path , "<STR_LIT>" ) , "<STR_LIT:w>" ) as f : <EOL> f . write ( "<STR_LIT>" ) <EOL> with open ( os . path . join ( self . site . page_path , "<STR_LIT>" ) , "<STR_LIT:w>" ) as f : <EOL> f . write ( "<STR_LIT>" ) <EOL> self . site . config . set ( "<STR_LIT:ignore>" , [ "<STR_LIT>" ] ) <EOL> self . site . build ( ) <EOL> self . assertFileDoesNotExist ( os . path . join ( self . site . build_path , "<STR_LIT>" ) ) <EOL> self . assertFileExists ( os . path . join ( self . site . build_path , "<STR_LIT>" ) ) </s>

from flask import Flask <EOL> from . import api , web

app = Flask ( __name__ )

from flask import Flask <EOL> from . import api , web <EOL> app = Flask ( __name__ ) <EOL> app . register_blueprint ( api . web ) <EOL> app . register_blueprint ( web . web ) </s>

"""<STR_LIT>""" <EOL> from setuptools import setup , find_packages <EOL> setup ( <EOL> name = '<STR_LIT>' , <EOL> version = '<STR_LIT>' , <EOL> author = '<STR_LIT>' , <EOL> author_email = '<STR_LIT>' , <EOL> url = '<STR_LIT>' , <EOL> license = '<STR_LIT>' , <EOL> description = __doc__ , <EOL> long_description = open ( '<STR_LIT>' ) . read ( ) , <EOL> keywords = [ '<STR_LIT>' , '<STR_LIT>' ] , <EOL> packages = find_packages ( ) , <EOL> scripts = [ ] , <EOL> entry_points = { } , <EOL> install_requires = [ <EOL> '<STR_LIT>' , <EOL> ] , <EOL> extras_require = { } , <EOL> include_package_data = True , <EOL> test_suite = '<STR_LIT>' , <EOL> platforms = '<STR_LIT>' , <EOL> classifiers = [ <EOL> '<STR_LIT>' ,

'<STR_LIT>' ,

"""<STR_LIT>""" <EOL> from setuptools import setup , find_packages <EOL> setup ( <EOL> name = '<STR_LIT>' , <EOL> version = '<STR_LIT>' , <EOL> author = '<STR_LIT>' , <EOL> author_email = '<STR_LIT>' , <EOL> url = '<STR_LIT>' , <EOL> license = '<STR_LIT>' , <EOL> description = __doc__ , <EOL> long_description = open ( '<STR_LIT>' ) . read ( ) , <EOL> keywords = [ '<STR_LIT>' , '<STR_LIT>' ] , <EOL> packages = find_packages ( ) , <EOL> scripts = [ ] , <EOL> entry_points = { } , <EOL> install_requires = [ <EOL> '<STR_LIT>' , <EOL> ] , <EOL> extras_require = { } , <EOL> include_package_data = True , <EOL> test_suite = '<STR_LIT>' , <EOL> platforms = '<STR_LIT>' , <EOL> classifiers = [ <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ] , <EOL> ) </s>

import requests <EOL> import langdetect <EOL> from textblob import TextBlob <EOL> try : <EOL> from urllib . parse import urljoin

except ImportError :

import requests <EOL> import langdetect <EOL> from textblob import TextBlob <EOL> try : <EOL> from urllib . parse import urljoin <EOL> except ImportError : <EOL> from urlparse import urljoin <EOL> try : <EOL> from . helper import * <EOL> from . findTitle import getTitle <EOL> from . justy import * <EOL> from . get_date import get_dates <EOL> from . findBody import getBody <EOL> from . entities import extract_entities <EOL> from . multi import * <EOL> except SystemError : <EOL> from helper import * <EOL> from justy import * <EOL> from findTitle import getTitle <EOL> from findBody import getBody <EOL> from get_date import get_dates <EOL> from entities import extract_entities <EOL> from lxmlTree import lxmlTree <EOL> from multi import * <EOL> class Capsule ( ) : <EOL> def __init__ ( self , url ) : <EOL> self . url = '<STR_LIT>' + url if url . startswith ( '<STR_LIT>' ) else url <EOL> if url . startswith ( '<STR_LIT>' ) : <EOL> with open ( url [ <NUM_LIT:7> : ] ) as f : <EOL> self . response = None <EOL> self . html = f . read ( ) <EOL> else : <EOL> self . response = requests . get ( self . url ) <EOL> self . html = self . response . text <EOL> self . lang = None <EOL> self . publish_date = None <EOL> self . title = None <EOL> self . multiTitle = None <EOL> self . body = None <EOL> self . body_blob = None <EOL> self . multiBody = None <EOL> self . multiBodyBlob = None <EOL> self . img_links = [ ] <EOL> self . entities = [ ] <EOL> self . source_name = extractDomain ( self . url ) <EOL> self . multi_publish_date = None <EOL> self . jt = None <EOL> def single_magic ( self , method = '<STR_LIT>' ) : <EOL> tree = makeTree ( self . html , self . url ) <EOL> if method == '<STR_LIT>' : <EOL> try : <EOL> self . get_language ( tree ) <EOL> except : <EOL> self . lang = '<STR_LIT>' <EOL> self . jt = justy ( self . html , self . lang ) <EOL> self . title = justyTitle ( self . jt ) <EOL> self . title = justyBody ( self . jt ) <EOL> else : <EOL> self . body = normalize ( normalize ( getBody ( tree ) ) ) <EOL> if self . body : <EOL> self . get_language ( tree ) <EOL> self . title = getTitle ( tree ) <EOL> wrong_imgs = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> self . img_links = list ( set ( [ urljoin ( self . source_name , x ) for x in tree . xpath ( '<STR_LIT>' ) <EOL> if not any ( [ w in x for w in wrong_imgs ] ) ] ) ) <EOL> self . body_blob = TextBlob ( self . body ) <EOL> self . publish_date = '<STR_LIT>' <EOL> for date_group in get_dates ( tree , self . lang ) : <EOL> if date_group : <EOL> self . publish_date = str ( date_group [ <NUM_LIT:0> ] ) <EOL> self . entities = extract_entities ( self . body_blob ) <EOL> def get_language ( self , tree ) : <EOL> if self . response and '<STR_LIT>' in self . response . headers : <EOL> self . lang = self . response . headers [ '<STR_LIT>' ] <EOL> if self . lang is None and '<STR_LIT>' in tree . attrib : <EOL> self . lang = tree . attrib [ '<STR_LIT>' ] <EOL> if self . response and self . lang is None : <EOL> self . lang = self . body_blob . detect_language ( ) <EOL> if self . lang is None : <EOL> self . lang = langdetect . detect ( self . body ) <EOL> def multi_magic ( self , most_similar_tree ) : <EOL> import textblob <EOL> this_tree = prune_first ( makeTree ( self . html , self . url ) , most_similar_tree ) <EOL> self . multiTitle = getTitle ( this_tree ) <EOL> self . multiBody = get_multi_body ( this_tree ) <EOL> self . multiBodyBlob = textblob . TextBlob ( self . multiBody ) <EOL> self . multi_publish_date = get_publish_from_meta ( this_tree ) or '<STR_LIT>' </s>

import tornado . web <EOL> import tornado . autoreload <EOL> import tornado <EOL> import os <EOL> import shutil <EOL> from sky . crawler import crawl <EOL> from sky . crawler . crawling import get_image_set <EOL> from sky . configs import DEFAULT_CRAWL_CONFIG <EOL> from sky . helper import extractDomain <EOL> from sky . scraper import Scraper <EOL> import json <EOL> def is_numeric ( x ) : <EOL> try : <EOL> int ( x ) <EOL> return True <EOL> except ValueError : <EOL> return False <EOL> class MainHandler ( tornado . web . RequestHandler ) : <EOL> def get ( self ) : <EOL> self . render ( '<STR_LIT>' , items = [ ] , cached = False ) <EOL> def post ( self ) : <EOL> CRAWL_CONFIG = DEFAULT_CRAWL_CONFIG . copy ( ) <EOL> CRAWL_CONFIG . update ( { <EOL> '<STR_LIT>' : os . path . join ( os . path . expanduser ( '<STR_LIT>' ) , '<STR_LIT>' ) , <EOL> } ) <EOL> args = self . request . arguments <EOL> print ( args ) <EOL> for arg in args : <EOL> value = args [ arg ] [ <NUM_LIT:0> ] . decode ( '<STR_LIT:utf8>' ) <EOL> if value and arg != '<STR_LIT:url>' and arg != '<STR_LIT>' : <EOL> print ( '<STR_LIT>' , arg , CRAWL_CONFIG [ arg ] ) <EOL> if isinstance ( CRAWL_CONFIG [ arg ] , list ) : <EOL> CRAWL_CONFIG [ arg ] = [ int ( value ) ] if is_numeric ( value ) else value . split ( '<STR_LIT:U+002CU+0020>' ) <EOL> else : <EOL> CRAWL_CONFIG [ arg ] = int ( value ) if is_numeric ( value ) else value . split ( '<STR_LIT:U+002CU+0020>' ) [ <NUM_LIT:0> ] <EOL> print ( '<STR_LIT>' , arg , CRAWL_CONFIG [ arg ] ) <EOL> url = self . get_argument ( '<STR_LIT:url>' , '<STR_LIT>' ) <EOL> use_cache = self . get_argument ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> domain = extractDomain ( url ) <EOL> CRAWL_CONFIG [ '<STR_LIT>' ] = [ url ] <EOL> CRAWL_CONFIG [ '<STR_LIT>' ] = domain [ <NUM_LIT:7> : ] <EOL> if use_cache != '<STR_LIT>' : <EOL> col_path = os . path . join ( CRAWL_CONFIG [ '<STR_LIT>' ] , <EOL> CRAWL_CONFIG [ '<STR_LIT>' ] ) <EOL> print ( col_path ) <EOL> if os . path . exists ( col_path ) : <EOL> shutil . rmtree ( col_path ) <EOL> crawl . start ( CRAWL_CONFIG )

SCRAPE_CONFIG = CRAWL_CONFIG . copy ( )

import tornado . web <EOL> import tornado . autoreload <EOL> import tornado <EOL> import os <EOL> import shutil <EOL> from sky . crawler import crawl <EOL> from sky . crawler . crawling import get_image_set <EOL> from sky . configs import DEFAULT_CRAWL_CONFIG <EOL> from sky . helper import extractDomain <EOL> from sky . scraper import Scraper <EOL> import json <EOL> def is_numeric ( x ) : <EOL> try : <EOL> int ( x ) <EOL> return True <EOL> except ValueError : <EOL> return False <EOL> class MainHandler ( tornado . web . RequestHandler ) : <EOL> def get ( self ) : <EOL> self . render ( '<STR_LIT>' , items = [ ] , cached = False ) <EOL> def post ( self ) : <EOL> CRAWL_CONFIG = DEFAULT_CRAWL_CONFIG . copy ( ) <EOL> CRAWL_CONFIG . update ( { <EOL> '<STR_LIT>' : os . path . join ( os . path . expanduser ( '<STR_LIT>' ) , '<STR_LIT>' ) , <EOL> } ) <EOL> args = self . request . arguments <EOL> print ( args ) <EOL> for arg in args : <EOL> value = args [ arg ] [ <NUM_LIT:0> ] . decode ( '<STR_LIT:utf8>' ) <EOL> if value and arg != '<STR_LIT:url>' and arg != '<STR_LIT>' : <EOL> print ( '<STR_LIT>' , arg , CRAWL_CONFIG [ arg ] ) <EOL> if isinstance ( CRAWL_CONFIG [ arg ] , list ) : <EOL> CRAWL_CONFIG [ arg ] = [ int ( value ) ] if is_numeric ( value ) else value . split ( '<STR_LIT:U+002CU+0020>' ) <EOL> else : <EOL> CRAWL_CONFIG [ arg ] = int ( value ) if is_numeric ( value ) else value . split ( '<STR_LIT:U+002CU+0020>' ) [ <NUM_LIT:0> ] <EOL> print ( '<STR_LIT>' , arg , CRAWL_CONFIG [ arg ] ) <EOL> url = self . get_argument ( '<STR_LIT:url>' , '<STR_LIT>' ) <EOL> use_cache = self . get_argument ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> domain = extractDomain ( url ) <EOL> CRAWL_CONFIG [ '<STR_LIT>' ] = [ url ] <EOL> CRAWL_CONFIG [ '<STR_LIT>' ] = domain [ <NUM_LIT:7> : ] <EOL> if use_cache != '<STR_LIT>' : <EOL> col_path = os . path . join ( CRAWL_CONFIG [ '<STR_LIT>' ] , <EOL> CRAWL_CONFIG [ '<STR_LIT>' ] ) <EOL> print ( col_path ) <EOL> if os . path . exists ( col_path ) : <EOL> shutil . rmtree ( col_path ) <EOL> crawl . start ( CRAWL_CONFIG ) <EOL> SCRAPE_CONFIG = CRAWL_CONFIG . copy ( ) <EOL> SCRAPE_CONFIG . update ( { <EOL> '<STR_LIT>' : <NUM_LIT> , <EOL> '<STR_LIT>' : <NUM_LIT:100> , <EOL> } ) <EOL> skindex = Scraper ( SCRAPE_CONFIG ) <EOL> skindex . load_local_pages ( ) <EOL> skindex . add_template_elements ( ) <EOL> res = skindex . process_all ( remove_visuals = True , <EOL> maxn = CRAWL_CONFIG [ '<STR_LIT>' ] ) <EOL> items = [ ] <EOL> for num , url in enumerate ( res ) : <EOL> if num == CRAWL_CONFIG [ '<STR_LIT>' ] : <EOL> break <EOL> dc = res [ url ] <EOL> dc [ '<STR_LIT:url>' ] = url <EOL> dc [ '<STR_LIT>' ] = domain <EOL> dc [ '<STR_LIT>' ] = [ x for x in reversed ( dc [ '<STR_LIT>' ] [ : <NUM_LIT:5> ] ) ] <EOL> items . append ( dc ) <EOL> print ( '<STR_LIT>' , len ( get_image_set ( { x [ '<STR_LIT:url>' ] : x for x in items } ) ) ) <EOL> if items and '<STR_LIT>' in items [ <NUM_LIT:0> ] : <EOL> items = sorted ( items , key = lambda x : len ( x [ '<STR_LIT>' ] ) , reverse = True ) <EOL> self . render ( '<STR_LIT>' , items = items , cached = False ) <EOL> settings = { <EOL> '<STR_LIT>' : os . path . join ( os . path . dirname ( __file__ ) , '<STR_LIT>' ) , <EOL> '<STR_LIT>' : os . path . join ( os . path . dirname ( __file__ ) , '<STR_LIT>' ) <EOL> } <EOL> def main ( host = '<STR_LIT:localhost>' , port = <NUM_LIT> ) : <EOL> application = tornado . web . Application ( [ <EOL> ( r"<STR_LIT:/>" , MainHandler ) , <EOL> ] , ** settings ) <EOL> application . listen ( int ( port ) , host ) <EOL> ioloop = tornado . ioloop . IOLoop ( ) . instance ( ) <EOL> print ( '<STR_LIT>' . format ( host , port , __file__ ) ) <EOL> ioloop . start ( ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> main ( ) </s>

from __future__ import absolute_import <EOL> import errno <EOL> import warnings <EOL> import hmac <EOL> from binascii import hexlify , unhexlify <EOL> from hashlib import md5 , sha1 , sha256 <EOL> from . . exceptions import SSLError , InsecurePlatformWarning <EOL> SSLContext = None <EOL> HAS_SNI = False <EOL> create_default_context = None <EOL> HASHFUNC_MAP = { <EOL> <NUM_LIT:32> : md5 , <EOL> <NUM_LIT> : sha1 , <EOL> <NUM_LIT:64> : sha256 , <EOL> } <EOL> def _const_compare_digest_backport ( a , b ) : <EOL> """<STR_LIT>""" <EOL> result = abs ( len ( a ) - len ( b ) ) <EOL> for l , r in zip ( bytearray ( a ) , bytearray ( b ) ) : <EOL> result |= l ^ r <EOL> return result == <NUM_LIT:0> <EOL> _const_compare_digest = getattr ( hmac , '<STR_LIT>' , <EOL> _const_compare_digest_backport ) <EOL> try : <EOL> import ssl <EOL> from ssl import wrap_socket , CERT_NONE , PROTOCOL_SSLv23 <EOL> from ssl import HAS_SNI <EOL> except ImportError : <EOL> pass <EOL> try : <EOL> from ssl import OP_NO_SSLv2 , OP_NO_SSLv3 , OP_NO_COMPRESSION <EOL> except ImportError : <EOL> OP_NO_SSLv2 , OP_NO_SSLv3 = <NUM_LIT> , <NUM_LIT> <EOL> OP_NO_COMPRESSION = <NUM_LIT> <EOL> DEFAULT_CIPHERS = ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> ) <EOL> try : <EOL> from ssl import SSLContext <EOL> except ImportError : <EOL> import sys <EOL> class SSLContext ( object ) : <EOL> supports_set_ciphers = ( ( <NUM_LIT:2> , <NUM_LIT:7> ) <= sys . version_info < ( <NUM_LIT:3> , ) or <EOL> ( <NUM_LIT:3> , <NUM_LIT:2> ) <= sys . version_info ) <EOL> def __init__ ( self , protocol_version ) : <EOL> self . protocol = protocol_version <EOL> self . check_hostname = False <EOL> self . verify_mode = ssl . CERT_NONE <EOL> self . ca_certs = None <EOL> self . options = <NUM_LIT:0> <EOL> self . certfile = None <EOL> self . keyfile = None <EOL> self . ciphers = None <EOL> def load_cert_chain ( self , certfile , keyfile ) : <EOL> self . certfile = certfile <EOL> self . keyfile = keyfile <EOL> def load_verify_locations ( self , cafile = None , capath = None ) : <EOL> self . ca_certs = cafile <EOL> if capath is not None : <EOL> raise SSLError ( "<STR_LIT>" ) <EOL> def set_ciphers ( self , cipher_suite ) :

if not self . supports_set_ciphers :

from __future__ import absolute_import <EOL> import errno <EOL> import warnings <EOL> import hmac <EOL> from binascii import hexlify , unhexlify <EOL> from hashlib import md5 , sha1 , sha256 <EOL> from . . exceptions import SSLError , InsecurePlatformWarning <EOL> SSLContext = None <EOL> HAS_SNI = False <EOL> create_default_context = None <EOL> HASHFUNC_MAP = { <EOL> <NUM_LIT:32> : md5 , <EOL> <NUM_LIT> : sha1 , <EOL> <NUM_LIT:64> : sha256 , <EOL> } <EOL> def _const_compare_digest_backport ( a , b ) : <EOL> """<STR_LIT>""" <EOL> result = abs ( len ( a ) - len ( b ) ) <EOL> for l , r in zip ( bytearray ( a ) , bytearray ( b ) ) : <EOL> result |= l ^ r <EOL> return result == <NUM_LIT:0> <EOL> _const_compare_digest = getattr ( hmac , '<STR_LIT>' , <EOL> _const_compare_digest_backport ) <EOL> try : <EOL> import ssl <EOL> from ssl import wrap_socket , CERT_NONE , PROTOCOL_SSLv23 <EOL> from ssl import HAS_SNI <EOL> except ImportError : <EOL> pass <EOL> try : <EOL> from ssl import OP_NO_SSLv2 , OP_NO_SSLv3 , OP_NO_COMPRESSION <EOL> except ImportError : <EOL> OP_NO_SSLv2 , OP_NO_SSLv3 = <NUM_LIT> , <NUM_LIT> <EOL> OP_NO_COMPRESSION = <NUM_LIT> <EOL> DEFAULT_CIPHERS = ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> ) <EOL> try : <EOL> from ssl import SSLContext <EOL> except ImportError : <EOL> import sys <EOL> class SSLContext ( object ) : <EOL> supports_set_ciphers = ( ( <NUM_LIT:2> , <NUM_LIT:7> ) <= sys . version_info < ( <NUM_LIT:3> , ) or <EOL> ( <NUM_LIT:3> , <NUM_LIT:2> ) <= sys . version_info ) <EOL> def __init__ ( self , protocol_version ) : <EOL> self . protocol = protocol_version <EOL> self . check_hostname = False <EOL> self . verify_mode = ssl . CERT_NONE <EOL> self . ca_certs = None <EOL> self . options = <NUM_LIT:0> <EOL> self . certfile = None <EOL> self . keyfile = None <EOL> self . ciphers = None <EOL> def load_cert_chain ( self , certfile , keyfile ) : <EOL> self . certfile = certfile <EOL> self . keyfile = keyfile <EOL> def load_verify_locations ( self , cafile = None , capath = None ) : <EOL> self . ca_certs = cafile <EOL> if capath is not None : <EOL> raise SSLError ( "<STR_LIT>" ) <EOL> def set_ciphers ( self , cipher_suite ) : <EOL> if not self . supports_set_ciphers : <EOL> raise TypeError ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> ) <EOL> self . ciphers = cipher_suite <EOL> def wrap_socket ( self , socket , server_hostname = None ) : <EOL> warnings . warn ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' , <EOL> InsecurePlatformWarning <EOL> ) <EOL> kwargs = { <EOL> '<STR_LIT>' : self . keyfile , <EOL> '<STR_LIT>' : self . certfile , <EOL> '<STR_LIT>' : self . ca_certs , <EOL> '<STR_LIT>' : self . verify_mode , <EOL> '<STR_LIT>' : self . protocol , <EOL> } <EOL> if self . supports_set_ciphers : <EOL> return wrap_socket ( socket , ciphers = self . ciphers , ** kwargs ) <EOL> else : <EOL> return wrap_socket ( socket , ** kwargs ) <EOL> def assert_fingerprint ( cert , fingerprint ) : <EOL> """<STR_LIT>""" <EOL> fingerprint = fingerprint . replace ( '<STR_LIT::>' , '<STR_LIT>' ) . lower ( ) <EOL> digest_length = len ( fingerprint ) <EOL> hashfunc = HASHFUNC_MAP . get ( digest_length ) <EOL> if not hashfunc : <EOL> raise SSLError ( <EOL> '<STR_LIT>' . format ( fingerprint ) ) <EOL> fingerprint_bytes = unhexlify ( fingerprint . encode ( ) ) <EOL> cert_digest = hashfunc ( cert ) . digest ( ) <EOL> if not _const_compare_digest ( cert_digest , fingerprint_bytes ) : <EOL> raise SSLError ( '<STR_LIT>' <EOL> . format ( fingerprint , hexlify ( cert_digest ) ) ) <EOL> def resolve_cert_reqs ( candidate ) : <EOL> """<STR_LIT>""" <EOL> if candidate is None : <EOL> return CERT_NONE <EOL> if isinstance ( candidate , str ) : <EOL> res = getattr ( ssl , candidate , None ) <EOL> if res is None : <EOL> res = getattr ( ssl , '<STR_LIT>' + candidate ) <EOL> return res <EOL> return candidate <EOL> def resolve_ssl_version ( candidate ) : <EOL> """<STR_LIT>""" <EOL> if candidate is None : <EOL> return PROTOCOL_SSLv23 <EOL> if isinstance ( candidate , str ) : <EOL> res = getattr ( ssl , candidate , None ) <EOL> if res is None : <EOL> res = getattr ( ssl , '<STR_LIT>' + candidate ) <EOL> return res <EOL> return candidate <EOL> def create_urllib3_context ( ssl_version = None , cert_reqs = None , <EOL> options = None , ciphers = None ) : <EOL> """<STR_LIT>""" <EOL> context = SSLContext ( ssl_version or ssl . PROTOCOL_SSLv23 ) <EOL> cert_reqs = ssl . CERT_REQUIRED if cert_reqs is None else cert_reqs <EOL> if options is None : <EOL> options = <NUM_LIT:0> <EOL> options |= OP_NO_SSLv2 <EOL> options |= OP_NO_SSLv3 <EOL> options |= OP_NO_COMPRESSION <EOL> context . options |= options <EOL> if getattr ( context , '<STR_LIT>' , True ) : <EOL> context . set_ciphers ( ciphers or DEFAULT_CIPHERS ) <EOL> context . verify_mode = cert_reqs <EOL> if getattr ( context , '<STR_LIT>' , None ) is not None : <EOL> context . check_hostname = False <EOL> return context <EOL> def ssl_wrap_socket ( sock , keyfile = None , certfile = None , cert_reqs = None , <EOL> ca_certs = None , server_hostname = None , <EOL> ssl_version = None , ciphers = None , ssl_context = None , <EOL> ca_cert_dir = None ) : <EOL> """<STR_LIT>""" <EOL> context = ssl_context <EOL> if context is None : <EOL> context = create_urllib3_context ( ssl_version , cert_reqs , <EOL> ciphers = ciphers ) <EOL> if ca_certs or ca_cert_dir : <EOL> try : <EOL> context . load_verify_locations ( ca_certs , ca_cert_dir ) <EOL> except IOError as e : <EOL> raise SSLError ( e ) <EOL> except OSError as e : <EOL> if e . errno == errno . ENOENT : <EOL> raise SSLError ( e ) <EOL> raise <EOL> if certfile : <EOL> context . load_cert_chain ( certfile , keyfile ) <EOL> if HAS_SNI : <EOL> return context . wrap_socket ( sock , server_hostname = server_hostname ) <EOL> return context . wrap_socket ( sock ) </s>

<s> from . sempai import imports

from . sempai import imports <EOL> from . import tests </s>

from ernie import mod , start <EOL> from ernie import Ernie <EOL> from time import sleep <EOL> def calc_add ( a , b ) : <EOL> return a + b <EOL> def slowcalc_add ( a , b ) : <EOL> sleep ( <NUM_LIT:2> ) <EOL> return a + b <EOL> def slowcalc_superslow ( ) : <EOL> sleep ( <NUM_LIT:10> )

def errorcalc_add ( a , b ) :

from ernie import mod , start <EOL> from ernie import Ernie <EOL> from time import sleep <EOL> def calc_add ( a , b ) : <EOL> return a + b <EOL> def slowcalc_add ( a , b ) : <EOL> sleep ( <NUM_LIT:2> ) <EOL> return a + b <EOL> def slowcalc_superslow ( ) : <EOL> sleep ( <NUM_LIT:10> ) <EOL> def errorcalc_add ( a , b ) : <EOL> raise Exception ( "<STR_LIT>" ) <EOL> mod ( '<STR_LIT>' ) . fun ( '<STR_LIT>' , calc_add ) <EOL> mod ( '<STR_LIT>' ) . fun ( '<STR_LIT>' , slowcalc_add ) <EOL> mod ( '<STR_LIT>' ) . fun ( '<STR_LIT>' , slowcalc_superslow ) <EOL> mod ( '<STR_LIT>' ) . fun ( '<STR_LIT>' , errorcalc_add ) <EOL> if __name__ == "<STR_LIT:__main__>" : <EOL> start ( ) </s>

import csv <EOL> import numpy <EOL> def write_top_n_titles ( titles_list , metric_array , n , filename ) : <EOL> top_n_metric_indices = metric_array . argsort ( ) [ : : - <NUM_LIT:1> ] [ : n ] <EOL> top_n_metric_titles = [ titles_list [ i ] [ <NUM_LIT:0> ] for i in top_n_metric_indices ] <EOL> file = open ( filename , '<STR_LIT:w>' ) <EOL> for t in top_n_metric_titles : <EOL> file . write ( '<STR_LIT>' % t ) <EOL> file . close ( ) <EOL> n = <NUM_LIT:5> <EOL> raw_data = [ ] <EOL> with open ( '<STR_LIT>' , '<STR_LIT>' ) as csvfile : <EOL> movie_reader = csv . reader ( csvfile , delimiter = '<STR_LIT:U+002C>' ) <EOL> for row in movie_reader : <EOL> raw_data . append ( row ) <EOL> num_titles = len ( raw_data [ <NUM_LIT:0> ] ) - <NUM_LIT:1> <EOL> num_users = len ( raw_data ) - <NUM_LIT:1> <EOL> print '<STR_LIT>' % ( num_titles , num_users ) <EOL> titles = [ t . split ( '<STR_LIT::>' ) for t in raw_data [ <NUM_LIT:0> ] [ <NUM_LIT:1> : ] ] <EOL> users = [ r [ <NUM_LIT:0> ] for r in raw_data [ <NUM_LIT:1> : ] ] <EOL> ratings = numpy . array ( [ [ int ( c ) if c != '<STR_LIT>' else numpy . nan for c in r [ <NUM_LIT:1> : ] ] for r in raw_data [ <NUM_LIT:1> : ] ] ) <EOL> masked_nans = numpy . ma . masked_array ( ratings , numpy . isnan ( ratings ) ) <EOL> mean_ratings = numpy . mean ( masked_nans , <NUM_LIT:0> ) <EOL> write_top_n_titles ( titles , mean_ratings , n , '<STR_LIT>' % n ) <EOL> all_ratings = numpy . ma . count ( masked_nans , <NUM_LIT:0> ) <EOL> masked_low = numpy . logical_or ( numpy . ma . masked_array ( ratings , ratings < <NUM_LIT:4> ) , masked_nans ) <EOL> high_ratings = numpy . ma . count ( masked_low , <NUM_LIT:0> ) <EOL> best_ratio = numpy . true_divide ( high_ratings , all_ratings ) <EOL> write_top_n_titles ( titles , best_ratio , n , '<STR_LIT>' % n ) <EOL> write_top_n_titles ( titles , all_ratings , n , '<STR_LIT>' % n )

star_wars_users_mask = masked_nans [ : , <NUM_LIT:0> ] . mask

import csv <EOL> import numpy <EOL> def write_top_n_titles ( titles_list , metric_array , n , filename ) : <EOL> top_n_metric_indices = metric_array . argsort ( ) [ : : - <NUM_LIT:1> ] [ : n ] <EOL> top_n_metric_titles = [ titles_list [ i ] [ <NUM_LIT:0> ] for i in top_n_metric_indices ] <EOL> file = open ( filename , '<STR_LIT:w>' ) <EOL> for t in top_n_metric_titles : <EOL> file . write ( '<STR_LIT>' % t ) <EOL> file . close ( ) <EOL> n = <NUM_LIT:5> <EOL> raw_data = [ ] <EOL> with open ( '<STR_LIT>' , '<STR_LIT>' ) as csvfile : <EOL> movie_reader = csv . reader ( csvfile , delimiter = '<STR_LIT:U+002C>' ) <EOL> for row in movie_reader : <EOL> raw_data . append ( row ) <EOL> num_titles = len ( raw_data [ <NUM_LIT:0> ] ) - <NUM_LIT:1> <EOL> num_users = len ( raw_data ) - <NUM_LIT:1> <EOL> print '<STR_LIT>' % ( num_titles , num_users ) <EOL> titles = [ t . split ( '<STR_LIT::>' ) for t in raw_data [ <NUM_LIT:0> ] [ <NUM_LIT:1> : ] ] <EOL> users = [ r [ <NUM_LIT:0> ] for r in raw_data [ <NUM_LIT:1> : ] ] <EOL> ratings = numpy . array ( [ [ int ( c ) if c != '<STR_LIT>' else numpy . nan for c in r [ <NUM_LIT:1> : ] ] for r in raw_data [ <NUM_LIT:1> : ] ] ) <EOL> masked_nans = numpy . ma . masked_array ( ratings , numpy . isnan ( ratings ) ) <EOL> mean_ratings = numpy . mean ( masked_nans , <NUM_LIT:0> ) <EOL> write_top_n_titles ( titles , mean_ratings , n , '<STR_LIT>' % n ) <EOL> all_ratings = numpy . ma . count ( masked_nans , <NUM_LIT:0> ) <EOL> masked_low = numpy . logical_or ( numpy . ma . masked_array ( ratings , ratings < <NUM_LIT:4> ) , masked_nans ) <EOL> high_ratings = numpy . ma . count ( masked_low , <NUM_LIT:0> ) <EOL> best_ratio = numpy . true_divide ( high_ratings , all_ratings ) <EOL> write_top_n_titles ( titles , best_ratio , n , '<STR_LIT>' % n ) <EOL> write_top_n_titles ( titles , all_ratings , n , '<STR_LIT>' % n ) <EOL> star_wars_users_mask = masked_nans [ : , <NUM_LIT:0> ] . mask <EOL> star_wars_users_mask_matrix = numpy . array ( [ star_wars_users_mask , ] * num_titles ) . T <EOL> cooc_star_wars_mask = numpy . logical_or ( masked_nans . mask , star_wars_users_mask_matrix ) <EOL> cooc_star_wars_count = numpy . ma . count ( numpy . ma . masked_array ( ratings , cooc_star_wars_mask ) , <NUM_LIT:0> ) <EOL> cooc_star_wars_ratio = cooc_star_wars_count / float ( numpy . ma . count ( masked_nans [ : , <NUM_LIT:0> ] ) ) <EOL> n = <NUM_LIT:6> <EOL> write_top_n_titles ( titles , cooc_star_wars_ratio , n , '<STR_LIT>' % n ) </s>

import sys <EOL> import os . path

from setuptools import setup , find_packages

import sys <EOL> import os . path <EOL> from setuptools import setup , find_packages <EOL> from setuptools . command . test import test as TestCommand <EOL> import sqlacodegen <EOL> class PyTest ( TestCommand ) : <EOL> def finalize_options ( self ) : <EOL> TestCommand . finalize_options ( self ) <EOL> self . test_args = [ ] <EOL> self . test_suite = True <EOL> def run_tests ( self ) : <EOL> import pytest <EOL> errno = pytest . main ( self . test_args ) <EOL> sys . exit ( errno ) <EOL> extra_requirements = ( ) <EOL> if sys . version_info < ( <NUM_LIT:2> , <NUM_LIT:7> ) : <EOL> extra_requirements = ( '<STR_LIT>' , ) <EOL> here = os . path . dirname ( __file__ ) <EOL> readme_path = os . path . join ( here , '<STR_LIT>' ) <EOL> readme = open ( readme_path ) . read ( ) <EOL> setup ( <EOL> name = '<STR_LIT>' , <EOL> description = '<STR_LIT>' , <EOL> long_description = readme , <EOL> version = sqlacodegen . version , <EOL> author = '<STR_LIT>' , <EOL> author_email = '<STR_LIT>' , <EOL> classifiers = [ <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> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' <EOL> ] , <EOL> keywords = '<STR_LIT>' , <EOL> license = '<STR_LIT>' , <EOL> packages = find_packages ( exclude = [ '<STR_LIT>' ] ) , <EOL> install_requires = ( <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' <EOL> ) + extra_requirements , <EOL> tests_require = [ '<STR_LIT>' , '<STR_LIT>' ] , <EOL> cmdclass = { '<STR_LIT:test>' : PyTest } , <EOL> zip_safe = False , <EOL> entry_points = { <EOL> '<STR_LIT>' : [ <EOL> '<STR_LIT>' <EOL> ] <EOL> } <EOL> ) </s>

'''<STR_LIT>''' <EOL> import itertools <EOL> class DifferentialCharacteristic ( object ) : <EOL> '''<STR_LIT>''' <EOL> characteristic_data = None <EOL> print_format = None <EOL> num_rounds = <NUM_LIT:0> <EOL> weight = <NUM_LIT:0> <EOL> msg_blocks = <NUM_LIT:1> <EOL> cipher = None <EOL> def __init__ ( self , data , cipher , rounds , weight ) : <EOL> self . characteristic_data = data <EOL> self . print_format = cipher . getFormatString ( ) <EOL> self . num_rounds = rounds <EOL> self . weight = weight <EOL> self . cipher = cipher <EOL> return <EOL> def getData ( self ) : <EOL> """<STR_LIT>""" <EOL> data = [ ] <EOL> for rnd in range ( <NUM_LIT:0> , ( self . num_rounds + <NUM_LIT:1> ) * self . msg_blocks ) : <EOL> tmp_row = [ ] <EOL> for word in self . print_format : <EOL> try : <EOL> if word == '<STR_LIT:w>' : <EOL> weight = self . characteristic_data [ word + str ( rnd ) ] <EOL> if self . cipher . name == "<STR_LIT>" or self . cipher . name == "<STR_LIT>" or self . cipher . name == "<STR_LIT>" : <EOL> tmp_row . append ( "<STR_LIT:->" + str ( int ( weight , <NUM_LIT:16> ) ) ) <EOL> else : <EOL> tmp_row . append ( "<STR_LIT:->" + str ( bin ( int ( weight , <NUM_LIT:16> ) ) . count ( '<STR_LIT:1>' ) ) ) <EOL> else : <EOL> tmp_row . append ( self . characteristic_data [ word + str ( rnd ) ] ) <EOL> except KeyError : <EOL> tmp_row . append ( "<STR_LIT:none>" ) <EOL> if tmp_row : <EOL> data . append ( tmp_row ) <EOL> return data <EOL> def printText ( self ) : <EOL> """<STR_LIT>""" <EOL> header = [ ] <EOL> data = self . getData ( ) <EOL> for word in self . print_format : <EOL> header . append ( word ) <EOL> col_width = max ( len ( s ) for s in list ( itertools . chain . from_iterable ( data ) ) ) + <NUM_LIT:2> <EOL> header_str = "<STR_LIT>" <EOL> data_str = "<STR_LIT>" <EOL> current_row = <NUM_LIT:0> <EOL> for entry in header : <EOL> header_str += entry . ljust ( col_width ) <EOL> for row in data : <EOL> data_str += str ( current_row ) + '<STR_LIT:\t>' <EOL> current_row += <NUM_LIT:1> <EOL> for entry in row : <EOL> data_str += entry . ljust ( col_width ) <EOL> data_str += '<STR_LIT:\n>' <EOL> print ( header_str ) <EOL> print ( "<STR_LIT:->" * len ( header_str ) ) <EOL> print ( data_str ) <EOL> print ( "<STR_LIT>" + str ( int ( self . weight , <NUM_LIT:16> ) ) ) <EOL> return <EOL> def getDOTString ( self ) : <EOL> """<STR_LIT>""" <EOL> result = "<STR_LIT>" <EOL> data = self . getData ( ) <EOL> last_node = "<STR_LIT>" <EOL> last_probability = None <EOL> for idx , entry in enumerate ( data ) : <EOL> new_node = "<STR_LIT>" . format ( idx ) <EOL> for value in entry [ : - <NUM_LIT:1> ] : <EOL> new_node += str ( value ) <EOL> result += new_node + "<STR_LIT>" . format ( entry [ <NUM_LIT:0> ] , entry [ <NUM_LIT:1> ] ) <EOL> if last_node != "<STR_LIT>" : <EOL> result += "<STR_LIT>" . format ( last_node , new_node , last_probability ) <EOL> last_probability = entry [ <NUM_LIT:2> ] <EOL> last_node = new_node <EOL> return result <EOL> def printDOT ( self ) : <EOL> """<STR_LIT>""" <EOL> print ( "<STR_LIT>" )

print ( self . getDOTString ( ) )

'''<STR_LIT>''' <EOL> import itertools <EOL> class DifferentialCharacteristic ( object ) : <EOL> '''<STR_LIT>''' <EOL> characteristic_data = None <EOL> print_format = None <EOL> num_rounds = <NUM_LIT:0> <EOL> weight = <NUM_LIT:0> <EOL> msg_blocks = <NUM_LIT:1> <EOL> cipher = None <EOL> def __init__ ( self , data , cipher , rounds , weight ) : <EOL> self . characteristic_data = data <EOL> self . print_format = cipher . getFormatString ( ) <EOL> self . num_rounds = rounds <EOL> self . weight = weight <EOL> self . cipher = cipher <EOL> return <EOL> def getData ( self ) : <EOL> """<STR_LIT>""" <EOL> data = [ ] <EOL> for rnd in range ( <NUM_LIT:0> , ( self . num_rounds + <NUM_LIT:1> ) * self . msg_blocks ) : <EOL> tmp_row = [ ] <EOL> for word in self . print_format : <EOL> try : <EOL> if word == '<STR_LIT:w>' : <EOL> weight = self . characteristic_data [ word + str ( rnd ) ] <EOL> if self . cipher . name == "<STR_LIT>" or self . cipher . name == "<STR_LIT>" or self . cipher . name == "<STR_LIT>" : <EOL> tmp_row . append ( "<STR_LIT:->" + str ( int ( weight , <NUM_LIT:16> ) ) ) <EOL> else : <EOL> tmp_row . append ( "<STR_LIT:->" + str ( bin ( int ( weight , <NUM_LIT:16> ) ) . count ( '<STR_LIT:1>' ) ) ) <EOL> else : <EOL> tmp_row . append ( self . characteristic_data [ word + str ( rnd ) ] ) <EOL> except KeyError : <EOL> tmp_row . append ( "<STR_LIT:none>" ) <EOL> if tmp_row : <EOL> data . append ( tmp_row ) <EOL> return data <EOL> def printText ( self ) : <EOL> """<STR_LIT>""" <EOL> header = [ ] <EOL> data = self . getData ( ) <EOL> for word in self . print_format : <EOL> header . append ( word ) <EOL> col_width = max ( len ( s ) for s in list ( itertools . chain . from_iterable ( data ) ) ) + <NUM_LIT:2> <EOL> header_str = "<STR_LIT>" <EOL> data_str = "<STR_LIT>" <EOL> current_row = <NUM_LIT:0> <EOL> for entry in header : <EOL> header_str += entry . ljust ( col_width ) <EOL> for row in data : <EOL> data_str += str ( current_row ) + '<STR_LIT:\t>' <EOL> current_row += <NUM_LIT:1> <EOL> for entry in row : <EOL> data_str += entry . ljust ( col_width ) <EOL> data_str += '<STR_LIT:\n>' <EOL> print ( header_str ) <EOL> print ( "<STR_LIT:->" * len ( header_str ) ) <EOL> print ( data_str ) <EOL> print ( "<STR_LIT>" + str ( int ( self . weight , <NUM_LIT:16> ) ) ) <EOL> return <EOL> def getDOTString ( self ) : <EOL> """<STR_LIT>""" <EOL> result = "<STR_LIT>" <EOL> data = self . getData ( ) <EOL> last_node = "<STR_LIT>" <EOL> last_probability = None <EOL> for idx , entry in enumerate ( data ) : <EOL> new_node = "<STR_LIT>" . format ( idx ) <EOL> for value in entry [ : - <NUM_LIT:1> ] : <EOL> new_node += str ( value ) <EOL> result += new_node + "<STR_LIT>" . format ( entry [ <NUM_LIT:0> ] , entry [ <NUM_LIT:1> ] ) <EOL> if last_node != "<STR_LIT>" : <EOL> result += "<STR_LIT>" . format ( last_node , new_node , last_probability ) <EOL> last_probability = entry [ <NUM_LIT:2> ] <EOL> last_node = new_node <EOL> return result <EOL> def printDOT ( self ) : <EOL> """<STR_LIT>""" <EOL> print ( "<STR_LIT>" ) <EOL> print ( self . getDOTString ( ) ) <EOL> print ( "<STR_LIT:}>" ) <EOL> return <EOL> def getTexString ( self ) : <EOL> """<STR_LIT>""" <EOL> header = [ "<STR_LIT>" ] <EOL> data = self . getData ( ) <EOL> for word in self . print_format : <EOL> header . append ( word ) <EOL> result = "<STR_LIT>" <EOL> result += "<STR_LIT>" <EOL> result += "<STR_LIT>" <EOL> result += "<STR_LIT>" + ( "<STR_LIT:c>" * ( len ( header ) + <NUM_LIT:1> ) ) + "<STR_LIT>" <EOL> result += "<STR_LIT>" <EOL> header_string = "<STR_LIT>" <EOL> for label in header : <EOL> header_string += label + "<STR_LIT>" <EOL> result += header_string [ : - <NUM_LIT:2> ] + "<STR_LIT>" <EOL> result += "<STR_LIT>" <EOL> for idx , entry in enumerate ( data ) : <EOL> tmp_row = "<STR_LIT>" . format ( idx ) <EOL> for value in entry : <EOL> tmp_row += "<STR_LIT>" + str ( value ) + "<STR_LIT>" <EOL> result += tmp_row [ : - <NUM_LIT:2> ] + "<STR_LIT>" <EOL> result += "<STR_LIT>" <EOL> result += "<STR_LIT>" <EOL> result += "<STR_LIT>" <EOL> return result </s>

from netmiko . brocade . brocade_nos_ssh import BrocadeNosSSH

from netmiko . brocade . brocade_fastiron_ssh import BrocadeFastironSSH

from netmiko . brocade . brocade_nos_ssh import BrocadeNosSSH <EOL> from netmiko . brocade . brocade_fastiron_ssh import BrocadeFastironSSH <EOL> from netmiko . brocade . brocade_netiron_ssh import BrocadeNetironSSH <EOL> __all__ = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] </s>

import re <EOL> import socket <EOL> from netmiko . netmiko_globals import MAX_BUFFER <EOL> from netmiko . ssh_connection import SSHConnection <EOL> class LinuxSSH ( SSHConnection ) : <EOL> def set_base_prompt ( self , pri_prompt_terminator = '<STR_LIT:$>' , <EOL> alt_prompt_terminator = '<STR_LIT:#>' , delay_factor = <NUM_LIT> ) : <EOL> """<STR_LIT>""" <EOL> return super ( SSHConnection , self ) . set_base_prompt ( <EOL> pri_prompt_terminator = pri_prompt_terminator , <EOL> alt_prompt_terminator = alt_prompt_terminator , <EOL> delay_factor = delay_factor ) <EOL> def send_config_set ( self , config_commands = None , exit_config_mode = True , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> if self . username == "<STR_LIT:root>" : <EOL> exit_config_mode = False <EOL> return super ( SSHConnection , self ) . send_config_set ( config_commands = config_commands , <EOL> exit_config_mode = exit_config_mode , <EOL> ** kwargs ) <EOL> def check_config_mode ( self , check_string = '<STR_LIT:#>' ) : <EOL> """<STR_LIT>""" <EOL> return super ( SSHConnection , self ) . check_config_mode ( check_string = check_string ) <EOL> def config_mode ( self , config_command = '<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> return self . enable ( cmd = config_command ) <EOL> def exit_config_mode ( self , exit_config = '<STR_LIT>' ) : <EOL> output = "<STR_LIT>" <EOL> if self . check_enable_mode ( ) : <EOL> self . remote_conn . sendall ( self . normalize_cmd ( exit_config ) ) <EOL> self . set_base_prompt ( ) <EOL> if self . check_enable_mode ( ) : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> return output <EOL> def check_enable_mode ( self , check_string = '<STR_LIT:#>' ) : <EOL> return self . check_config_mode ( check_string = check_string ) <EOL> def exit_enable_mode ( self , exit_command = '<STR_LIT>' ) : <EOL> """<STR_LIT>"""

return self . exit_config_mode ( exit_config = exit_command )

import re <EOL> import socket <EOL> from netmiko . netmiko_globals import MAX_BUFFER <EOL> from netmiko . ssh_connection import SSHConnection <EOL> class LinuxSSH ( SSHConnection ) : <EOL> def set_base_prompt ( self , pri_prompt_terminator = '<STR_LIT:$>' , <EOL> alt_prompt_terminator = '<STR_LIT:#>' , delay_factor = <NUM_LIT> ) : <EOL> """<STR_LIT>""" <EOL> return super ( SSHConnection , self ) . set_base_prompt ( <EOL> pri_prompt_terminator = pri_prompt_terminator , <EOL> alt_prompt_terminator = alt_prompt_terminator , <EOL> delay_factor = delay_factor ) <EOL> def send_config_set ( self , config_commands = None , exit_config_mode = True , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> if self . username == "<STR_LIT:root>" : <EOL> exit_config_mode = False <EOL> return super ( SSHConnection , self ) . send_config_set ( config_commands = config_commands , <EOL> exit_config_mode = exit_config_mode , <EOL> ** kwargs ) <EOL> def check_config_mode ( self , check_string = '<STR_LIT:#>' ) : <EOL> """<STR_LIT>""" <EOL> return super ( SSHConnection , self ) . check_config_mode ( check_string = check_string ) <EOL> def config_mode ( self , config_command = '<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> return self . enable ( cmd = config_command ) <EOL> def exit_config_mode ( self , exit_config = '<STR_LIT>' ) : <EOL> output = "<STR_LIT>" <EOL> if self . check_enable_mode ( ) : <EOL> self . remote_conn . sendall ( self . normalize_cmd ( exit_config ) ) <EOL> self . set_base_prompt ( ) <EOL> if self . check_enable_mode ( ) : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> return output <EOL> def check_enable_mode ( self , check_string = '<STR_LIT:#>' ) : <EOL> return self . check_config_mode ( check_string = check_string ) <EOL> def exit_enable_mode ( self , exit_command = '<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> return self . exit_config_mode ( exit_config = exit_command ) <EOL> def enable ( self , cmd = '<STR_LIT>' , pattern = '<STR_LIT>' , re_flags = re . IGNORECASE ) : <EOL> """<STR_LIT>""" <EOL> output = "<STR_LIT>" <EOL> if not self . check_enable_mode ( ) : <EOL> self . remote_conn . sendall ( self . normalize_cmd ( cmd ) ) <EOL> pattern = re . escape ( pattern ) <EOL> base_prompt_pattern = re . escape ( self . base_prompt ) <EOL> output = '<STR_LIT>' <EOL> try : <EOL> output += self . remote_conn . recv ( MAX_BUFFER ) . decode ( '<STR_LIT:utf-8>' , '<STR_LIT:ignore>' ) <EOL> if re . search ( pattern , output , flags = re_flags ) : <EOL> self . remote_conn . sendall ( self . normalize_cmd ( self . secret ) ) <EOL> self . set_base_prompt ( ) <EOL> except socket . timeout : <EOL> raise NetMikoTimeoutException ( "<STR_LIT>" ) <EOL> if not self . check_enable_mode ( ) : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> return output </s>

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

"""<STR_LIT>""" <EOL> from __future__ import print_function <EOL> from __future__ import unicode_literals <EOL> import io <EOL> import sys <EOL> def parse_yaml ( yaml_file ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> import yaml <EOL> except ImportError : <EOL> sys . exit ( "<STR_LIT>" ) <EOL> try : <EOL> with io . open ( yaml_file , encoding = '<STR_LIT:utf-8>' ) as fname : <EOL> return yaml . load ( fname ) <EOL> except IOError : <EOL> sys . exit ( "<STR_LIT>" . format ( yaml_file ) ) </s>

from . base import * <EOL> try : <EOL> from . local import * <EOL> except ImportError , exc :

exc . args = tuple ( [ '<STR_LIT>' % exc . args [ <NUM_LIT:0> ] ] )

from . base import * <EOL> try : <EOL> from . local import * <EOL> except ImportError , exc : <EOL> exc . args = tuple ( [ '<STR_LIT>' % exc . args [ <NUM_LIT:0> ] ] ) <EOL> raise exc </s>

from prettytable import PrettyTable <EOL> from . common import * <EOL> from . . import colors <EOL> from . . local_file import LocalFile <EOL> def process_add ( file_type , solution_type , files ) : <EOL> if not load_session ( ) or global_vars . problem . sessionId is None : <EOL> fatal ( '<STR_LIT>' ) <EOL> as_checker = False <EOL> as_validator = False <EOL> if file_type == '<STR_LIT>' or file_type == '<STR_LIT>' : <EOL> if len ( files ) != <NUM_LIT:1> : <EOL> fatal ( '<STR_LIT>' '<STR_LIT>' + file_type + '<STR_LIT:s>' ) <EOL> if file_type == '<STR_LIT>' : <EOL> as_checker = True <EOL> else : <EOL> as_validator = True <EOL> file_type = '<STR_LIT:source>' <EOL> if solution_type is not None : <EOL> if file_type != '<STR_LIT>' : <EOL> fatal ( '<STR_LIT>' ) <EOL> if solution_type == '<STR_LIT>' : <EOL> solution_type = '<STR_LIT>' <EOL> table = PrettyTable ( [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> for filename in files : <EOL> local = global_vars . problem . get_local_by_filename ( os . path . basename ( filename ) ) <EOL> if local is not None : <EOL> print ( '<STR_LIT>' % os . path . basename ( filename ) ) <EOL> status = colors . warning ( '<STR_LIT>' ) <EOL> else : <EOL> local = LocalFile ( os . path . basename ( filename ) , <EOL> os . path . dirname ( filename ) , <EOL> str ( os . path . basename ( filename ) . split ( '<STR_LIT:.>' ) [ <NUM_LIT:0> ] ) , <EOL> file_type <EOL> ) <EOL> if local . upload ( ) : <EOL> status = colors . success ( '<STR_LIT>' ) <EOL> global_vars . problem . local_files . append ( local ) <EOL> if as_checker : <EOL> global_vars . problem . set_checker_validator ( local . polygon_filename , '<STR_LIT>' ) <EOL> if as_validator :

global_vars . problem . set_checker_validator ( local . polygon_filename , '<STR_LIT>' )

from prettytable import PrettyTable <EOL> from . common import * <EOL> from . . import colors <EOL> from . . local_file import LocalFile <EOL> def process_add ( file_type , solution_type , files ) : <EOL> if not load_session ( ) or global_vars . problem . sessionId is None : <EOL> fatal ( '<STR_LIT>' ) <EOL> as_checker = False <EOL> as_validator = False <EOL> if file_type == '<STR_LIT>' or file_type == '<STR_LIT>' : <EOL> if len ( files ) != <NUM_LIT:1> : <EOL> fatal ( '<STR_LIT>' '<STR_LIT>' + file_type + '<STR_LIT:s>' ) <EOL> if file_type == '<STR_LIT>' : <EOL> as_checker = True <EOL> else : <EOL> as_validator = True <EOL> file_type = '<STR_LIT:source>' <EOL> if solution_type is not None : <EOL> if file_type != '<STR_LIT>' : <EOL> fatal ( '<STR_LIT>' ) <EOL> if solution_type == '<STR_LIT>' : <EOL> solution_type = '<STR_LIT>' <EOL> table = PrettyTable ( [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> for filename in files : <EOL> local = global_vars . problem . get_local_by_filename ( os . path . basename ( filename ) ) <EOL> if local is not None : <EOL> print ( '<STR_LIT>' % os . path . basename ( filename ) ) <EOL> status = colors . warning ( '<STR_LIT>' ) <EOL> else : <EOL> local = LocalFile ( os . path . basename ( filename ) , <EOL> os . path . dirname ( filename ) , <EOL> str ( os . path . basename ( filename ) . split ( '<STR_LIT:.>' ) [ <NUM_LIT:0> ] ) , <EOL> file_type <EOL> ) <EOL> if local . upload ( ) : <EOL> status = colors . success ( '<STR_LIT>' ) <EOL> global_vars . problem . local_files . append ( local ) <EOL> if as_checker : <EOL> global_vars . problem . set_checker_validator ( local . polygon_filename , '<STR_LIT>' ) <EOL> if as_validator : <EOL> global_vars . problem . set_checker_validator ( local . polygon_filename , '<STR_LIT>' ) <EOL> if solution_type is not None : <EOL> global_vars . problem . change_solution_type ( local . polygon_filename , solution_type . upper ( ) ) <EOL> else : <EOL> status = colors . error ( '<STR_LIT>' ) <EOL> table . add_row ( [ local . type , local . polygon_filename , local . filename , status ] ) <EOL> print ( table ) <EOL> save_session ( ) <EOL> def add_parser ( subparsers ) : <EOL> parser_add = subparsers . add_parser ( <EOL> '<STR_LIT>' , <EOL> help = "<STR_LIT>" <EOL> ) <EOL> parser_add . add_argument ( '<STR_LIT>' , choices = [ '<STR_LIT>' , '<STR_LIT:source>' , '<STR_LIT>' , '<STR_LIT>' ] , <EOL> help = '<STR_LIT>' ) <EOL> parser_add . add_argument ( '<STR_LIT>' , dest = '<STR_LIT>' , choices = [ '<STR_LIT>' , '<STR_LIT:OK>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] , <EOL> help = '<STR_LIT>' ) <EOL> parser_add . add_argument ( '<STR_LIT:file>' , nargs = '<STR_LIT:+>' , help = '<STR_LIT>' ) <EOL> parser_add . set_defaults ( func = lambda options : process_add ( options . file_type , options . solution_type , options . file ) ) </s>

from __future__ import print_function , unicode_literals <EOL> import compileall <EOL> import os <EOL> import re <EOL> import subprocess <EOL> import shutil <EOL> import glob <EOL> import fnmatch <EOL> import sys <EOL> import zipfile <EOL> from logging import ( critical as crit , error as eror , <EOL> info , debug as debg ) <EOL> VERSION = { <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" <EOL> } <EOL> class cfg : <EOL> fExtra = fLib = fScripts = fBin = False <EOL> plat = "<STR_LIT>" <EOL> dest = "<STR_LIT>"

path_jni = "<STR_LIT>"

from __future__ import print_function , unicode_literals <EOL> import compileall <EOL> import os <EOL> import re <EOL> import subprocess <EOL> import shutil <EOL> import glob <EOL> import fnmatch <EOL> import sys <EOL> import zipfile <EOL> from logging import ( critical as crit , error as eror , <EOL> info , debug as debg ) <EOL> VERSION = { <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" , <EOL> "<STR_LIT>" : "<STR_LIT>" <EOL> } <EOL> class cfg : <EOL> fExtra = fLib = fScripts = fBin = False <EOL> plat = "<STR_LIT>" <EOL> dest = "<STR_LIT>" <EOL> path_jni = "<STR_LIT>" <EOL> path_bin = os . path . join ( path_jni , "<STR_LIT>" ) <EOL> def options ( ) : <EOL> import logging <EOL> l = logging . getLogger ( "<STR_LIT>" ) <EOL> l . setLevel ( logging . DEBUG ) <EOL> for arg in sys . argv : <EOL> if arg in ( "<STR_LIT>" , ) : <EOL> cfg . plat = "<STR_LIT>" <EOL> cfg . dest = "<STR_LIT>" <EOL> cfg . path_bin = os . path . join ( cfg . path_jni , "<STR_LIT>" ) <EOL> elif arg in ( "<STR_LIT>" , ) : <EOL> cfg . fExtra = True <EOL> elif arg in ( "<STR_LIT>" , ) : <EOL> cfg . fLib = True <EOL> elif arg in ( "<STR_LIT>" , ) : <EOL> cfg . fScripts = True <EOL> elif arg in ( "<STR_LIT>" , ) : <EOL> cfg . fBin = True <EOL> assert cfg . fExtra or cfg . fLib or cfg . fScripts or cfg . fBin <EOL> def main ( ) : <EOL> options ( ) <EOL> for i in ( "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ) : <EOL> if os . path . isfile ( "<STR_LIT>" + i . upper ( ) ) : <EOL> VERSION [ i ] = "<STR_LIT:_>" + open ( "<STR_LIT>" + i . upper ( ) ) . read ( ) . strip ( ) <EOL> if os . path . isfile ( "<STR_LIT>" ) : <EOL> VERSION [ "<STR_LIT>" ] = "<STR_LIT:_>" + open ( "<STR_LIT>" ) . read ( ) . strip ( ) <EOL> pwd = os . getcwd ( ) <EOL> cfg . dest = os . path . abspath ( os . path . join ( pwd , cfg . dest ) ) <EOL> cfg . path_bin = os . path . abspath ( os . path . join ( pwd , cfg . path_bin ) ) + "<STR_LIT:/>" <EOL> cfg . fLib and zipup_libs ( pwd ) <EOL> cfg . fExtra and zipup_extra ( pwd ) <EOL> cfg . fBin and zipup_bin ( pwd ) <EOL> cfg . fScripts and zipup_script ( pwd ) <EOL> info ( '<STR_LIT>' ) <EOL> def run ( cmd , exit = True , cwd = None ) : <EOL> debg ( cmd ) <EOL> if subprocess . Popen ( cmd . split ( ) , cwd = cwd ) . wait ( ) != <NUM_LIT:0> : <EOL> if exit : <EOL> crit ( '<STR_LIT>' ) <EOL> sys . exit ( <NUM_LIT:1> ) <EOL> else : <EOL> eror ( '<STR_LIT>' ) <EOL> def find ( directory , pattern = None , exclude = None ) : <EOL> class Pattern : <EOL> def __init__ ( self , exp ) : <EOL> self . __exp__ = exp <EOL> def __eq__ ( self , b ) : <EOL> ret = fnmatch . fnmatch ( b , self . __exp__ ) <EOL> return ret <EOL> debg ( '<STR_LIT>' % ( directory , pattern ) ) <EOL> matches = [ ] <EOL> misses = [ ] <EOL> if exclude is None : <EOL> exclude = [ ] <EOL> else : <EOL> exclude = [ Pattern ( i ) for i in exclude ] <EOL> directory = os . path . abspath ( directory ) <EOL> for root , dirs , files in os . walk ( directory ) : <EOL> for basename in dirs + files : <EOL> if basename in exclude : <EOL> if basename in dirs : <EOL> dirs . remove ( basename ) <EOL> continue <EOL> path = os . path . join ( root , basename ) <EOL> if pattern is None or re . search ( pattern , path ) : <EOL> matches . append ( path ) <EOL> else : <EOL> misses . append ( path ) <EOL> debg ( '<STR_LIT>' % ( len ( matches ) , len ( misses ) ) ) <EOL> return matches , misses <EOL> def rm ( path ) : <EOL> debg ( '<STR_LIT>' % path ) <EOL> try : <EOL> if os . path . isdir ( path ) : <EOL> shutil . rmtree ( path ) <EOL> else : <EOL> os . remove ( path ) <EOL> except OSError : <EOL> pass <EOL> def strip ( path ) : <EOL> ndkpath = os . environ [ "<STR_LIT>" ] <EOL> toolchain = os . path . join ( <EOL> ndkpath , "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> if cfg . plat == "<STR_LIT>" : <EOL> toolchain = os . path . join ( <EOL> ndkpath , "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> run ( '<STR_LIT>' % ( toolchain , path ) ) <EOL> def zipup ( out_path , in_path , top , exclude = None , prefix = '<STR_LIT>' ) : <EOL> info ( "<STR_LIT>" % out_path ) <EOL> rm ( out_path ) <EOL> zip_file = zipfile . ZipFile ( out_path , '<STR_LIT:w>' , compression = zipfile . ZIP_DEFLATED ) <EOL> for path in find ( in_path , exclude = exclude ) [ <NUM_LIT:0> ] : <EOL> if os . path . islink ( path ) : <EOL> dest = os . readlink ( path ) <EOL> attr = zipfile . ZipInfo ( ) <EOL> attr . filename = prefix + path [ len ( top ) : ] . lstrip ( '<STR_LIT:/>' ) <EOL> attr . create_system = <NUM_LIT:3> <EOL> attr . external_attr = <NUM_LIT> L <EOL> zip_file . writestr ( attr , dest ) <EOL> elif not os . path . isdir ( path ) : <EOL> arcname = prefix + path [ len ( top ) : ] . lstrip ( '<STR_LIT:/>' ) <EOL> debg ( '<STR_LIT>' % ( arcname , out_path ) ) <EOL> zip_file . write ( path , arcname ) <EOL> zip_file . close ( ) <EOL> def install_py4a ( pwd ) : <EOL> class PathInfo : <EOL> def __init__ ( self , file_or_dir , relSrc , relDst ) : <EOL> self . file_or_dir = file_or_dir <EOL> self . src = relSrc <EOL> self . dst = relDst <EOL> class PkgInfo : <EOL> def __init__ ( self , seq , build , * items ) : <EOL> self . path_seq = seq <EOL> self . build = build <EOL> self . items = items <EOL> path_libs = cfg . dest + "<STR_LIT>" <EOL> run ( "<STR_LIT>" % path_libs ) <EOL> pkgs = { <EOL> '<STR_LIT>' : PkgInfo ( <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) , False , PathInfo ( False , '<STR_LIT>' , '<STR_LIT>' ) ) , <EOL> '<STR_LIT>' : PkgInfo ( <EOL> ( '<STR_LIT>' , ) , False , <EOL> PathInfo ( True , '<STR_LIT>' , '<STR_LIT>' ) ) , <EOL> '<STR_LIT>' : PkgInfo ( <EOL> ( '<STR_LIT>' , ) , True , <EOL> PathInfo ( False , "<STR_LIT>" , "<STR_LIT>" ) , <EOL> PathInfo ( False , "<STR_LIT>" , "<STR_LIT>" ) ) , <EOL> '<STR_LIT>' : PkgInfo ( <EOL> ( '<STR_LIT>' , ) , False , <EOL> PathInfo ( True , "<STR_LIT>" , '<STR_LIT>' ) , <EOL> PathInfo ( False , "<STR_LIT>" , '<STR_LIT>' ) ) , <EOL> } <EOL> for title , v in pkgs . items ( ) : <EOL> info ( title ) <EOL> path = os . path . join ( * ( ( pwd , '<STR_LIT>' ) + v . path_seq ) ) <EOL> if v . build : <EOL> run ( '<STR_LIT>' , cwd = path ) <EOL> debg ( "<STR_LIT>" % ( path , ) ) <EOL> for item in v . items : <EOL> src = os . path . join ( path , item . src ) <EOL> dst = os . path . join ( path_libs , item . dst ) <EOL> if not item . file_or_dir : <EOL> shutil . copytree ( src , dst ) <EOL> continue <EOL> for fname in glob . glob ( src ) : <EOL> shutil . copy ( fname , dst ) <EOL> def zipup_libs ( pwd ) : <EOL> info ( '<STR_LIT>' ) <EOL> root = os . path . join ( cfg . dest , "<STR_LIT>" ) <EOL> output = os . path . join ( root , "<STR_LIT>" ) <EOL> run ( "<STR_LIT>" % ( root + "<STR_LIT>" ) ) <EOL> run ( "<STR_LIT>" % output ) <EOL> shutil . copytree ( "<STR_LIT>" , output + "<STR_LIT>" ) <EOL> shutil . copy2 ( "<STR_LIT>" , <EOL> root + "<STR_LIT>" ) <EOL> shutil . copy2 ( "<STR_LIT>" , <EOL> root + "<STR_LIT>" ) <EOL> zipup ( '<STR_LIT>' % VERSION [ "<STR_LIT>" ] , <EOL> root , root ) <EOL> def zipup_extra ( pwd ) : <EOL> info ( '<STR_LIT>' ) <EOL> install_py4a ( pwd ) <EOL> root = os . path . join ( cfg . dest , "<STR_LIT>" ) <EOL> def rename_pyo_pyc ( fname ) : <EOL> fdest = os . path . splitext ( fname ) [ <NUM_LIT:0> ] + "<STR_LIT>" <EOL> if os . path . isfile ( fdest ) : <EOL> os . remove ( fdest ) <EOL> shutil . copy2 ( fname , fdest ) <EOL> compileall . compile_dir ( root , quiet = True ) <EOL> map ( rename_pyo_pyc , find ( root , "<STR_LIT>" ) [ <NUM_LIT:0> ] ) <EOL> zipup ( '<STR_LIT>' % VERSION [ "<STR_LIT>" ] , <EOL> root , root , <EOL> exclude = [ "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ] ) <EOL> def zipup_cleanup ( pwd ) : <EOL> map ( rm , find ( '<STR_LIT>' , '<STR_LIT>' ) [ <NUM_LIT:0> ] ) <EOL> map ( rm , find ( '<STR_LIT>' , '<STR_LIT>' ) [ <NUM_LIT:0> ] ) <EOL> map ( rm , find ( '<STR_LIT>' , '<STR_LIT>' ) [ <NUM_LIT:0> ] ) <EOL> map ( rm , find ( '<STR_LIT>' , '<STR_LIT>' ) [ <NUM_LIT:0> ] ) <EOL> def clean_library ( lib ) : <EOL> rm ( os . path . join ( pwd , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , lib ) ) <EOL> map ( clean_library , <EOL> [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> def zipup_bin ( pwd ) : <EOL> info ( '<STR_LIT>' ) <EOL> root = os . path . join ( cfg . dest , "<STR_LIT>" ) <EOL> outlib = os . path . join ( root , "<STR_LIT>" ) <EOL> outtic = os . path . join ( root , "<STR_LIT>" ) <EOL> output = os . path . join ( outlib , "<STR_LIT>" ) <EOL> run ( "<STR_LIT>" % ( root + "<STR_LIT>" ) ) <EOL> run ( "<STR_LIT>" % outtic + "<STR_LIT>" ) <EOL> run ( "<STR_LIT>" % outtic + "<STR_LIT>" ) <EOL> run ( "<STR_LIT>" % outtic + "<STR_LIT>" ) <EOL> run ( "<STR_LIT>" % outtic + "<STR_LIT>" ) <EOL> run ( "<STR_LIT>" % output ) <EOL> def pickup ( src , dst , later = False ) : <EOL> _dst = os . path . join ( dst , os . path . basename ( src ) ) <EOL> if os . path . islink ( src ) : <EOL> if later : <EOL> return src <EOL> linkto = os . readlink ( src ) <EOL> os . symlink ( linkto , _dst ) <EOL> return <EOL> debg ( "<STR_LIT>" % src ) <EOL> shutil . copy2 ( src , _dst ) <EOL> def copyre ( path , pat , dst ) : <EOL> remains = [ ] <EOL> for fname in os . listdir ( path ) : <EOL> if not re . match ( pat , fname ) : <EOL> continue <EOL> fname = os . path . join ( path , fname ) <EOL> ret = pickup ( fname , dst , later = True ) <EOL> ret and remains . append ( ret ) <EOL> for fname in remains : <EOL> pickup ( fname , dst ) <EOL> info ( '<STR_LIT>' ) <EOL> info ( '<STR_LIT>' % ( cfg . path_bin + "<STR_LIT>" ) ) <EOL> shutil . copy2 ( cfg . path_bin + "<STR_LIT>" , root + "<STR_LIT>" ) <EOL> ticpath = ( "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> copyre ( ticpath + "<STR_LIT>" , "<STR_LIT>" , outtic + "<STR_LIT>" ) <EOL> copyre ( ticpath + "<STR_LIT>" , "<STR_LIT>" , outtic + "<STR_LIT>" ) <EOL> copyre ( ticpath + "<STR_LIT>" , "<STR_LIT>" , outtic + "<STR_LIT>" ) <EOL> copyre ( ticpath + "<STR_LIT>" , "<STR_LIT>" , outtic + "<STR_LIT>" ) <EOL> copyre ( cfg . path_bin , "<STR_LIT>" , outlib ) <EOL> copyre ( cfg . path_bin , "<STR_LIT>" , output ) <EOL> info ( '<STR_LIT>' ) <EOL> map ( strip , find ( root , '<STR_LIT>' ) [ <NUM_LIT:0> ] ) <EOL> strip ( root + '<STR_LIT>' ) <EOL> info ( '<STR_LIT>' ) <EOL> map ( rm , find ( output , '<STR_LIT>' ) [ <NUM_LIT:0> ] ) <EOL> zipup ( '<STR_LIT>' % ( VERSION [ "<STR_LIT>" ] , cfg . plat ) , <EOL> root , root ) <EOL> def zipup_script ( pwd ) : <EOL> root = os . path . join ( pwd , '<STR_LIT>' ) <EOL> info ( '<STR_LIT>' ) <EOL> zipup ( os . path . join ( pwd , '<STR_LIT>' % VERSION [ "<STR_LIT>" ] ) , <EOL> root , root ) <EOL> if __name__ == "<STR_LIT:__main__>" : <EOL> main ( ) </s>

__author__ = '<STR_LIT>' <EOL> import sys <EOL> import os . path <EOL> import getopt <EOL> import gdata . auth <EOL> import gdata . docs . service <EOL> class OAuthSample ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , consumer_key , consuer_secret ) : <EOL> """<STR_LIT>""" <EOL> self . consumer_key = consumer_key <EOL> self . consumer_secret = consuer_secret <EOL> self . gd_client = gdata . docs . service . DocsService ( ) <EOL> def _PrintFeed ( self , feed ) : <EOL> """<STR_LIT>""" <EOL> if not feed . entry : <EOL> print '<STR_LIT>' <EOL> i = <NUM_LIT:1> <EOL> for entry in feed . entry : <EOL> print '<STR_LIT>' % ( i , entry . title . text . encode ( '<STR_LIT>' ) ) <EOL> i += <NUM_LIT:1> <EOL> def _ListAllDocuments ( self ) : <EOL> """<STR_LIT>""" <EOL> feed = self . gd_client . GetDocumentListFeed ( ) <EOL> self . _PrintFeed ( feed ) <EOL> def Run ( self ) : <EOL> """<STR_LIT>""" <EOL> print '<STR_LIT>' <EOL> self . gd_client . SetOAuthInputParameters ( <EOL> gdata . auth . OAuthSignatureMethod . HMAC_SHA1 , <EOL> self . consumer_key , consumer_secret = self . consumer_secret ) <EOL> print '<STR_LIT>' <EOL> request_token = self . gd_client . FetchOAuthRequestToken ( ) <EOL> print '<STR_LIT>' % request_token <EOL> print '<STR_LIT>' <EOL> self . gd_client . SetOAuthToken ( request_token ) <EOL> print '<STR_LIT>' <EOL> print '<STR_LIT>' <EOL> auth_url = self . gd_client . GenerateOAuthAuthorizationURL ( ) <EOL> print '<STR_LIT>' % auth_url <EOL> raw_input ( '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> print '<STR_LIT>' <EOL> self . gd_client . UpgradeToOAuthAccessToken ( ) <EOL> print '<STR_LIT>' % ( <EOL> self . gd_client . token_store . find_token ( request_token . scopes [ <NUM_LIT:0> ] ) ) <EOL> print '<STR_LIT>' <EOL> self . _ListAllDocuments ( ) <EOL> print '<STR_LIT>' <EOL> self . gd_client . RevokeOAuthToken ( ) <EOL> print '<STR_LIT>' <EOL> def main ( ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> opts , args = getopt . getopt ( sys . argv [ <NUM_LIT:1> : ] , '<STR_LIT>' , [ '<STR_LIT>' , <EOL> '<STR_LIT>' ] ) <EOL> except getopt . error , msg : <EOL> print ( '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> sys . exit ( <NUM_LIT:2> ) <EOL> consumer_key = '<STR_LIT>' <EOL> consumer_secret = '<STR_LIT>' <EOL> for option , arg in opts : <EOL> if option == '<STR_LIT>' : <EOL> consumer_key = arg <EOL> elif option == '<STR_LIT>' : <EOL> consumer_secret = arg <EOL> while not consumer_key : <EOL> consumer_key = raw_input ( '<STR_LIT>' ) <EOL> while not consumer_secret : <EOL> consumer_secret = raw_input ( '<STR_LIT>' ) <EOL> sample = OAuthSample ( consumer_key , consumer_secret ) <EOL> sample . Run ( )

if __name__ == '<STR_LIT:__main__>' :

__author__ = '<STR_LIT>' <EOL> import sys <EOL> import os . path <EOL> import getopt <EOL> import gdata . auth <EOL> import gdata . docs . service <EOL> class OAuthSample ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , consumer_key , consuer_secret ) : <EOL> """<STR_LIT>""" <EOL> self . consumer_key = consumer_key <EOL> self . consumer_secret = consuer_secret <EOL> self . gd_client = gdata . docs . service . DocsService ( ) <EOL> def _PrintFeed ( self , feed ) : <EOL> """<STR_LIT>""" <EOL> if not feed . entry : <EOL> print '<STR_LIT>' <EOL> i = <NUM_LIT:1> <EOL> for entry in feed . entry : <EOL> print '<STR_LIT>' % ( i , entry . title . text . encode ( '<STR_LIT>' ) ) <EOL> i += <NUM_LIT:1> <EOL> def _ListAllDocuments ( self ) : <EOL> """<STR_LIT>""" <EOL> feed = self . gd_client . GetDocumentListFeed ( ) <EOL> self . _PrintFeed ( feed ) <EOL> def Run ( self ) : <EOL> """<STR_LIT>""" <EOL> print '<STR_LIT>' <EOL> self . gd_client . SetOAuthInputParameters ( <EOL> gdata . auth . OAuthSignatureMethod . HMAC_SHA1 , <EOL> self . consumer_key , consumer_secret = self . consumer_secret ) <EOL> print '<STR_LIT>' <EOL> request_token = self . gd_client . FetchOAuthRequestToken ( ) <EOL> print '<STR_LIT>' % request_token <EOL> print '<STR_LIT>' <EOL> self . gd_client . SetOAuthToken ( request_token ) <EOL> print '<STR_LIT>' <EOL> print '<STR_LIT>' <EOL> auth_url = self . gd_client . GenerateOAuthAuthorizationURL ( ) <EOL> print '<STR_LIT>' % auth_url <EOL> raw_input ( '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> print '<STR_LIT>' <EOL> self . gd_client . UpgradeToOAuthAccessToken ( ) <EOL> print '<STR_LIT>' % ( <EOL> self . gd_client . token_store . find_token ( request_token . scopes [ <NUM_LIT:0> ] ) ) <EOL> print '<STR_LIT>' <EOL> self . _ListAllDocuments ( ) <EOL> print '<STR_LIT>' <EOL> self . gd_client . RevokeOAuthToken ( ) <EOL> print '<STR_LIT>' <EOL> def main ( ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> opts , args = getopt . getopt ( sys . argv [ <NUM_LIT:1> : ] , '<STR_LIT>' , [ '<STR_LIT>' , <EOL> '<STR_LIT>' ] ) <EOL> except getopt . error , msg : <EOL> print ( '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> sys . exit ( <NUM_LIT:2> ) <EOL> consumer_key = '<STR_LIT>' <EOL> consumer_secret = '<STR_LIT>' <EOL> for option , arg in opts : <EOL> if option == '<STR_LIT>' : <EOL> consumer_key = arg <EOL> elif option == '<STR_LIT>' : <EOL> consumer_secret = arg <EOL> while not consumer_key : <EOL> consumer_key = raw_input ( '<STR_LIT>' ) <EOL> while not consumer_secret : <EOL> consumer_secret = raw_input ( '<STR_LIT>' ) <EOL> sample = OAuthSample ( consumer_key , consumer_secret ) <EOL> sample . Run ( ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> main ( ) </s>

__author__ = '<STR_LIT>' <EOL> import unittest <EOL> import StringIO <EOL> import os . path <EOL> import atom . mock_http_core <EOL> import atom . http_core <EOL> class EchoClientTest ( unittest . TestCase ) : <EOL> def test_echo_response ( self ) : <EOL> client = atom . mock_http_core . EchoHttpClient ( ) <EOL> request = atom . http_core . HttpRequest ( method = '<STR_LIT:POST>' , <EOL> uri = atom . http_core . Uri ( host = '<STR_LIT>' , path = '<STR_LIT:/>' ) ) <EOL> request . add_body_part ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> response = client . request ( request ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == '<STR_LIT>' ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == '<STR_LIT:/>' ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) is None ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == '<STR_LIT:POST>' ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == str ( len ( <EOL> '<STR_LIT>' ) ) ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT:Content-Type>' ) == '<STR_LIT>' ) <EOL> self . assert_ ( response . read ( ) == '<STR_LIT>' ) <EOL> request = atom . http_core . HttpRequest ( method = '<STR_LIT:POST>' , <EOL> uri = atom . http_core . Uri ( host = '<STR_LIT>' , path = None ) ) <EOL> response = client . request ( request ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == '<STR_LIT>' ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == '<STR_LIT:POST>' ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == '<STR_LIT:/>' ) <EOL> request = atom . http_core . HttpRequest ( method = '<STR_LIT:POST>' , <EOL> uri = atom . http_core . Uri ( scheme = '<STR_LIT>' , host = '<STR_LIT>' , <EOL> port = <NUM_LIT> , path = '<STR_LIT>' , <EOL> query = { '<STR_LIT:test>' : '<STR_LIT:true>' , '<STR_LIT>' : '<STR_LIT:yes>' } ) , <EOL> headers = { '<STR_LIT>' : '<STR_LIT>' , '<STR_LIT>' : '<STR_LIT:True>' } )

request . add_body_part ( '<STR_LIT:start>' , '<STR_LIT>' )

__author__ = '<STR_LIT>' <EOL> import unittest <EOL> import StringIO <EOL> import os . path <EOL> import atom . mock_http_core <EOL> import atom . http_core <EOL> class EchoClientTest ( unittest . TestCase ) : <EOL> def test_echo_response ( self ) : <EOL> client = atom . mock_http_core . EchoHttpClient ( ) <EOL> request = atom . http_core . HttpRequest ( method = '<STR_LIT:POST>' , <EOL> uri = atom . http_core . Uri ( host = '<STR_LIT>' , path = '<STR_LIT:/>' ) ) <EOL> request . add_body_part ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> response = client . request ( request ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == '<STR_LIT>' ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == '<STR_LIT:/>' ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) is None ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == '<STR_LIT:POST>' ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == str ( len ( <EOL> '<STR_LIT>' ) ) ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT:Content-Type>' ) == '<STR_LIT>' ) <EOL> self . assert_ ( response . read ( ) == '<STR_LIT>' ) <EOL> request = atom . http_core . HttpRequest ( method = '<STR_LIT:POST>' , <EOL> uri = atom . http_core . Uri ( host = '<STR_LIT>' , path = None ) ) <EOL> response = client . request ( request ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == '<STR_LIT>' ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == '<STR_LIT:POST>' ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == '<STR_LIT:/>' ) <EOL> request = atom . http_core . HttpRequest ( method = '<STR_LIT:POST>' , <EOL> uri = atom . http_core . Uri ( scheme = '<STR_LIT>' , host = '<STR_LIT>' , <EOL> port = <NUM_LIT> , path = '<STR_LIT>' , <EOL> query = { '<STR_LIT:test>' : '<STR_LIT:true>' , '<STR_LIT>' : '<STR_LIT:yes>' } ) , <EOL> headers = { '<STR_LIT>' : '<STR_LIT>' , '<STR_LIT>' : '<STR_LIT:True>' } ) <EOL> request . add_body_part ( '<STR_LIT:start>' , '<STR_LIT>' ) <EOL> request . add_body_part ( StringIO . StringIO ( '<STR_LIT>' ) , <EOL> '<STR_LIT>' , len ( '<STR_LIT>' ) ) <EOL> request . add_body_part ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> response = client . request ( request ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == '<STR_LIT>' ) <EOL> self . assert_ ( <EOL> response . getheader ( '<STR_LIT>' ) == '<STR_LIT>' ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == '<STR_LIT>' ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == '<STR_LIT:POST>' ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT:Content-Type>' ) == ( <EOL> '<STR_LIT>' % ( atom . http_core . MIME_BOUNDARY , ) ) ) <EOL> expected_body = ( '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT:start>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) % ( atom . http_core . MIME_BOUNDARY , <EOL> atom . http_core . MIME_BOUNDARY , atom . http_core . MIME_BOUNDARY , <EOL> atom . http_core . MIME_BOUNDARY , ) <EOL> self . assert_ ( response . read ( ) == expected_body ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == str ( <EOL> len ( expected_body ) ) ) <EOL> class MockHttpClientTest ( unittest . TestCase ) : <EOL> def setUp ( self ) : <EOL> self . client = atom . mock_http_core . MockHttpClient ( ) <EOL> def test_respond_with_recording ( self ) : <EOL> request = atom . http_core . HttpRequest ( method = '<STR_LIT:GET>' ) <EOL> atom . http_core . parse_uri ( '<STR_LIT>' ) . modify_request ( request ) <EOL> self . client . add_response ( request , <NUM_LIT:200> , '<STR_LIT:OK>' , body = '<STR_LIT>' ) <EOL> response = self . client . request ( request ) <EOL> self . assert_ ( response . status == <NUM_LIT:200> ) <EOL> self . assert_ ( response . reason == '<STR_LIT:OK>' ) <EOL> self . assert_ ( response . read ( ) == '<STR_LIT>' ) <EOL> def test_save_and_load_recordings ( self ) : <EOL> request = atom . http_core . HttpRequest ( method = '<STR_LIT:GET>' ) <EOL> atom . http_core . parse_uri ( '<STR_LIT>' ) . modify_request ( request ) <EOL> self . client . add_response ( request , <NUM_LIT:200> , '<STR_LIT:OK>' , body = '<STR_LIT>' ) <EOL> response = self . client . request ( request ) <EOL> self . client . _save_recordings ( '<STR_LIT>' ) <EOL> self . client . _recordings = [ ] <EOL> response = self . client . request ( request ) <EOL> self . assert_ ( response is None ) <EOL> self . client . _load_recordings ( '<STR_LIT>' ) <EOL> response = self . client . request ( request ) <EOL> self . assert_ ( response . status == <NUM_LIT:200> ) <EOL> self . assert_ ( response . reason == '<STR_LIT:OK>' ) <EOL> self . assert_ ( response . read ( ) == '<STR_LIT>' ) <EOL> def test_use_recordings ( self ) : <EOL> request = atom . http_core . HttpRequest ( method = '<STR_LIT:GET>' ) <EOL> atom . http_core . parse_uri ( '<STR_LIT>' ) . modify_request ( request ) <EOL> self . client . _load_or_use_client ( '<STR_LIT>' , <EOL> atom . http_core . HttpClient ( ) ) <EOL> response = self . client . request ( request ) <EOL> if self . client . real_client : <EOL> self . client . _save_recordings ( '<STR_LIT>' ) <EOL> self . assert_ ( response . status == <NUM_LIT:200> ) <EOL> self . assert_ ( response . reason == '<STR_LIT:OK>' ) <EOL> self . assert_ ( response . getheader ( '<STR_LIT>' ) == '<STR_LIT>' ) <EOL> body = response . read ( ) <EOL> self . assert_ ( body . startswith ( '<STR_LIT>' ) ) <EOL> def test_match_request ( self ) : <EOL> x = atom . http_core . HttpRequest ( '<STR_LIT>' , '<STR_LIT:GET>' ) <EOL> y = atom . http_core . HttpRequest ( '<STR_LIT>' , '<STR_LIT:GET>' ) <EOL> self . assertTrue ( atom . mock_http_core . _match_request ( x , y ) ) <EOL> y = atom . http_core . HttpRequest ( '<STR_LIT>' , '<STR_LIT:POST>' ) <EOL> self . assertFalse ( atom . mock_http_core . _match_request ( x , y ) ) <EOL> y = atom . http_core . HttpRequest ( '<STR_LIT>' , '<STR_LIT:GET>' ) <EOL> self . assertFalse ( atom . mock_http_core . _match_request ( x , y ) ) <EOL> y = atom . http_core . HttpRequest ( '<STR_LIT>' , '<STR_LIT:GET>' ) <EOL> self . assertFalse ( atom . mock_http_core . _match_request ( x , y ) ) <EOL> y = atom . http_core . HttpRequest ( '<STR_LIT>' , '<STR_LIT:GET>' ) <EOL> self . assertTrue ( atom . mock_http_core . _match_request ( x , y ) ) <EOL> x = atom . http_core . HttpRequest ( '<STR_LIT>' , '<STR_LIT:GET>' ) <EOL> y = atom . http_core . HttpRequest ( '<STR_LIT>' , '<STR_LIT:GET>' ) <EOL> self . assertTrue ( atom . mock_http_core . _match_request ( x , y ) ) <EOL> y = atom . http_core . HttpRequest ( '<STR_LIT>' , '<STR_LIT:GET>' ) <EOL> self . assertFalse ( atom . mock_http_core . _match_request ( x , y ) ) <EOL> y = atom . http_core . HttpRequest ( '<STR_LIT>' , '<STR_LIT:GET>' ) <EOL> self . assertFalse ( atom . mock_http_core . _match_request ( x , y ) ) <EOL> def test_use_named_sessions ( self ) : <EOL> self . client . _delete_recordings ( '<STR_LIT>' ) <EOL> self . client . use_cached_session ( '<STR_LIT>' , <EOL> atom . mock_http_core . EchoHttpClient ( ) ) <EOL> request = atom . http_core . HttpRequest ( '<STR_LIT>' , '<STR_LIT:GET>' ) <EOL> response = self . client . request ( request ) <EOL> self . assertEqual ( response . getheader ( '<STR_LIT>' ) , '<STR_LIT:GET>' ) <EOL> self . assertEqual ( response . getheader ( '<STR_LIT>' ) , '<STR_LIT>' ) <EOL> self . assertEqual ( response . getheader ( '<STR_LIT>' ) , None ) <EOL> self . assertFalse ( '<STR_LIT>' in self . client . _recordings [ <NUM_LIT:0> ] [ <NUM_LIT:1> ] . _headers ) <EOL> self . client . _recordings [ <NUM_LIT:0> ] [ <NUM_LIT:1> ] . _headers [ '<STR_LIT>' ] = '<STR_LIT:1>' <EOL> self . assertTrue ( '<STR_LIT>' in self . client . _recordings [ <NUM_LIT:0> ] [ <NUM_LIT:1> ] . _headers ) <EOL> self . client . close_session ( ) <EOL> client = atom . mock_http_core . MockHttpClient ( ) <EOL> client . use_cached_session ( '<STR_LIT>' , <EOL> atom . mock_http_core . EchoHttpClient ( ) ) <EOL> response = client . request ( request ) <EOL> self . assertEqual ( response . getheader ( '<STR_LIT>' ) , '<STR_LIT:GET>' ) <EOL> self . assertEqual ( response . getheader ( '<STR_LIT>' ) , '<STR_LIT>' ) <EOL> self . assertEqual ( response . getheader ( '<STR_LIT>' ) , '<STR_LIT:1>' ) <EOL> def suite ( ) : <EOL> return unittest . TestSuite ( ( unittest . makeSuite ( MockHttpClientTest , '<STR_LIT:test>' ) , <EOL> unittest . makeSuite ( EchoClientTest , '<STR_LIT:test>' ) ) ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> unittest . main ( ) </s>

__author__ = '<STR_LIT>' <EOL> import unittest

import gdata . codesearch

__author__ = '<STR_LIT>' <EOL> import unittest <EOL> import gdata . codesearch <EOL> import gdata . test_data <EOL> class CodeSearchDataTest ( unittest . TestCase ) : <EOL> def setUp ( self ) : <EOL> self . feed = gdata . codesearch . CodesearchFeedFromString ( <EOL> gdata . test_data . CODE_SEARCH_FEED ) <EOL> def testCorrectXmlConversion ( self ) : <EOL> self . assert_ ( self . feed . id . text == <EOL> '<STR_LIT>' ) <EOL> self . assert_ ( len ( self . feed . entry ) == <NUM_LIT:10> ) <EOL> for entry in self . feed . entry : <EOL> if entry . id . text == ( '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) : <EOL> self . assert_ ( len ( entry . match ) == <NUM_LIT:4> ) <EOL> for match in entry . match : <EOL> if match . line_number == '<STR_LIT:4>' : <EOL> self . assert_ ( match . type == '<STR_LIT>' ) <EOL> self . assert_ ( entry . file . name == <EOL> '<STR_LIT>' ) <EOL> self . assert_ ( entry . package . name == '<STR_LIT>' ) <EOL> self . assert_ ( entry . package . uri == '<STR_LIT>' ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> unittest . main ( ) </s>

r"""<STR_LIT>""" <EOL> __version__ = '<STR_LIT>' <EOL> __all__ = [ <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , <EOL> ] <EOL> from decoder import JSONDecoder <EOL> from encoder import JSONEncoder <EOL> _default_encoder = JSONEncoder ( <EOL> skipkeys = False , <EOL> ensure_ascii = True , <EOL> check_circular = True , <EOL> allow_nan = True , <EOL> indent = None , <EOL> separators = None , <EOL> encoding = '<STR_LIT:utf-8>' , <EOL> default = None , <EOL> ) <EOL> def dump ( obj , fp , skipkeys = False , ensure_ascii = True , check_circular = True , <EOL> allow_nan = True , cls = None , indent = None , separators = None , <EOL> encoding = '<STR_LIT:utf-8>' , default = None , ** kw ) : <EOL> """<STR_LIT>""" <EOL> if ( skipkeys is False and ensure_ascii is True and <EOL> check_circular is True and allow_nan is True and <EOL> cls is None and indent is None and separators is None and <EOL> encoding == '<STR_LIT:utf-8>' and default is None and not kw ) : <EOL> iterable = _default_encoder . iterencode ( obj ) <EOL> else : <EOL> if cls is None : <EOL> cls = JSONEncoder <EOL> iterable = cls ( skipkeys = skipkeys , ensure_ascii = ensure_ascii , <EOL> check_circular = check_circular , allow_nan = allow_nan , indent = indent , <EOL> separators = separators , encoding = encoding , <EOL> default = default , ** kw ) . iterencode ( obj ) <EOL> for chunk in iterable :

fp . write ( chunk )

r"""<STR_LIT>""" <EOL> __version__ = '<STR_LIT>' <EOL> __all__ = [ <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , <EOL> ] <EOL> from decoder import JSONDecoder <EOL> from encoder import JSONEncoder <EOL> _default_encoder = JSONEncoder ( <EOL> skipkeys = False , <EOL> ensure_ascii = True , <EOL> check_circular = True , <EOL> allow_nan = True , <EOL> indent = None , <EOL> separators = None , <EOL> encoding = '<STR_LIT:utf-8>' , <EOL> default = None , <EOL> ) <EOL> def dump ( obj , fp , skipkeys = False , ensure_ascii = True , check_circular = True , <EOL> allow_nan = True , cls = None , indent = None , separators = None , <EOL> encoding = '<STR_LIT:utf-8>' , default = None , ** kw ) : <EOL> """<STR_LIT>""" <EOL> if ( skipkeys is False and ensure_ascii is True and <EOL> check_circular is True and allow_nan is True and <EOL> cls is None and indent is None and separators is None and <EOL> encoding == '<STR_LIT:utf-8>' and default is None and not kw ) : <EOL> iterable = _default_encoder . iterencode ( obj ) <EOL> else : <EOL> if cls is None : <EOL> cls = JSONEncoder <EOL> iterable = cls ( skipkeys = skipkeys , ensure_ascii = ensure_ascii , <EOL> check_circular = check_circular , allow_nan = allow_nan , indent = indent , <EOL> separators = separators , encoding = encoding , <EOL> default = default , ** kw ) . iterencode ( obj ) <EOL> for chunk in iterable : <EOL> fp . write ( chunk ) <EOL> def dumps ( obj , skipkeys = False , ensure_ascii = True , check_circular = True , <EOL> allow_nan = True , cls = None , indent = None , separators = None , <EOL> encoding = '<STR_LIT:utf-8>' , default = None , ** kw ) : <EOL> """<STR_LIT>""" <EOL> if ( skipkeys is False and ensure_ascii is True and <EOL> check_circular is True and allow_nan is True and <EOL> cls is None and indent is None and separators is None and <EOL> encoding == '<STR_LIT:utf-8>' and default is None and not kw ) : <EOL> return _default_encoder . encode ( obj ) <EOL> if cls is None : <EOL> cls = JSONEncoder <EOL> return cls ( <EOL> skipkeys = skipkeys , ensure_ascii = ensure_ascii , <EOL> check_circular = check_circular , allow_nan = allow_nan , indent = indent , <EOL> separators = separators , encoding = encoding , default = default , <EOL> ** kw ) . encode ( obj ) <EOL> _default_decoder = JSONDecoder ( encoding = None , object_hook = None ) <EOL> def load ( fp , encoding = None , cls = None , object_hook = None , parse_float = None , <EOL> parse_int = None , parse_constant = None , ** kw ) : <EOL> """<STR_LIT>""" <EOL> return loads ( fp . read ( ) , <EOL> encoding = encoding , cls = cls , object_hook = object_hook , <EOL> parse_float = parse_float , parse_int = parse_int , <EOL> parse_constant = parse_constant , ** kw ) <EOL> def loads ( s , encoding = None , cls = None , object_hook = None , parse_float = None , <EOL> parse_int = None , parse_constant = None , ** kw ) : <EOL> """<STR_LIT>""" <EOL> if ( cls is None and encoding is None and object_hook is None and <EOL> parse_int is None and parse_float is None and <EOL> parse_constant is None and not kw ) : <EOL> return _default_decoder . decode ( s ) <EOL> if cls is None : <EOL> cls = JSONDecoder <EOL> if object_hook is not None : <EOL> kw [ '<STR_LIT>' ] = object_hook <EOL> if parse_float is not None : <EOL> kw [ '<STR_LIT>' ] = parse_float <EOL> if parse_int is not None : <EOL> kw [ '<STR_LIT>' ] = parse_int <EOL> if parse_constant is not None : <EOL> kw [ '<STR_LIT>' ] = parse_constant <EOL> return cls ( encoding = encoding , ** kw ) . decode ( s ) </s>

from btcommon import * <EOL> import _msbt as bt <EOL> bt . initwinsock ( ) <EOL> def discover_devices ( duration = <NUM_LIT:8> , flush_cache = True , lookup_names = False ) : <EOL> return bt . discover_devices ( flush_cache , lookup_names ) <EOL> def lookup_name ( address , timeout = <NUM_LIT:10> ) : <EOL> if not is_valid_address ( address ) : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> return bt . lookup_name ( address ) <EOL> class BluetoothSocket : <EOL> def __init__ ( self , proto = RFCOMM , sockfd = None ) : <EOL> if proto not in [ RFCOMM ] : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> if sockfd : <EOL> self . _sockfd = sockfd <EOL> else : <EOL> self . _sockfd = bt . socket ( bt . SOCK_STREAM , bt . BTHPROTO_RFCOMM ) <EOL> self . _proto = proto <EOL> self . _sdp_handle = None <EOL> self . _raw_sdp_record = None <EOL> self . _blocking = True

self . _timeout = False

from btcommon import * <EOL> import _msbt as bt <EOL> bt . initwinsock ( ) <EOL> def discover_devices ( duration = <NUM_LIT:8> , flush_cache = True , lookup_names = False ) : <EOL> return bt . discover_devices ( flush_cache , lookup_names ) <EOL> def lookup_name ( address , timeout = <NUM_LIT:10> ) : <EOL> if not is_valid_address ( address ) : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> return bt . lookup_name ( address ) <EOL> class BluetoothSocket : <EOL> def __init__ ( self , proto = RFCOMM , sockfd = None ) : <EOL> if proto not in [ RFCOMM ] : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> if sockfd : <EOL> self . _sockfd = sockfd <EOL> else : <EOL> self . _sockfd = bt . socket ( bt . SOCK_STREAM , bt . BTHPROTO_RFCOMM ) <EOL> self . _proto = proto <EOL> self . _sdp_handle = None <EOL> self . _raw_sdp_record = None <EOL> self . _blocking = True <EOL> self . _timeout = False <EOL> def bind ( self , addrport ) : <EOL> if self . _proto == RFCOMM : <EOL> addr , port = addrport <EOL> if port == <NUM_LIT:0> : port = bt . BT_PORT_ANY <EOL> status = bt . bind ( self . _sockfd , addr , port ) <EOL> def listen ( self , backlog ) : <EOL> bt . listen ( self . _sockfd , backlog ) <EOL> def accept ( self ) : <EOL> clientfd , addr , port = bt . accept ( self . _sockfd ) <EOL> client = BluetoothSocket ( self . _proto , sockfd = clientfd ) <EOL> return client , ( addr , port ) <EOL> def connect ( self , addrport ) : <EOL> addr , port = addrport <EOL> bt . connect ( self . _sockfd , addr , port ) <EOL> def send ( self , data ) : <EOL> return bt . send ( self . _sockfd , data ) <EOL> def recv ( self , numbytes ) : <EOL> return bt . recv ( self . _sockfd , numbytes ) <EOL> def close ( self ) : <EOL> return bt . close ( self . _sockfd ) <EOL> def getsockname ( self ) : <EOL> return bt . getsockname ( self . _sockfd ) <EOL> def setblocking ( self , blocking ) : <EOL> s = bt . setblocking ( self . _sockfd , blocking ) <EOL> self . _blocking = blocking <EOL> def settimeout ( self , timeout ) : <EOL> if timeout < <NUM_LIT:0> : raise ValueError ( "<STR_LIT>" ) <EOL> if timeout == <NUM_LIT:0> : <EOL> self . setblocking ( False ) <EOL> else : <EOL> self . setblocking ( True ) <EOL> timeout = <NUM_LIT:0> <EOL> s = bt . settimeout ( self . _sockfd , timeout ) <EOL> self . _timeout = timeout <EOL> def gettimeout ( self ) : <EOL> if self . _blocking and not self . _timeout : return None <EOL> return bt . gettimeout ( self . _sockfd ) <EOL> def fileno ( self ) : <EOL> return self . _sockfd <EOL> def dup ( self ) : <EOL> return BluetoothSocket ( self . _proto , sockfd = bt . dup ( self . _sockfd ) ) <EOL> def makefile ( self ) : <EOL> raise "<STR_LIT>" <EOL> def advertise_service ( sock , name , service_id = "<STR_LIT>" , service_classes = [ ] , profiles = [ ] , provider = "<STR_LIT>" , description = "<STR_LIT>" , protocols = [ ] ) : <EOL> if service_id != "<STR_LIT>" and not is_valid_uuid ( service_id ) : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> for uuid in service_classes : <EOL> if not is_valid_uuid ( uuid ) : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> for uuid , version in profiles : <EOL> if not is_valid_uuid ( uuid ) or version < <NUM_LIT:0> or version > <NUM_LIT> : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> for uuid in protocols : <EOL> if not is_valid_uuid ( uuid ) : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> if sock . _raw_sdp_record is not None : <EOL> raise IOError ( "<STR_LIT>" ) <EOL> avpairs = [ ] <EOL> if len ( service_id ) > <NUM_LIT:0> : <EOL> avpairs . append ( ( "<STR_LIT>" , SERVICE_ID_ATTRID ) ) <EOL> avpairs . append ( ( "<STR_LIT>" , service_id ) ) <EOL> if len ( service_classes ) > <NUM_LIT:0> : <EOL> seq = [ ( "<STR_LIT>" , svc_class ) for svc_class in service_classes ] <EOL> avpairs . append ( ( "<STR_LIT>" , SERVICE_CLASS_ID_LIST_ATTRID ) ) <EOL> avpairs . append ( ( "<STR_LIT>" , seq ) ) <EOL> assert sock . _proto == RFCOMM <EOL> addr , port = sock . getsockname ( ) <EOL> avpairs . append ( ( "<STR_LIT>" , PROTOCOL_DESCRIPTOR_LIST_ATTRID ) ) <EOL> l2cap_pd = ( "<STR_LIT>" , ( ( "<STR_LIT>" , L2CAP_UUID ) , ) ) <EOL> rfcomm_pd = ( "<STR_LIT>" , ( ( "<STR_LIT>" , RFCOMM_UUID ) , ( "<STR_LIT>" , port ) ) ) <EOL> proto_list = [ l2cap_pd , rfcomm_pd ] <EOL> for proto_uuid in protocols : <EOL> proto_list . append ( ( "<STR_LIT>" , ( ( "<STR_LIT>" , proto_uuid ) , ) ) ) <EOL> avpairs . append ( ( "<STR_LIT>" , proto_list ) ) <EOL> avpairs . append ( ( "<STR_LIT>" , BROWSE_GROUP_LIST_ATTRID ) ) <EOL> avpairs . append ( ( "<STR_LIT>" , ( ( "<STR_LIT>" , PUBLIC_BROWSE_GROUP ) , ) ) ) <EOL> if len ( profiles ) > <NUM_LIT:0> : <EOL> seq = [ ( "<STR_LIT>" , ( ( "<STR_LIT>" , uuid ) , ( "<STR_LIT>" , version ) ) ) for uuid , version in profiles ] <EOL> avpairs . append ( ( "<STR_LIT>" , <EOL> BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRID ) ) <EOL> avpairs . append ( ( "<STR_LIT>" , seq ) ) <EOL> avpairs . append ( ( "<STR_LIT>" , SERVICE_NAME_ATTRID ) ) <EOL> avpairs . append ( ( "<STR_LIT>" , name ) ) <EOL> if len ( description ) > <NUM_LIT:0> : <EOL> avpairs . append ( ( "<STR_LIT>" , SERVICE_DESCRIPTION_ATTRID ) ) <EOL> avpairs . append ( ( "<STR_LIT>" , description ) ) <EOL> if len ( provider ) > <NUM_LIT:0> : <EOL> avpairs . append ( ( "<STR_LIT>" , PROVIDER_NAME_ATTRID ) ) <EOL> avpairs . append ( ( "<STR_LIT>" , provider ) ) <EOL> sock . _raw_sdp_record = sdp_make_data_element ( "<STR_LIT>" , avpairs ) <EOL> sock . _sdp_handle = bt . set_service_raw ( sock . _raw_sdp_record , True ) <EOL> def stop_advertising ( sock ) : <EOL> if sock . _raw_sdp_record is None : <EOL> raise IOError ( "<STR_LIT>" "<STR_LIT>" ) <EOL> bt . set_service_raw ( sock . _raw_sdp_record , False , sock . _sdp_handle ) <EOL> sock . _raw_sdp_record = None <EOL> sock . _sdp_handle = None <EOL> def find_service ( name = None , uuid = None , address = None ) : <EOL> if address is not None : <EOL> addresses = [ address ] <EOL> else : <EOL> addresses = discover_devices ( lookup_names = False ) <EOL> results = [ ] <EOL> for addr in addresses : <EOL> uuidstr = uuid or PUBLIC_BROWSE_GROUP <EOL> if not is_valid_uuid ( uuidstr ) : raise ValueError ( "<STR_LIT>" ) <EOL> uuidstr = to_full_uuid ( uuidstr ) <EOL> dresults = bt . find_service ( addr , uuidstr ) <EOL> for dict in dresults : <EOL> raw = dict [ "<STR_LIT>" ] <EOL> record = sdp_parse_raw_record ( raw ) <EOL> if SERVICE_CLASS_ID_LIST_ATTRID in record : <EOL> svc_class_id_list = [ t [ <NUM_LIT:1> ] for t in record [ SERVICE_CLASS_ID_LIST_ATTRID ] ] <EOL> dict [ "<STR_LIT>" ] = svc_class_id_list <EOL> else : <EOL> dict [ "<STR_LIT>" ] = [ ] <EOL> if BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRID in record : <EOL> pdl = [ ] <EOL> for profile_desc in record [ BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRID ] : <EOL> uuidpair , versionpair = profile_desc [ <NUM_LIT:1> ] <EOL> pdl . append ( ( uuidpair [ <NUM_LIT:1> ] , versionpair [ <NUM_LIT:1> ] ) ) <EOL> dict [ "<STR_LIT>" ] = pdl <EOL> else : <EOL> dict [ "<STR_LIT>" ] = [ ] <EOL> dict [ "<STR_LIT>" ] = record . get ( PROVIDER_NAME_ATTRID , None ) <EOL> dict [ "<STR_LIT>" ] = record . get ( SERVICE_ID_ATTRID , None ) <EOL> dict [ "<STR_LIT:name>" ] = record . get ( SERVICE_NAME_ATTRID , None ) <EOL> dict [ "<STR_LIT>" ] = record . get ( SERVICE_RECORD_HANDLE_ATTRID , None ) <EOL> if name is None : <EOL> results . extend ( dresults ) <EOL> else : <EOL> results . extend ( [ d for d in dresults if d [ "<STR_LIT:name>" ] == name ] ) <EOL> return results <EOL> class DeviceDiscoverer : <EOL> def __init__ ( self ) : <EOL> raise NotImplementedError </s>

"""<STR_LIT>"""

from twisted . conch . _version import version

"""<STR_LIT>""" <EOL> from twisted . conch . _version import version <EOL> __version__ = version . short ( ) </s>

"""<STR_LIT>""" <EOL> import string <EOL> from zope . interface import implements <EOL> from twisted . conch . insults import insults , helper <EOL> from twisted . python import log , reflect <EOL> _counters = { } <EOL> class Logging ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , original ) : <EOL> self . original = original <EOL> key = reflect . qual ( original . __class__ ) <EOL> count = _counters . get ( key , <NUM_LIT:0> ) <EOL> _counters [ key ] = count + <NUM_LIT:1> <EOL> self . _logFile = file ( key + '<STR_LIT:->' + str ( count ) , '<STR_LIT:w>' ) <EOL> def __str__ ( self ) : <EOL> return str ( super ( Logging , self ) . __getattribute__ ( '<STR_LIT>' ) ) <EOL> def __repr__ ( self ) : <EOL> return repr ( super ( Logging , self ) . __getattribute__ ( '<STR_LIT>' ) ) <EOL> def __getattribute__ ( self , name ) : <EOL> original = super ( Logging , self ) . __getattribute__ ( '<STR_LIT>' ) <EOL> logFile = super ( Logging , self ) . __getattribute__ ( '<STR_LIT>' ) <EOL> logFile . write ( name + '<STR_LIT:\n>' ) <EOL> return getattr ( original , name ) <EOL> class TransportSequence ( object ) : <EOL> """<STR_LIT>""" <EOL> implements ( insults . ITerminalTransport ) <EOL> for keyID in ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) : <EOL> exec '<STR_LIT>' % ( keyID , ) <EOL> TAB = '<STR_LIT:\t>' <EOL> BACKSPACE = '<STR_LIT>' <EOL> def __init__ ( self , * transports ) : <EOL> assert transports , "<STR_LIT>" <EOL> self . transports = transports <EOL> for method in insults . ITerminalTransport : <EOL> exec """<STR_LIT>""" % ( method , method ) <EOL> class LocalTerminalBufferMixin ( object ) : <EOL> """<STR_LIT>""" <EOL> def makeConnection ( self , transport ) : <EOL> self . terminalCopy = helper . TerminalBuffer ( )

self . terminalCopy . connectionMade ( )

"""<STR_LIT>""" <EOL> import string <EOL> from zope . interface import implements <EOL> from twisted . conch . insults import insults , helper <EOL> from twisted . python import log , reflect <EOL> _counters = { } <EOL> class Logging ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , original ) : <EOL> self . original = original <EOL> key = reflect . qual ( original . __class__ ) <EOL> count = _counters . get ( key , <NUM_LIT:0> ) <EOL> _counters [ key ] = count + <NUM_LIT:1> <EOL> self . _logFile = file ( key + '<STR_LIT:->' + str ( count ) , '<STR_LIT:w>' ) <EOL> def __str__ ( self ) : <EOL> return str ( super ( Logging , self ) . __getattribute__ ( '<STR_LIT>' ) ) <EOL> def __repr__ ( self ) : <EOL> return repr ( super ( Logging , self ) . __getattribute__ ( '<STR_LIT>' ) ) <EOL> def __getattribute__ ( self , name ) : <EOL> original = super ( Logging , self ) . __getattribute__ ( '<STR_LIT>' ) <EOL> logFile = super ( Logging , self ) . __getattribute__ ( '<STR_LIT>' ) <EOL> logFile . write ( name + '<STR_LIT:\n>' ) <EOL> return getattr ( original , name ) <EOL> class TransportSequence ( object ) : <EOL> """<STR_LIT>""" <EOL> implements ( insults . ITerminalTransport ) <EOL> for keyID in ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) : <EOL> exec '<STR_LIT>' % ( keyID , ) <EOL> TAB = '<STR_LIT:\t>' <EOL> BACKSPACE = '<STR_LIT>' <EOL> def __init__ ( self , * transports ) : <EOL> assert transports , "<STR_LIT>" <EOL> self . transports = transports <EOL> for method in insults . ITerminalTransport : <EOL> exec """<STR_LIT>""" % ( method , method ) <EOL> class LocalTerminalBufferMixin ( object ) : <EOL> """<STR_LIT>""" <EOL> def makeConnection ( self , transport ) : <EOL> self . terminalCopy = helper . TerminalBuffer ( ) <EOL> self . terminalCopy . connectionMade ( ) <EOL> return super ( LocalTerminalBufferMixin , self ) . makeConnection ( <EOL> TransportSequence ( transport , self . terminalCopy ) ) <EOL> def __str__ ( self ) : <EOL> return str ( self . terminalCopy ) <EOL> class RecvLine ( insults . TerminalProtocol ) : <EOL> """<STR_LIT>""" <EOL> width = <NUM_LIT> <EOL> height = <NUM_LIT> <EOL> TABSTOP = <NUM_LIT:4> <EOL> ps = ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> pn = <NUM_LIT:0> <EOL> def connectionMade ( self ) : <EOL> self . lineBuffer = [ ] <EOL> self . lineBufferIndex = <NUM_LIT:0> <EOL> t = self . terminal <EOL> self . keyHandlers = { <EOL> t . LEFT_ARROW : self . handle_LEFT , <EOL> t . RIGHT_ARROW : self . handle_RIGHT , <EOL> t . TAB : self . handle_TAB , <EOL> '<STR_LIT:\r>' : self . handle_RETURN , <EOL> '<STR_LIT:\n>' : self . handle_RETURN , <EOL> t . BACKSPACE : self . handle_BACKSPACE , <EOL> t . DELETE : self . handle_DELETE , <EOL> t . INSERT : self . handle_INSERT , <EOL> t . HOME : self . handle_HOME , <EOL> t . END : self . handle_END } <EOL> self . initializeScreen ( ) <EOL> def initializeScreen ( self ) : <EOL> self . terminal . reset ( ) <EOL> self . terminal . write ( self . ps [ self . pn ] ) <EOL> self . setInsertMode ( ) <EOL> def currentLineBuffer ( self ) : <EOL> s = '<STR_LIT>' . join ( self . lineBuffer ) <EOL> return s [ : self . lineBufferIndex ] , s [ self . lineBufferIndex : ] <EOL> def setInsertMode ( self ) : <EOL> self . mode = '<STR_LIT>' <EOL> self . terminal . setModes ( [ insults . modes . IRM ] ) <EOL> def setTypeoverMode ( self ) : <EOL> self . mode = '<STR_LIT>' <EOL> self . terminal . resetModes ( [ insults . modes . IRM ] ) <EOL> def drawInputLine ( self ) : <EOL> """<STR_LIT>""" <EOL> self . terminal . write ( self . ps [ self . pn ] + '<STR_LIT>' . join ( self . lineBuffer ) ) <EOL> def terminalSize ( self , width , height ) : <EOL> self . terminal . eraseDisplay ( ) <EOL> self . terminal . cursorHome ( ) <EOL> self . width = width <EOL> self . height = height <EOL> self . drawInputLine ( ) <EOL> def unhandledControlSequence ( self , seq ) : <EOL> pass <EOL> def keystrokeReceived ( self , keyID , modifier ) : <EOL> m = self . keyHandlers . get ( keyID ) <EOL> if m is not None : <EOL> m ( ) <EOL> elif keyID in string . printable : <EOL> self . characterReceived ( keyID , False ) <EOL> else : <EOL> log . msg ( "<STR_LIT>" % ( keyID , ) ) <EOL> def characterReceived ( self , ch , moreCharactersComing ) : <EOL> if self . mode == '<STR_LIT>' : <EOL> self . lineBuffer . insert ( self . lineBufferIndex , ch ) <EOL> else : <EOL> self . lineBuffer [ self . lineBufferIndex : self . lineBufferIndex + <NUM_LIT:1> ] = [ ch ] <EOL> self . lineBufferIndex += <NUM_LIT:1> <EOL> self . terminal . write ( ch ) <EOL> def handle_TAB ( self ) : <EOL> n = self . TABSTOP - ( len ( self . lineBuffer ) % self . TABSTOP ) <EOL> self . terminal . cursorForward ( n ) <EOL> self . lineBufferIndex += n <EOL> self . lineBuffer . extend ( '<STR_LIT:U+0020>' * n ) <EOL> def handle_LEFT ( self ) : <EOL> if self . lineBufferIndex > <NUM_LIT:0> : <EOL> self . lineBufferIndex -= <NUM_LIT:1> <EOL> self . terminal . cursorBackward ( ) <EOL> def handle_RIGHT ( self ) : <EOL> if self . lineBufferIndex < len ( self . lineBuffer ) : <EOL> self . lineBufferIndex += <NUM_LIT:1> <EOL> self . terminal . cursorForward ( ) <EOL> def handle_HOME ( self ) : <EOL> if self . lineBufferIndex : <EOL> self . terminal . cursorBackward ( self . lineBufferIndex ) <EOL> self . lineBufferIndex = <NUM_LIT:0> <EOL> def handle_END ( self ) : <EOL> offset = len ( self . lineBuffer ) - self . lineBufferIndex <EOL> if offset : <EOL> self . terminal . cursorForward ( offset ) <EOL> self . lineBufferIndex = len ( self . lineBuffer ) <EOL> def handle_BACKSPACE ( self ) : <EOL> if self . lineBufferIndex > <NUM_LIT:0> : <EOL> self . lineBufferIndex -= <NUM_LIT:1> <EOL> del self . lineBuffer [ self . lineBufferIndex ] <EOL> self . terminal . cursorBackward ( ) <EOL> self . terminal . deleteCharacter ( ) <EOL> def handle_DELETE ( self ) : <EOL> if self . lineBufferIndex < len ( self . lineBuffer ) : <EOL> del self . lineBuffer [ self . lineBufferIndex ] <EOL> self . terminal . deleteCharacter ( ) <EOL> def handle_RETURN ( self ) : <EOL> line = '<STR_LIT>' . join ( self . lineBuffer ) <EOL> self . lineBuffer = [ ] <EOL> self . lineBufferIndex = <NUM_LIT:0> <EOL> self . terminal . nextLine ( ) <EOL> self . lineReceived ( line ) <EOL> def handle_INSERT ( self ) : <EOL> assert self . mode in ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> if self . mode == '<STR_LIT>' : <EOL> self . setInsertMode ( ) <EOL> else : <EOL> self . setTypeoverMode ( ) <EOL> def lineReceived ( self , line ) : <EOL> pass <EOL> class HistoricRecvLine ( RecvLine ) : <EOL> """<STR_LIT>""" <EOL> def connectionMade ( self ) : <EOL> RecvLine . connectionMade ( self ) <EOL> self . historyLines = [ ] <EOL> self . historyPosition = <NUM_LIT:0> <EOL> t = self . terminal <EOL> self . keyHandlers . update ( { t . UP_ARROW : self . handle_UP , <EOL> t . DOWN_ARROW : self . handle_DOWN } ) <EOL> def currentHistoryBuffer ( self ) : <EOL> b = tuple ( self . historyLines ) <EOL> return b [ : self . historyPosition ] , b [ self . historyPosition : ] <EOL> def _deliverBuffer ( self , buf ) : <EOL> if buf : <EOL> for ch in buf [ : - <NUM_LIT:1> ] : <EOL> self . characterReceived ( ch , True ) <EOL> self . characterReceived ( buf [ - <NUM_LIT:1> ] , False ) <EOL> def handle_UP ( self ) : <EOL> if self . lineBuffer and self . historyPosition == len ( self . historyLines ) : <EOL> self . historyLines . append ( self . lineBuffer ) <EOL> if self . historyPosition > <NUM_LIT:0> : <EOL> self . handle_HOME ( ) <EOL> self . terminal . eraseToLineEnd ( ) <EOL> self . historyPosition -= <NUM_LIT:1> <EOL> self . lineBuffer = [ ] <EOL> self . _deliverBuffer ( self . historyLines [ self . historyPosition ] ) <EOL> def handle_DOWN ( self ) : <EOL> if self . historyPosition < len ( self . historyLines ) - <NUM_LIT:1> : <EOL> self . handle_HOME ( ) <EOL> self . terminal . eraseToLineEnd ( ) <EOL> self . historyPosition += <NUM_LIT:1> <EOL> self . lineBuffer = [ ] <EOL> self . _deliverBuffer ( self . historyLines [ self . historyPosition ] ) <EOL> else : <EOL> self . handle_HOME ( ) <EOL> self . terminal . eraseToLineEnd ( ) <EOL> self . historyPosition = len ( self . historyLines ) <EOL> self . lineBuffer = [ ] <EOL> self . lineBufferIndex = <NUM_LIT:0> <EOL> def handle_RETURN ( self ) : <EOL> if self . lineBuffer : <EOL> self . historyLines . append ( '<STR_LIT>' . join ( self . lineBuffer ) ) <EOL> self . historyPosition = len ( self . historyLines ) <EOL> return RecvLine . handle_RETURN ( self ) </s>

"""<STR_LIT>""" <EOL> try : <EOL> import pwd <EOL> except ImportError : <EOL> pwd = None <EOL> import os , base64 <EOL> from twisted . trial . unittest import TestCase <EOL> from twisted . python . filepath import FilePath <EOL> from twisted . cred . checkers import InMemoryUsernamePasswordDatabaseDontUse <EOL> from twisted . cred . credentials import UsernamePassword , IUsernamePassword , SSHPrivateKey , ISSHPrivateKey <EOL> from twisted . cred . error import UnhandledCredentials , UnauthorizedLogin <EOL> from twisted . python . fakepwd import UserDatabase <EOL> from twisted . test . test_process import MockOS <EOL> try : <EOL> import Crypto . Cipher . DES3 <EOL> import pyasn1 <EOL> except ImportError : <EOL> SSHPublicKeyDatabase = None <EOL> else : <EOL> from twisted . conch . ssh import keys <EOL> from twisted . conch . checkers import SSHPublicKeyDatabase , SSHProtocolChecker <EOL> from twisted . conch . error import NotEnoughAuthentication , ValidPublicKey <EOL> from twisted . conch . test import keydata <EOL> class SSHPublicKeyDatabaseTestCase ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> if pwd is None : <EOL> skip = "<STR_LIT>" <EOL> elif SSHPublicKeyDatabase is None : <EOL> skip = "<STR_LIT>" <EOL> def setUp ( self ) : <EOL> self . checker = SSHPublicKeyDatabase ( ) <EOL> self . key1 = base64 . encodestring ( "<STR_LIT>" ) <EOL> self . key2 = base64 . encodestring ( "<STR_LIT>" ) <EOL> self . content = "<STR_LIT>" % ( self . key1 , self . key2 ) <EOL> self . mockos = MockOS ( ) <EOL> self . mockos . path = FilePath ( self . mktemp ( ) ) <EOL> self . mockos . path . makedirs ( ) <EOL> self . sshDir = self . mockos . path . child ( '<STR_LIT>' ) <EOL> self . sshDir . makedirs ( ) <EOL> userdb = UserDatabase ( ) <EOL> userdb . addUser ( '<STR_LIT:user>' , '<STR_LIT:password>' , <NUM_LIT:1> , <NUM_LIT:2> , '<STR_LIT>' , <EOL> self . mockos . path . path , '<STR_LIT>' ) <EOL> self . patch ( pwd , "<STR_LIT>" , userdb . getpwnam ) <EOL> self . patch ( os , "<STR_LIT>" , self . mockos . seteuid ) <EOL> self . patch ( os , "<STR_LIT>" , self . mockos . setegid ) <EOL> def _testCheckKey ( self , filename ) : <EOL> self . sshDir . child ( filename ) . setContent ( self . content ) <EOL> user = UsernamePassword ( "<STR_LIT:user>" , "<STR_LIT:password>" ) <EOL> user . blob = "<STR_LIT>" <EOL> self . assertTrue ( self . checker . checkKey ( user ) ) <EOL> user . blob = "<STR_LIT>" <EOL> self . assertTrue ( self . checker . checkKey ( user ) ) <EOL> user . blob = "<STR_LIT>" <EOL> self . assertFalse ( self . checker . checkKey ( user ) ) <EOL> def test_checkKey ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _testCheckKey ( "<STR_LIT>" ) <EOL> self . assertEquals ( self . mockos . seteuidCalls , [ ] ) <EOL> self . assertEquals ( self . mockos . setegidCalls , [ ] ) <EOL> def test_checkKey2 ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _testCheckKey ( "<STR_LIT>" ) <EOL> self . assertEquals ( self . mockos . seteuidCalls , [ ] ) <EOL> self . assertEquals ( self . mockos . setegidCalls , [ ] ) <EOL> def test_checkKeyAsRoot ( self ) : <EOL> """<STR_LIT>""" <EOL> keyFile = self . sshDir . child ( "<STR_LIT>" ) <EOL> keyFile . setContent ( self . content ) <EOL> keyFile . chmod ( <NUM_LIT> ) <EOL> self . addCleanup ( keyFile . chmod , <NUM_LIT:0> <NUM_LIT> ) <EOL> savedSeteuid = os . seteuid <EOL> def seteuid ( euid ) : <EOL> keyFile . chmod ( <NUM_LIT:0> <NUM_LIT> ) <EOL> return savedSeteuid ( euid ) <EOL> self . patch ( os , "<STR_LIT>" , seteuid ) <EOL> user = UsernamePassword ( "<STR_LIT:user>" , "<STR_LIT:password>" ) <EOL> user . blob = "<STR_LIT>" <EOL> self . assertTrue ( self . checker . checkKey ( user ) ) <EOL> self . assertEquals ( self . mockos . seteuidCalls , [ <NUM_LIT:0> , <NUM_LIT:1> , <NUM_LIT:0> , os . getuid ( ) ] ) <EOL> self . assertEquals ( self . mockos . setegidCalls , [ <NUM_LIT:2> , os . getgid ( ) ] ) <EOL> def test_requestAvatarId ( self ) : <EOL> """<STR_LIT>""" <EOL> def _checkKey ( ignored ) : <EOL> return True <EOL> self . patch ( self . checker , '<STR_LIT>' , _checkKey ) <EOL> credentials = SSHPrivateKey ( '<STR_LIT:test>' , '<STR_LIT>' , keydata . publicRSA_openssh , <EOL> '<STR_LIT:foo>' , keys . Key . fromString ( keydata . privateRSA_openssh ) . sign ( '<STR_LIT:foo>' ) ) <EOL> d = self . checker . requestAvatarId ( credentials ) <EOL> def _verify ( avatarId ) : <EOL> self . assertEquals ( avatarId , '<STR_LIT:test>' ) <EOL> return d . addCallback ( _verify ) <EOL> def test_requestAvatarIdWithoutSignature ( self ) : <EOL> """<STR_LIT>""" <EOL> def _checkKey ( ignored ) : <EOL> return True <EOL> self . patch ( self . checker , '<STR_LIT>' , _checkKey ) <EOL> credentials = SSHPrivateKey ( '<STR_LIT:test>' , '<STR_LIT>' , keydata . publicRSA_openssh , None , None ) <EOL> d = self . checker . requestAvatarId ( credentials ) <EOL> return self . assertFailure ( d , ValidPublicKey ) <EOL> def test_requestAvatarIdInvalidKey ( self ) : <EOL> """<STR_LIT>""" <EOL> def _checkKey ( ignored ) : <EOL> return False <EOL> self . patch ( self . checker , '<STR_LIT>' , _checkKey ) <EOL> d = self . checker . requestAvatarId ( None ) ; <EOL> return self . assertFailure ( d , UnauthorizedLogin ) <EOL> def test_requestAvatarIdInvalidSignature ( self ) :

"""<STR_LIT>"""

"""<STR_LIT>""" <EOL> try : <EOL> import pwd <EOL> except ImportError : <EOL> pwd = None <EOL> import os , base64 <EOL> from twisted . trial . unittest import TestCase <EOL> from twisted . python . filepath import FilePath <EOL> from twisted . cred . checkers import InMemoryUsernamePasswordDatabaseDontUse <EOL> from twisted . cred . credentials import UsernamePassword , IUsernamePassword , SSHPrivateKey , ISSHPrivateKey <EOL> from twisted . cred . error import UnhandledCredentials , UnauthorizedLogin <EOL> from twisted . python . fakepwd import UserDatabase <EOL> from twisted . test . test_process import MockOS <EOL> try : <EOL> import Crypto . Cipher . DES3 <EOL> import pyasn1 <EOL> except ImportError : <EOL> SSHPublicKeyDatabase = None <EOL> else : <EOL> from twisted . conch . ssh import keys <EOL> from twisted . conch . checkers import SSHPublicKeyDatabase , SSHProtocolChecker <EOL> from twisted . conch . error import NotEnoughAuthentication , ValidPublicKey <EOL> from twisted . conch . test import keydata <EOL> class SSHPublicKeyDatabaseTestCase ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> if pwd is None : <EOL> skip = "<STR_LIT>" <EOL> elif SSHPublicKeyDatabase is None : <EOL> skip = "<STR_LIT>" <EOL> def setUp ( self ) : <EOL> self . checker = SSHPublicKeyDatabase ( ) <EOL> self . key1 = base64 . encodestring ( "<STR_LIT>" ) <EOL> self . key2 = base64 . encodestring ( "<STR_LIT>" ) <EOL> self . content = "<STR_LIT>" % ( self . key1 , self . key2 ) <EOL> self . mockos = MockOS ( ) <EOL> self . mockos . path = FilePath ( self . mktemp ( ) ) <EOL> self . mockos . path . makedirs ( ) <EOL> self . sshDir = self . mockos . path . child ( '<STR_LIT>' ) <EOL> self . sshDir . makedirs ( ) <EOL> userdb = UserDatabase ( ) <EOL> userdb . addUser ( '<STR_LIT:user>' , '<STR_LIT:password>' , <NUM_LIT:1> , <NUM_LIT:2> , '<STR_LIT>' , <EOL> self . mockos . path . path , '<STR_LIT>' ) <EOL> self . patch ( pwd , "<STR_LIT>" , userdb . getpwnam ) <EOL> self . patch ( os , "<STR_LIT>" , self . mockos . seteuid ) <EOL> self . patch ( os , "<STR_LIT>" , self . mockos . setegid ) <EOL> def _testCheckKey ( self , filename ) : <EOL> self . sshDir . child ( filename ) . setContent ( self . content ) <EOL> user = UsernamePassword ( "<STR_LIT:user>" , "<STR_LIT:password>" ) <EOL> user . blob = "<STR_LIT>" <EOL> self . assertTrue ( self . checker . checkKey ( user ) ) <EOL> user . blob = "<STR_LIT>" <EOL> self . assertTrue ( self . checker . checkKey ( user ) ) <EOL> user . blob = "<STR_LIT>" <EOL> self . assertFalse ( self . checker . checkKey ( user ) ) <EOL> def test_checkKey ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _testCheckKey ( "<STR_LIT>" ) <EOL> self . assertEquals ( self . mockos . seteuidCalls , [ ] ) <EOL> self . assertEquals ( self . mockos . setegidCalls , [ ] ) <EOL> def test_checkKey2 ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _testCheckKey ( "<STR_LIT>" ) <EOL> self . assertEquals ( self . mockos . seteuidCalls , [ ] ) <EOL> self . assertEquals ( self . mockos . setegidCalls , [ ] ) <EOL> def test_checkKeyAsRoot ( self ) : <EOL> """<STR_LIT>""" <EOL> keyFile = self . sshDir . child ( "<STR_LIT>" ) <EOL> keyFile . setContent ( self . content ) <EOL> keyFile . chmod ( <NUM_LIT> ) <EOL> self . addCleanup ( keyFile . chmod , <NUM_LIT:0> <NUM_LIT> ) <EOL> savedSeteuid = os . seteuid <EOL> def seteuid ( euid ) : <EOL> keyFile . chmod ( <NUM_LIT:0> <NUM_LIT> ) <EOL> return savedSeteuid ( euid ) <EOL> self . patch ( os , "<STR_LIT>" , seteuid ) <EOL> user = UsernamePassword ( "<STR_LIT:user>" , "<STR_LIT:password>" ) <EOL> user . blob = "<STR_LIT>" <EOL> self . assertTrue ( self . checker . checkKey ( user ) ) <EOL> self . assertEquals ( self . mockos . seteuidCalls , [ <NUM_LIT:0> , <NUM_LIT:1> , <NUM_LIT:0> , os . getuid ( ) ] ) <EOL> self . assertEquals ( self . mockos . setegidCalls , [ <NUM_LIT:2> , os . getgid ( ) ] ) <EOL> def test_requestAvatarId ( self ) : <EOL> """<STR_LIT>""" <EOL> def _checkKey ( ignored ) : <EOL> return True <EOL> self . patch ( self . checker , '<STR_LIT>' , _checkKey ) <EOL> credentials = SSHPrivateKey ( '<STR_LIT:test>' , '<STR_LIT>' , keydata . publicRSA_openssh , <EOL> '<STR_LIT:foo>' , keys . Key . fromString ( keydata . privateRSA_openssh ) . sign ( '<STR_LIT:foo>' ) ) <EOL> d = self . checker . requestAvatarId ( credentials ) <EOL> def _verify ( avatarId ) : <EOL> self . assertEquals ( avatarId , '<STR_LIT:test>' ) <EOL> return d . addCallback ( _verify ) <EOL> def test_requestAvatarIdWithoutSignature ( self ) : <EOL> """<STR_LIT>""" <EOL> def _checkKey ( ignored ) : <EOL> return True <EOL> self . patch ( self . checker , '<STR_LIT>' , _checkKey ) <EOL> credentials = SSHPrivateKey ( '<STR_LIT:test>' , '<STR_LIT>' , keydata . publicRSA_openssh , None , None ) <EOL> d = self . checker . requestAvatarId ( credentials ) <EOL> return self . assertFailure ( d , ValidPublicKey ) <EOL> def test_requestAvatarIdInvalidKey ( self ) : <EOL> """<STR_LIT>""" <EOL> def _checkKey ( ignored ) : <EOL> return False <EOL> self . patch ( self . checker , '<STR_LIT>' , _checkKey ) <EOL> d = self . checker . requestAvatarId ( None ) ; <EOL> return self . assertFailure ( d , UnauthorizedLogin ) <EOL> def test_requestAvatarIdInvalidSignature ( self ) : <EOL> """<STR_LIT>""" <EOL> def _checkKey ( ignored ) : <EOL> return True <EOL> self . patch ( self . checker , '<STR_LIT>' , _checkKey ) <EOL> credentials = SSHPrivateKey ( '<STR_LIT:test>' , '<STR_LIT>' , keydata . publicRSA_openssh , <EOL> '<STR_LIT:foo>' , keys . Key . fromString ( keydata . privateDSA_openssh ) . sign ( '<STR_LIT:foo>' ) ) <EOL> d = self . checker . requestAvatarId ( credentials ) <EOL> return self . assertFailure ( d , UnauthorizedLogin ) <EOL> def test_requestAvatarIdNormalizeException ( self ) : <EOL> """<STR_LIT>""" <EOL> def _checkKey ( ignored ) : <EOL> return True <EOL> self . patch ( self . checker , '<STR_LIT>' , _checkKey ) <EOL> credentials = SSHPrivateKey ( '<STR_LIT:test>' , None , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) <EOL> d = self . checker . requestAvatarId ( credentials ) <EOL> def _verifyLoggedException ( failure ) : <EOL> errors = self . flushLoggedErrors ( keys . BadKeyError ) <EOL> self . assertEqual ( len ( errors ) , <NUM_LIT:1> ) <EOL> return failure <EOL> d . addErrback ( _verifyLoggedException ) <EOL> return self . assertFailure ( d , UnauthorizedLogin ) <EOL> class SSHProtocolCheckerTestCase ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> if SSHPublicKeyDatabase is None : <EOL> skip = "<STR_LIT>" <EOL> def test_registerChecker ( self ) : <EOL> """<STR_LIT>""" <EOL> checker = SSHProtocolChecker ( ) <EOL> self . assertEquals ( checker . credentialInterfaces , [ ] ) <EOL> checker . registerChecker ( SSHPublicKeyDatabase ( ) , ) <EOL> self . assertEquals ( checker . credentialInterfaces , [ ISSHPrivateKey ] ) <EOL> self . assertIsInstance ( checker . checkers [ ISSHPrivateKey ] , <EOL> SSHPublicKeyDatabase ) <EOL> def test_registerCheckerWithInterface ( self ) : <EOL> """<STR_LIT>""" <EOL> checker = SSHProtocolChecker ( ) <EOL> self . assertEquals ( checker . credentialInterfaces , [ ] ) <EOL> checker . registerChecker ( SSHPublicKeyDatabase ( ) , IUsernamePassword ) <EOL> self . assertEquals ( checker . credentialInterfaces , [ IUsernamePassword ] ) <EOL> self . assertIsInstance ( checker . checkers [ IUsernamePassword ] , <EOL> SSHPublicKeyDatabase ) <EOL> def test_requestAvatarId ( self ) : <EOL> """<STR_LIT>""" <EOL> checker = SSHProtocolChecker ( ) <EOL> passwordDatabase = InMemoryUsernamePasswordDatabaseDontUse ( ) <EOL> passwordDatabase . addUser ( '<STR_LIT:test>' , '<STR_LIT:test>' ) <EOL> checker . registerChecker ( passwordDatabase ) <EOL> d = checker . requestAvatarId ( UsernamePassword ( '<STR_LIT:test>' , '<STR_LIT:test>' ) ) <EOL> def _callback ( avatarId ) : <EOL> self . assertEquals ( avatarId , '<STR_LIT:test>' ) <EOL> return d . addCallback ( _callback ) <EOL> def test_requestAvatarIdWithNotEnoughAuthentication ( self ) : <EOL> """<STR_LIT>""" <EOL> checker = SSHProtocolChecker ( ) <EOL> def _areDone ( avatarId ) : <EOL> return False <EOL> self . patch ( checker , '<STR_LIT>' , _areDone ) <EOL> passwordDatabase = InMemoryUsernamePasswordDatabaseDontUse ( ) <EOL> passwordDatabase . addUser ( '<STR_LIT:test>' , '<STR_LIT:test>' ) <EOL> checker . registerChecker ( passwordDatabase ) <EOL> d = checker . requestAvatarId ( UsernamePassword ( '<STR_LIT:test>' , '<STR_LIT:test>' ) ) <EOL> return self . assertFailure ( d , NotEnoughAuthentication ) <EOL> def test_requestAvatarIdInvalidCredential ( self ) : <EOL> """<STR_LIT>""" <EOL> checker = SSHProtocolChecker ( ) <EOL> d = checker . requestAvatarId ( UsernamePassword ( '<STR_LIT:test>' , '<STR_LIT:test>' ) ) <EOL> return self . assertFailure ( d , UnhandledCredentials ) <EOL> def test_areDone ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertEquals ( SSHProtocolChecker ( ) . areDone ( None ) , True ) </s>

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

"""<STR_LIT>""" <EOL> from twisted import __version__ as version , version as longversion <EOL> longversion = str ( longversion ) <EOL> copyright = """<STR_LIT>""" <EOL> disclaimer = '''<STR_LIT>''' % copyright </s>

"""<STR_LIT>""" <EOL> import socket <EOL> from zope . interface import implements , classImplements <EOL> import sys <EOL> import warnings <EOL> from heapq import heappush , heappop , heapify <EOL> import traceback <EOL> from twisted . python . compat import set <EOL> from twisted . python . util import unsignedID <EOL> from twisted . internet . interfaces import IReactorCore , IReactorTime , IReactorThreads <EOL> from twisted . internet . interfaces import IResolverSimple , IReactorPluggableResolver <EOL> from twisted . internet . interfaces import IConnector , IDelayedCall <EOL> from twisted . internet import fdesc , main , error , abstract , defer , threads <EOL> from twisted . python import log , failure , reflect <EOL> from twisted . python . runtime import seconds as runtimeSeconds , platform <EOL> from twisted . internet . defer import Deferred , DeferredList <EOL> from twisted . persisted import styles <EOL> from twisted . python import threadable <EOL> class DelayedCall ( styles . Ephemeral ) : <EOL> implements ( IDelayedCall ) <EOL> debug = False <EOL> _str = None <EOL> def __init__ ( self , time , func , args , kw , cancel , reset , <EOL> seconds = runtimeSeconds ) : <EOL> """<STR_LIT>""" <EOL> self . time , self . func , self . args , self . kw = time , func , args , kw <EOL> self . resetter = reset <EOL> self . canceller = cancel <EOL> self . seconds = seconds <EOL> self . cancelled = self . called = <NUM_LIT:0> <EOL> self . delayed_time = <NUM_LIT:0> <EOL> if self . debug : <EOL> self . creator = traceback . format_stack ( ) [ : - <NUM_LIT:2> ] <EOL> def getTime ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . time + self . delayed_time <EOL> def cancel ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . cancelled : <EOL> raise error . AlreadyCancelled <EOL> elif self . called : <EOL> raise error . AlreadyCalled <EOL> else : <EOL> self . canceller ( self ) <EOL> self . cancelled = <NUM_LIT:1> <EOL> if self . debug : <EOL> self . _str = str ( self ) <EOL> del self . func , self . args , self . kw <EOL> def reset ( self , secondsFromNow ) : <EOL> """<STR_LIT>""" <EOL> if self . cancelled : <EOL> raise error . AlreadyCancelled <EOL> elif self . called : <EOL> raise error . AlreadyCalled <EOL> else : <EOL> newTime = self . seconds ( ) + secondsFromNow <EOL> if newTime < self . time : <EOL> self . delayed_time = <NUM_LIT:0> <EOL> self . time = newTime <EOL> self . resetter ( self ) <EOL> else : <EOL> self . delayed_time = newTime - self . time <EOL> def delay ( self , secondsLater ) : <EOL> """<STR_LIT>""" <EOL> if self . cancelled : <EOL> raise error . AlreadyCancelled <EOL> elif self . called : <EOL> raise error . AlreadyCalled <EOL> else : <EOL> self . delayed_time += secondsLater <EOL> if self . delayed_time < <NUM_LIT:0> : <EOL> self . activate_delay ( ) <EOL> self . resetter ( self ) <EOL> def activate_delay ( self ) : <EOL> self . time += self . delayed_time <EOL> self . delayed_time = <NUM_LIT:0> <EOL> def active ( self ) : <EOL> """<STR_LIT>""" <EOL> return not ( self . cancelled or self . called ) <EOL> def __le__ ( self , other ) : <EOL> """<STR_LIT>""" <EOL> return self . time <= other . time <EOL> def __lt__ ( self , other ) : <EOL> """<STR_LIT>""" <EOL> return self . time < other . time <EOL> def __str__ ( self ) : <EOL> if self . _str is not None : <EOL> return self . _str <EOL> if hasattr ( self , '<STR_LIT>' ) : <EOL> if hasattr ( self . func , '<STR_LIT>' ) : <EOL> func = self . func . func_name <EOL> if hasattr ( self . func , '<STR_LIT>' ) : <EOL> func = self . func . im_class . __name__ + '<STR_LIT:.>' + func <EOL> else : <EOL> func = reflect . safe_repr ( self . func ) <EOL> else : <EOL> func = None <EOL> now = self . seconds ( ) <EOL> L = [ "<STR_LIT>" % ( <EOL> unsignedID ( self ) , self . time - now , self . called , <EOL> self . cancelled ) ] <EOL> if func is not None : <EOL> L . extend ( ( "<STR_LIT:U+0020>" , func , "<STR_LIT:(>" ) ) <EOL> if self . args : <EOL> L . append ( "<STR_LIT:U+002CU+0020>" . join ( [ reflect . safe_repr ( e ) for e in self . args ] ) ) <EOL> if self . kw : <EOL> L . append ( "<STR_LIT:U+002CU+0020>" ) <EOL> if self . kw : <EOL> L . append ( "<STR_LIT:U+002CU+0020>" . join ( [ '<STR_LIT>' % ( k , reflect . safe_repr ( v ) ) for ( k , v ) in self . kw . iteritems ( ) ] ) ) <EOL> L . append ( "<STR_LIT:)>" ) <EOL> if self . debug : <EOL> L . append ( "<STR_LIT>" % ( '<STR_LIT:U+0020>' . join ( self . creator ) ) ) <EOL> L . append ( '<STR_LIT:>>' ) <EOL> return "<STR_LIT>" . join ( L ) <EOL> class ThreadedResolver ( object ) : <EOL> """<STR_LIT>""" <EOL> implements ( IResolverSimple ) <EOL> def __init__ ( self , reactor ) : <EOL> self . reactor = reactor <EOL> self . _runningQueries = { } <EOL> def _fail ( self , name , err ) : <EOL> err = error . DNSLookupError ( "<STR_LIT>" % ( name , err ) ) <EOL> return failure . Failure ( err ) <EOL> def _cleanup ( self , name , lookupDeferred ) : <EOL> userDeferred , cancelCall = self . _runningQueries [ lookupDeferred ] <EOL> del self . _runningQueries [ lookupDeferred ] <EOL> userDeferred . errback ( self . _fail ( name , "<STR_LIT>" ) ) <EOL> def _checkTimeout ( self , result , name , lookupDeferred ) : <EOL> try : <EOL> userDeferred , cancelCall = self . _runningQueries [ lookupDeferred ] <EOL> except KeyError : <EOL> pass <EOL> else : <EOL> del self . _runningQueries [ lookupDeferred ] <EOL> cancelCall . cancel ( ) <EOL> if isinstance ( result , failure . Failure ) : <EOL> userDeferred . errback ( self . _fail ( name , result . getErrorMessage ( ) ) ) <EOL> else : <EOL> userDeferred . callback ( result ) <EOL> def getHostByName ( self , name , timeout = ( <NUM_LIT:1> , <NUM_LIT:3> , <NUM_LIT:11> , <NUM_LIT> ) ) : <EOL> """<STR_LIT>""" <EOL> if timeout : <EOL> timeoutDelay = sum ( timeout ) <EOL> else : <EOL> timeoutDelay = <NUM_LIT> <EOL> userDeferred = defer . Deferred ( ) <EOL> lookupDeferred = threads . deferToThreadPool ( <EOL> self . reactor , self . reactor . getThreadPool ( ) , <EOL> socket . gethostbyname , name ) <EOL> cancelCall = self . reactor . callLater ( <EOL> timeoutDelay , self . _cleanup , name , lookupDeferred ) <EOL> self . _runningQueries [ lookupDeferred ] = ( userDeferred , cancelCall ) <EOL> lookupDeferred . addBoth ( self . _checkTimeout , name , lookupDeferred ) <EOL> return userDeferred <EOL> class BlockingResolver : <EOL> implements ( IResolverSimple ) <EOL> def getHostByName ( self , name , timeout = ( <NUM_LIT:1> , <NUM_LIT:3> , <NUM_LIT:11> , <NUM_LIT> ) ) : <EOL> try : <EOL> address = socket . gethostbyname ( name ) <EOL> except socket . error : <EOL> msg = "<STR_LIT>" % ( name , ) <EOL> err = error . DNSLookupError ( msg ) <EOL> return defer . fail ( err ) <EOL> else : <EOL> return defer . succeed ( address ) <EOL> class _ThreePhaseEvent ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self ) : <EOL> self . before = [ ] <EOL> self . during = [ ] <EOL> self . after = [ ] <EOL> self . state = '<STR_LIT>'

def addTrigger ( self , phase , callable , * args , ** kwargs ) :

"""<STR_LIT>""" <EOL> import socket <EOL> from zope . interface import implements , classImplements <EOL> import sys <EOL> import warnings <EOL> from heapq import heappush , heappop , heapify <EOL> import traceback <EOL> from twisted . python . compat import set <EOL> from twisted . python . util import unsignedID <EOL> from twisted . internet . interfaces import IReactorCore , IReactorTime , IReactorThreads <EOL> from twisted . internet . interfaces import IResolverSimple , IReactorPluggableResolver <EOL> from twisted . internet . interfaces import IConnector , IDelayedCall <EOL> from twisted . internet import fdesc , main , error , abstract , defer , threads <EOL> from twisted . python import log , failure , reflect <EOL> from twisted . python . runtime import seconds as runtimeSeconds , platform <EOL> from twisted . internet . defer import Deferred , DeferredList <EOL> from twisted . persisted import styles <EOL> from twisted . python import threadable <EOL> class DelayedCall ( styles . Ephemeral ) : <EOL> implements ( IDelayedCall ) <EOL> debug = False <EOL> _str = None <EOL> def __init__ ( self , time , func , args , kw , cancel , reset , <EOL> seconds = runtimeSeconds ) : <EOL> """<STR_LIT>""" <EOL> self . time , self . func , self . args , self . kw = time , func , args , kw <EOL> self . resetter = reset <EOL> self . canceller = cancel <EOL> self . seconds = seconds <EOL> self . cancelled = self . called = <NUM_LIT:0> <EOL> self . delayed_time = <NUM_LIT:0> <EOL> if self . debug : <EOL> self . creator = traceback . format_stack ( ) [ : - <NUM_LIT:2> ] <EOL> def getTime ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . time + self . delayed_time <EOL> def cancel ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . cancelled : <EOL> raise error . AlreadyCancelled <EOL> elif self . called : <EOL> raise error . AlreadyCalled <EOL> else : <EOL> self . canceller ( self ) <EOL> self . cancelled = <NUM_LIT:1> <EOL> if self . debug : <EOL> self . _str = str ( self ) <EOL> del self . func , self . args , self . kw <EOL> def reset ( self , secondsFromNow ) : <EOL> """<STR_LIT>""" <EOL> if self . cancelled : <EOL> raise error . AlreadyCancelled <EOL> elif self . called : <EOL> raise error . AlreadyCalled <EOL> else : <EOL> newTime = self . seconds ( ) + secondsFromNow <EOL> if newTime < self . time : <EOL> self . delayed_time = <NUM_LIT:0> <EOL> self . time = newTime <EOL> self . resetter ( self ) <EOL> else : <EOL> self . delayed_time = newTime - self . time <EOL> def delay ( self , secondsLater ) : <EOL> """<STR_LIT>""" <EOL> if self . cancelled : <EOL> raise error . AlreadyCancelled <EOL> elif self . called : <EOL> raise error . AlreadyCalled <EOL> else : <EOL> self . delayed_time += secondsLater <EOL> if self . delayed_time < <NUM_LIT:0> : <EOL> self . activate_delay ( ) <EOL> self . resetter ( self ) <EOL> def activate_delay ( self ) : <EOL> self . time += self . delayed_time <EOL> self . delayed_time = <NUM_LIT:0> <EOL> def active ( self ) : <EOL> """<STR_LIT>""" <EOL> return not ( self . cancelled or self . called ) <EOL> def __le__ ( self , other ) : <EOL> """<STR_LIT>""" <EOL> return self . time <= other . time <EOL> def __lt__ ( self , other ) : <EOL> """<STR_LIT>""" <EOL> return self . time < other . time <EOL> def __str__ ( self ) : <EOL> if self . _str is not None : <EOL> return self . _str <EOL> if hasattr ( self , '<STR_LIT>' ) : <EOL> if hasattr ( self . func , '<STR_LIT>' ) : <EOL> func = self . func . func_name <EOL> if hasattr ( self . func , '<STR_LIT>' ) : <EOL> func = self . func . im_class . __name__ + '<STR_LIT:.>' + func <EOL> else : <EOL> func = reflect . safe_repr ( self . func ) <EOL> else : <EOL> func = None <EOL> now = self . seconds ( ) <EOL> L = [ "<STR_LIT>" % ( <EOL> unsignedID ( self ) , self . time - now , self . called , <EOL> self . cancelled ) ] <EOL> if func is not None : <EOL> L . extend ( ( "<STR_LIT:U+0020>" , func , "<STR_LIT:(>" ) ) <EOL> if self . args : <EOL> L . append ( "<STR_LIT:U+002CU+0020>" . join ( [ reflect . safe_repr ( e ) for e in self . args ] ) ) <EOL> if self . kw : <EOL> L . append ( "<STR_LIT:U+002CU+0020>" ) <EOL> if self . kw : <EOL> L . append ( "<STR_LIT:U+002CU+0020>" . join ( [ '<STR_LIT>' % ( k , reflect . safe_repr ( v ) ) for ( k , v ) in self . kw . iteritems ( ) ] ) ) <EOL> L . append ( "<STR_LIT:)>" ) <EOL> if self . debug : <EOL> L . append ( "<STR_LIT>" % ( '<STR_LIT:U+0020>' . join ( self . creator ) ) ) <EOL> L . append ( '<STR_LIT:>>' ) <EOL> return "<STR_LIT>" . join ( L ) <EOL> class ThreadedResolver ( object ) : <EOL> """<STR_LIT>""" <EOL> implements ( IResolverSimple ) <EOL> def __init__ ( self , reactor ) : <EOL> self . reactor = reactor <EOL> self . _runningQueries = { } <EOL> def _fail ( self , name , err ) : <EOL> err = error . DNSLookupError ( "<STR_LIT>" % ( name , err ) ) <EOL> return failure . Failure ( err ) <EOL> def _cleanup ( self , name , lookupDeferred ) : <EOL> userDeferred , cancelCall = self . _runningQueries [ lookupDeferred ] <EOL> del self . _runningQueries [ lookupDeferred ] <EOL> userDeferred . errback ( self . _fail ( name , "<STR_LIT>" ) ) <EOL> def _checkTimeout ( self , result , name , lookupDeferred ) : <EOL> try : <EOL> userDeferred , cancelCall = self . _runningQueries [ lookupDeferred ] <EOL> except KeyError : <EOL> pass <EOL> else : <EOL> del self . _runningQueries [ lookupDeferred ] <EOL> cancelCall . cancel ( ) <EOL> if isinstance ( result , failure . Failure ) : <EOL> userDeferred . errback ( self . _fail ( name , result . getErrorMessage ( ) ) ) <EOL> else : <EOL> userDeferred . callback ( result ) <EOL> def getHostByName ( self , name , timeout = ( <NUM_LIT:1> , <NUM_LIT:3> , <NUM_LIT:11> , <NUM_LIT> ) ) : <EOL> """<STR_LIT>""" <EOL> if timeout : <EOL> timeoutDelay = sum ( timeout ) <EOL> else : <EOL> timeoutDelay = <NUM_LIT> <EOL> userDeferred = defer . Deferred ( ) <EOL> lookupDeferred = threads . deferToThreadPool ( <EOL> self . reactor , self . reactor . getThreadPool ( ) , <EOL> socket . gethostbyname , name ) <EOL> cancelCall = self . reactor . callLater ( <EOL> timeoutDelay , self . _cleanup , name , lookupDeferred ) <EOL> self . _runningQueries [ lookupDeferred ] = ( userDeferred , cancelCall ) <EOL> lookupDeferred . addBoth ( self . _checkTimeout , name , lookupDeferred ) <EOL> return userDeferred <EOL> class BlockingResolver : <EOL> implements ( IResolverSimple ) <EOL> def getHostByName ( self , name , timeout = ( <NUM_LIT:1> , <NUM_LIT:3> , <NUM_LIT:11> , <NUM_LIT> ) ) : <EOL> try : <EOL> address = socket . gethostbyname ( name ) <EOL> except socket . error : <EOL> msg = "<STR_LIT>" % ( name , ) <EOL> err = error . DNSLookupError ( msg ) <EOL> return defer . fail ( err ) <EOL> else : <EOL> return defer . succeed ( address ) <EOL> class _ThreePhaseEvent ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self ) : <EOL> self . before = [ ] <EOL> self . during = [ ] <EOL> self . after = [ ] <EOL> self . state = '<STR_LIT>' <EOL> def addTrigger ( self , phase , callable , * args , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> if phase not in ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) : <EOL> raise KeyError ( "<STR_LIT>" ) <EOL> getattr ( self , phase ) . append ( ( callable , args , kwargs ) ) <EOL> return phase , callable , args , kwargs <EOL> def removeTrigger ( self , handle ) : <EOL> """<STR_LIT>""" <EOL> return getattr ( self , '<STR_LIT>' + self . state ) ( handle ) <EOL> def removeTrigger_BASE ( self , handle ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> phase , callable , args , kwargs = handle <EOL> except ( TypeError , ValueError ) : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> else : <EOL> if phase not in ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) : <EOL> raise KeyError ( "<STR_LIT>" ) <EOL> getattr ( self , phase ) . remove ( ( callable , args , kwargs ) ) <EOL> def removeTrigger_BEFORE ( self , handle ) : <EOL> """<STR_LIT>""" <EOL> phase , callable , args , kwargs = handle <EOL> if phase != '<STR_LIT>' : <EOL> return self . removeTrigger_BASE ( handle ) <EOL> if ( callable , args , kwargs ) in self . finishedBefore : <EOL> warnings . warn ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" , <EOL> category = DeprecationWarning , <EOL> stacklevel = <NUM_LIT:3> ) <EOL> else : <EOL> self . removeTrigger_BASE ( handle ) <EOL> def fireEvent ( self ) : <EOL> """<STR_LIT>""" <EOL> self . state = '<STR_LIT>' <EOL> self . finishedBefore = [ ] <EOL> beforeResults = [ ] <EOL> while self . before : <EOL> callable , args , kwargs = self . before . pop ( <NUM_LIT:0> ) <EOL> self . finishedBefore . append ( ( callable , args , kwargs ) ) <EOL> try : <EOL> result = callable ( * args , ** kwargs ) <EOL> except : <EOL> log . err ( ) <EOL> else : <EOL> if isinstance ( result , Deferred ) : <EOL> beforeResults . append ( result ) <EOL> DeferredList ( beforeResults ) . addCallback ( self . _continueFiring ) <EOL> def _continueFiring ( self , ignored ) : <EOL> """<STR_LIT>""" <EOL> self . state = '<STR_LIT>' <EOL> self . finishedBefore = [ ] <EOL> for phase in self . during , self . after : <EOL> while phase : <EOL> callable , args , kwargs = phase . pop ( <NUM_LIT:0> ) <EOL> try : <EOL> callable ( * args , ** kwargs ) <EOL> except : <EOL> log . err ( ) <EOL> class ReactorBase ( object ) : <EOL> """<STR_LIT>""" <EOL> implements ( IReactorCore , IReactorTime , IReactorPluggableResolver ) <EOL> _stopped = True <EOL> installed = False <EOL> usingThreads = False <EOL> resolver = BlockingResolver ( ) <EOL> __name__ = "<STR_LIT>" <EOL> def __init__ ( self ) : <EOL> self . threadCallQueue = [ ] <EOL> self . _eventTriggers = { } <EOL> self . _pendingTimedCalls = [ ] <EOL> self . _newTimedCalls = [ ] <EOL> self . _cancellations = <NUM_LIT:0> <EOL> self . running = False <EOL> self . _started = False <EOL> self . _justStopped = False <EOL> self . _internalReaders = set ( ) <EOL> self . waker = None <EOL> self . addSystemEventTrigger ( <EOL> '<STR_LIT>' , '<STR_LIT>' , self . _reallyStartRunning ) <EOL> self . addSystemEventTrigger ( '<STR_LIT>' , '<STR_LIT>' , self . crash ) <EOL> self . addSystemEventTrigger ( '<STR_LIT>' , '<STR_LIT>' , self . disconnectAll ) <EOL> if platform . supportsThreads ( ) : <EOL> self . _initThreads ( ) <EOL> self . installWaker ( ) <EOL> _lock = None <EOL> def installWaker ( self ) : <EOL> raise NotImplementedError ( <EOL> reflect . qual ( self . __class__ ) + "<STR_LIT>" ) <EOL> def installResolver ( self , resolver ) : <EOL> assert IResolverSimple . providedBy ( resolver ) <EOL> oldResolver = self . resolver <EOL> self . resolver = resolver <EOL> return oldResolver <EOL> def wakeUp ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . waker : <EOL> self . waker . wakeUp ( ) <EOL> def doIteration ( self , delay ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError ( <EOL> reflect . qual ( self . __class__ ) + "<STR_LIT>" ) <EOL> def addReader ( self , reader ) : <EOL> raise NotImplementedError ( <EOL> reflect . qual ( self . __class__ ) + "<STR_LIT>" ) <EOL> def addWriter ( self , writer ) : <EOL> raise NotImplementedError ( <EOL> reflect . qual ( self . __class__ ) + "<STR_LIT>" ) <EOL> def removeReader ( self , reader ) : <EOL> raise NotImplementedError ( <EOL> reflect . qual ( self . __class__ ) + "<STR_LIT>" ) <EOL> def removeWriter ( self , writer ) : <EOL> raise NotImplementedError ( <EOL> reflect . qual ( self . __class__ ) + "<STR_LIT>" ) <EOL> def removeAll ( self ) : <EOL> raise NotImplementedError ( <EOL> reflect . qual ( self . __class__ ) + "<STR_LIT>" ) <EOL> def getReaders ( self ) : <EOL> raise NotImplementedError ( <EOL> reflect . qual ( self . __class__ ) + "<STR_LIT>" ) <EOL> def getWriters ( self ) : <EOL> raise NotImplementedError ( <EOL> reflect . qual ( self . __class__ ) + "<STR_LIT>" ) <EOL> def resolve ( self , name , timeout = ( <NUM_LIT:1> , <NUM_LIT:3> , <NUM_LIT:11> , <NUM_LIT> ) ) : <EOL> """<STR_LIT>""" <EOL> if not name : <EOL> return defer . succeed ( '<STR_LIT>' ) <EOL> if abstract . isIPAddress ( name ) : <EOL> return defer . succeed ( name ) <EOL> return self . resolver . getHostByName ( name , timeout ) <EOL> def stop ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _stopped : <EOL> raise error . ReactorNotRunning ( <EOL> "<STR_LIT>" ) <EOL> self . _stopped = True <EOL> self . _justStopped = True <EOL> def crash ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _started = False <EOL> self . running = False <EOL> self . addSystemEventTrigger ( <EOL> '<STR_LIT>' , '<STR_LIT>' , self . _reallyStartRunning ) <EOL> def sigInt ( self , * args ) : <EOL> """<STR_LIT>""" <EOL> log . msg ( "<STR_LIT>" ) <EOL> self . callFromThread ( self . stop ) <EOL> def sigBreak ( self , * args ) : <EOL> """<STR_LIT>""" <EOL> log . msg ( "<STR_LIT>" ) <EOL> self . callFromThread ( self . stop ) <EOL> def sigTerm ( self , * args ) : <EOL> """<STR_LIT>""" <EOL> log . msg ( "<STR_LIT>" ) <EOL> self . callFromThread ( self . stop ) <EOL> def disconnectAll ( self ) : <EOL> """<STR_LIT>""" <EOL> selectables = self . removeAll ( ) <EOL> for reader in selectables : <EOL> log . callWithLogger ( reader , <EOL> reader . connectionLost , <EOL> failure . Failure ( main . CONNECTION_LOST ) ) <EOL> def iterate ( self , delay = <NUM_LIT:0> ) : <EOL> """<STR_LIT>""" <EOL> self . runUntilCurrent ( ) <EOL> self . doIteration ( delay ) <EOL> def fireSystemEvent ( self , eventType ) : <EOL> """<STR_LIT>""" <EOL> event = self . _eventTriggers . get ( eventType ) <EOL> if event is not None : <EOL> event . fireEvent ( ) <EOL> def addSystemEventTrigger ( self , _phase , _eventType , _f , * args , ** kw ) : <EOL> """<STR_LIT>""" <EOL> assert callable ( _f ) , "<STR_LIT>" % _f <EOL> if _eventType not in self . _eventTriggers : <EOL> self . _eventTriggers [ _eventType ] = _ThreePhaseEvent ( ) <EOL> return ( _eventType , self . _eventTriggers [ _eventType ] . addTrigger ( <EOL> _phase , _f , * args , ** kw ) ) <EOL> def removeSystemEventTrigger ( self , triggerID ) : <EOL> """<STR_LIT>""" <EOL> eventType , handle = triggerID <EOL> self . _eventTriggers [ eventType ] . removeTrigger ( handle ) <EOL> def callWhenRunning ( self , _callable , * args , ** kw ) : <EOL> """<STR_LIT>""" <EOL> if self . running : <EOL> _callable ( * args , ** kw ) <EOL> else : <EOL> return self . addSystemEventTrigger ( '<STR_LIT>' , '<STR_LIT>' , <EOL> _callable , * args , ** kw ) <EOL> def startRunning ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _started : <EOL> raise error . ReactorAlreadyRunning ( ) <EOL> self . _started = True <EOL> self . _stopped = False <EOL> threadable . registerAsIOThread ( ) <EOL> self . fireSystemEvent ( '<STR_LIT>' ) <EOL> def _reallyStartRunning ( self ) : <EOL> """<STR_LIT>""" <EOL> self . running = True <EOL> seconds = staticmethod ( runtimeSeconds ) <EOL> def callLater ( self , _seconds , _f , * args , ** kw ) : <EOL> """<STR_LIT>""" <EOL> assert callable ( _f ) , "<STR_LIT>" % _f <EOL> assert sys . maxint >= _seconds >= <NUM_LIT:0> , "<STR_LIT>" % ( _seconds , ) <EOL> tple = DelayedCall ( self . seconds ( ) + _seconds , _f , args , kw , <EOL> self . _cancelCallLater , <EOL> self . _moveCallLaterSooner , <EOL> seconds = self . seconds ) <EOL> self . _newTimedCalls . append ( tple ) <EOL> return tple <EOL> def _moveCallLaterSooner ( self , tple ) : <EOL> heap = self . _pendingTimedCalls <EOL> try : <EOL> pos = heap . index ( tple ) <EOL> elt = heap [ pos ] <EOL> while pos != <NUM_LIT:0> : <EOL> parent = ( pos - <NUM_LIT:1> ) // <NUM_LIT:2> <EOL> if heap [ parent ] <= elt : <EOL> break <EOL> heap [ pos ] = heap [ parent ] <EOL> pos = parent <EOL> heap [ pos ] = elt <EOL> except ValueError : <EOL> pass <EOL> def _cancelCallLater ( self , tple ) : <EOL> self . _cancellations += <NUM_LIT:1> <EOL> def getDelayedCalls ( self ) : <EOL> """<STR_LIT>""" <EOL> return [ x for x in ( self . _pendingTimedCalls + self . _newTimedCalls ) if not x . cancelled ] <EOL> def _insertNewDelayedCalls ( self ) : <EOL> for call in self . _newTimedCalls : <EOL> if call . cancelled : <EOL> self . _cancellations -= <NUM_LIT:1> <EOL> else : <EOL> call . activate_delay ( ) <EOL> heappush ( self . _pendingTimedCalls , call ) <EOL> self . _newTimedCalls = [ ] <EOL> def timeout ( self ) : <EOL> self . _insertNewDelayedCalls ( ) <EOL> if not self . _pendingTimedCalls : <EOL> return None <EOL> return max ( <NUM_LIT:0> , self . _pendingTimedCalls [ <NUM_LIT:0> ] . time - self . seconds ( ) ) <EOL> def runUntilCurrent ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . threadCallQueue : <EOL> count = <NUM_LIT:0> <EOL> total = len ( self . threadCallQueue ) <EOL> for ( f , a , kw ) in self . threadCallQueue : <EOL> try : <EOL> f ( * a , ** kw ) <EOL> except : <EOL> log . err ( ) <EOL> count += <NUM_LIT:1> <EOL> if count == total : <EOL> break <EOL> del self . threadCallQueue [ : count ] <EOL> if self . threadCallQueue : <EOL> self . wakeUp ( ) <EOL> self . _insertNewDelayedCalls ( ) <EOL> now = self . seconds ( ) <EOL> while self . _pendingTimedCalls and ( self . _pendingTimedCalls [ <NUM_LIT:0> ] . time <= now ) : <EOL> call = heappop ( self . _pendingTimedCalls ) <EOL> if call . cancelled : <EOL> self . _cancellations -= <NUM_LIT:1> <EOL> continue <EOL> if call . delayed_time > <NUM_LIT:0> : <EOL> call . activate_delay ( ) <EOL> heappush ( self . _pendingTimedCalls , call ) <EOL> continue <EOL> try : <EOL> call . called = <NUM_LIT:1> <EOL> call . func ( * call . args , ** call . kw ) <EOL> except : <EOL> log . deferr ( ) <EOL> if hasattr ( call , "<STR_LIT>" ) : <EOL> e = "<STR_LIT:\n>" <EOL> e += "<STR_LIT>" + "<STR_LIT>" <EOL> e += "<STR_LIT>" <EOL> e += "<STR_LIT>" . join ( call . creator ) . rstrip ( ) . replace ( "<STR_LIT:\n>" , "<STR_LIT>" ) <EOL> e += "<STR_LIT:\n>" <EOL> log . msg ( e ) <EOL> if ( self . _cancellations > <NUM_LIT:50> and <EOL> self . _cancellations > len ( self . _pendingTimedCalls ) >> <NUM_LIT:1> ) : <EOL> self . _cancellations = <NUM_LIT:0> <EOL> self . _pendingTimedCalls = [ x for x in self . _pendingTimedCalls <EOL> if not x . cancelled ] <EOL> heapify ( self . _pendingTimedCalls ) <EOL> if self . _justStopped : <EOL> self . _justStopped = False <EOL> self . fireSystemEvent ( "<STR_LIT>" ) <EOL> def _checkProcessArgs ( self , args , env ) : <EOL> """<STR_LIT>""" <EOL> defaultEncoding = sys . getdefaultencoding ( ) <EOL> def argChecker ( arg ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( arg , unicode ) : <EOL> try : <EOL> arg = arg . encode ( defaultEncoding ) <EOL> except UnicodeEncodeError : <EOL> return None <EOL> warnings . warn ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" , <EOL> category = DeprecationWarning , <EOL> stacklevel = <NUM_LIT:4> ) <EOL> if isinstance ( arg , str ) and '<STR_LIT>' not in arg : <EOL> return arg <EOL> return None <EOL> if not isinstance ( args , ( tuple , list ) ) : <EOL> raise TypeError ( "<STR_LIT>" ) <EOL> outputArgs = [ ] <EOL> for arg in args : <EOL> arg = argChecker ( arg ) <EOL> if arg is None : <EOL> raise TypeError ( "<STR_LIT>" ) <EOL> else : <EOL> outputArgs . append ( arg ) <EOL> outputEnv = None <EOL> if env is not None : <EOL> outputEnv = { } <EOL> for key , val in env . iteritems ( ) : <EOL> key = argChecker ( key ) <EOL> if key is None : <EOL> raise TypeError ( "<STR_LIT>" ) <EOL> val = argChecker ( val ) <EOL> if val is None : <EOL> raise TypeError ( "<STR_LIT>" ) <EOL> outputEnv [ key ] = val <EOL> return outputArgs , outputEnv <EOL> if platform . supportsThreads ( ) : <EOL> threadpool = None <EOL> _threadpoolStartupID = None <EOL> threadpoolShutdownID = None <EOL> def _initThreads ( self ) : <EOL> self . usingThreads = True <EOL> self . resolver = ThreadedResolver ( self ) <EOL> def callFromThread ( self , f , * args , ** kw ) : <EOL> """<STR_LIT>""" <EOL> assert callable ( f ) , "<STR_LIT>" % ( f , ) <EOL> self . threadCallQueue . append ( ( f , args , kw ) ) <EOL> self . wakeUp ( ) <EOL> def _initThreadPool ( self ) : <EOL> """<STR_LIT>""" <EOL> from twisted . python import threadpool <EOL> self . threadpool = threadpool . ThreadPool ( <EOL> <NUM_LIT:0> , <NUM_LIT:10> , '<STR_LIT>' ) <EOL> self . _threadpoolStartupID = self . callWhenRunning ( <EOL> self . threadpool . start ) <EOL> self . threadpoolShutdownID = self . addSystemEventTrigger ( <EOL> '<STR_LIT>' , '<STR_LIT>' , self . _stopThreadPool ) <EOL> def _uninstallHandler ( self ) : <EOL> pass <EOL> def _stopThreadPool ( self ) : <EOL> """<STR_LIT>""" <EOL> triggers = [ self . _threadpoolStartupID , self . threadpoolShutdownID ] <EOL> for trigger in filter ( None , triggers ) : <EOL> try : <EOL> self . removeSystemEventTrigger ( trigger ) <EOL> except ValueError : <EOL> pass <EOL> self . _threadpoolStartupID = None <EOL> self . threadpoolShutdownID = None <EOL> self . threadpool . stop ( ) <EOL> self . threadpool = None <EOL> def getThreadPool ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . threadpool is None : <EOL> self . _initThreadPool ( ) <EOL> return self . threadpool <EOL> def callInThread ( self , _callable , * args , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> self . getThreadPool ( ) . callInThread ( _callable , * args , ** kwargs ) <EOL> def suggestThreadPoolSize ( self , size ) : <EOL> """<STR_LIT>""" <EOL> self . getThreadPool ( ) . adjustPoolsize ( maxthreads = size ) <EOL> else : <EOL> def callFromThread ( self , f , * args , ** kw ) : <EOL> assert callable ( f ) , "<STR_LIT>" % ( f , ) <EOL> self . threadCallQueue . append ( ( f , args , kw ) ) <EOL> if platform . supportsThreads ( ) : <EOL> classImplements ( ReactorBase , IReactorThreads ) <EOL> class BaseConnector ( styles . Ephemeral ) : <EOL> """<STR_LIT>""" <EOL> implements ( IConnector ) <EOL> timeoutID = None <EOL> factoryStarted = <NUM_LIT:0> <EOL> def __init__ ( self , factory , timeout , reactor ) : <EOL> self . state = "<STR_LIT>" <EOL> self . reactor = reactor <EOL> self . factory = factory <EOL> self . timeout = timeout <EOL> def disconnect ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . state == '<STR_LIT>' : <EOL> self . stopConnecting ( ) <EOL> elif self . state == '<STR_LIT>' : <EOL> self . transport . loseConnection ( ) <EOL> def connect ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . state != "<STR_LIT>" : <EOL> raise RuntimeError , "<STR_LIT>" <EOL> self . state = "<STR_LIT>" <EOL> if not self . factoryStarted : <EOL> self . factory . doStart ( ) <EOL> self . factoryStarted = <NUM_LIT:1> <EOL> self . transport = transport = self . _makeTransport ( ) <EOL> if self . timeout is not None : <EOL> self . timeoutID = self . reactor . callLater ( self . timeout , transport . failIfNotConnected , error . TimeoutError ( ) ) <EOL> self . factory . startedConnecting ( self ) <EOL> def stopConnecting ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . state != "<STR_LIT>" : <EOL> raise error . NotConnectingError , "<STR_LIT>" <EOL> self . state = "<STR_LIT>" <EOL> self . transport . failIfNotConnected ( error . UserError ( ) ) <EOL> del self . transport <EOL> def cancelTimeout ( self ) : <EOL> if self . timeoutID is not None : <EOL> try : <EOL> self . timeoutID . cancel ( ) <EOL> except ValueError : <EOL> pass <EOL> del self . timeoutID <EOL> def buildProtocol ( self , addr ) : <EOL> self . state = "<STR_LIT>" <EOL> self . cancelTimeout ( ) <EOL> return self . factory . buildProtocol ( addr ) <EOL> def connectionFailed ( self , reason ) : <EOL> self . cancelTimeout ( ) <EOL> self . transport = None <EOL> self . state = "<STR_LIT>" <EOL> self . factory . clientConnectionFailed ( self , reason ) <EOL> if self . state == "<STR_LIT>" : <EOL> self . factory . doStop ( ) <EOL> self . factoryStarted = <NUM_LIT:0> <EOL> def connectionLost ( self , reason ) : <EOL> self . state = "<STR_LIT>" <EOL> self . factory . clientConnectionLost ( self , reason ) <EOL> if self . state == "<STR_LIT>" : <EOL> self . factory . doStop ( ) <EOL> self . factoryStarted = <NUM_LIT:0> <EOL> def getDestination ( self ) : <EOL> raise NotImplementedError ( <EOL> reflect . qual ( self . __class__ ) + "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> class BasePort ( abstract . FileDescriptor ) : <EOL> """<STR_LIT>""" <EOL> addressFamily = None <EOL> socketType = None <EOL> def createInternetSocket ( self ) : <EOL> s = socket . socket ( self . addressFamily , self . socketType ) <EOL> s . setblocking ( <NUM_LIT:0> ) <EOL> fdesc . _setCloseOnExec ( s . fileno ( ) ) <EOL> return s <EOL> def doWrite ( self ) : <EOL> """<STR_LIT>""" <EOL> raise RuntimeError , "<STR_LIT>" % reflect . qual ( self . __class__ ) <EOL> class _SignalReactorMixin ( object ) : <EOL> """<STR_LIT>""" <EOL> _installSignalHandlers = False <EOL> def _handleSignals ( self ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> import signal <EOL> except ImportError : <EOL> log . msg ( "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> return <EOL> if signal . getsignal ( signal . SIGINT ) == signal . default_int_handler : <EOL> signal . signal ( signal . SIGINT , self . sigInt ) <EOL> signal . signal ( signal . SIGTERM , self . sigTerm ) <EOL> if hasattr ( signal , "<STR_LIT>" ) : <EOL> signal . signal ( signal . SIGBREAK , self . sigBreak ) <EOL> def startRunning ( self , installSignalHandlers = True ) : <EOL> """<STR_LIT>""" <EOL> self . _installSignalHandlers = installSignalHandlers <EOL> ReactorBase . startRunning ( self ) <EOL> def _reallyStartRunning ( self ) : <EOL> """<STR_LIT>""" <EOL> ReactorBase . _reallyStartRunning ( self ) <EOL> if self . _installSignalHandlers : <EOL> self . _handleSignals ( ) <EOL> def run ( self , installSignalHandlers = True ) : <EOL> self . startRunning ( installSignalHandlers = installSignalHandlers ) <EOL> self . mainLoop ( ) <EOL> def mainLoop ( self ) : <EOL> while self . _started : <EOL> try : <EOL> while self . _started : <EOL> self . runUntilCurrent ( ) <EOL> t2 = self . timeout ( ) <EOL> t = self . running and t2 <EOL> self . doIteration ( t ) <EOL> except : <EOL> log . msg ( "<STR_LIT>" ) <EOL> log . err ( ) <EOL> else : <EOL> log . msg ( '<STR_LIT>' ) <EOL> __all__ = [ ] </s>

<s> try :

try : <EOL> install = __import__ ( '<STR_LIT>' ) . install <EOL> except ImportError : <EOL> from twisted . plugins . twisted_qtstub import errorMessage <EOL> raise ImportError ( errorMessage ) <EOL> else : <EOL> import warnings <EOL> warnings . warn ( "<STR_LIT>" , <EOL> category = DeprecationWarning ) <EOL> __all__ = [ '<STR_LIT>' ] </s>

"""<STR_LIT>""" <EOL> from twisted . python . failure import Failure <EOL> from twisted . internet . defer import CancelledError <EOL> from twisted . internet . protocol import Protocol , ClientCreator <EOL> from twisted . internet . task import Clock <EOL> from twisted . trial . unittest import TestCase <EOL> from twisted . test . proto_helpers import MemoryReactor , StringTransport <EOL> class MemoryConnector : <EOL> _disconnected = False <EOL> def disconnect ( self ) : <EOL> self . _disconnected = True <EOL> class MemoryReactorWithConnectorsAndTime ( MemoryReactor , Clock ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self ) : <EOL> MemoryReactor . __init__ ( self ) <EOL> Clock . __init__ ( self ) <EOL> self . connectors = [ ] <EOL> def connectTCP ( self , * a , ** kw ) : <EOL> MemoryReactor . connectTCP ( self , * a , ** kw ) <EOL> connector = MemoryConnector ( ) <EOL> self . connectors . append ( connector ) <EOL> return connector <EOL> def connectUNIX ( self , * a , ** kw ) : <EOL> MemoryReactor . connectUNIX ( self , * a , ** kw ) <EOL> connector = MemoryConnector ( ) <EOL> self . connectors . append ( connector ) <EOL> return connector <EOL> def connectSSL ( self , * a , ** kw ) : <EOL> MemoryReactor . connectSSL ( self , * a , ** kw ) <EOL> connector = MemoryConnector ( ) <EOL> self . connectors . append ( connector ) <EOL> return connector <EOL> class ClientCreatorTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def _basicConnectTest ( self , check ) : <EOL> """<STR_LIT>""" <EOL> class SomeProtocol ( Protocol ) : <EOL> pass <EOL> reactor = MemoryReactorWithConnectorsAndTime ( ) <EOL> cc = ClientCreator ( reactor , SomeProtocol ) <EOL> factory = check ( reactor , cc ) <EOL> protocol = factory . buildProtocol ( None ) <EOL> self . assertIsInstance ( protocol , SomeProtocol ) <EOL> def test_connectTCP ( self ) : <EOL> """<STR_LIT>""" <EOL> def check ( reactor , cc ) : <EOL> cc . connectTCP ( '<STR_LIT>' , <NUM_LIT> , <NUM_LIT> , ( '<STR_LIT>' , <NUM_LIT> ) ) <EOL> host , port , factory , timeout , bindAddress = reactor . tcpClients . pop ( ) <EOL> self . assertEquals ( host , '<STR_LIT>' ) <EOL> self . assertEquals ( port , <NUM_LIT> ) <EOL> self . assertEquals ( timeout , <NUM_LIT> ) <EOL> self . assertEquals ( bindAddress , ( '<STR_LIT>' , <NUM_LIT> ) ) <EOL> return factory <EOL> self . _basicConnectTest ( check ) <EOL> def test_connectUNIX ( self ) : <EOL> """<STR_LIT>""" <EOL> def check ( reactor , cc ) : <EOL> cc . connectUNIX ( '<STR_LIT>' , <NUM_LIT> , True ) <EOL> address , factory , timeout , checkPID = reactor . unixClients . pop ( ) <EOL> self . assertEquals ( address , '<STR_LIT>' ) <EOL> self . assertEquals ( timeout , <NUM_LIT> ) <EOL> self . assertEquals ( checkPID , True ) <EOL> return factory <EOL> self . _basicConnectTest ( check ) <EOL> def test_connectSSL ( self ) : <EOL> """<STR_LIT>""" <EOL> def check ( reactor , cc ) : <EOL> expectedContextFactory = object ( ) <EOL> cc . connectSSL ( '<STR_LIT>' , <NUM_LIT> , expectedContextFactory , <NUM_LIT> , ( '<STR_LIT>' , <NUM_LIT> ) ) <EOL> host , port , factory , contextFactory , timeout , bindAddress = reactor . sslClients . pop ( ) <EOL> self . assertEquals ( host , '<STR_LIT>' )

self . assertEquals ( port , <NUM_LIT> )

"""<STR_LIT>""" <EOL> from twisted . python . failure import Failure <EOL> from twisted . internet . defer import CancelledError <EOL> from twisted . internet . protocol import Protocol , ClientCreator <EOL> from twisted . internet . task import Clock <EOL> from twisted . trial . unittest import TestCase <EOL> from twisted . test . proto_helpers import MemoryReactor , StringTransport <EOL> class MemoryConnector : <EOL> _disconnected = False <EOL> def disconnect ( self ) : <EOL> self . _disconnected = True <EOL> class MemoryReactorWithConnectorsAndTime ( MemoryReactor , Clock ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self ) : <EOL> MemoryReactor . __init__ ( self ) <EOL> Clock . __init__ ( self ) <EOL> self . connectors = [ ] <EOL> def connectTCP ( self , * a , ** kw ) : <EOL> MemoryReactor . connectTCP ( self , * a , ** kw ) <EOL> connector = MemoryConnector ( ) <EOL> self . connectors . append ( connector ) <EOL> return connector <EOL> def connectUNIX ( self , * a , ** kw ) : <EOL> MemoryReactor . connectUNIX ( self , * a , ** kw ) <EOL> connector = MemoryConnector ( ) <EOL> self . connectors . append ( connector ) <EOL> return connector <EOL> def connectSSL ( self , * a , ** kw ) : <EOL> MemoryReactor . connectSSL ( self , * a , ** kw ) <EOL> connector = MemoryConnector ( ) <EOL> self . connectors . append ( connector ) <EOL> return connector <EOL> class ClientCreatorTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def _basicConnectTest ( self , check ) : <EOL> """<STR_LIT>""" <EOL> class SomeProtocol ( Protocol ) : <EOL> pass <EOL> reactor = MemoryReactorWithConnectorsAndTime ( ) <EOL> cc = ClientCreator ( reactor , SomeProtocol ) <EOL> factory = check ( reactor , cc ) <EOL> protocol = factory . buildProtocol ( None ) <EOL> self . assertIsInstance ( protocol , SomeProtocol ) <EOL> def test_connectTCP ( self ) : <EOL> """<STR_LIT>""" <EOL> def check ( reactor , cc ) : <EOL> cc . connectTCP ( '<STR_LIT>' , <NUM_LIT> , <NUM_LIT> , ( '<STR_LIT>' , <NUM_LIT> ) ) <EOL> host , port , factory , timeout , bindAddress = reactor . tcpClients . pop ( ) <EOL> self . assertEquals ( host , '<STR_LIT>' ) <EOL> self . assertEquals ( port , <NUM_LIT> ) <EOL> self . assertEquals ( timeout , <NUM_LIT> ) <EOL> self . assertEquals ( bindAddress , ( '<STR_LIT>' , <NUM_LIT> ) ) <EOL> return factory <EOL> self . _basicConnectTest ( check ) <EOL> def test_connectUNIX ( self ) : <EOL> """<STR_LIT>""" <EOL> def check ( reactor , cc ) : <EOL> cc . connectUNIX ( '<STR_LIT>' , <NUM_LIT> , True ) <EOL> address , factory , timeout , checkPID = reactor . unixClients . pop ( ) <EOL> self . assertEquals ( address , '<STR_LIT>' ) <EOL> self . assertEquals ( timeout , <NUM_LIT> ) <EOL> self . assertEquals ( checkPID , True ) <EOL> return factory <EOL> self . _basicConnectTest ( check ) <EOL> def test_connectSSL ( self ) : <EOL> """<STR_LIT>""" <EOL> def check ( reactor , cc ) : <EOL> expectedContextFactory = object ( ) <EOL> cc . connectSSL ( '<STR_LIT>' , <NUM_LIT> , expectedContextFactory , <NUM_LIT> , ( '<STR_LIT>' , <NUM_LIT> ) ) <EOL> host , port , factory , contextFactory , timeout , bindAddress = reactor . sslClients . pop ( ) <EOL> self . assertEquals ( host , '<STR_LIT>' ) <EOL> self . assertEquals ( port , <NUM_LIT> ) <EOL> self . assertIdentical ( contextFactory , expectedContextFactory ) <EOL> self . assertEquals ( timeout , <NUM_LIT> ) <EOL> self . assertEquals ( bindAddress , ( '<STR_LIT>' , <NUM_LIT> ) ) <EOL> return factory <EOL> self . _basicConnectTest ( check ) <EOL> def _cancelConnectTest ( self , connect ) : <EOL> """<STR_LIT>""" <EOL> reactor = MemoryReactorWithConnectorsAndTime ( ) <EOL> cc = ClientCreator ( reactor , Protocol ) <EOL> d = connect ( cc ) <EOL> connector = reactor . connectors . pop ( ) <EOL> self . assertFalse ( connector . _disconnected ) <EOL> d . cancel ( ) <EOL> self . assertTrue ( connector . _disconnected ) <EOL> return self . assertFailure ( d , CancelledError ) <EOL> def test_cancelConnectTCP ( self ) : <EOL> """<STR_LIT>""" <EOL> def connect ( cc ) : <EOL> return cc . connectTCP ( '<STR_LIT>' , <NUM_LIT> ) <EOL> return self . _cancelConnectTest ( connect ) <EOL> def test_cancelConnectUNIX ( self ) : <EOL> """<STR_LIT>""" <EOL> def connect ( cc ) : <EOL> return cc . connectUNIX ( '<STR_LIT>' ) <EOL> return self . _cancelConnectTest ( connect ) <EOL> def test_cancelConnectSSL ( self ) : <EOL> """<STR_LIT>""" <EOL> def connect ( cc ) : <EOL> return cc . connectSSL ( '<STR_LIT>' , <NUM_LIT> , object ( ) ) <EOL> return self . _cancelConnectTest ( connect ) <EOL> def _cancelConnectTimeoutTest ( self , connect ) : <EOL> """<STR_LIT>""" <EOL> reactor = MemoryReactorWithConnectorsAndTime ( ) <EOL> cc = ClientCreator ( reactor , Protocol ) <EOL> d = connect ( reactor , cc ) <EOL> connector = reactor . connectors . pop ( ) <EOL> self . assertEquals ( len ( reactor . getDelayedCalls ( ) ) , <NUM_LIT:1> ) <EOL> d . cancel ( ) <EOL> self . assertEquals ( reactor . getDelayedCalls ( ) , [ ] ) <EOL> self . assertTrue ( connector . _disconnected ) <EOL> return self . assertFailure ( d , CancelledError ) <EOL> def test_cancelConnectTCPTimeout ( self ) : <EOL> """<STR_LIT>""" <EOL> def connect ( reactor , cc ) : <EOL> d = cc . connectTCP ( '<STR_LIT>' , <NUM_LIT> ) <EOL> host , port , factory , timeout , bindAddress = reactor . tcpClients . pop ( ) <EOL> protocol = factory . buildProtocol ( None ) <EOL> transport = StringTransport ( ) <EOL> protocol . makeConnection ( transport ) <EOL> return d <EOL> return self . _cancelConnectTimeoutTest ( connect ) <EOL> def test_cancelConnectUNIXTimeout ( self ) : <EOL> """<STR_LIT>""" <EOL> def connect ( reactor , cc ) : <EOL> d = cc . connectUNIX ( '<STR_LIT>' ) <EOL> address , factory , timeout , bindAddress = reactor . unixClients . pop ( ) <EOL> protocol = factory . buildProtocol ( None ) <EOL> transport = StringTransport ( ) <EOL> protocol . makeConnection ( transport ) <EOL> return d <EOL> return self . _cancelConnectTimeoutTest ( connect ) <EOL> def test_cancelConnectSSLTimeout ( self ) : <EOL> """<STR_LIT>""" <EOL> def connect ( reactor , cc ) : <EOL> d = cc . connectSSL ( '<STR_LIT>' , <NUM_LIT> , object ( ) ) <EOL> host , port , factory , contextFactory , timeout , bindADdress = reactor . sslClients . pop ( ) <EOL> protocol = factory . buildProtocol ( None ) <EOL> transport = StringTransport ( ) <EOL> protocol . makeConnection ( transport ) <EOL> return d <EOL> return self . _cancelConnectTimeoutTest ( connect ) <EOL> def _cancelConnectFailedTimeoutTest ( self , connect ) : <EOL> """<STR_LIT>""" <EOL> reactor = MemoryReactorWithConnectorsAndTime ( ) <EOL> cc = ClientCreator ( reactor , Protocol ) <EOL> d , factory = connect ( reactor , cc ) <EOL> connector = reactor . connectors . pop ( ) <EOL> factory . clientConnectionFailed ( <EOL> connector , Failure ( Exception ( "<STR_LIT>" ) ) ) <EOL> self . assertEquals ( len ( reactor . getDelayedCalls ( ) ) , <NUM_LIT:1> ) <EOL> d . cancel ( ) <EOL> self . assertEquals ( reactor . getDelayedCalls ( ) , [ ] ) <EOL> return self . assertFailure ( d , CancelledError ) <EOL> def test_cancelConnectTCPFailedTimeout ( self ) : <EOL> """<STR_LIT>""" <EOL> def connect ( reactor , cc ) : <EOL> d = cc . connectTCP ( '<STR_LIT>' , <NUM_LIT> ) <EOL> host , port , factory , timeout , bindAddress = reactor . tcpClients . pop ( ) <EOL> return d , factory <EOL> return self . _cancelConnectFailedTimeoutTest ( connect ) <EOL> def test_cancelConnectUNIXFailedTimeout ( self ) : <EOL> """<STR_LIT>""" <EOL> def connect ( reactor , cc ) : <EOL> d = cc . connectUNIX ( '<STR_LIT>' ) <EOL> address , factory , timeout , bindAddress = reactor . unixClients . pop ( ) <EOL> return d , factory <EOL> return self . _cancelConnectFailedTimeoutTest ( connect ) <EOL> def test_cancelConnectSSLFailedTimeout ( self ) : <EOL> """<STR_LIT>""" <EOL> def connect ( reactor , cc ) : <EOL> d = cc . connectSSL ( '<STR_LIT>' , <NUM_LIT> , object ( ) ) <EOL> host , port , factory , contextFactory , timeout , bindADdress = reactor . sslClients . pop ( ) <EOL> return d , factory <EOL> return self . _cancelConnectFailedTimeoutTest ( connect ) </s>

def reset ( ) : <EOL> resetFilenum ( ) <EOL> setNumberSections ( False ) <EOL> def resetFilenum ( ) : <EOL> setFilenum ( <NUM_LIT:0> ) <EOL> def setFilenum ( arg ) : <EOL> global filenum <EOL> filenum = arg <EOL> def getFilenum ( ) : <EOL> global filenum <EOL> return filenum <EOL> def getNextFilenum ( ) : <EOL> global filenum

filenum += <NUM_LIT:1>

def reset ( ) : <EOL> resetFilenum ( ) <EOL> setNumberSections ( False ) <EOL> def resetFilenum ( ) : <EOL> setFilenum ( <NUM_LIT:0> ) <EOL> def setFilenum ( arg ) : <EOL> global filenum <EOL> filenum = arg <EOL> def getFilenum ( ) : <EOL> global filenum <EOL> return filenum <EOL> def getNextFilenum ( ) : <EOL> global filenum <EOL> filenum += <NUM_LIT:1> <EOL> return filenum <EOL> def setNumberSections ( arg ) : <EOL> global numberSections <EOL> numberSections = arg <EOL> def getNumberSections ( ) : <EOL> global numberSections <EOL> return numberSections <EOL> reset ( ) </s>

"""<STR_LIT>""" <EOL> import rfc822 <EOL> import os <EOL> import time <EOL> try : <EOL> import cPickle as pickle <EOL> except ImportError : <EOL> import pickle <EOL> from twisted . python import log <EOL> from twisted . python . failure import Failure <EOL> from twisted . python . compat import set <EOL> from twisted . mail import relay <EOL> from twisted . mail import bounce <EOL> from twisted . internet import protocol <EOL> from twisted . internet . defer import Deferred , DeferredList <EOL> from twisted . internet . error import DNSLookupError <EOL> from twisted . mail import smtp <EOL> from twisted . application import internet <EOL> class ManagedRelayerMixin : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , manager ) : <EOL> self . manager = manager <EOL> def sentMail ( self , code , resp , numOk , addresses , log ) : <EOL> """<STR_LIT>""" <EOL> message = self . names [ <NUM_LIT:0> ] <EOL> if code in smtp . SUCCESS : <EOL> self . manager . notifySuccess ( self . factory , message ) <EOL> else : <EOL> self . manager . notifyFailure ( self . factory , message ) <EOL> del self . messages [ <NUM_LIT:0> ] <EOL> del self . names [ <NUM_LIT:0> ] <EOL> def connectionLost ( self , reason ) : <EOL> """<STR_LIT>""" <EOL> self . manager . notifyDone ( self . factory ) <EOL> class SMTPManagedRelayer ( ManagedRelayerMixin , relay . SMTPRelayer ) : <EOL> def __init__ ( self , messages , manager , * args , ** kw ) : <EOL> """<STR_LIT>""" <EOL> ManagedRelayerMixin . __init__ ( self , manager ) <EOL> relay . SMTPRelayer . __init__ ( self , messages , * args , ** kw ) <EOL> class ESMTPManagedRelayer ( ManagedRelayerMixin , relay . ESMTPRelayer ) : <EOL> def __init__ ( self , messages , manager , * args , ** kw ) : <EOL> """<STR_LIT>""" <EOL> ManagedRelayerMixin . __init__ ( self , manager ) <EOL> relay . ESMTPRelayer . __init__ ( self , messages , * args , ** kw ) <EOL> class SMTPManagedRelayerFactory ( protocol . ClientFactory ) : <EOL> protocol = SMTPManagedRelayer <EOL> def __init__ ( self , messages , manager , * args , ** kw ) : <EOL> self . messages = messages <EOL> self . manager = manager <EOL> self . pArgs = args <EOL> self . pKwArgs = kw <EOL> def buildProtocol ( self , addr ) : <EOL> protocol = self . protocol ( self . messages , self . manager , * self . pArgs , <EOL> ** self . pKwArgs ) <EOL> protocol . factory = self <EOL> return protocol <EOL> def clientConnectionFailed ( self , connector , reason ) : <EOL> """<STR_LIT>""" <EOL> self . manager . notifyNoConnection ( self ) <EOL> self . manager . notifyDone ( self ) <EOL> class ESMTPManagedRelayerFactory ( SMTPManagedRelayerFactory ) : <EOL> protocol = ESMTPManagedRelayer <EOL> def __init__ ( self , messages , manager , secret , contextFactory , * args , ** kw ) : <EOL> self . secret = secret <EOL> self . contextFactory = contextFactory <EOL> SMTPManagedRelayerFactory . __init__ ( self , messages , manager , * args , ** kw ) <EOL> def buildProtocol ( self , addr ) : <EOL> s = self . secret and self . secret ( addr ) <EOL> protocol = self . protocol ( self . messages , self . manager , s , <EOL> self . contextFactory , * self . pArgs , ** self . pKwArgs ) <EOL> protocol . factory = self <EOL> return protocol <EOL> class Queue : <EOL> """<STR_LIT>""" <EOL> noisy = True <EOL> def __init__ ( self , directory ) : <EOL> self . directory = directory <EOL> self . _init ( ) <EOL> def _init ( self ) : <EOL> self . n = <NUM_LIT:0> <EOL> self . waiting = { } <EOL> self . relayed = { } <EOL> self . readDirectory ( ) <EOL> def __getstate__ ( self ) : <EOL> """<STR_LIT>""" <EOL> return { '<STR_LIT>' : self . directory } <EOL> def __setstate__ ( self , state ) : <EOL> """<STR_LIT>""" <EOL> self . __dict__ . update ( state ) <EOL> self . _init ( ) <EOL> def readDirectory ( self ) : <EOL> """<STR_LIT>""" <EOL> for message in os . listdir ( self . directory ) : <EOL> if message [ - <NUM_LIT:2> : ] != '<STR_LIT>' : <EOL> continue <EOL> self . addMessage ( message [ : - <NUM_LIT:2> ] ) <EOL> def getWaiting ( self ) : <EOL> return self . waiting . keys ( ) <EOL> def hasWaiting ( self ) : <EOL> return len ( self . waiting ) > <NUM_LIT:0> <EOL> def getRelayed ( self ) : <EOL> return self . relayed . keys ( ) <EOL> def setRelaying ( self , message ) : <EOL> del self . waiting [ message ] <EOL> self . relayed [ message ] = <NUM_LIT:1> <EOL> def setWaiting ( self , message ) : <EOL> del self . relayed [ message ] <EOL> self . waiting [ message ] = <NUM_LIT:1> <EOL> def addMessage ( self , message ) : <EOL> if message not in self . relayed : <EOL> self . waiting [ message ] = <NUM_LIT:1> <EOL> if self . noisy : <EOL> log . msg ( '<STR_LIT>' + message + '<STR_LIT>' ) <EOL> def done ( self , message ) : <EOL> """<STR_LIT>""" <EOL> message = os . path . basename ( message ) <EOL> os . remove ( self . getPath ( message ) + '<STR_LIT>' ) <EOL> os . remove ( self . getPath ( message ) + '<STR_LIT>' ) <EOL> del self . relayed [ message ] <EOL> def getPath ( self , message ) : <EOL> """<STR_LIT>""" <EOL> return os . path . join ( self . directory , message ) <EOL> def getEnvelope ( self , message ) : <EOL> return pickle . load ( self . getEnvelopeFile ( message ) ) <EOL> def getEnvelopeFile ( self , message ) : <EOL> return open ( os . path . join ( self . directory , message + '<STR_LIT>' ) , '<STR_LIT:rb>' ) <EOL> def createNewMessage ( self ) : <EOL> """<STR_LIT>""" <EOL> fname = "<STR_LIT>" % ( os . getpid ( ) , time . time ( ) , self . n , id ( self ) ) <EOL> self . n = self . n + <NUM_LIT:1> <EOL> headerFile = open ( os . path . join ( self . directory , fname + '<STR_LIT>' ) , '<STR_LIT:wb>' ) <EOL> tempFilename = os . path . join ( self . directory , fname + '<STR_LIT>' ) <EOL> finalFilename = os . path . join ( self . directory , fname + '<STR_LIT>' ) <EOL> messageFile = open ( tempFilename , '<STR_LIT:wb>' ) <EOL> from twisted . mail . mail import FileMessage <EOL> return headerFile , FileMessage ( messageFile , tempFilename , finalFilename ) <EOL> class _AttemptManager ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , manager ) : <EOL> self . manager = manager <EOL> self . _completionDeferreds = [ ] <EOL> def getCompletionDeferred ( self ) : <EOL> self . _completionDeferreds . append ( Deferred ( ) ) <EOL> return self . _completionDeferreds [ - <NUM_LIT:1> ] <EOL> def _finish ( self , relay , message ) : <EOL> self . manager . managed [ relay ] . remove ( os . path . basename ( message ) ) <EOL> self . manager . queue . done ( message ) <EOL> def notifySuccess ( self , relay , message ) : <EOL> """<STR_LIT>""" <EOL> if self . manager . queue . noisy : <EOL> log . msg ( "<STR_LIT>" % message ) <EOL> self . _finish ( relay , message ) <EOL> def notifyFailure ( self , relay , message ) : <EOL> """<STR_LIT>""" <EOL> if self . manager . queue . noisy : <EOL> log . msg ( "<STR_LIT>" + message ) <EOL> message = os . path . basename ( message ) <EOL> fp = self . manager . queue . getEnvelopeFile ( message ) <EOL> from_ , to = pickle . load ( fp ) <EOL> fp . close ( ) <EOL> from_ , to , bounceMessage = bounce . generateBounce ( open ( self . manager . queue . getPath ( message ) + '<STR_LIT>' ) , from_ , to ) <EOL> fp , outgoingMessage = self . manager . queue . createNewMessage ( ) <EOL> pickle . dump ( [ from_ , to ] , fp ) <EOL> fp . close ( ) <EOL> for line in bounceMessage . splitlines ( ) : <EOL> outgoingMessage . lineReceived ( line ) <EOL> outgoingMessage . eomReceived ( ) <EOL> self . _finish ( relay , self . manager . queue . getPath ( message ) ) <EOL> def notifyDone ( self , relay ) : <EOL> """<STR_LIT>""" <EOL> for message in self . manager . managed . get ( relay , ( ) ) : <EOL> if self . manager . queue . noisy : <EOL> log . msg ( "<STR_LIT>" + message + "<STR_LIT>" ) <EOL> self . manager . queue . setWaiting ( message ) <EOL> try : <EOL> del self . manager . managed [ relay ] <EOL> except KeyError : <EOL> pass <EOL> notifications = self . _completionDeferreds <EOL> self . _completionDeferreds = None <EOL> for d in notifications : <EOL> d . callback ( None ) <EOL> def notifyNoConnection ( self , relay ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> msgs = self . manager . managed [ relay ] <EOL> except KeyError : <EOL> log . msg ( "<STR_LIT>" ) <EOL> return <EOL> if self . manager . queue . noisy : <EOL> log . msg ( "<STR_LIT>" + str ( msgs ) ) <EOL> def setWaiting ( queue , messages ) : <EOL> map ( queue . setWaiting , messages ) <EOL> from twisted . internet import reactor <EOL> reactor . callLater ( <NUM_LIT:30> , setWaiting , self . manager . queue , msgs ) <EOL> del self . manager . managed [ relay ] <EOL> class SmartHostSMTPRelayingManager : <EOL> """<STR_LIT>""" <EOL> factory = SMTPManagedRelayerFactory <EOL> PORT = <NUM_LIT> <EOL> mxcalc = None <EOL> def __init__ ( self , queue , maxConnections = <NUM_LIT:2> , maxMessagesPerConnection = <NUM_LIT:10> ) : <EOL> """<STR_LIT>""" <EOL> self . maxConnections = maxConnections <EOL> self . maxMessagesPerConnection = maxMessagesPerConnection <EOL> self . managed = { } <EOL> self . queue = queue <EOL> self . fArgs = ( ) <EOL> self . fKwArgs = { } <EOL> def __getstate__ ( self ) : <EOL> """<STR_LIT>""" <EOL> dct = self . __dict__ . copy ( ) <EOL> del dct [ '<STR_LIT>' ] <EOL> return dct <EOL> def __setstate__ ( self , state ) : <EOL> """<STR_LIT>""" <EOL> self . __dict__ . update ( state ) <EOL> self . managed = { } <EOL> def checkState ( self ) : <EOL> """<STR_LIT>""" <EOL> self . queue . readDirectory ( ) <EOL> if ( len ( self . managed ) >= self . maxConnections ) : <EOL> return <EOL> if not self . queue . hasWaiting ( ) : <EOL> return <EOL> return self . _checkStateMX ( ) <EOL> def _checkStateMX ( self ) : <EOL> nextMessages = self . queue . getWaiting ( ) <EOL> nextMessages . reverse ( ) <EOL> exchanges = { } <EOL> for msg in nextMessages : <EOL> from_ , to = self . queue . getEnvelope ( msg ) <EOL> name , addr = rfc822 . parseaddr ( to ) <EOL> parts = addr . split ( '<STR_LIT:@>' , <NUM_LIT:1> ) <EOL> if len ( parts ) != <NUM_LIT:2> : <EOL> log . err ( "<STR_LIT>" + to ) <EOL> continue <EOL> domain = parts [ <NUM_LIT:1> ] <EOL> self . queue . setRelaying ( msg ) <EOL> exchanges . setdefault ( domain , [ ] ) . append ( self . queue . getPath ( msg ) ) <EOL> if len ( exchanges ) >= ( self . maxConnections - len ( self . managed ) ) : <EOL> break <EOL> if self . mxcalc is None : <EOL> self . mxcalc = MXCalculator ( ) <EOL> relays = [ ] <EOL> for ( domain , msgs ) in exchanges . iteritems ( ) : <EOL> manager = _AttemptManager ( self ) <EOL> factory = self . factory ( msgs , manager , * self . fArgs , ** self . fKwArgs ) <EOL> self . managed [ factory ] = map ( os . path . basename , msgs ) <EOL> relayAttemptDeferred = manager . getCompletionDeferred ( ) <EOL> connectSetupDeferred = self . mxcalc . getMX ( domain ) <EOL> connectSetupDeferred . addCallback ( lambda mx : str ( mx . name ) ) <EOL> connectSetupDeferred . addCallback ( self . _cbExchange , self . PORT , factory ) <EOL> connectSetupDeferred . addErrback ( lambda err : ( relayAttemptDeferred . errback ( err ) , err ) [ <NUM_LIT:1> ] ) <EOL> connectSetupDeferred . addErrback ( self . _ebExchange , factory , domain ) <EOL> relays . append ( relayAttemptDeferred ) <EOL> return DeferredList ( relays ) <EOL> def _cbExchange ( self , address , port , factory ) : <EOL> from twisted . internet import reactor <EOL> reactor . connectTCP ( address , port , factory ) <EOL> def _ebExchange ( self , failure , factory , domain ) : <EOL> log . err ( '<STR_LIT>' + domain ) <EOL> log . err ( failure ) <EOL> def setWaiting ( queue , messages ) : <EOL> map ( queue . setWaiting , messages ) <EOL> from twisted . internet import reactor <EOL> reactor . callLater ( <NUM_LIT:30> , setWaiting , self . queue , self . managed [ factory ] ) <EOL> del self . managed [ factory ] <EOL> class SmartHostESMTPRelayingManager ( SmartHostSMTPRelayingManager ) : <EOL> factory = ESMTPManagedRelayerFactory <EOL> def _checkState ( manager ) : <EOL> manager . checkState ( ) <EOL> def RelayStateHelper ( manager , delay ) : <EOL> return internet . TimerService ( delay , _checkState , manager ) <EOL> class CanonicalNameLoop ( Exception ) : <EOL> """<STR_LIT>""" <EOL> class CanonicalNameChainTooLong ( Exception ) : <EOL> """<STR_LIT>"""

class MXCalculator :

"""<STR_LIT>""" <EOL> import rfc822 <EOL> import os <EOL> import time <EOL> try : <EOL> import cPickle as pickle <EOL> except ImportError : <EOL> import pickle <EOL> from twisted . python import log <EOL> from twisted . python . failure import Failure <EOL> from twisted . python . compat import set <EOL> from twisted . mail import relay <EOL> from twisted . mail import bounce <EOL> from twisted . internet import protocol <EOL> from twisted . internet . defer import Deferred , DeferredList <EOL> from twisted . internet . error import DNSLookupError <EOL> from twisted . mail import smtp <EOL> from twisted . application import internet <EOL> class ManagedRelayerMixin : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , manager ) : <EOL> self . manager = manager <EOL> def sentMail ( self , code , resp , numOk , addresses , log ) : <EOL> """<STR_LIT>""" <EOL> message = self . names [ <NUM_LIT:0> ] <EOL> if code in smtp . SUCCESS : <EOL> self . manager . notifySuccess ( self . factory , message ) <EOL> else : <EOL> self . manager . notifyFailure ( self . factory , message ) <EOL> del self . messages [ <NUM_LIT:0> ] <EOL> del self . names [ <NUM_LIT:0> ] <EOL> def connectionLost ( self , reason ) : <EOL> """<STR_LIT>""" <EOL> self . manager . notifyDone ( self . factory ) <EOL> class SMTPManagedRelayer ( ManagedRelayerMixin , relay . SMTPRelayer ) : <EOL> def __init__ ( self , messages , manager , * args , ** kw ) : <EOL> """<STR_LIT>""" <EOL> ManagedRelayerMixin . __init__ ( self , manager ) <EOL> relay . SMTPRelayer . __init__ ( self , messages , * args , ** kw ) <EOL> class ESMTPManagedRelayer ( ManagedRelayerMixin , relay . ESMTPRelayer ) : <EOL> def __init__ ( self , messages , manager , * args , ** kw ) : <EOL> """<STR_LIT>""" <EOL> ManagedRelayerMixin . __init__ ( self , manager ) <EOL> relay . ESMTPRelayer . __init__ ( self , messages , * args , ** kw ) <EOL> class SMTPManagedRelayerFactory ( protocol . ClientFactory ) : <EOL> protocol = SMTPManagedRelayer <EOL> def __init__ ( self , messages , manager , * args , ** kw ) : <EOL> self . messages = messages <EOL> self . manager = manager <EOL> self . pArgs = args <EOL> self . pKwArgs = kw <EOL> def buildProtocol ( self , addr ) : <EOL> protocol = self . protocol ( self . messages , self . manager , * self . pArgs , <EOL> ** self . pKwArgs ) <EOL> protocol . factory = self <EOL> return protocol <EOL> def clientConnectionFailed ( self , connector , reason ) : <EOL> """<STR_LIT>""" <EOL> self . manager . notifyNoConnection ( self ) <EOL> self . manager . notifyDone ( self ) <EOL> class ESMTPManagedRelayerFactory ( SMTPManagedRelayerFactory ) : <EOL> protocol = ESMTPManagedRelayer <EOL> def __init__ ( self , messages , manager , secret , contextFactory , * args , ** kw ) : <EOL> self . secret = secret <EOL> self . contextFactory = contextFactory <EOL> SMTPManagedRelayerFactory . __init__ ( self , messages , manager , * args , ** kw ) <EOL> def buildProtocol ( self , addr ) : <EOL> s = self . secret and self . secret ( addr ) <EOL> protocol = self . protocol ( self . messages , self . manager , s , <EOL> self . contextFactory , * self . pArgs , ** self . pKwArgs ) <EOL> protocol . factory = self <EOL> return protocol <EOL> class Queue : <EOL> """<STR_LIT>""" <EOL> noisy = True <EOL> def __init__ ( self , directory ) : <EOL> self . directory = directory <EOL> self . _init ( ) <EOL> def _init ( self ) : <EOL> self . n = <NUM_LIT:0> <EOL> self . waiting = { } <EOL> self . relayed = { } <EOL> self . readDirectory ( ) <EOL> def __getstate__ ( self ) : <EOL> """<STR_LIT>""" <EOL> return { '<STR_LIT>' : self . directory } <EOL> def __setstate__ ( self , state ) : <EOL> """<STR_LIT>""" <EOL> self . __dict__ . update ( state ) <EOL> self . _init ( ) <EOL> def readDirectory ( self ) : <EOL> """<STR_LIT>""" <EOL> for message in os . listdir ( self . directory ) : <EOL> if message [ - <NUM_LIT:2> : ] != '<STR_LIT>' : <EOL> continue <EOL> self . addMessage ( message [ : - <NUM_LIT:2> ] ) <EOL> def getWaiting ( self ) : <EOL> return self . waiting . keys ( ) <EOL> def hasWaiting ( self ) : <EOL> return len ( self . waiting ) > <NUM_LIT:0> <EOL> def getRelayed ( self ) : <EOL> return self . relayed . keys ( ) <EOL> def setRelaying ( self , message ) : <EOL> del self . waiting [ message ] <EOL> self . relayed [ message ] = <NUM_LIT:1> <EOL> def setWaiting ( self , message ) : <EOL> del self . relayed [ message ] <EOL> self . waiting [ message ] = <NUM_LIT:1> <EOL> def addMessage ( self , message ) : <EOL> if message not in self . relayed : <EOL> self . waiting [ message ] = <NUM_LIT:1> <EOL> if self . noisy : <EOL> log . msg ( '<STR_LIT>' + message + '<STR_LIT>' ) <EOL> def done ( self , message ) : <EOL> """<STR_LIT>""" <EOL> message = os . path . basename ( message ) <EOL> os . remove ( self . getPath ( message ) + '<STR_LIT>' ) <EOL> os . remove ( self . getPath ( message ) + '<STR_LIT>' ) <EOL> del self . relayed [ message ] <EOL> def getPath ( self , message ) : <EOL> """<STR_LIT>""" <EOL> return os . path . join ( self . directory , message ) <EOL> def getEnvelope ( self , message ) : <EOL> return pickle . load ( self . getEnvelopeFile ( message ) ) <EOL> def getEnvelopeFile ( self , message ) : <EOL> return open ( os . path . join ( self . directory , message + '<STR_LIT>' ) , '<STR_LIT:rb>' ) <EOL> def createNewMessage ( self ) : <EOL> """<STR_LIT>""" <EOL> fname = "<STR_LIT>" % ( os . getpid ( ) , time . time ( ) , self . n , id ( self ) ) <EOL> self . n = self . n + <NUM_LIT:1> <EOL> headerFile = open ( os . path . join ( self . directory , fname + '<STR_LIT>' ) , '<STR_LIT:wb>' ) <EOL> tempFilename = os . path . join ( self . directory , fname + '<STR_LIT>' ) <EOL> finalFilename = os . path . join ( self . directory , fname + '<STR_LIT>' ) <EOL> messageFile = open ( tempFilename , '<STR_LIT:wb>' ) <EOL> from twisted . mail . mail import FileMessage <EOL> return headerFile , FileMessage ( messageFile , tempFilename , finalFilename ) <EOL> class _AttemptManager ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , manager ) : <EOL> self . manager = manager <EOL> self . _completionDeferreds = [ ] <EOL> def getCompletionDeferred ( self ) : <EOL> self . _completionDeferreds . append ( Deferred ( ) ) <EOL> return self . _completionDeferreds [ - <NUM_LIT:1> ] <EOL> def _finish ( self , relay , message ) : <EOL> self . manager . managed [ relay ] . remove ( os . path . basename ( message ) ) <EOL> self . manager . queue . done ( message ) <EOL> def notifySuccess ( self , relay , message ) : <EOL> """<STR_LIT>""" <EOL> if self . manager . queue . noisy : <EOL> log . msg ( "<STR_LIT>" % message ) <EOL> self . _finish ( relay , message ) <EOL> def notifyFailure ( self , relay , message ) : <EOL> """<STR_LIT>""" <EOL> if self . manager . queue . noisy : <EOL> log . msg ( "<STR_LIT>" + message ) <EOL> message = os . path . basename ( message ) <EOL> fp = self . manager . queue . getEnvelopeFile ( message ) <EOL> from_ , to = pickle . load ( fp ) <EOL> fp . close ( ) <EOL> from_ , to , bounceMessage = bounce . generateBounce ( open ( self . manager . queue . getPath ( message ) + '<STR_LIT>' ) , from_ , to ) <EOL> fp , outgoingMessage = self . manager . queue . createNewMessage ( ) <EOL> pickle . dump ( [ from_ , to ] , fp ) <EOL> fp . close ( ) <EOL> for line in bounceMessage . splitlines ( ) : <EOL> outgoingMessage . lineReceived ( line ) <EOL> outgoingMessage . eomReceived ( ) <EOL> self . _finish ( relay , self . manager . queue . getPath ( message ) ) <EOL> def notifyDone ( self , relay ) : <EOL> """<STR_LIT>""" <EOL> for message in self . manager . managed . get ( relay , ( ) ) : <EOL> if self . manager . queue . noisy : <EOL> log . msg ( "<STR_LIT>" + message + "<STR_LIT>" ) <EOL> self . manager . queue . setWaiting ( message ) <EOL> try : <EOL> del self . manager . managed [ relay ] <EOL> except KeyError : <EOL> pass <EOL> notifications = self . _completionDeferreds <EOL> self . _completionDeferreds = None <EOL> for d in notifications : <EOL> d . callback ( None ) <EOL> def notifyNoConnection ( self , relay ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> msgs = self . manager . managed [ relay ] <EOL> except KeyError : <EOL> log . msg ( "<STR_LIT>" ) <EOL> return <EOL> if self . manager . queue . noisy : <EOL> log . msg ( "<STR_LIT>" + str ( msgs ) ) <EOL> def setWaiting ( queue , messages ) : <EOL> map ( queue . setWaiting , messages ) <EOL> from twisted . internet import reactor <EOL> reactor . callLater ( <NUM_LIT:30> , setWaiting , self . manager . queue , msgs ) <EOL> del self . manager . managed [ relay ] <EOL> class SmartHostSMTPRelayingManager : <EOL> """<STR_LIT>""" <EOL> factory = SMTPManagedRelayerFactory <EOL> PORT = <NUM_LIT> <EOL> mxcalc = None <EOL> def __init__ ( self , queue , maxConnections = <NUM_LIT:2> , maxMessagesPerConnection = <NUM_LIT:10> ) : <EOL> """<STR_LIT>""" <EOL> self . maxConnections = maxConnections <EOL> self . maxMessagesPerConnection = maxMessagesPerConnection <EOL> self . managed = { } <EOL> self . queue = queue <EOL> self . fArgs = ( ) <EOL> self . fKwArgs = { } <EOL> def __getstate__ ( self ) : <EOL> """<STR_LIT>""" <EOL> dct = self . __dict__ . copy ( ) <EOL> del dct [ '<STR_LIT>' ] <EOL> return dct <EOL> def __setstate__ ( self , state ) : <EOL> """<STR_LIT>""" <EOL> self . __dict__ . update ( state ) <EOL> self . managed = { } <EOL> def checkState ( self ) : <EOL> """<STR_LIT>""" <EOL> self . queue . readDirectory ( ) <EOL> if ( len ( self . managed ) >= self . maxConnections ) : <EOL> return <EOL> if not self . queue . hasWaiting ( ) : <EOL> return <EOL> return self . _checkStateMX ( ) <EOL> def _checkStateMX ( self ) : <EOL> nextMessages = self . queue . getWaiting ( ) <EOL> nextMessages . reverse ( ) <EOL> exchanges = { } <EOL> for msg in nextMessages : <EOL> from_ , to = self . queue . getEnvelope ( msg ) <EOL> name , addr = rfc822 . parseaddr ( to ) <EOL> parts = addr . split ( '<STR_LIT:@>' , <NUM_LIT:1> ) <EOL> if len ( parts ) != <NUM_LIT:2> : <EOL> log . err ( "<STR_LIT>" + to ) <EOL> continue <EOL> domain = parts [ <NUM_LIT:1> ] <EOL> self . queue . setRelaying ( msg ) <EOL> exchanges . setdefault ( domain , [ ] ) . append ( self . queue . getPath ( msg ) ) <EOL> if len ( exchanges ) >= ( self . maxConnections - len ( self . managed ) ) : <EOL> break <EOL> if self . mxcalc is None : <EOL> self . mxcalc = MXCalculator ( ) <EOL> relays = [ ] <EOL> for ( domain , msgs ) in exchanges . iteritems ( ) : <EOL> manager = _AttemptManager ( self ) <EOL> factory = self . factory ( msgs , manager , * self . fArgs , ** self . fKwArgs ) <EOL> self . managed [ factory ] = map ( os . path . basename , msgs ) <EOL> relayAttemptDeferred = manager . getCompletionDeferred ( ) <EOL> connectSetupDeferred = self . mxcalc . getMX ( domain ) <EOL> connectSetupDeferred . addCallback ( lambda mx : str ( mx . name ) ) <EOL> connectSetupDeferred . addCallback ( self . _cbExchange , self . PORT , factory ) <EOL> connectSetupDeferred . addErrback ( lambda err : ( relayAttemptDeferred . errback ( err ) , err ) [ <NUM_LIT:1> ] ) <EOL> connectSetupDeferred . addErrback ( self . _ebExchange , factory , domain ) <EOL> relays . append ( relayAttemptDeferred ) <EOL> return DeferredList ( relays ) <EOL> def _cbExchange ( self , address , port , factory ) : <EOL> from twisted . internet import reactor <EOL> reactor . connectTCP ( address , port , factory ) <EOL> def _ebExchange ( self , failure , factory , domain ) : <EOL> log . err ( '<STR_LIT>' + domain ) <EOL> log . err ( failure ) <EOL> def setWaiting ( queue , messages ) : <EOL> map ( queue . setWaiting , messages ) <EOL> from twisted . internet import reactor <EOL> reactor . callLater ( <NUM_LIT:30> , setWaiting , self . queue , self . managed [ factory ] ) <EOL> del self . managed [ factory ] <EOL> class SmartHostESMTPRelayingManager ( SmartHostSMTPRelayingManager ) : <EOL> factory = ESMTPManagedRelayerFactory <EOL> def _checkState ( manager ) : <EOL> manager . checkState ( ) <EOL> def RelayStateHelper ( manager , delay ) : <EOL> return internet . TimerService ( delay , _checkState , manager ) <EOL> class CanonicalNameLoop ( Exception ) : <EOL> """<STR_LIT>""" <EOL> class CanonicalNameChainTooLong ( Exception ) : <EOL> """<STR_LIT>""" <EOL> class MXCalculator : <EOL> """<STR_LIT>""" <EOL> timeOutBadMX = <NUM_LIT> * <NUM_LIT> <EOL> fallbackToDomain = True <EOL> def __init__ ( self , resolver = None , clock = None ) : <EOL> self . badMXs = { } <EOL> if resolver is None : <EOL> from twisted . names . client import createResolver <EOL> resolver = createResolver ( ) <EOL> self . resolver = resolver <EOL> if clock is None : <EOL> from twisted . internet import reactor as clock <EOL> self . clock = clock <EOL> def markBad ( self , mx ) : <EOL> """<STR_LIT>""" <EOL> self . badMXs [ str ( mx ) ] = self . clock . seconds ( ) + self . timeOutBadMX <EOL> def markGood ( self , mx ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> del self . badMXs [ mx ] <EOL> except KeyError : <EOL> pass <EOL> def getMX ( self , domain , maximumCanonicalChainLength = <NUM_LIT:3> ) : <EOL> """<STR_LIT>""" <EOL> mailExchangeDeferred = self . resolver . lookupMailExchange ( domain ) <EOL> mailExchangeDeferred . addCallback ( self . _filterRecords ) <EOL> mailExchangeDeferred . addCallback ( <EOL> self . _cbMX , domain , maximumCanonicalChainLength ) <EOL> mailExchangeDeferred . addErrback ( self . _ebMX , domain ) <EOL> return mailExchangeDeferred <EOL> def _filterRecords ( self , records ) : <EOL> """<STR_LIT>""" <EOL> recordBag = { } <EOL> for answer in records [ <NUM_LIT:0> ] : <EOL> recordBag . setdefault ( str ( answer . name ) , [ ] ) . append ( answer . payload ) <EOL> return recordBag <EOL> def _cbMX ( self , answers , domain , cnamesLeft ) : <EOL> """<STR_LIT>""" <EOL> from twisted . names import dns , error <EOL> seenAliases = set ( ) <EOL> exchanges = [ ] <EOL> pertinentRecords = answers . get ( domain , [ ] ) <EOL> while pertinentRecords : <EOL> record = pertinentRecords . pop ( ) <EOL> if record . TYPE == dns . CNAME : <EOL> seenAliases . add ( domain ) <EOL> canonicalName = str ( record . name ) <EOL> if canonicalName in answers : <EOL> if canonicalName in seenAliases : <EOL> return Failure ( CanonicalNameLoop ( record ) ) <EOL> pertinentRecords = answers [ canonicalName ] <EOL> exchanges = [ ] <EOL> else : <EOL> if cnamesLeft : <EOL> return self . getMX ( canonicalName , cnamesLeft - <NUM_LIT:1> ) <EOL> else : <EOL> return Failure ( CanonicalNameChainTooLong ( record ) ) <EOL> if record . TYPE == dns . MX : <EOL> exchanges . append ( ( record . preference , record ) ) <EOL> if exchanges : <EOL> exchanges . sort ( ) <EOL> for ( preference , record ) in exchanges : <EOL> host = str ( record . name ) <EOL> if host not in self . badMXs : <EOL> return record <EOL> t = self . clock . seconds ( ) - self . badMXs [ host ] <EOL> if t >= <NUM_LIT:0> : <EOL> del self . badMXs [ host ] <EOL> return record <EOL> return exchanges [ <NUM_LIT:0> ] [ <NUM_LIT:1> ] <EOL> else : <EOL> return Failure ( <EOL> error . DNSNameError ( "<STR_LIT>" % ( domain , ) ) ) <EOL> def _ebMX ( self , failure , domain ) : <EOL> from twisted . names import error , dns <EOL> if self . fallbackToDomain : <EOL> failure . trap ( error . DNSNameError ) <EOL> log . msg ( "<STR_LIT>" % ( domain , ) ) <EOL> d = self . resolver . getHostByName ( domain ) <EOL> def cbResolved ( addr ) : <EOL> return dns . Record_MX ( name = addr ) <EOL> def ebResolved ( err ) : <EOL> err . trap ( error . DNSNameError ) <EOL> raise DNSLookupError ( ) <EOL> d . addCallbacks ( cbResolved , ebResolved ) <EOL> return d <EOL> elif failure . check ( error . DNSNameError ) : <EOL> raise IOError ( "<STR_LIT>" % ( domain , ) ) <EOL> return failure </s>

"""<STR_LIT>"""

from twisted . names . _version import version

"""<STR_LIT>""" <EOL> from twisted . names . _version import version <EOL> __version__ = version . short ( ) </s>

"""<STR_LIT>""" <EOL> import getpass , pickle , time , socket <EOL> import os <EOL> import StringIO <EOL> from email . Message import Message <EOL> from email . Generator import Generator <EOL> from zope . interface import implements , Interface <EOL> from twisted . news . nntp import NNTPError <EOL> from twisted . mail import smtp <EOL> from twisted . internet import defer <EOL> from twisted . enterprise import adbapi <EOL> from twisted . persisted import dirdbm <EOL> from twisted . python . hashlib import md5 <EOL> ERR_NOGROUP , ERR_NOARTICLE = range ( <NUM_LIT:2> , <NUM_LIT:4> ) <EOL> OVERVIEW_FMT = [ <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' <EOL> ] <EOL> def hexdigest ( md5 ) : <EOL> return '<STR_LIT>' . join ( map ( lambda x : hex ( ord ( x ) ) [ <NUM_LIT:2> : ] , md5 . digest ( ) ) ) <EOL> class Article : <EOL> def __init__ ( self , head , body ) : <EOL> self . body = body <EOL> self . headers = { } <EOL> header = None <EOL> for line in head . split ( '<STR_LIT:\r\n>' ) : <EOL> if line [ <NUM_LIT:0> ] in '<STR_LIT>' : <EOL> i = list ( self . headers [ header ] ) <EOL> i [ <NUM_LIT:1> ] += '<STR_LIT:\r\n>' + line <EOL> else : <EOL> i = line . split ( '<STR_LIT>' , <NUM_LIT:1> ) <EOL> header = i [ <NUM_LIT:0> ] . lower ( ) <EOL> self . headers [ header ] = tuple ( i ) <EOL> if not self . getHeader ( '<STR_LIT>' ) : <EOL> s = str ( time . time ( ) ) + self . body <EOL> id = hexdigest ( md5 ( s ) ) + '<STR_LIT:@>' + socket . gethostname ( ) <EOL> self . putHeader ( '<STR_LIT>' , '<STR_LIT>' % id ) <EOL> if not self . getHeader ( '<STR_LIT>' ) : <EOL> self . putHeader ( '<STR_LIT>' , str ( len ( self . body ) ) ) <EOL> if not self . getHeader ( '<STR_LIT>' ) : <EOL> self . putHeader ( '<STR_LIT>' , str ( self . body . count ( '<STR_LIT:\n>' ) ) ) <EOL> if not self . getHeader ( '<STR_LIT>' ) : <EOL> self . putHeader ( '<STR_LIT>' , time . ctime ( time . time ( ) ) ) <EOL> def getHeader ( self , header ) : <EOL> h = header . lower ( ) <EOL> if self . headers . has_key ( h ) : <EOL> return self . headers [ h ] [ <NUM_LIT:1> ] <EOL> else : <EOL> return '<STR_LIT>' <EOL> def putHeader ( self , header , value ) : <EOL> self . headers [ header . lower ( ) ] = ( header , value ) <EOL> def textHeaders ( self ) : <EOL> headers = [ ] <EOL> for i in self . headers . values ( ) : <EOL> headers . append ( '<STR_LIT>' % i ) <EOL> return '<STR_LIT:\r\n>' . join ( headers ) + '<STR_LIT:\r\n>' <EOL> def overview ( self ) : <EOL> xover = [ ] <EOL> for i in OVERVIEW_FMT : <EOL> xover . append ( self . getHeader ( i ) ) <EOL> return xover <EOL> class NewsServerError ( Exception ) : <EOL> pass <EOL> class INewsStorage ( Interface ) : <EOL> """<STR_LIT>""" <EOL> def listRequest ( ) : <EOL> """<STR_LIT>""" <EOL> def subscriptionRequest ( ) : <EOL> """<STR_LIT>""" <EOL> def postRequest ( message ) : <EOL> """<STR_LIT>""" <EOL> def overviewRequest ( ) : <EOL> """<STR_LIT>""" <EOL> def xoverRequest ( group , low , high ) : <EOL> """<STR_LIT>""" <EOL> def xhdrRequest ( group , low , high , header ) : <EOL> """<STR_LIT>""" <EOL> def listGroupRequest ( group ) : <EOL> """<STR_LIT>""" <EOL> def groupRequest ( group ) : <EOL> """<STR_LIT>""" <EOL> def articleExistsRequest ( id ) : <EOL> """<STR_LIT>""" <EOL> def articleRequest ( group , index , id = None ) : <EOL> """<STR_LIT>""" <EOL> def headRequest ( group , index ) : <EOL> """<STR_LIT>""" <EOL> def bodyRequest ( group , index ) : <EOL> """<STR_LIT>""" <EOL> class NewsStorage : <EOL> """<STR_LIT>""" <EOL> def listRequest ( self ) : <EOL> raise NotImplementedError ( ) <EOL> def subscriptionRequest ( self ) : <EOL> raise NotImplementedError ( ) <EOL> def postRequest ( self , message ) : <EOL> raise NotImplementedError ( ) <EOL> def overviewRequest ( self ) : <EOL> return defer . succeed ( OVERVIEW_FMT ) <EOL> def xoverRequest ( self , group , low , high ) : <EOL> raise NotImplementedError ( ) <EOL> def xhdrRequest ( self , group , low , high , header ) : <EOL> raise NotImplementedError ( ) <EOL> def listGroupRequest ( self , group ) : <EOL> raise NotImplementedError ( ) <EOL> def groupRequest ( self , group ) : <EOL> raise NotImplementedError ( ) <EOL> def articleExistsRequest ( self , id ) : <EOL> raise NotImplementedError ( ) <EOL> def articleRequest ( self , group , index , id = None ) : <EOL> raise NotImplementedError ( ) <EOL> def headRequest ( self , group , index ) : <EOL> raise NotImplementedError ( ) <EOL> def bodyRequest ( self , group , index ) : <EOL> raise NotImplementedError ( ) <EOL> class _ModerationMixin : <EOL> """<STR_LIT>""" <EOL> sendmail = staticmethod ( smtp . sendmail ) <EOL> def notifyModerators ( self , moderators , article ) : <EOL> """<STR_LIT>""" <EOL> group = article . getHeader ( '<STR_LIT>' ) <EOL> subject = article . getHeader ( '<STR_LIT>' ) <EOL> if self . _sender is None : <EOL> sender = '<STR_LIT>' + socket . gethostname ( ) <EOL> else : <EOL> sender = self . _sender <EOL> msg = Message ( ) <EOL> msg [ '<STR_LIT>' ] = smtp . messageid ( ) <EOL> msg [ '<STR_LIT>' ] = sender <EOL> msg [ '<STR_LIT>' ] = '<STR_LIT:U+002CU+0020>' . join ( moderators ) <EOL> msg [ '<STR_LIT>' ] = '<STR_LIT>' % ( group , subject ) <EOL> msg [ '<STR_LIT:Content-Type>' ] = '<STR_LIT>' <EOL> payload = Message ( ) <EOL> for header , value in article . headers . values ( ) : <EOL> payload . add_header ( header , value ) <EOL> payload . set_payload ( article . body ) <EOL> msg . attach ( payload ) <EOL> out = StringIO . StringIO ( ) <EOL> gen = Generator ( out , False ) <EOL> gen . flatten ( msg ) <EOL> msg = out . getvalue ( ) <EOL> return self . sendmail ( self . _mailhost , sender , moderators , msg ) <EOL> class PickleStorage ( _ModerationMixin ) : <EOL> """<STR_LIT>""" <EOL> implements ( INewsStorage ) <EOL> sharedDBs = { } <EOL> def __init__ ( self , filename , groups = None , moderators = ( ) , <EOL> mailhost = None , sender = None ) : <EOL> """<STR_LIT>""" <EOL> self . datafile = filename <EOL> self . load ( filename , groups , moderators ) <EOL> self . _mailhost = mailhost <EOL> self . _sender = sender <EOL> def getModerators ( self , groups ) : <EOL> moderators = [ ] <EOL> for group in groups : <EOL> moderators . extend ( self . db [ '<STR_LIT>' ] . get ( group , None ) ) <EOL> return filter ( None , moderators ) <EOL> def listRequest ( self ) : <EOL> "<STR_LIT>" <EOL> l = self . db [ '<STR_LIT>' ] <EOL> r = [ ] <EOL> for i in l : <EOL> if len ( self . db [ i ] . keys ( ) ) : <EOL> low = min ( self . db [ i ] . keys ( ) ) <EOL> high = max ( self . db [ i ] . keys ( ) ) + <NUM_LIT:1> <EOL> else : <EOL> low = high = <NUM_LIT:0> <EOL> if self . db [ '<STR_LIT>' ] . has_key ( i ) : <EOL> flags = '<STR_LIT:m>' <EOL> else : <EOL> flags = '<STR_LIT:y>' <EOL> r . append ( ( i , high , low , flags ) ) <EOL> return defer . succeed ( r ) <EOL> def subscriptionRequest ( self ) : <EOL> return defer . succeed ( [ '<STR_LIT>' ] ) <EOL> def postRequest ( self , message ) : <EOL> cleave = message . find ( '<STR_LIT>' ) <EOL> headers , article = message [ : cleave ] , message [ cleave + <NUM_LIT:4> : ] <EOL> a = Article ( headers , article ) <EOL> groups = a . getHeader ( '<STR_LIT>' ) . split ( ) <EOL> xref = [ ] <EOL> moderators = self . getModerators ( groups ) <EOL> if moderators and not a . getHeader ( '<STR_LIT>' ) : <EOL> return self . notifyModerators ( moderators , a ) <EOL> for group in groups : <EOL> if self . db . has_key ( group ) : <EOL> if len ( self . db [ group ] . keys ( ) ) : <EOL> index = max ( self . db [ group ] . keys ( ) ) + <NUM_LIT:1> <EOL> else : <EOL> index = <NUM_LIT:1> <EOL> xref . append ( ( group , str ( index ) ) ) <EOL> self . db [ group ] [ index ] = a <EOL> if len ( xref ) == <NUM_LIT:0> : <EOL> return defer . fail ( None ) <EOL> a . putHeader ( '<STR_LIT>' , '<STR_LIT>' % ( <EOL> socket . gethostname ( ) . split ( ) [ <NUM_LIT:0> ] , <EOL> '<STR_LIT>' . join ( map ( lambda x : '<STR_LIT::>' . join ( x ) , xref ) ) <EOL> ) ) <EOL> self . flush ( ) <EOL> return defer . succeed ( None ) <EOL> def overviewRequest ( self ) : <EOL> return defer . succeed ( OVERVIEW_FMT ) <EOL> def xoverRequest ( self , group , low , high ) : <EOL> if not self . db . has_key ( group ) : <EOL> return defer . succeed ( [ ] ) <EOL> r = [ ] <EOL> for i in self . db [ group ] . keys ( ) : <EOL> if ( low is None or i >= low ) and ( high is None or i <= high ) : <EOL> r . append ( [ str ( i ) ] + self . db [ group ] [ i ] . overview ( ) ) <EOL> return defer . succeed ( r ) <EOL> def xhdrRequest ( self , group , low , high , header ) : <EOL> if not self . db . has_key ( group ) : <EOL> return defer . succeed ( [ ] ) <EOL> r = [ ] <EOL> for i in self . db [ group ] . keys ( ) : <EOL> if low is None or i >= low and high is None or i <= high : <EOL> r . append ( ( i , self . db [ group ] [ i ] . getHeader ( header ) ) ) <EOL> return defer . succeed ( r ) <EOL> def listGroupRequest ( self , group ) : <EOL> if self . db . has_key ( group ) : <EOL> return defer . succeed ( ( group , self . db [ group ] . keys ( ) ) ) <EOL> else : <EOL> return defer . fail ( None ) <EOL> def groupRequest ( self , group ) : <EOL> if self . db . has_key ( group ) : <EOL> if len ( self . db [ group ] . keys ( ) ) : <EOL> num = len ( self . db [ group ] . keys ( ) ) <EOL> low = min ( self . db [ group ] . keys ( ) ) <EOL> high = max ( self . db [ group ] . keys ( ) ) <EOL> else : <EOL> num = low = high = <NUM_LIT:0> <EOL> flags = '<STR_LIT:y>' <EOL> return defer . succeed ( ( group , num , high , low , flags ) ) <EOL> else : <EOL> return defer . fail ( ERR_NOGROUP ) <EOL> def articleExistsRequest ( self , id ) : <EOL> for group in self . db [ '<STR_LIT>' ] : <EOL> for a in self . db [ group ] . values ( ) : <EOL> if a . getHeader ( '<STR_LIT>' ) == id : <EOL> return defer . succeed ( <NUM_LIT:1> ) <EOL> return defer . succeed ( <NUM_LIT:0> ) <EOL> def articleRequest ( self , group , index , id = None ) : <EOL> if id is not None : <EOL> raise NotImplementedError <EOL> if self . db . has_key ( group ) : <EOL> if self . db [ group ] . has_key ( index ) : <EOL> a = self . db [ group ] [ index ] <EOL> return defer . succeed ( ( <EOL> index , <EOL> a . getHeader ( '<STR_LIT>' ) , <EOL> StringIO . StringIO ( a . textHeaders ( ) + '<STR_LIT:\r\n>' + a . body ) <EOL> ) ) <EOL> else : <EOL> return defer . fail ( ERR_NOARTICLE ) <EOL> else : <EOL> return defer . fail ( ERR_NOGROUP ) <EOL> def headRequest ( self , group , index ) : <EOL> if self . db . has_key ( group ) : <EOL> if self . db [ group ] . has_key ( index ) : <EOL> a = self . db [ group ] [ index ] <EOL> return defer . succeed ( ( index , a . getHeader ( '<STR_LIT>' ) , a . textHeaders ( ) ) ) <EOL> else : <EOL> return defer . fail ( ERR_NOARTICLE ) <EOL> else : <EOL> return defer . fail ( ERR_NOGROUP ) <EOL> def bodyRequest ( self , group , index ) : <EOL> if self . db . has_key ( group ) : <EOL> if self . db [ group ] . has_key ( index ) : <EOL> a = self . db [ group ] [ index ] <EOL> return defer . succeed ( ( index , a . getHeader ( '<STR_LIT>' ) , StringIO . StringIO ( a . body ) ) ) <EOL> else : <EOL> return defer . fail ( ERR_NOARTICLE ) <EOL> else : <EOL> return defer . fail ( ERR_NOGROUP ) <EOL> def flush ( self ) : <EOL> f = open ( self . datafile , '<STR_LIT:w>' ) <EOL> pickle . dump ( self . db , f ) <EOL> f . close ( ) <EOL> def load ( self , filename , groups = None , moderators = ( ) ) : <EOL> if PickleStorage . sharedDBs . has_key ( filename ) : <EOL> self . db = PickleStorage . sharedDBs [ filename ] <EOL> else : <EOL> try : <EOL> self . db = pickle . load ( open ( filename ) ) <EOL> PickleStorage . sharedDBs [ filename ] = self . db <EOL> except IOError : <EOL> self . db = PickleStorage . sharedDBs [ filename ] = { } <EOL> self . db [ '<STR_LIT>' ] = groups <EOL> if groups is not None : <EOL> for i in groups : <EOL> self . db [ i ] = { } <EOL> self . db [ '<STR_LIT>' ] = dict ( moderators ) <EOL> self . flush ( ) <EOL> class Group : <EOL> name = None <EOL> flags = '<STR_LIT>' <EOL> minArticle = <NUM_LIT:1> <EOL> maxArticle = <NUM_LIT:0> <EOL> articles = None <EOL> def __init__ ( self , name , flags = '<STR_LIT:y>' ) : <EOL> self . name = name <EOL> self . flags = flags <EOL> self . articles = { } <EOL> class NewsShelf ( _ModerationMixin ) : <EOL> """<STR_LIT>""" <EOL> implements ( INewsStorage ) <EOL> def __init__ ( self , mailhost , path , sender = None ) : <EOL> """<STR_LIT>""" <EOL> self . path = path <EOL> self . _mailhost = self . mailhost = mailhost <EOL> self . _sender = sender <EOL> if not os . path . exists ( path ) : <EOL> os . mkdir ( path ) <EOL> self . dbm = dirdbm . Shelf ( os . path . join ( path , "<STR_LIT>" ) ) <EOL> if not len ( self . dbm . keys ( ) ) : <EOL> self . initialize ( ) <EOL> def initialize ( self ) : <EOL> self . dbm [ '<STR_LIT>' ] = dirdbm . Shelf ( os . path . join ( self . path , '<STR_LIT>' ) ) <EOL> self . dbm [ '<STR_LIT>' ] = dirdbm . Shelf ( os . path . join ( self . path , '<STR_LIT>' ) ) <EOL> self . dbm [ '<STR_LIT>' ] = [ ] <EOL> self . dbm [ '<STR_LIT>' ] = dirdbm . Shelf ( os . path . join ( self . path , '<STR_LIT>' ) ) <EOL> def addGroup ( self , name , flags ) : <EOL> self . dbm [ '<STR_LIT>' ] [ name ] = Group ( name , flags ) <EOL> def addSubscription ( self , name ) : <EOL> self . dbm [ '<STR_LIT>' ] = self . dbm [ '<STR_LIT>' ] + [ name ] <EOL> def addModerator ( self , group , email ) : <EOL> self . dbm [ '<STR_LIT>' ] [ group ] = email <EOL> def listRequest ( self ) : <EOL> result = [ ] <EOL> for g in self . dbm [ '<STR_LIT>' ] . values ( ) : <EOL> result . append ( ( g . name , g . maxArticle , g . minArticle , g . flags ) ) <EOL> return defer . succeed ( result ) <EOL> def subscriptionRequest ( self ) : <EOL> return defer . succeed ( self . dbm [ '<STR_LIT>' ] ) <EOL> def getModerator ( self , groups ) : <EOL> for group in groups : <EOL> try : <EOL> return self . dbm [ '<STR_LIT>' ] [ group ] <EOL> except KeyError : <EOL> pass <EOL> return None <EOL> def notifyModerator ( self , moderator , article ) : <EOL> """<STR_LIT>""" <EOL> return self . notifyModerators ( [ moderator ] , article ) <EOL> def postRequest ( self , message ) : <EOL> cleave = message . find ( '<STR_LIT>' ) <EOL> headers , article = message [ : cleave ] , message [ cleave + <NUM_LIT:4> : ] <EOL> article = Article ( headers , article ) <EOL> groups = article . getHeader ( '<STR_LIT>' ) . split ( ) <EOL> xref = [ ] <EOL> moderator = self . getModerator ( groups ) <EOL> if moderator and not article . getHeader ( '<STR_LIT>' ) : <EOL> return self . notifyModerators ( [ moderator ] , article ) <EOL> for group in groups : <EOL> try : <EOL> g = self . dbm [ '<STR_LIT>' ] [ group ] <EOL> except KeyError : <EOL> pass <EOL> else : <EOL> index = g . maxArticle + <NUM_LIT:1> <EOL> g . maxArticle += <NUM_LIT:1> <EOL> g . articles [ index ] = article <EOL> xref . append ( ( group , str ( index ) ) ) <EOL> self . dbm [ '<STR_LIT>' ] [ group ] = g <EOL> if not xref : <EOL> return defer . fail ( NewsServerError ( "<STR_LIT>" + '<STR_LIT:U+0020>' . join ( groups ) ) ) <EOL> article . putHeader ( '<STR_LIT>' , '<STR_LIT>' % ( socket . gethostname ( ) . split ( ) [ <NUM_LIT:0> ] , '<STR_LIT:U+0020>' . join ( map ( lambda x : '<STR_LIT::>' . join ( x ) , xref ) ) ) ) <EOL> self . dbm [ '<STR_LIT>' ] [ article . getHeader ( '<STR_LIT>' ) ] = xref <EOL> return defer . succeed ( None ) <EOL> def overviewRequest ( self ) : <EOL> return defer . succeed ( OVERVIEW_FMT ) <EOL> def xoverRequest ( self , group , low , high ) : <EOL> if not self . dbm [ '<STR_LIT>' ] . has_key ( group ) : <EOL> return defer . succeed ( [ ] ) <EOL> if low is None : <EOL> low = <NUM_LIT:0> <EOL> if high is None : <EOL> high = self . dbm [ '<STR_LIT>' ] [ group ] . maxArticle <EOL> r = [ ] <EOL> for i in range ( low , high + <NUM_LIT:1> ) : <EOL> if self . dbm [ '<STR_LIT>' ] [ group ] . articles . has_key ( i ) : <EOL> r . append ( [ str ( i ) ] + self . dbm [ '<STR_LIT>' ] [ group ] . articles [ i ] . overview ( ) ) <EOL> return defer . succeed ( r ) <EOL> def xhdrRequest ( self , group , low , high , header ) : <EOL> if group not in self . dbm [ '<STR_LIT>' ] : <EOL> return defer . succeed ( [ ] ) <EOL> if low is None : <EOL> low = <NUM_LIT:0> <EOL> if high is None : <EOL> high = self . dbm [ '<STR_LIT>' ] [ group ] . maxArticle <EOL> r = [ ] <EOL> for i in range ( low , high + <NUM_LIT:1> ) : <EOL> if self . dbm [ '<STR_LIT>' ] [ group ] . articles . has_key ( i ) : <EOL> r . append ( ( i , self . dbm [ '<STR_LIT>' ] [ group ] . articles [ i ] . getHeader ( header ) ) ) <EOL> return defer . succeed ( r ) <EOL> def listGroupRequest ( self , group ) : <EOL> if self . dbm [ '<STR_LIT>' ] . has_key ( group ) : <EOL> return defer . succeed ( ( group , self . dbm [ '<STR_LIT>' ] [ group ] . articles . keys ( ) ) ) <EOL> return defer . fail ( NewsServerError ( "<STR_LIT>" + group ) ) <EOL> def groupRequest ( self , group ) : <EOL> try : <EOL> g = self . dbm [ '<STR_LIT>' ] [ group ] <EOL> except KeyError : <EOL> return defer . fail ( NewsServerError ( "<STR_LIT>" + group ) ) <EOL> else : <EOL> flags = g . flags <EOL> low = g . minArticle <EOL> high = g . maxArticle <EOL> num = high - low + <NUM_LIT:1> <EOL> return defer . succeed ( ( group , num , high , low , flags ) ) <EOL> def articleExistsRequest ( self , id ) : <EOL> return defer . succeed ( id in self . dbm [ '<STR_LIT>' ] ) <EOL> def articleRequest ( self , group , index , id = None ) : <EOL> if id is not None : <EOL> try : <EOL> xref = self . dbm [ '<STR_LIT>' ] [ id ] <EOL> except KeyError : <EOL> return defer . fail ( NewsServerError ( "<STR_LIT>" + id ) ) <EOL> else : <EOL> group , index = xref [ <NUM_LIT:0> ] <EOL> index = int ( index ) <EOL> try : <EOL> a = self . dbm [ '<STR_LIT>' ] [ group ] . articles [ index ] <EOL> except KeyError : <EOL> return defer . fail ( NewsServerError ( "<STR_LIT>" + group ) ) <EOL> else : <EOL> return defer . succeed ( ( <EOL> index , <EOL> a . getHeader ( '<STR_LIT>' ) , <EOL> StringIO . StringIO ( a . textHeaders ( ) + '<STR_LIT:\r\n>' + a . body ) <EOL> ) ) <EOL> def headRequest ( self , group , index , id = None ) : <EOL> if id is not None : <EOL> try : <EOL> xref = self . dbm [ '<STR_LIT>' ] [ id ] <EOL> except KeyError : <EOL> return defer . fail ( NewsServerError ( "<STR_LIT>" + id ) ) <EOL> else : <EOL> group , index = xref [ <NUM_LIT:0> ] <EOL> index = int ( index ) <EOL> try : <EOL> a = self . dbm [ '<STR_LIT>' ] [ group ] . articles [ index ] <EOL> except KeyError : <EOL> return defer . fail ( NewsServerError ( "<STR_LIT>" + group ) ) <EOL> else : <EOL> return defer . succeed ( ( index , a . getHeader ( '<STR_LIT>' ) , a . textHeaders ( ) ) ) <EOL> def bodyRequest ( self , group , index , id = None ) : <EOL> if id is not None : <EOL> try : <EOL> xref = self . dbm [ '<STR_LIT>' ] [ id ] <EOL> except KeyError : <EOL> return defer . fail ( NewsServerError ( "<STR_LIT>" + id ) ) <EOL> else : <EOL> group , index = xref [ <NUM_LIT:0> ] <EOL> index = int ( index ) <EOL> try : <EOL> a = self . dbm [ '<STR_LIT>' ] [ group ] . articles [ index ] <EOL> except KeyError : <EOL> return defer . fail ( NewsServerError ( "<STR_LIT>" + group ) ) <EOL> else : <EOL> return defer . succeed ( ( index , a . getHeader ( '<STR_LIT>' ) , StringIO . StringIO ( a . body ) ) ) <EOL> class NewsStorageAugmentation : <EOL> """<STR_LIT>""" <EOL> implements ( INewsStorage ) <EOL> schema = """<STR_LIT>""" <EOL> def __init__ ( self , info ) : <EOL> self . info = info <EOL> self . dbpool = adbapi . ConnectionPool ( ** self . info ) <EOL> def __setstate__ ( self , state ) : <EOL> self . __dict__ = state <EOL> self . info [ '<STR_LIT:password>' ] = getpass . getpass ( '<STR_LIT>' % ( self . info [ '<STR_LIT:user>' ] , ) ) <EOL> self . dbpool = adbapi . ConnectionPool ( ** self . info ) <EOL> del self . info [ '<STR_LIT:password>' ] <EOL> def listRequest ( self ) : <EOL> sql = """<STR_LIT>""" <EOL> return self . dbpool . runQuery ( sql ) <EOL> def subscriptionRequest ( self ) : <EOL> sql = """<STR_LIT>""" <EOL> return self . dbpool . runQuery ( sql ) <EOL> def postRequest ( self , message ) : <EOL> cleave = message . find ( '<STR_LIT>' ) <EOL> headers , article = message [ : cleave ] , message [ cleave + <NUM_LIT:4> : ] <EOL> article = Article ( headers , article ) <EOL> return self . dbpool . runInteraction ( self . _doPost , article ) <EOL> def _doPost ( self , transaction , article ) : <EOL> groups = article . getHeader ( '<STR_LIT>' ) . split ( ) <EOL> if not len ( groups ) : <EOL> raise NNTPError ( '<STR_LIT>' ) <EOL> sql = """<STR_LIT>""" % ( '<STR_LIT:U+002CU+0020>' . join ( [ ( "<STR_LIT>" % ( adbapi . safe ( group ) , ) ) for group in groups ] ) , ) <EOL> transaction . execute ( sql ) <EOL> result = transaction . fetchall ( ) <EOL> if not len ( result ) : <EOL> raise NNTPError ( '<STR_LIT>' ) <EOL> sql = """<STR_LIT>""" % ( '<STR_LIT:U+002CU+0020>' . join ( [ ( "<STR_LIT>" % ( id , ) ) for ( group , id ) in result ] ) , ) <EOL> transaction . execute ( sql ) <EOL> indices = transaction . fetchall ( ) <EOL> if not len ( indices ) : <EOL> raise NNTPError ( '<STR_LIT>' ) <EOL> gidToName = dict ( [ ( b , a ) for ( a , b ) in result ] ) <EOL> gidToIndex = dict ( indices ) <EOL> nameIndex = [ ] <EOL> for i in gidToName : <EOL> nameIndex . append ( ( gidToName [ i ] , gidToIndex [ i ] ) ) <EOL> xrefs = socket . gethostname ( ) . split ( ) [ <NUM_LIT:0> ] <EOL> xrefs = xrefs + '<STR_LIT:U+0020>' + '<STR_LIT:U+0020>' . join ( [ ( '<STR_LIT>' % ( group , id ) ) for ( group , id ) in nameIndex ] ) <EOL> article . putHeader ( '<STR_LIT>' , xrefs ) <EOL> sql = """<STR_LIT>""" % ( <EOL> adbapi . safe ( article . getHeader ( '<STR_LIT>' ) ) , <EOL> adbapi . safe ( article . textHeaders ( ) ) , <EOL> adbapi . safe ( article . body ) <EOL> ) <EOL> transaction . execute ( sql ) <EOL> for gid in gidToName : <EOL> sql = """<STR_LIT>""" % ( gid , gidToIndex [ gid ] ) <EOL> transaction . execute ( sql ) <EOL> return len ( nameIndex ) <EOL> def overviewRequest ( self ) : <EOL> sql = """<STR_LIT>""" <EOL> return self . dbpool . runQuery ( sql ) . addCallback ( lambda result : [ header [ <NUM_LIT:0> ] for header in result ] ) <EOL> def xoverRequest ( self , group , low , high ) : <EOL> sql = """<STR_LIT>""" % ( <EOL> adbapi . safe ( group ) , <EOL> low is not None and "<STR_LIT>" % ( low , ) or "<STR_LIT>" , <EOL> high is not None and "<STR_LIT>" % ( high , ) or "<STR_LIT>" <EOL> ) <EOL> return self . dbpool . runQuery ( sql ) . addCallback ( <EOL> lambda results : [ <EOL> [ id ] + Article ( header , None ) . overview ( ) for ( id , header ) in results <EOL> ] <EOL> ) <EOL> def xhdrRequest ( self , group , low , high , header ) : <EOL> sql = """<STR_LIT>""" % ( adbapi . safe ( group ) , low , high ) <EOL> return self . dbpool . runQuery ( sql ) . addCallback ( <EOL> lambda results : [ <EOL> ( i , Article ( h , None ) . getHeader ( h ) ) for ( i , h ) in results <EOL> ] <EOL> ) <EOL> def listGroupRequest ( self , group ) : <EOL> sql = """<STR_LIT>""" % ( adbapi . safe ( group ) , )

return self . dbpool . runQuery ( sql ) . addCallback (

"""<STR_LIT>""" <EOL> import getpass , pickle , time , socket <EOL> import os <EOL> import StringIO <EOL> from email . Message import Message <EOL> from email . Generator import Generator <EOL> from zope . interface import implements , Interface <EOL> from twisted . news . nntp import NNTPError <EOL> from twisted . mail import smtp <EOL> from twisted . internet import defer <EOL> from twisted . enterprise import adbapi <EOL> from twisted . persisted import dirdbm <EOL> from twisted . python . hashlib import md5 <EOL> ERR_NOGROUP , ERR_NOARTICLE = range ( <NUM_LIT:2> , <NUM_LIT:4> ) <EOL> OVERVIEW_FMT = [ <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' <EOL> ] <EOL> def hexdigest ( md5 ) : <EOL> return '<STR_LIT>' . join ( map ( lambda x : hex ( ord ( x ) ) [ <NUM_LIT:2> : ] , md5 . digest ( ) ) ) <EOL> class Article : <EOL> def __init__ ( self , head , body ) : <EOL> self . body = body <EOL> self . headers = { } <EOL> header = None <EOL> for line in head . split ( '<STR_LIT:\r\n>' ) : <EOL> if line [ <NUM_LIT:0> ] in '<STR_LIT>' : <EOL> i = list ( self . headers [ header ] ) <EOL> i [ <NUM_LIT:1> ] += '<STR_LIT:\r\n>' + line <EOL> else : <EOL> i = line . split ( '<STR_LIT>' , <NUM_LIT:1> ) <EOL> header = i [ <NUM_LIT:0> ] . lower ( ) <EOL> self . headers [ header ] = tuple ( i ) <EOL> if not self . getHeader ( '<STR_LIT>' ) : <EOL> s = str ( time . time ( ) ) + self . body <EOL> id = hexdigest ( md5 ( s ) ) + '<STR_LIT:@>' + socket . gethostname ( ) <EOL> self . putHeader ( '<STR_LIT>' , '<STR_LIT>' % id ) <EOL> if not self . getHeader ( '<STR_LIT>' ) : <EOL> self . putHeader ( '<STR_LIT>' , str ( len ( self . body ) ) ) <EOL> if not self . getHeader ( '<STR_LIT>' ) : <EOL> self . putHeader ( '<STR_LIT>' , str ( self . body . count ( '<STR_LIT:\n>' ) ) ) <EOL> if not self . getHeader ( '<STR_LIT>' ) : <EOL> self . putHeader ( '<STR_LIT>' , time . ctime ( time . time ( ) ) ) <EOL> def getHeader ( self , header ) : <EOL> h = header . lower ( ) <EOL> if self . headers . has_key ( h ) : <EOL> return self . headers [ h ] [ <NUM_LIT:1> ] <EOL> else : <EOL> return '<STR_LIT>' <EOL> def putHeader ( self , header , value ) : <EOL> self . headers [ header . lower ( ) ] = ( header , value ) <EOL> def textHeaders ( self ) : <EOL> headers = [ ] <EOL> for i in self . headers . values ( ) : <EOL> headers . append ( '<STR_LIT>' % i ) <EOL> return '<STR_LIT:\r\n>' . join ( headers ) + '<STR_LIT:\r\n>' <EOL> def overview ( self ) : <EOL> xover = [ ] <EOL> for i in OVERVIEW_FMT : <EOL> xover . append ( self . getHeader ( i ) ) <EOL> return xover <EOL> class NewsServerError ( Exception ) : <EOL> pass <EOL> class INewsStorage ( Interface ) : <EOL> """<STR_LIT>""" <EOL> def listRequest ( ) : <EOL> """<STR_LIT>""" <EOL> def subscriptionRequest ( ) : <EOL> """<STR_LIT>""" <EOL> def postRequest ( message ) : <EOL> """<STR_LIT>""" <EOL> def overviewRequest ( ) : <EOL> """<STR_LIT>""" <EOL> def xoverRequest ( group , low , high ) : <EOL> """<STR_LIT>""" <EOL> def xhdrRequest ( group , low , high , header ) : <EOL> """<STR_LIT>""" <EOL> def listGroupRequest ( group ) : <EOL> """<STR_LIT>""" <EOL> def groupRequest ( group ) : <EOL> """<STR_LIT>""" <EOL> def articleExistsRequest ( id ) : <EOL> """<STR_LIT>""" <EOL> def articleRequest ( group , index , id = None ) : <EOL> """<STR_LIT>""" <EOL> def headRequest ( group , index ) : <EOL> """<STR_LIT>""" <EOL> def bodyRequest ( group , index ) : <EOL> """<STR_LIT>""" <EOL> class NewsStorage : <EOL> """<STR_LIT>""" <EOL> def listRequest ( self ) : <EOL> raise NotImplementedError ( ) <EOL> def subscriptionRequest ( self ) : <EOL> raise NotImplementedError ( ) <EOL> def postRequest ( self , message ) : <EOL> raise NotImplementedError ( ) <EOL> def overviewRequest ( self ) : <EOL> return defer . succeed ( OVERVIEW_FMT ) <EOL> def xoverRequest ( self , group , low , high ) : <EOL> raise NotImplementedError ( ) <EOL> def xhdrRequest ( self , group , low , high , header ) : <EOL> raise NotImplementedError ( ) <EOL> def listGroupRequest ( self , group ) : <EOL> raise NotImplementedError ( ) <EOL> def groupRequest ( self , group ) : <EOL> raise NotImplementedError ( ) <EOL> def articleExistsRequest ( self , id ) : <EOL> raise NotImplementedError ( ) <EOL> def articleRequest ( self , group , index , id = None ) : <EOL> raise NotImplementedError ( ) <EOL> def headRequest ( self , group , index ) : <EOL> raise NotImplementedError ( ) <EOL> def bodyRequest ( self , group , index ) : <EOL> raise NotImplementedError ( ) <EOL> class _ModerationMixin : <EOL> """<STR_LIT>""" <EOL> sendmail = staticmethod ( smtp . sendmail ) <EOL> def notifyModerators ( self , moderators , article ) : <EOL> """<STR_LIT>""" <EOL> group = article . getHeader ( '<STR_LIT>' ) <EOL> subject = article . getHeader ( '<STR_LIT>' ) <EOL> if self . _sender is None : <EOL> sender = '<STR_LIT>' + socket . gethostname ( ) <EOL> else : <EOL> sender = self . _sender <EOL> msg = Message ( ) <EOL> msg [ '<STR_LIT>' ] = smtp . messageid ( ) <EOL> msg [ '<STR_LIT>' ] = sender <EOL> msg [ '<STR_LIT>' ] = '<STR_LIT:U+002CU+0020>' . join ( moderators ) <EOL> msg [ '<STR_LIT>' ] = '<STR_LIT>' % ( group , subject ) <EOL> msg [ '<STR_LIT:Content-Type>' ] = '<STR_LIT>' <EOL> payload = Message ( ) <EOL> for header , value in article . headers . values ( ) : <EOL> payload . add_header ( header , value ) <EOL> payload . set_payload ( article . body ) <EOL> msg . attach ( payload ) <EOL> out = StringIO . StringIO ( ) <EOL> gen = Generator ( out , False ) <EOL> gen . flatten ( msg ) <EOL> msg = out . getvalue ( ) <EOL> return self . sendmail ( self . _mailhost , sender , moderators , msg ) <EOL> class PickleStorage ( _ModerationMixin ) : <EOL> """<STR_LIT>""" <EOL> implements ( INewsStorage ) <EOL> sharedDBs = { } <EOL> def __init__ ( self , filename , groups = None , moderators = ( ) , <EOL> mailhost = None , sender = None ) : <EOL> """<STR_LIT>""" <EOL> self . datafile = filename <EOL> self . load ( filename , groups , moderators ) <EOL> self . _mailhost = mailhost <EOL> self . _sender = sender <EOL> def getModerators ( self , groups ) : <EOL> moderators = [ ] <EOL> for group in groups : <EOL> moderators . extend ( self . db [ '<STR_LIT>' ] . get ( group , None ) ) <EOL> return filter ( None , moderators ) <EOL> def listRequest ( self ) : <EOL> "<STR_LIT>" <EOL> l = self . db [ '<STR_LIT>' ] <EOL> r = [ ] <EOL> for i in l : <EOL> if len ( self . db [ i ] . keys ( ) ) : <EOL> low = min ( self . db [ i ] . keys ( ) ) <EOL> high = max ( self . db [ i ] . keys ( ) ) + <NUM_LIT:1> <EOL> else : <EOL> low = high = <NUM_LIT:0> <EOL> if self . db [ '<STR_LIT>' ] . has_key ( i ) : <EOL> flags = '<STR_LIT:m>' <EOL> else : <EOL> flags = '<STR_LIT:y>' <EOL> r . append ( ( i , high , low , flags ) ) <EOL> return defer . succeed ( r ) <EOL> def subscriptionRequest ( self ) : <EOL> return defer . succeed ( [ '<STR_LIT>' ] ) <EOL> def postRequest ( self , message ) : <EOL> cleave = message . find ( '<STR_LIT>' ) <EOL> headers , article = message [ : cleave ] , message [ cleave + <NUM_LIT:4> : ] <EOL> a = Article ( headers , article ) <EOL> groups = a . getHeader ( '<STR_LIT>' ) . split ( ) <EOL> xref = [ ] <EOL> moderators = self . getModerators ( groups ) <EOL> if moderators and not a . getHeader ( '<STR_LIT>' ) : <EOL> return self . notifyModerators ( moderators , a ) <EOL> for group in groups : <EOL> if self . db . has_key ( group ) : <EOL> if len ( self . db [ group ] . keys ( ) ) : <EOL> index = max ( self . db [ group ] . keys ( ) ) + <NUM_LIT:1> <EOL> else : <EOL> index = <NUM_LIT:1> <EOL> xref . append ( ( group , str ( index ) ) ) <EOL> self . db [ group ] [ index ] = a <EOL> if len ( xref ) == <NUM_LIT:0> : <EOL> return defer . fail ( None ) <EOL> a . putHeader ( '<STR_LIT>' , '<STR_LIT>' % ( <EOL> socket . gethostname ( ) . split ( ) [ <NUM_LIT:0> ] , <EOL> '<STR_LIT>' . join ( map ( lambda x : '<STR_LIT::>' . join ( x ) , xref ) ) <EOL> ) ) <EOL> self . flush ( ) <EOL> return defer . succeed ( None ) <EOL> def overviewRequest ( self ) : <EOL> return defer . succeed ( OVERVIEW_FMT ) <EOL> def xoverRequest ( self , group , low , high ) : <EOL> if not self . db . has_key ( group ) : <EOL> return defer . succeed ( [ ] ) <EOL> r = [ ] <EOL> for i in self . db [ group ] . keys ( ) : <EOL> if ( low is None or i >= low ) and ( high is None or i <= high ) : <EOL> r . append ( [ str ( i ) ] + self . db [ group ] [ i ] . overview ( ) ) <EOL> return defer . succeed ( r ) <EOL> def xhdrRequest ( self , group , low , high , header ) : <EOL> if not self . db . has_key ( group ) : <EOL> return defer . succeed ( [ ] ) <EOL> r = [ ] <EOL> for i in self . db [ group ] . keys ( ) : <EOL> if low is None or i >= low and high is None or i <= high : <EOL> r . append ( ( i , self . db [ group ] [ i ] . getHeader ( header ) ) ) <EOL> return defer . succeed ( r ) <EOL> def listGroupRequest ( self , group ) : <EOL> if self . db . has_key ( group ) : <EOL> return defer . succeed ( ( group , self . db [ group ] . keys ( ) ) ) <EOL> else : <EOL> return defer . fail ( None ) <EOL> def groupRequest ( self , group ) : <EOL> if self . db . has_key ( group ) : <EOL> if len ( self . db [ group ] . keys ( ) ) : <EOL> num = len ( self . db [ group ] . keys ( ) ) <EOL> low = min ( self . db [ group ] . keys ( ) ) <EOL> high = max ( self . db [ group ] . keys ( ) ) <EOL> else : <EOL> num = low = high = <NUM_LIT:0> <EOL> flags = '<STR_LIT:y>' <EOL> return defer . succeed ( ( group , num , high , low , flags ) ) <EOL> else : <EOL> return defer . fail ( ERR_NOGROUP ) <EOL> def articleExistsRequest ( self , id ) : <EOL> for group in self . db [ '<STR_LIT>' ] : <EOL> for a in self . db [ group ] . values ( ) : <EOL> if a . getHeader ( '<STR_LIT>' ) == id : <EOL> return defer . succeed ( <NUM_LIT:1> ) <EOL> return defer . succeed ( <NUM_LIT:0> ) <EOL> def articleRequest ( self , group , index , id = None ) : <EOL> if id is not None : <EOL> raise NotImplementedError <EOL> if self . db . has_key ( group ) : <EOL> if self . db [ group ] . has_key ( index ) : <EOL> a = self . db [ group ] [ index ] <EOL> return defer . succeed ( ( <EOL> index , <EOL> a . getHeader ( '<STR_LIT>' ) , <EOL> StringIO . StringIO ( a . textHeaders ( ) + '<STR_LIT:\r\n>' + a . body ) <EOL> ) ) <EOL> else : <EOL> return defer . fail ( ERR_NOARTICLE ) <EOL> else : <EOL> return defer . fail ( ERR_NOGROUP ) <EOL> def headRequest ( self , group , index ) : <EOL> if self . db . has_key ( group ) : <EOL> if self . db [ group ] . has_key ( index ) : <EOL> a = self . db [ group ] [ index ] <EOL> return defer . succeed ( ( index , a . getHeader ( '<STR_LIT>' ) , a . textHeaders ( ) ) ) <EOL> else : <EOL> return defer . fail ( ERR_NOARTICLE ) <EOL> else : <EOL> return defer . fail ( ERR_NOGROUP ) <EOL> def bodyRequest ( self , group , index ) : <EOL> if self . db . has_key ( group ) : <EOL> if self . db [ group ] . has_key ( index ) : <EOL> a = self . db [ group ] [ index ] <EOL> return defer . succeed ( ( index , a . getHeader ( '<STR_LIT>' ) , StringIO . StringIO ( a . body ) ) ) <EOL> else : <EOL> return defer . fail ( ERR_NOARTICLE ) <EOL> else : <EOL> return defer . fail ( ERR_NOGROUP ) <EOL> def flush ( self ) : <EOL> f = open ( self . datafile , '<STR_LIT:w>' ) <EOL> pickle . dump ( self . db , f ) <EOL> f . close ( ) <EOL> def load ( self , filename , groups = None , moderators = ( ) ) : <EOL> if PickleStorage . sharedDBs . has_key ( filename ) : <EOL> self . db = PickleStorage . sharedDBs [ filename ] <EOL> else : <EOL> try : <EOL> self . db = pickle . load ( open ( filename ) ) <EOL> PickleStorage . sharedDBs [ filename ] = self . db <EOL> except IOError : <EOL> self . db = PickleStorage . sharedDBs [ filename ] = { } <EOL> self . db [ '<STR_LIT>' ] = groups <EOL> if groups is not None : <EOL> for i in groups : <EOL> self . db [ i ] = { } <EOL> self . db [ '<STR_LIT>' ] = dict ( moderators ) <EOL> self . flush ( ) <EOL> class Group : <EOL> name = None <EOL> flags = '<STR_LIT>' <EOL> minArticle = <NUM_LIT:1> <EOL> maxArticle = <NUM_LIT:0> <EOL> articles = None <EOL> def __init__ ( self , name , flags = '<STR_LIT:y>' ) : <EOL> self . name = name <EOL> self . flags = flags <EOL> self . articles = { } <EOL> class NewsShelf ( _ModerationMixin ) : <EOL> """<STR_LIT>""" <EOL> implements ( INewsStorage ) <EOL> def __init__ ( self , mailhost , path , sender = None ) : <EOL> """<STR_LIT>""" <EOL> self . path = path <EOL> self . _mailhost = self . mailhost = mailhost <EOL> self . _sender = sender <EOL> if not os . path . exists ( path ) : <EOL> os . mkdir ( path ) <EOL> self . dbm = dirdbm . Shelf ( os . path . join ( path , "<STR_LIT>" ) ) <EOL> if not len ( self . dbm . keys ( ) ) : <EOL> self . initialize ( ) <EOL> def initialize ( self ) : <EOL> self . dbm [ '<STR_LIT>' ] = dirdbm . Shelf ( os . path . join ( self . path , '<STR_LIT>' ) ) <EOL> self . dbm [ '<STR_LIT>' ] = dirdbm . Shelf ( os . path . join ( self . path , '<STR_LIT>' ) ) <EOL> self . dbm [ '<STR_LIT>' ] = [ ] <EOL> self . dbm [ '<STR_LIT>' ] = dirdbm . Shelf ( os . path . join ( self . path , '<STR_LIT>' ) ) <EOL> def addGroup ( self , name , flags ) : <EOL> self . dbm [ '<STR_LIT>' ] [ name ] = Group ( name , flags ) <EOL> def addSubscription ( self , name ) : <EOL> self . dbm [ '<STR_LIT>' ] = self . dbm [ '<STR_LIT>' ] + [ name ] <EOL> def addModerator ( self , group , email ) : <EOL> self . dbm [ '<STR_LIT>' ] [ group ] = email <EOL> def listRequest ( self ) : <EOL> result = [ ] <EOL> for g in self . dbm [ '<STR_LIT>' ] . values ( ) : <EOL> result . append ( ( g . name , g . maxArticle , g . minArticle , g . flags ) ) <EOL> return defer . succeed ( result ) <EOL> def subscriptionRequest ( self ) : <EOL> return defer . succeed ( self . dbm [ '<STR_LIT>' ] ) <EOL> def getModerator ( self , groups ) : <EOL> for group in groups : <EOL> try : <EOL> return self . dbm [ '<STR_LIT>' ] [ group ] <EOL> except KeyError : <EOL> pass <EOL> return None <EOL> def notifyModerator ( self , moderator , article ) : <EOL> """<STR_LIT>""" <EOL> return self . notifyModerators ( [ moderator ] , article ) <EOL> def postRequest ( self , message ) : <EOL> cleave = message . find ( '<STR_LIT>' ) <EOL> headers , article = message [ : cleave ] , message [ cleave + <NUM_LIT:4> : ] <EOL> article = Article ( headers , article ) <EOL> groups = article . getHeader ( '<STR_LIT>' ) . split ( ) <EOL> xref = [ ] <EOL> moderator = self . getModerator ( groups ) <EOL> if moderator and not article . getHeader ( '<STR_LIT>' ) : <EOL> return self . notifyModerators ( [ moderator ] , article ) <EOL> for group in groups : <EOL> try : <EOL> g = self . dbm [ '<STR_LIT>' ] [ group ] <EOL> except KeyError : <EOL> pass <EOL> else : <EOL> index = g . maxArticle + <NUM_LIT:1> <EOL> g . maxArticle += <NUM_LIT:1> <EOL> g . articles [ index ] = article <EOL> xref . append ( ( group , str ( index ) ) ) <EOL> self . dbm [ '<STR_LIT>' ] [ group ] = g <EOL> if not xref : <EOL> return defer . fail ( NewsServerError ( "<STR_LIT>" + '<STR_LIT:U+0020>' . join ( groups ) ) ) <EOL> article . putHeader ( '<STR_LIT>' , '<STR_LIT>' % ( socket . gethostname ( ) . split ( ) [ <NUM_LIT:0> ] , '<STR_LIT:U+0020>' . join ( map ( lambda x : '<STR_LIT::>' . join ( x ) , xref ) ) ) ) <EOL> self . dbm [ '<STR_LIT>' ] [ article . getHeader ( '<STR_LIT>' ) ] = xref <EOL> return defer . succeed ( None ) <EOL> def overviewRequest ( self ) : <EOL> return defer . succeed ( OVERVIEW_FMT ) <EOL> def xoverRequest ( self , group , low , high ) : <EOL> if not self . dbm [ '<STR_LIT>' ] . has_key ( group ) : <EOL> return defer . succeed ( [ ] ) <EOL> if low is None : <EOL> low = <NUM_LIT:0> <EOL> if high is None : <EOL> high = self . dbm [ '<STR_LIT>' ] [ group ] . maxArticle <EOL> r = [ ] <EOL> for i in range ( low , high + <NUM_LIT:1> ) : <EOL> if self . dbm [ '<STR_LIT>' ] [ group ] . articles . has_key ( i ) : <EOL> r . append ( [ str ( i ) ] + self . dbm [ '<STR_LIT>' ] [ group ] . articles [ i ] . overview ( ) ) <EOL> return defer . succeed ( r ) <EOL> def xhdrRequest ( self , group , low , high , header ) : <EOL> if group not in self . dbm [ '<STR_LIT>' ] : <EOL> return defer . succeed ( [ ] ) <EOL> if low is None : <EOL> low = <NUM_LIT:0> <EOL> if high is None : <EOL> high = self . dbm [ '<STR_LIT>' ] [ group ] . maxArticle <EOL> r = [ ] <EOL> for i in range ( low , high + <NUM_LIT:1> ) : <EOL> if self . dbm [ '<STR_LIT>' ] [ group ] . articles . has_key ( i ) : <EOL> r . append ( ( i , self . dbm [ '<STR_LIT>' ] [ group ] . articles [ i ] . getHeader ( header ) ) ) <EOL> return defer . succeed ( r ) <EOL> def listGroupRequest ( self , group ) : <EOL> if self . dbm [ '<STR_LIT>' ] . has_key ( group ) : <EOL> return defer . succeed ( ( group , self . dbm [ '<STR_LIT>' ] [ group ] . articles . keys ( ) ) ) <EOL> return defer . fail ( NewsServerError ( "<STR_LIT>" + group ) ) <EOL> def groupRequest ( self , group ) : <EOL> try : <EOL> g = self . dbm [ '<STR_LIT>' ] [ group ] <EOL> except KeyError : <EOL> return defer . fail ( NewsServerError ( "<STR_LIT>" + group ) ) <EOL> else : <EOL> flags = g . flags <EOL> low = g . minArticle <EOL> high = g . maxArticle <EOL> num = high - low + <NUM_LIT:1> <EOL> return defer . succeed ( ( group , num , high , low , flags ) ) <EOL> def articleExistsRequest ( self , id ) : <EOL> return defer . succeed ( id in self . dbm [ '<STR_LIT>' ] ) <EOL> def articleRequest ( self , group , index , id = None ) : <EOL> if id is not None : <EOL> try : <EOL> xref = self . dbm [ '<STR_LIT>' ] [ id ] <EOL> except KeyError : <EOL> return defer . fail ( NewsServerError ( "<STR_LIT>" + id ) ) <EOL> else : <EOL> group , index = xref [ <NUM_LIT:0> ] <EOL> index = int ( index ) <EOL> try : <EOL> a = self . dbm [ '<STR_LIT>' ] [ group ] . articles [ index ] <EOL> except KeyError : <EOL> return defer . fail ( NewsServerError ( "<STR_LIT>" + group ) ) <EOL> else : <EOL> return defer . succeed ( ( <EOL> index , <EOL> a . getHeader ( '<STR_LIT>' ) , <EOL> StringIO . StringIO ( a . textHeaders ( ) + '<STR_LIT:\r\n>' + a . body ) <EOL> ) ) <EOL> def headRequest ( self , group , index , id = None ) : <EOL> if id is not None : <EOL> try : <EOL> xref = self . dbm [ '<STR_LIT>' ] [ id ] <EOL> except KeyError : <EOL> return defer . fail ( NewsServerError ( "<STR_LIT>" + id ) ) <EOL> else : <EOL> group , index = xref [ <NUM_LIT:0> ] <EOL> index = int ( index ) <EOL> try : <EOL> a = self . dbm [ '<STR_LIT>' ] [ group ] . articles [ index ] <EOL> except KeyError : <EOL> return defer . fail ( NewsServerError ( "<STR_LIT>" + group ) ) <EOL> else : <EOL> return defer . succeed ( ( index , a . getHeader ( '<STR_LIT>' ) , a . textHeaders ( ) ) ) <EOL> def bodyRequest ( self , group , index , id = None ) : <EOL> if id is not None : <EOL> try : <EOL> xref = self . dbm [ '<STR_LIT>' ] [ id ] <EOL> except KeyError : <EOL> return defer . fail ( NewsServerError ( "<STR_LIT>" + id ) ) <EOL> else : <EOL> group , index = xref [ <NUM_LIT:0> ] <EOL> index = int ( index ) <EOL> try : <EOL> a = self . dbm [ '<STR_LIT>' ] [ group ] . articles [ index ] <EOL> except KeyError : <EOL> return defer . fail ( NewsServerError ( "<STR_LIT>" + group ) ) <EOL> else : <EOL> return defer . succeed ( ( index , a . getHeader ( '<STR_LIT>' ) , StringIO . StringIO ( a . body ) ) ) <EOL> class NewsStorageAugmentation : <EOL> """<STR_LIT>""" <EOL> implements ( INewsStorage ) <EOL> schema = """<STR_LIT>""" <EOL> def __init__ ( self , info ) : <EOL> self . info = info <EOL> self . dbpool = adbapi . ConnectionPool ( ** self . info ) <EOL> def __setstate__ ( self , state ) : <EOL> self . __dict__ = state <EOL> self . info [ '<STR_LIT:password>' ] = getpass . getpass ( '<STR_LIT>' % ( self . info [ '<STR_LIT:user>' ] , ) ) <EOL> self . dbpool = adbapi . ConnectionPool ( ** self . info ) <EOL> del self . info [ '<STR_LIT:password>' ] <EOL> def listRequest ( self ) : <EOL> sql = """<STR_LIT>""" <EOL> return self . dbpool . runQuery ( sql ) <EOL> def subscriptionRequest ( self ) : <EOL> sql = """<STR_LIT>""" <EOL> return self . dbpool . runQuery ( sql ) <EOL> def postRequest ( self , message ) : <EOL> cleave = message . find ( '<STR_LIT>' ) <EOL> headers , article = message [ : cleave ] , message [ cleave + <NUM_LIT:4> : ] <EOL> article = Article ( headers , article ) <EOL> return self . dbpool . runInteraction ( self . _doPost , article ) <EOL> def _doPost ( self , transaction , article ) : <EOL> groups = article . getHeader ( '<STR_LIT>' ) . split ( ) <EOL> if not len ( groups ) : <EOL> raise NNTPError ( '<STR_LIT>' ) <EOL> sql = """<STR_LIT>""" % ( '<STR_LIT:U+002CU+0020>' . join ( [ ( "<STR_LIT>" % ( adbapi . safe ( group ) , ) ) for group in groups ] ) , ) <EOL> transaction . execute ( sql ) <EOL> result = transaction . fetchall ( ) <EOL> if not len ( result ) : <EOL> raise NNTPError ( '<STR_LIT>' ) <EOL> sql = """<STR_LIT>""" % ( '<STR_LIT:U+002CU+0020>' . join ( [ ( "<STR_LIT>" % ( id , ) ) for ( group , id ) in result ] ) , ) <EOL> transaction . execute ( sql ) <EOL> indices = transaction . fetchall ( ) <EOL> if not len ( indices ) : <EOL> raise NNTPError ( '<STR_LIT>' ) <EOL> gidToName = dict ( [ ( b , a ) for ( a , b ) in result ] ) <EOL> gidToIndex = dict ( indices ) <EOL> nameIndex = [ ] <EOL> for i in gidToName : <EOL> nameIndex . append ( ( gidToName [ i ] , gidToIndex [ i ] ) ) <EOL> xrefs = socket . gethostname ( ) . split ( ) [ <NUM_LIT:0> ] <EOL> xrefs = xrefs + '<STR_LIT:U+0020>' + '<STR_LIT:U+0020>' . join ( [ ( '<STR_LIT>' % ( group , id ) ) for ( group , id ) in nameIndex ] ) <EOL> article . putHeader ( '<STR_LIT>' , xrefs ) <EOL> sql = """<STR_LIT>""" % ( <EOL> adbapi . safe ( article . getHeader ( '<STR_LIT>' ) ) , <EOL> adbapi . safe ( article . textHeaders ( ) ) , <EOL> adbapi . safe ( article . body ) <EOL> ) <EOL> transaction . execute ( sql ) <EOL> for gid in gidToName : <EOL> sql = """<STR_LIT>""" % ( gid , gidToIndex [ gid ] ) <EOL> transaction . execute ( sql ) <EOL> return len ( nameIndex ) <EOL> def overviewRequest ( self ) : <EOL> sql = """<STR_LIT>""" <EOL> return self . dbpool . runQuery ( sql ) . addCallback ( lambda result : [ header [ <NUM_LIT:0> ] for header in result ] ) <EOL> def xoverRequest ( self , group , low , high ) : <EOL> sql = """<STR_LIT>""" % ( <EOL> adbapi . safe ( group ) , <EOL> low is not None and "<STR_LIT>" % ( low , ) or "<STR_LIT>" , <EOL> high is not None and "<STR_LIT>" % ( high , ) or "<STR_LIT>" <EOL> ) <EOL> return self . dbpool . runQuery ( sql ) . addCallback ( <EOL> lambda results : [ <EOL> [ id ] + Article ( header , None ) . overview ( ) for ( id , header ) in results <EOL> ] <EOL> ) <EOL> def xhdrRequest ( self , group , low , high , header ) : <EOL> sql = """<STR_LIT>""" % ( adbapi . safe ( group ) , low , high ) <EOL> return self . dbpool . runQuery ( sql ) . addCallback ( <EOL> lambda results : [ <EOL> ( i , Article ( h , None ) . getHeader ( h ) ) for ( i , h ) in results <EOL> ] <EOL> ) <EOL> def listGroupRequest ( self , group ) : <EOL> sql = """<STR_LIT>""" % ( adbapi . safe ( group ) , ) <EOL> return self . dbpool . runQuery ( sql ) . addCallback ( <EOL> lambda results , group = group : ( group , [ res [ <NUM_LIT:0> ] for res in results ] ) <EOL> ) <EOL> def groupRequest ( self , group ) : <EOL> sql = """<STR_LIT>""" % ( adbapi . safe ( group ) , ) <EOL> return self . dbpool . runQuery ( sql ) . addCallback ( <EOL> lambda results : tuple ( results [ <NUM_LIT:0> ] ) <EOL> ) <EOL> def articleExistsRequest ( self , id ) : <EOL> sql = """<STR_LIT>""" % ( adbapi . safe ( id ) , ) <EOL> return self . dbpool . runQuery ( sql ) . addCallback ( <EOL> lambda result : bool ( result [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] ) <EOL> ) <EOL> def articleRequest ( self , group , index , id = None ) : <EOL> if id is not None : <EOL> sql = """<STR_LIT>""" % ( adbapi . safe ( id ) , adbapi . safe ( group ) ) <EOL> else : <EOL> sql = """<STR_LIT>""" % ( index , adbapi . safe ( group ) ) <EOL> return self . dbpool . runQuery ( sql ) . addCallback ( <EOL> lambda result : ( <EOL> result [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] , <EOL> result [ <NUM_LIT:0> ] [ <NUM_LIT:1> ] , <EOL> StringIO . StringIO ( result [ <NUM_LIT:0> ] [ <NUM_LIT:2> ] + '<STR_LIT:\r\n>' + result [ <NUM_LIT:0> ] [ <NUM_LIT:3> ] ) <EOL> ) <EOL> ) <EOL> def headRequest ( self , group , index ) : <EOL> sql = """<STR_LIT>""" % ( index , adbapi . safe ( group ) ) <EOL> return self . dbpool . runQuery ( sql ) . addCallback ( lambda result : result [ <NUM_LIT:0> ] ) <EOL> def bodyRequest ( self , group , index ) : <EOL> sql = """<STR_LIT>""" % ( index , adbapi . safe ( group ) ) <EOL> return self . dbpool . runQuery ( sql ) . addCallback ( <EOL> lambda result : result [ <NUM_LIT:0> ] <EOL> ) . addCallback ( <EOL> lambda ( index , id , body ) : ( index , id , StringIO . StringIO ( body ) ) <EOL> ) <EOL> def makeGroupSQL ( groups ) : <EOL> res = '<STR_LIT>' <EOL> for g in groups : <EOL> res = res + """<STR_LIT>""" % ( adbapi . safe ( g ) , ) <EOL> return res <EOL> def makeOverviewSQL ( ) : <EOL> res = '<STR_LIT>' <EOL> for o in OVERVIEW_FMT : <EOL> res = res + """<STR_LIT>""" % ( adbapi . safe ( o ) , ) <EOL> return res </s>

"""<STR_LIT>""" <EOL> from __future__ import nested_scopes <EOL> from twisted . internet import defer <EOL> import base <EOL> INSERT , DELETE , UPDATE = range ( <NUM_LIT:3> ) <EOL> class RowJournal ( base . Journal ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , log , journaledService , reflector ) : <EOL> self . reflector = reflector <EOL> self . commands = [ ] <EOL> self . syncing = <NUM_LIT:0> <EOL> base . Journal . __init__ ( self , log , journaledService ) <EOL> def updateRow ( self , obj ) : <EOL> """<STR_LIT>""" <EOL> self . commands . append ( ( UPDATE , obj ) ) <EOL> def insertRow ( self , obj ) : <EOL> """<STR_LIT>""" <EOL> self . commands . append ( ( INSERT , obj ) ) <EOL> def deleteRow ( self , obj ) : <EOL> """<STR_LIT>""" <EOL> self . commands . append ( ( DELETE , obj ) ) <EOL> def loadObjectsFrom ( self , tableName , parentRow = None , data = None , whereClause = None , forceChildren = <NUM_LIT:0> ) : <EOL> """<STR_LIT>""" <EOL> d = self . sync ( ) <EOL> d . addCallback ( lambda result : self . reflector . loadObjectsFrom ( <EOL> tableName , parentRow = parentRow , data = data , whereClause = whereClause , <EOL> forceChildren = forceChildren ) ) <EOL> return d <EOL> def sync ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . syncing : <EOL> raise ValueError , "<STR_LIT>" <EOL> comandMap = { INSERT : self . reflector . insertRowSQL , <EOL> UPDATE : self . reflector . updateRowSQL , <EOL> DELETE : self . reflector . deleteRowSQL } <EOL> sqlCommands = [ ] <EOL> for kind , obj in self . commands : <EOL> sqlCommands . append ( comandMap [ kind ] ( obj ) ) <EOL> self . commands = [ ] <EOL> if sqlCommands : <EOL> self . syncing = <NUM_LIT:1> <EOL> d = self . reflector . dbpool . runInteraction ( self . _sync , self . latestIndex , sqlCommands ) <EOL> d . addCallback ( self . _syncDone ) <EOL> return d <EOL> else : <EOL> return defer . succeed ( <NUM_LIT:1> ) <EOL> def _sync ( self , txn , index , commands ) : <EOL> """<STR_LIT>""" <EOL> for c in commands : <EOL> txn . execute ( c ) <EOL> txn . update ( "<STR_LIT>" % index ) <EOL> def _syncDone ( self , result ) : <EOL> self . syncing = <NUM_LIT:0> <EOL> return result <EOL> def getLastSnapshot ( self ) : <EOL> """<STR_LIT>"""

conn = self . reflector . dbpool . connect ( )

"""<STR_LIT>""" <EOL> from __future__ import nested_scopes <EOL> from twisted . internet import defer <EOL> import base <EOL> INSERT , DELETE , UPDATE = range ( <NUM_LIT:3> ) <EOL> class RowJournal ( base . Journal ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , log , journaledService , reflector ) : <EOL> self . reflector = reflector <EOL> self . commands = [ ] <EOL> self . syncing = <NUM_LIT:0> <EOL> base . Journal . __init__ ( self , log , journaledService ) <EOL> def updateRow ( self , obj ) : <EOL> """<STR_LIT>""" <EOL> self . commands . append ( ( UPDATE , obj ) ) <EOL> def insertRow ( self , obj ) : <EOL> """<STR_LIT>""" <EOL> self . commands . append ( ( INSERT , obj ) ) <EOL> def deleteRow ( self , obj ) : <EOL> """<STR_LIT>""" <EOL> self . commands . append ( ( DELETE , obj ) ) <EOL> def loadObjectsFrom ( self , tableName , parentRow = None , data = None , whereClause = None , forceChildren = <NUM_LIT:0> ) : <EOL> """<STR_LIT>""" <EOL> d = self . sync ( ) <EOL> d . addCallback ( lambda result : self . reflector . loadObjectsFrom ( <EOL> tableName , parentRow = parentRow , data = data , whereClause = whereClause , <EOL> forceChildren = forceChildren ) ) <EOL> return d <EOL> def sync ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . syncing : <EOL> raise ValueError , "<STR_LIT>" <EOL> comandMap = { INSERT : self . reflector . insertRowSQL , <EOL> UPDATE : self . reflector . updateRowSQL , <EOL> DELETE : self . reflector . deleteRowSQL } <EOL> sqlCommands = [ ] <EOL> for kind , obj in self . commands : <EOL> sqlCommands . append ( comandMap [ kind ] ( obj ) ) <EOL> self . commands = [ ] <EOL> if sqlCommands : <EOL> self . syncing = <NUM_LIT:1> <EOL> d = self . reflector . dbpool . runInteraction ( self . _sync , self . latestIndex , sqlCommands ) <EOL> d . addCallback ( self . _syncDone ) <EOL> return d <EOL> else : <EOL> return defer . succeed ( <NUM_LIT:1> ) <EOL> def _sync ( self , txn , index , commands ) : <EOL> """<STR_LIT>""" <EOL> for c in commands : <EOL> txn . execute ( c ) <EOL> txn . update ( "<STR_LIT>" % index ) <EOL> def _syncDone ( self , result ) : <EOL> self . syncing = <NUM_LIT:0> <EOL> return result <EOL> def getLastSnapshot ( self ) : <EOL> """<STR_LIT>""" <EOL> conn = self . reflector . dbpool . connect ( ) <EOL> cursor = conn . cursor ( ) <EOL> cursor . execute ( "<STR_LIT>" ) <EOL> return cursor . fetchall ( ) [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] </s>

"""<STR_LIT>""" <EOL> import re <EOL> import struct <EOL> import warnings <EOL> import cStringIO <EOL> import math <EOL> from zope . interface import implements <EOL> from twisted . internet import protocol , defer , interfaces , error <EOL> from twisted . python import log , deprecate , versions <EOL> LENGTH , DATA , COMMA = range ( <NUM_LIT:3> ) <EOL> NUMBER = re . compile ( '<STR_LIT>' ) <EOL> deprecatedSince = versions . Version ( "<STR_LIT>" , <NUM_LIT:10> , <NUM_LIT:2> , <NUM_LIT:0> ) <EOL> message = "<STR_LIT>" <EOL> for attr in [ "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ] : <EOL> deprecate . deprecatedModuleAttribute ( <EOL> deprecatedSince , message , __name__ , attr ) <EOL> del deprecatedSince , message , attr <EOL> DEBUG = <NUM_LIT:0> <EOL> class NetstringParseError ( ValueError ) : <EOL> """<STR_LIT>""" <EOL> class IncompleteNetstring ( Exception ) : <EOL> """<STR_LIT>""" <EOL> class NetstringReceiver ( protocol . Protocol ) : <EOL> """<STR_LIT>""" <EOL> MAX_LENGTH = <NUM_LIT> <EOL> _LENGTH = re . compile ( '<STR_LIT>' ) <EOL> _LENGTH_PREFIX = re . compile ( '<STR_LIT>' ) <EOL> _MISSING_LENGTH = ( "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> _OVERFLOW = ( "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> _TOO_LONG = ( "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> _MISSING_COMMA = "<STR_LIT>" <EOL> _DATA_SUPPORT_DEPRECATED = ( "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> _PARSING_LENGTH , _PARSING_PAYLOAD = range ( <NUM_LIT:2> ) <EOL> def makeConnection ( self , transport ) : <EOL> """<STR_LIT>""" <EOL> protocol . Protocol . makeConnection ( self , transport ) <EOL> self . _remainingData = "<STR_LIT>" <EOL> self . _currentPayloadSize = <NUM_LIT:0> <EOL> self . _payload = cStringIO . StringIO ( ) <EOL> self . _state = self . _PARSING_LENGTH <EOL> self . _expectedPayloadSize = <NUM_LIT:0> <EOL> self . brokenPeer = <NUM_LIT:0> <EOL> def sendString ( self , string ) : <EOL> """<STR_LIT>""" <EOL> if not isinstance ( string , str ) : <EOL> warnings . warn ( self . _DATA_SUPPORT_DEPRECATED , DeprecationWarning , <NUM_LIT:2> ) <EOL> string = str ( string ) <EOL> self . transport . write ( '<STR_LIT>' % ( len ( string ) , string ) ) <EOL> def dataReceived ( self , data ) : <EOL> """<STR_LIT>""" <EOL> self . _remainingData += data <EOL> while self . _remainingData : <EOL> try : <EOL> self . _consumeData ( ) <EOL> except IncompleteNetstring : <EOL> break <EOL> except NetstringParseError : <EOL> self . _handleParseError ( ) <EOL> break <EOL> def stringReceived ( self , string ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError ( ) <EOL> def _maxLengthSize ( self ) : <EOL> """<STR_LIT>""" <EOL> return math . ceil ( math . log10 ( self . MAX_LENGTH ) ) + <NUM_LIT:1> <EOL> def _consumeData ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _state == self . _PARSING_LENGTH : <EOL> self . _consumeLength ( ) <EOL> self . _prepareForPayloadConsumption ( ) <EOL> if self . _state == self . _PARSING_PAYLOAD : <EOL> self . _consumePayload ( ) <EOL> def _consumeLength ( self ) : <EOL> """<STR_LIT>""" <EOL> lengthMatch = self . _LENGTH . match ( self . _remainingData ) <EOL> if not lengthMatch : <EOL> self . _checkPartialLengthSpecification ( ) <EOL> raise IncompleteNetstring ( ) <EOL> self . _processLength ( lengthMatch ) <EOL> def _checkPartialLengthSpecification ( self ) : <EOL> """<STR_LIT>""" <EOL> partialLengthMatch = self . _LENGTH_PREFIX . match ( self . _remainingData ) <EOL> if not partialLengthMatch : <EOL> raise NetstringParseError ( self . _MISSING_LENGTH ) <EOL> lengthSpecification = ( partialLengthMatch . group ( <NUM_LIT:1> ) ) <EOL> self . _extractLength ( lengthSpecification ) <EOL> def _processLength ( self , lengthMatch ) : <EOL> """<STR_LIT>""" <EOL> endOfNumber = lengthMatch . end ( <NUM_LIT:1> ) <EOL> startOfData = lengthMatch . end ( <NUM_LIT:2> ) <EOL> lengthString = self . _remainingData [ : endOfNumber ] <EOL> self . _expectedPayloadSize = self . _extractLength ( lengthString ) + <NUM_LIT:1> <EOL> self . _remainingData = self . _remainingData [ startOfData : ] <EOL> def _extractLength ( self , lengthAsString ) : <EOL> """<STR_LIT>""" <EOL> self . _checkStringSize ( lengthAsString ) <EOL> length = int ( lengthAsString ) <EOL> if length > self . MAX_LENGTH : <EOL> raise NetstringParseError ( self . _TOO_LONG % ( self . MAX_LENGTH , ) ) <EOL> return length <EOL> def _checkStringSize ( self , lengthAsString ) : <EOL> """<STR_LIT>""" <EOL> if len ( lengthAsString ) > self . _maxLengthSize ( ) : <EOL> raise NetstringParseError ( self . _TOO_LONG % ( self . MAX_LENGTH , ) ) <EOL> def _prepareForPayloadConsumption ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _state = self . _PARSING_PAYLOAD <EOL> self . _currentPayloadSize = <NUM_LIT:0> <EOL> self . _payload . seek ( <NUM_LIT:0> ) <EOL> self . _payload . truncate ( ) <EOL> def _consumePayload ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _extractPayload ( ) <EOL> if self . _currentPayloadSize < self . _expectedPayloadSize : <EOL> raise IncompleteNetstring ( ) <EOL> self . _checkForTrailingComma ( ) <EOL> self . _state = self . _PARSING_LENGTH <EOL> self . _processPayload ( ) <EOL> def _extractPayload ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _payloadComplete ( ) : <EOL> remainingPayloadSize = ( self . _expectedPayloadSize - <EOL> self . _currentPayloadSize ) <EOL> self . _payload . write ( self . _remainingData [ : remainingPayloadSize ] ) <EOL> self . _remainingData = self . _remainingData [ remainingPayloadSize : ] <EOL> self . _currentPayloadSize = self . _expectedPayloadSize <EOL> else : <EOL> self . _payload . write ( self . _remainingData ) <EOL> self . _currentPayloadSize += len ( self . _remainingData ) <EOL> self . _remainingData = "<STR_LIT>" <EOL> def _payloadComplete ( self ) : <EOL> """<STR_LIT>""" <EOL> return ( len ( self . _remainingData ) + self . _currentPayloadSize >= <EOL> self . _expectedPayloadSize ) <EOL> def _processPayload ( self ) : <EOL> """<STR_LIT>""" <EOL> self . stringReceived ( self . _payload . getvalue ( ) [ : - <NUM_LIT:1> ] ) <EOL> def _checkForTrailingComma ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _payload . getvalue ( ) [ - <NUM_LIT:1> ] != "<STR_LIT:U+002C>" : <EOL> raise NetstringParseError ( self . _MISSING_COMMA ) <EOL> def _handleParseError ( self ) : <EOL> """<STR_LIT>""" <EOL> self . transport . loseConnection ( ) <EOL> self . brokenPeer = <NUM_LIT:1> <EOL> class LineOnlyReceiver ( protocol . Protocol ) : <EOL> """<STR_LIT>""" <EOL> _buffer = '<STR_LIT>' <EOL> delimiter = '<STR_LIT:\r\n>' <EOL> MAX_LENGTH = <NUM_LIT> <EOL> def dataReceived ( self , data ) : <EOL> """<STR_LIT>""" <EOL> lines = ( self . _buffer + data ) . split ( self . delimiter ) <EOL> self . _buffer = lines . pop ( - <NUM_LIT:1> ) <EOL> for line in lines : <EOL> if self . transport . disconnecting : <EOL> return <EOL> if len ( line ) > self . MAX_LENGTH : <EOL> return self . lineLengthExceeded ( line ) <EOL> else : <EOL> self . lineReceived ( line ) <EOL> if len ( self . _buffer ) > self . MAX_LENGTH : <EOL> return self . lineLengthExceeded ( self . _buffer ) <EOL> def lineReceived ( self , line ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError <EOL> def sendLine ( self , line ) : <EOL> """<STR_LIT>""" <EOL> return self . transport . writeSequence ( ( line , self . delimiter ) ) <EOL> def lineLengthExceeded ( self , line ) : <EOL> """<STR_LIT>""" <EOL> return error . ConnectionLost ( '<STR_LIT>' ) <EOL> class _PauseableMixin : <EOL> paused = False <EOL> def pauseProducing ( self ) : <EOL> self . paused = True <EOL> self . transport . pauseProducing ( ) <EOL> def resumeProducing ( self ) : <EOL> self . paused = False <EOL> self . transport . resumeProducing ( ) <EOL> self . dataReceived ( '<STR_LIT>' ) <EOL> def stopProducing ( self ) : <EOL> self . paused = True <EOL> self . transport . stopProducing ( ) <EOL> class LineReceiver ( protocol . Protocol , _PauseableMixin ) : <EOL> """<STR_LIT>""" <EOL> line_mode = <NUM_LIT:1> <EOL> __buffer = '<STR_LIT>' <EOL> delimiter = '<STR_LIT:\r\n>' <EOL> MAX_LENGTH = <NUM_LIT> <EOL> def clearLineBuffer ( self ) : <EOL> """<STR_LIT>""" <EOL> b = self . __buffer <EOL> self . __buffer = "<STR_LIT>" <EOL> return b <EOL> def dataReceived ( self , data ) : <EOL> """<STR_LIT>""" <EOL> self . __buffer = self . __buffer + data <EOL> while self . line_mode and not self . paused : <EOL> try : <EOL> line , self . __buffer = self . __buffer . split ( self . delimiter , <NUM_LIT:1> ) <EOL> except ValueError : <EOL> if len ( self . __buffer ) > self . MAX_LENGTH : <EOL> line , self . __buffer = self . __buffer , '<STR_LIT>' <EOL> return self . lineLengthExceeded ( line ) <EOL> break <EOL> else : <EOL> linelength = len ( line ) <EOL> if linelength > self . MAX_LENGTH : <EOL> exceeded = line + self . __buffer <EOL> self . __buffer = '<STR_LIT>' <EOL> return self . lineLengthExceeded ( exceeded ) <EOL> why = self . lineReceived ( line ) <EOL> if why or self . transport and self . transport . disconnecting : <EOL> return why <EOL> else : <EOL> if not self . paused : <EOL> data = self . __buffer <EOL> self . __buffer = '<STR_LIT>' <EOL> if data : <EOL> return self . rawDataReceived ( data ) <EOL> def setLineMode ( self , extra = '<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> self . line_mode = <NUM_LIT:1> <EOL> if extra : <EOL> return self . dataReceived ( extra ) <EOL> def setRawMode ( self ) : <EOL> """<STR_LIT>""" <EOL> self . line_mode = <NUM_LIT:0> <EOL> def rawDataReceived ( self , data ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError <EOL> def lineReceived ( self , line ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError <EOL> def sendLine ( self , line ) : <EOL> """<STR_LIT>""" <EOL> return self . transport . write ( line + self . delimiter ) <EOL> def lineLengthExceeded ( self , line ) : <EOL> """<STR_LIT>""" <EOL> return self . transport . loseConnection ( ) <EOL> class StringTooLongError ( AssertionError ) : <EOL> """<STR_LIT>""" <EOL> class IntNStringReceiver ( protocol . Protocol , _PauseableMixin ) : <EOL> """<STR_LIT>""" <EOL> MAX_LENGTH = <NUM_LIT> <EOL> recvd = "<STR_LIT>" <EOL> def stringReceived ( self , string ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError <EOL> def lengthLimitExceeded ( self , length ) : <EOL> """<STR_LIT>""" <EOL> self . transport . loseConnection ( ) <EOL> def dataReceived ( self , recd ) : <EOL> """<STR_LIT>""" <EOL> self . recvd = self . recvd + recd <EOL> while len ( self . recvd ) >= self . prefixLength and not self . paused : <EOL> length , = struct . unpack ( <EOL> self . structFormat , self . recvd [ : self . prefixLength ] ) <EOL> if length > self . MAX_LENGTH : <EOL> self . lengthLimitExceeded ( length ) <EOL> return <EOL> if len ( self . recvd ) < length + self . prefixLength : <EOL> break <EOL> packet = self . recvd [ self . prefixLength : length + self . prefixLength ] <EOL> self . recvd = self . recvd [ length + self . prefixLength : ] <EOL> self . stringReceived ( packet ) <EOL> def sendString ( self , string ) : <EOL> """<STR_LIT>""" <EOL> if len ( string ) >= <NUM_LIT:2> ** ( <NUM_LIT:8> * self . prefixLength ) : <EOL> raise StringTooLongError ( <EOL> "<STR_LIT>" % ( <EOL> len ( string ) , <NUM_LIT:2> ** ( <NUM_LIT:8> * self . prefixLength ) ) ) <EOL> self . transport . write (

struct . pack ( self . structFormat , len ( string ) ) + string )

"""<STR_LIT>""" <EOL> import re <EOL> import struct <EOL> import warnings <EOL> import cStringIO <EOL> import math <EOL> from zope . interface import implements <EOL> from twisted . internet import protocol , defer , interfaces , error <EOL> from twisted . python import log , deprecate , versions <EOL> LENGTH , DATA , COMMA = range ( <NUM_LIT:3> ) <EOL> NUMBER = re . compile ( '<STR_LIT>' ) <EOL> deprecatedSince = versions . Version ( "<STR_LIT>" , <NUM_LIT:10> , <NUM_LIT:2> , <NUM_LIT:0> ) <EOL> message = "<STR_LIT>" <EOL> for attr in [ "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ] : <EOL> deprecate . deprecatedModuleAttribute ( <EOL> deprecatedSince , message , __name__ , attr ) <EOL> del deprecatedSince , message , attr <EOL> DEBUG = <NUM_LIT:0> <EOL> class NetstringParseError ( ValueError ) : <EOL> """<STR_LIT>""" <EOL> class IncompleteNetstring ( Exception ) : <EOL> """<STR_LIT>""" <EOL> class NetstringReceiver ( protocol . Protocol ) : <EOL> """<STR_LIT>""" <EOL> MAX_LENGTH = <NUM_LIT> <EOL> _LENGTH = re . compile ( '<STR_LIT>' ) <EOL> _LENGTH_PREFIX = re . compile ( '<STR_LIT>' ) <EOL> _MISSING_LENGTH = ( "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> _OVERFLOW = ( "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> _TOO_LONG = ( "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> _MISSING_COMMA = "<STR_LIT>" <EOL> _DATA_SUPPORT_DEPRECATED = ( "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> _PARSING_LENGTH , _PARSING_PAYLOAD = range ( <NUM_LIT:2> ) <EOL> def makeConnection ( self , transport ) : <EOL> """<STR_LIT>""" <EOL> protocol . Protocol . makeConnection ( self , transport ) <EOL> self . _remainingData = "<STR_LIT>" <EOL> self . _currentPayloadSize = <NUM_LIT:0> <EOL> self . _payload = cStringIO . StringIO ( ) <EOL> self . _state = self . _PARSING_LENGTH <EOL> self . _expectedPayloadSize = <NUM_LIT:0> <EOL> self . brokenPeer = <NUM_LIT:0> <EOL> def sendString ( self , string ) : <EOL> """<STR_LIT>""" <EOL> if not isinstance ( string , str ) : <EOL> warnings . warn ( self . _DATA_SUPPORT_DEPRECATED , DeprecationWarning , <NUM_LIT:2> ) <EOL> string = str ( string ) <EOL> self . transport . write ( '<STR_LIT>' % ( len ( string ) , string ) ) <EOL> def dataReceived ( self , data ) : <EOL> """<STR_LIT>""" <EOL> self . _remainingData += data <EOL> while self . _remainingData : <EOL> try : <EOL> self . _consumeData ( ) <EOL> except IncompleteNetstring : <EOL> break <EOL> except NetstringParseError : <EOL> self . _handleParseError ( ) <EOL> break <EOL> def stringReceived ( self , string ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError ( ) <EOL> def _maxLengthSize ( self ) : <EOL> """<STR_LIT>""" <EOL> return math . ceil ( math . log10 ( self . MAX_LENGTH ) ) + <NUM_LIT:1> <EOL> def _consumeData ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _state == self . _PARSING_LENGTH : <EOL> self . _consumeLength ( ) <EOL> self . _prepareForPayloadConsumption ( ) <EOL> if self . _state == self . _PARSING_PAYLOAD : <EOL> self . _consumePayload ( ) <EOL> def _consumeLength ( self ) : <EOL> """<STR_LIT>""" <EOL> lengthMatch = self . _LENGTH . match ( self . _remainingData ) <EOL> if not lengthMatch : <EOL> self . _checkPartialLengthSpecification ( ) <EOL> raise IncompleteNetstring ( ) <EOL> self . _processLength ( lengthMatch ) <EOL> def _checkPartialLengthSpecification ( self ) : <EOL> """<STR_LIT>""" <EOL> partialLengthMatch = self . _LENGTH_PREFIX . match ( self . _remainingData ) <EOL> if not partialLengthMatch : <EOL> raise NetstringParseError ( self . _MISSING_LENGTH ) <EOL> lengthSpecification = ( partialLengthMatch . group ( <NUM_LIT:1> ) ) <EOL> self . _extractLength ( lengthSpecification ) <EOL> def _processLength ( self , lengthMatch ) : <EOL> """<STR_LIT>""" <EOL> endOfNumber = lengthMatch . end ( <NUM_LIT:1> ) <EOL> startOfData = lengthMatch . end ( <NUM_LIT:2> ) <EOL> lengthString = self . _remainingData [ : endOfNumber ] <EOL> self . _expectedPayloadSize = self . _extractLength ( lengthString ) + <NUM_LIT:1> <EOL> self . _remainingData = self . _remainingData [ startOfData : ] <EOL> def _extractLength ( self , lengthAsString ) : <EOL> """<STR_LIT>""" <EOL> self . _checkStringSize ( lengthAsString ) <EOL> length = int ( lengthAsString ) <EOL> if length > self . MAX_LENGTH : <EOL> raise NetstringParseError ( self . _TOO_LONG % ( self . MAX_LENGTH , ) ) <EOL> return length <EOL> def _checkStringSize ( self , lengthAsString ) : <EOL> """<STR_LIT>""" <EOL> if len ( lengthAsString ) > self . _maxLengthSize ( ) : <EOL> raise NetstringParseError ( self . _TOO_LONG % ( self . MAX_LENGTH , ) ) <EOL> def _prepareForPayloadConsumption ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _state = self . _PARSING_PAYLOAD <EOL> self . _currentPayloadSize = <NUM_LIT:0> <EOL> self . _payload . seek ( <NUM_LIT:0> ) <EOL> self . _payload . truncate ( ) <EOL> def _consumePayload ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _extractPayload ( ) <EOL> if self . _currentPayloadSize < self . _expectedPayloadSize : <EOL> raise IncompleteNetstring ( ) <EOL> self . _checkForTrailingComma ( ) <EOL> self . _state = self . _PARSING_LENGTH <EOL> self . _processPayload ( ) <EOL> def _extractPayload ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _payloadComplete ( ) : <EOL> remainingPayloadSize = ( self . _expectedPayloadSize - <EOL> self . _currentPayloadSize ) <EOL> self . _payload . write ( self . _remainingData [ : remainingPayloadSize ] ) <EOL> self . _remainingData = self . _remainingData [ remainingPayloadSize : ] <EOL> self . _currentPayloadSize = self . _expectedPayloadSize <EOL> else : <EOL> self . _payload . write ( self . _remainingData ) <EOL> self . _currentPayloadSize += len ( self . _remainingData ) <EOL> self . _remainingData = "<STR_LIT>" <EOL> def _payloadComplete ( self ) : <EOL> """<STR_LIT>""" <EOL> return ( len ( self . _remainingData ) + self . _currentPayloadSize >= <EOL> self . _expectedPayloadSize ) <EOL> def _processPayload ( self ) : <EOL> """<STR_LIT>""" <EOL> self . stringReceived ( self . _payload . getvalue ( ) [ : - <NUM_LIT:1> ] ) <EOL> def _checkForTrailingComma ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _payload . getvalue ( ) [ - <NUM_LIT:1> ] != "<STR_LIT:U+002C>" : <EOL> raise NetstringParseError ( self . _MISSING_COMMA ) <EOL> def _handleParseError ( self ) : <EOL> """<STR_LIT>""" <EOL> self . transport . loseConnection ( ) <EOL> self . brokenPeer = <NUM_LIT:1> <EOL> class LineOnlyReceiver ( protocol . Protocol ) : <EOL> """<STR_LIT>""" <EOL> _buffer = '<STR_LIT>' <EOL> delimiter = '<STR_LIT:\r\n>' <EOL> MAX_LENGTH = <NUM_LIT> <EOL> def dataReceived ( self , data ) : <EOL> """<STR_LIT>""" <EOL> lines = ( self . _buffer + data ) . split ( self . delimiter ) <EOL> self . _buffer = lines . pop ( - <NUM_LIT:1> ) <EOL> for line in lines : <EOL> if self . transport . disconnecting : <EOL> return <EOL> if len ( line ) > self . MAX_LENGTH : <EOL> return self . lineLengthExceeded ( line ) <EOL> else : <EOL> self . lineReceived ( line ) <EOL> if len ( self . _buffer ) > self . MAX_LENGTH : <EOL> return self . lineLengthExceeded ( self . _buffer ) <EOL> def lineReceived ( self , line ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError <EOL> def sendLine ( self , line ) : <EOL> """<STR_LIT>""" <EOL> return self . transport . writeSequence ( ( line , self . delimiter ) ) <EOL> def lineLengthExceeded ( self , line ) : <EOL> """<STR_LIT>""" <EOL> return error . ConnectionLost ( '<STR_LIT>' ) <EOL> class _PauseableMixin : <EOL> paused = False <EOL> def pauseProducing ( self ) : <EOL> self . paused = True <EOL> self . transport . pauseProducing ( ) <EOL> def resumeProducing ( self ) : <EOL> self . paused = False <EOL> self . transport . resumeProducing ( ) <EOL> self . dataReceived ( '<STR_LIT>' ) <EOL> def stopProducing ( self ) : <EOL> self . paused = True <EOL> self . transport . stopProducing ( ) <EOL> class LineReceiver ( protocol . Protocol , _PauseableMixin ) : <EOL> """<STR_LIT>""" <EOL> line_mode = <NUM_LIT:1> <EOL> __buffer = '<STR_LIT>' <EOL> delimiter = '<STR_LIT:\r\n>' <EOL> MAX_LENGTH = <NUM_LIT> <EOL> def clearLineBuffer ( self ) : <EOL> """<STR_LIT>""" <EOL> b = self . __buffer <EOL> self . __buffer = "<STR_LIT>" <EOL> return b <EOL> def dataReceived ( self , data ) : <EOL> """<STR_LIT>""" <EOL> self . __buffer = self . __buffer + data <EOL> while self . line_mode and not self . paused : <EOL> try : <EOL> line , self . __buffer = self . __buffer . split ( self . delimiter , <NUM_LIT:1> ) <EOL> except ValueError : <EOL> if len ( self . __buffer ) > self . MAX_LENGTH : <EOL> line , self . __buffer = self . __buffer , '<STR_LIT>' <EOL> return self . lineLengthExceeded ( line ) <EOL> break <EOL> else : <EOL> linelength = len ( line ) <EOL> if linelength > self . MAX_LENGTH : <EOL> exceeded = line + self . __buffer <EOL> self . __buffer = '<STR_LIT>' <EOL> return self . lineLengthExceeded ( exceeded ) <EOL> why = self . lineReceived ( line ) <EOL> if why or self . transport and self . transport . disconnecting : <EOL> return why <EOL> else : <EOL> if not self . paused : <EOL> data = self . __buffer <EOL> self . __buffer = '<STR_LIT>' <EOL> if data : <EOL> return self . rawDataReceived ( data ) <EOL> def setLineMode ( self , extra = '<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> self . line_mode = <NUM_LIT:1> <EOL> if extra : <EOL> return self . dataReceived ( extra ) <EOL> def setRawMode ( self ) : <EOL> """<STR_LIT>""" <EOL> self . line_mode = <NUM_LIT:0> <EOL> def rawDataReceived ( self , data ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError <EOL> def lineReceived ( self , line ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError <EOL> def sendLine ( self , line ) : <EOL> """<STR_LIT>""" <EOL> return self . transport . write ( line + self . delimiter ) <EOL> def lineLengthExceeded ( self , line ) : <EOL> """<STR_LIT>""" <EOL> return self . transport . loseConnection ( ) <EOL> class StringTooLongError ( AssertionError ) : <EOL> """<STR_LIT>""" <EOL> class IntNStringReceiver ( protocol . Protocol , _PauseableMixin ) : <EOL> """<STR_LIT>""" <EOL> MAX_LENGTH = <NUM_LIT> <EOL> recvd = "<STR_LIT>" <EOL> def stringReceived ( self , string ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError <EOL> def lengthLimitExceeded ( self , length ) : <EOL> """<STR_LIT>""" <EOL> self . transport . loseConnection ( ) <EOL> def dataReceived ( self , recd ) : <EOL> """<STR_LIT>""" <EOL> self . recvd = self . recvd + recd <EOL> while len ( self . recvd ) >= self . prefixLength and not self . paused : <EOL> length , = struct . unpack ( <EOL> self . structFormat , self . recvd [ : self . prefixLength ] ) <EOL> if length > self . MAX_LENGTH : <EOL> self . lengthLimitExceeded ( length ) <EOL> return <EOL> if len ( self . recvd ) < length + self . prefixLength : <EOL> break <EOL> packet = self . recvd [ self . prefixLength : length + self . prefixLength ] <EOL> self . recvd = self . recvd [ length + self . prefixLength : ] <EOL> self . stringReceived ( packet ) <EOL> def sendString ( self , string ) : <EOL> """<STR_LIT>""" <EOL> if len ( string ) >= <NUM_LIT:2> ** ( <NUM_LIT:8> * self . prefixLength ) : <EOL> raise StringTooLongError ( <EOL> "<STR_LIT>" % ( <EOL> len ( string ) , <NUM_LIT:2> ** ( <NUM_LIT:8> * self . prefixLength ) ) ) <EOL> self . transport . write ( <EOL> struct . pack ( self . structFormat , len ( string ) ) + string ) <EOL> class Int32StringReceiver ( IntNStringReceiver ) : <EOL> """<STR_LIT>""" <EOL> structFormat = "<STR_LIT>" <EOL> prefixLength = struct . calcsize ( structFormat ) <EOL> class Int16StringReceiver ( IntNStringReceiver ) : <EOL> """<STR_LIT>""" <EOL> structFormat = "<STR_LIT>" <EOL> prefixLength = struct . calcsize ( structFormat ) <EOL> class Int8StringReceiver ( IntNStringReceiver ) : <EOL> """<STR_LIT>""" <EOL> structFormat = "<STR_LIT>" <EOL> prefixLength = struct . calcsize ( structFormat ) <EOL> class StatefulStringProtocol : <EOL> """<STR_LIT>""" <EOL> state = '<STR_LIT>' <EOL> def stringReceived ( self , string ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> pto = '<STR_LIT>' + self . state <EOL> statehandler = getattr ( self , pto ) <EOL> except AttributeError : <EOL> log . msg ( '<STR_LIT>' , self . state , '<STR_LIT>' ) <EOL> else : <EOL> self . state = statehandler ( string ) <EOL> if self . state == '<STR_LIT>' : <EOL> self . transport . loseConnection ( ) <EOL> class FileSender : <EOL> """<STR_LIT>""" <EOL> implements ( interfaces . IProducer ) <EOL> CHUNK_SIZE = <NUM_LIT:2> ** <NUM_LIT> <EOL> lastSent = '<STR_LIT>' <EOL> deferred = None <EOL> def beginFileTransfer ( self , file , consumer , transform = None ) : <EOL> """<STR_LIT>""" <EOL> self . file = file <EOL> self . consumer = consumer <EOL> self . transform = transform <EOL> self . deferred = deferred = defer . Deferred ( ) <EOL> self . consumer . registerProducer ( self , False ) <EOL> return deferred <EOL> def resumeProducing ( self ) : <EOL> chunk = '<STR_LIT>' <EOL> if self . file : <EOL> chunk = self . file . read ( self . CHUNK_SIZE ) <EOL> if not chunk : <EOL> self . file = None <EOL> self . consumer . unregisterProducer ( ) <EOL> if self . deferred : <EOL> self . deferred . callback ( self . lastSent ) <EOL> self . deferred = None <EOL> return <EOL> if self . transform : <EOL> chunk = self . transform ( chunk ) <EOL> self . consumer . write ( chunk ) <EOL> self . lastSent = chunk [ - <NUM_LIT:1> ] <EOL> def pauseProducing ( self ) : <EOL> pass <EOL> def stopProducing ( self ) : <EOL> if self . deferred : <EOL> self . deferred . errback ( <EOL> Exception ( "<STR_LIT>" ) ) <EOL> self . deferred = None </s>

"""<STR_LIT>""" <EOL> import ctypes <EOL> import ctypes . util <EOL> class INotifyError ( Exception ) : <EOL> """<STR_LIT>""" <EOL> def init ( ) : <EOL> """<STR_LIT>""" <EOL> fd = libc . inotify_init ( ) <EOL> if fd < <NUM_LIT:0> :

raise INotifyError ( "<STR_LIT>" )

"""<STR_LIT>""" <EOL> import ctypes <EOL> import ctypes . util <EOL> class INotifyError ( Exception ) : <EOL> """<STR_LIT>""" <EOL> def init ( ) : <EOL> """<STR_LIT>""" <EOL> fd = libc . inotify_init ( ) <EOL> if fd < <NUM_LIT:0> : <EOL> raise INotifyError ( "<STR_LIT>" ) <EOL> return fd <EOL> def add ( fd , path , mask ) : <EOL> """<STR_LIT>""" <EOL> wd = libc . inotify_add_watch ( fd , path , mask ) <EOL> if wd < <NUM_LIT:0> : <EOL> raise INotifyError ( "<STR_LIT>" % ( path , wd ) ) <EOL> return wd <EOL> def remove ( fd , wd ) : <EOL> """<STR_LIT>""" <EOL> libc . inotify_rm_watch ( fd , wd ) <EOL> def initializeModule ( libc ) : <EOL> """<STR_LIT>""" <EOL> for function in ( "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ) : <EOL> if getattr ( libc , function , None ) is None : <EOL> raise ImportError ( "<STR_LIT>" ) <EOL> libc . inotify_add_watch . argtypes = [ <EOL> ctypes . c_int , ctypes . c_char_p , ctypes . c_int ] <EOL> name = ctypes . util . find_library ( '<STR_LIT:c>' ) <EOL> if not name : <EOL> raise ImportError ( "<STR_LIT>" ) <EOL> libc = ctypes . cdll . LoadLibrary ( name ) <EOL> initializeModule ( libc ) </s>

"""<STR_LIT>""" <EOL> import os <EOL> import re <EOL> class DirectoryExists ( OSError ) : <EOL> """<STR_LIT>""" <EOL> pass <EOL> class DirectoryDoesntExist ( OSError ) : <EOL> """<STR_LIT>""" <EOL> pass <EOL> class CommandFailed ( OSError ) : <EOL> pass <EOL> def sh ( command , null = True , prompt = False ) : <EOL> """<STR_LIT>""" <EOL> print "<STR_LIT>" , command <EOL> if prompt : <EOL> if raw_input ( "<STR_LIT>" ) . startswith ( '<STR_LIT:n>' ) : <EOL> return <EOL> if null : <EOL> command = "<STR_LIT>" % command <EOL> if os . system ( command ) != <NUM_LIT:0> : <EOL> raise CommandFailed ( command ) <EOL> def runChdirSafe ( f , * args , ** kw ) : <EOL> origdir = os . path . abspath ( '<STR_LIT:.>' )

try :

"""<STR_LIT>""" <EOL> import os <EOL> import re <EOL> class DirectoryExists ( OSError ) : <EOL> """<STR_LIT>""" <EOL> pass <EOL> class DirectoryDoesntExist ( OSError ) : <EOL> """<STR_LIT>""" <EOL> pass <EOL> class CommandFailed ( OSError ) : <EOL> pass <EOL> def sh ( command , null = True , prompt = False ) : <EOL> """<STR_LIT>""" <EOL> print "<STR_LIT>" , command <EOL> if prompt : <EOL> if raw_input ( "<STR_LIT>" ) . startswith ( '<STR_LIT:n>' ) : <EOL> return <EOL> if null : <EOL> command = "<STR_LIT>" % command <EOL> if os . system ( command ) != <NUM_LIT:0> : <EOL> raise CommandFailed ( command ) <EOL> def runChdirSafe ( f , * args , ** kw ) : <EOL> origdir = os . path . abspath ( '<STR_LIT:.>' ) <EOL> try : <EOL> return f ( * args , ** kw ) <EOL> finally : <EOL> os . chdir ( origdir ) </s>

"""<STR_LIT>""" <EOL> import re <EOL> import exceptions <EOL> import os <EOL> try : <EOL> import win32api <EOL> import win32con <EOL> except ImportError : <EOL> pass <EOL> from twisted . python . runtime import platform <EOL> ERROR_FILE_NOT_FOUND = <NUM_LIT:2> <EOL> ERROR_PATH_NOT_FOUND = <NUM_LIT:3> <EOL> ERROR_INVALID_NAME = <NUM_LIT> <EOL> ERROR_DIRECTORY = <NUM_LIT> <EOL> O_BINARY = getattr ( os , "<STR_LIT>" , <NUM_LIT:0> ) <EOL> def _determineWindowsError ( ) : <EOL> """<STR_LIT>""" <EOL> return getattr ( exceptions , '<STR_LIT>' , FakeWindowsError ) <EOL> class FakeWindowsError ( OSError ) : <EOL> """<STR_LIT>""" <EOL> WindowsError = _determineWindowsError ( ) <EOL> def getProgramsMenuPath ( ) : <EOL> """<STR_LIT>""" <EOL> if not platform . isWinNT ( ) : <EOL> return "<STR_LIT>" <EOL> keyname = '<STR_LIT>' <EOL> hShellFolders = win32api . RegOpenKeyEx ( win32con . HKEY_LOCAL_MACHINE , <EOL> keyname , <NUM_LIT:0> , win32con . KEY_READ ) <EOL> return win32api . RegQueryValueEx ( hShellFolders , '<STR_LIT>' ) [ <NUM_LIT:0> ] <EOL> def getProgramFilesPath ( ) : <EOL> """<STR_LIT>""" <EOL> keyname = '<STR_LIT>' <EOL> currentV = win32api . RegOpenKeyEx ( win32con . HKEY_LOCAL_MACHINE , <EOL> keyname , <NUM_LIT:0> , win32con . KEY_READ ) <EOL> return win32api . RegQueryValueEx ( currentV , '<STR_LIT>' ) [ <NUM_LIT:0> ] <EOL> _cmdLineQuoteRe = re . compile ( r'<STR_LIT>' ) <EOL> _cmdLineQuoteRe2 = re . compile ( r'<STR_LIT>' ) <EOL> def cmdLineQuote ( s ) : <EOL> """<STR_LIT>""" <EOL> quote = ( ( "<STR_LIT:U+0020>" in s ) or ( "<STR_LIT:\t>" in s ) or ( '<STR_LIT:">' in s ) or s == '<STR_LIT>' ) and '<STR_LIT:">' or '<STR_LIT>' <EOL> return quote + _cmdLineQuoteRe2 . sub ( r"<STR_LIT>" , _cmdLineQuoteRe . sub ( r'<STR_LIT>' , s ) ) + quote <EOL> def quoteArguments ( arguments ) : <EOL> """<STR_LIT>""" <EOL> return '<STR_LIT:U+0020>' . join ( [ cmdLineQuote ( a ) for a in arguments ] ) <EOL> class _ErrorFormatter ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , WinError , FormatMessage , errorTab ) : <EOL> self . winError = WinError <EOL> self . formatMessage = FormatMessage <EOL> self . errorTab = errorTab <EOL> def fromEnvironment ( cls ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> from ctypes import WinError <EOL> except ImportError : <EOL> WinError = None <EOL> try : <EOL> from win32api import FormatMessage <EOL> except ImportError : <EOL> FormatMessage = None <EOL> try : <EOL> from socket import errorTab <EOL> except ImportError : <EOL> errorTab = None <EOL> return cls ( WinError , FormatMessage , errorTab ) <EOL> fromEnvironment = classmethod ( fromEnvironment )

def formatError ( self , errorcode ) :

"""<STR_LIT>""" <EOL> import re <EOL> import exceptions <EOL> import os <EOL> try : <EOL> import win32api <EOL> import win32con <EOL> except ImportError : <EOL> pass <EOL> from twisted . python . runtime import platform <EOL> ERROR_FILE_NOT_FOUND = <NUM_LIT:2> <EOL> ERROR_PATH_NOT_FOUND = <NUM_LIT:3> <EOL> ERROR_INVALID_NAME = <NUM_LIT> <EOL> ERROR_DIRECTORY = <NUM_LIT> <EOL> O_BINARY = getattr ( os , "<STR_LIT>" , <NUM_LIT:0> ) <EOL> def _determineWindowsError ( ) : <EOL> """<STR_LIT>""" <EOL> return getattr ( exceptions , '<STR_LIT>' , FakeWindowsError ) <EOL> class FakeWindowsError ( OSError ) : <EOL> """<STR_LIT>""" <EOL> WindowsError = _determineWindowsError ( ) <EOL> def getProgramsMenuPath ( ) : <EOL> """<STR_LIT>""" <EOL> if not platform . isWinNT ( ) : <EOL> return "<STR_LIT>" <EOL> keyname = '<STR_LIT>' <EOL> hShellFolders = win32api . RegOpenKeyEx ( win32con . HKEY_LOCAL_MACHINE , <EOL> keyname , <NUM_LIT:0> , win32con . KEY_READ ) <EOL> return win32api . RegQueryValueEx ( hShellFolders , '<STR_LIT>' ) [ <NUM_LIT:0> ] <EOL> def getProgramFilesPath ( ) : <EOL> """<STR_LIT>""" <EOL> keyname = '<STR_LIT>' <EOL> currentV = win32api . RegOpenKeyEx ( win32con . HKEY_LOCAL_MACHINE , <EOL> keyname , <NUM_LIT:0> , win32con . KEY_READ ) <EOL> return win32api . RegQueryValueEx ( currentV , '<STR_LIT>' ) [ <NUM_LIT:0> ] <EOL> _cmdLineQuoteRe = re . compile ( r'<STR_LIT>' ) <EOL> _cmdLineQuoteRe2 = re . compile ( r'<STR_LIT>' ) <EOL> def cmdLineQuote ( s ) : <EOL> """<STR_LIT>""" <EOL> quote = ( ( "<STR_LIT:U+0020>" in s ) or ( "<STR_LIT:\t>" in s ) or ( '<STR_LIT:">' in s ) or s == '<STR_LIT>' ) and '<STR_LIT:">' or '<STR_LIT>' <EOL> return quote + _cmdLineQuoteRe2 . sub ( r"<STR_LIT>" , _cmdLineQuoteRe . sub ( r'<STR_LIT>' , s ) ) + quote <EOL> def quoteArguments ( arguments ) : <EOL> """<STR_LIT>""" <EOL> return '<STR_LIT:U+0020>' . join ( [ cmdLineQuote ( a ) for a in arguments ] ) <EOL> class _ErrorFormatter ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , WinError , FormatMessage , errorTab ) : <EOL> self . winError = WinError <EOL> self . formatMessage = FormatMessage <EOL> self . errorTab = errorTab <EOL> def fromEnvironment ( cls ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> from ctypes import WinError <EOL> except ImportError : <EOL> WinError = None <EOL> try : <EOL> from win32api import FormatMessage <EOL> except ImportError : <EOL> FormatMessage = None <EOL> try : <EOL> from socket import errorTab <EOL> except ImportError : <EOL> errorTab = None <EOL> return cls ( WinError , FormatMessage , errorTab ) <EOL> fromEnvironment = classmethod ( fromEnvironment ) <EOL> def formatError ( self , errorcode ) : <EOL> """<STR_LIT>""" <EOL> if self . winError is not None : <EOL> return self . winError ( errorcode ) [ <NUM_LIT:1> ] <EOL> if self . formatMessage is not None : <EOL> return self . formatMessage ( errorcode ) <EOL> if self . errorTab is not None : <EOL> result = self . errorTab . get ( errorcode ) <EOL> if result is not None : <EOL> return result <EOL> return os . strerror ( errorcode ) <EOL> formatError = _ErrorFormatter . fromEnvironment ( ) . formatError </s>

"""<STR_LIT>""" <EOL> from __future__ import generators <EOL> import sys <EOL> import zipfile <EOL> import py_compile <EOL> from twisted . python . procutils import which <EOL> tkdll = '<STR_LIT>' <EOL> if which ( tkdll ) or which ( '<STR_LIT>' % tkdll ) : <EOL> try : <EOL> import Tkinter <EOL> from Tkinter import * <EOL> from twisted . internet import tksupport <EOL> except ImportError : <EOL> pass <EOL> from twisted . internet import reactor , defer <EOL> from twisted . python import failure , log , zipstream , util , usage , log <EOL> import os . path <EOL> class ProgressBar : <EOL> def __init__ ( self , master = None , orientation = "<STR_LIT>" , <EOL> min = <NUM_LIT:0> , max = <NUM_LIT:100> , width = <NUM_LIT:100> , height = <NUM_LIT> , <EOL> doLabel = <NUM_LIT:1> , appearance = "<STR_LIT>" , <EOL> fillColor = "<STR_LIT>" , background = "<STR_LIT>" , <EOL> labelColor = "<STR_LIT>" , labelFont = "<STR_LIT>" , <EOL> labelText = "<STR_LIT>" , labelFormat = "<STR_LIT>" , <EOL> value = <NUM_LIT:0> , bd = <NUM_LIT:2> ) : <EOL> self . master = master <EOL> self . orientation = orientation <EOL> self . min = min <EOL> self . max = max <EOL> self . width = width <EOL> self . height = height <EOL> self . doLabel = doLabel <EOL> self . fillColor = fillColor <EOL> self . labelFont = labelFont <EOL> self . labelColor = labelColor <EOL> self . background = background <EOL> self . labelText = labelText <EOL> self . labelFormat = labelFormat <EOL> self . value = value <EOL> self . frame = Frame ( master , relief = appearance , bd = bd ) <EOL> self . canvas = Canvas ( self . frame , height = height , width = width , bd = <NUM_LIT:0> , <EOL> highlightthickness = <NUM_LIT:0> , background = background ) <EOL> self . scale = self . canvas . create_rectangle ( <NUM_LIT:0> , <NUM_LIT:0> , width , height , <EOL> fill = fillColor ) <EOL> self . label = self . canvas . create_text ( self . canvas . winfo_reqwidth ( ) / <NUM_LIT:2> , <EOL> height / <NUM_LIT:2> , text = labelText , <EOL> anchor = "<STR_LIT:c>" , fill = labelColor , <EOL> font = self . labelFont ) <EOL> self . update ( ) <EOL> self . canvas . pack ( side = '<STR_LIT>' , fill = '<STR_LIT:x>' , expand = '<STR_LIT>' ) <EOL> def pack ( self , * args , ** kwargs ) : <EOL> self . frame . pack ( * args , ** kwargs ) <EOL> def updateProgress ( self , newValue , newMax = None ) : <EOL> if newMax : <EOL> self . max = newMax <EOL> self . value = newValue <EOL> self . update ( ) <EOL> def update ( self ) : <EOL> value = self . value <EOL> if value > self . max : <EOL> value = self . max <EOL> if value < self . min : <EOL> value = self . min <EOL> if self . orientation == "<STR_LIT>" : <EOL> self . canvas . coords ( self . scale , <NUM_LIT:0> , <NUM_LIT:0> , <EOL> float ( value ) / self . max * self . width , self . height ) <EOL> else : <EOL> self . canvas . coords ( self . scale , <NUM_LIT:0> , <EOL> self . height - ( float ( value ) / <EOL> self . max * self . height ) , <EOL> self . width , self . height ) <EOL> self . canvas . itemconfig ( self . scale , fill = self . fillColor ) <EOL> self . canvas . itemconfig ( self . label , fill = self . labelColor ) <EOL> if self . doLabel : <EOL> if value : <EOL> if value >= <NUM_LIT:0> : <EOL> pvalue = int ( ( float ( value ) / float ( self . max ) ) * <EOL> <NUM_LIT> ) <EOL> else : <EOL> pvalue = <NUM_LIT:0> <EOL> self . canvas . itemconfig ( self . label , text = self . labelFormat <EOL> % pvalue ) <EOL> else : <EOL> self . canvas . itemconfig ( self . label , text = '<STR_LIT>' ) <EOL> else : <EOL> self . canvas . itemconfig ( self . label , text = self . labelFormat % <EOL> self . labelText ) <EOL> self . canvas . update_idletasks ( ) <EOL> class Progressor : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , title , * args , ** kwargs ) : <EOL> self . title = title <EOL> self . stopping = <NUM_LIT:0> <EOL> self . bar = None <EOL> self . iterator = None <EOL> self . remaining = <NUM_LIT:1000> <EOL> def setBar ( self , bar , max ) : <EOL> self . bar = bar <EOL> bar . updateProgress ( <NUM_LIT:0> , max ) <EOL> return self <EOL> def setIterator ( self , iterator ) : <EOL> self . iterator = iterator <EOL> return self <EOL> def updateBar ( self , deferred ) : <EOL> b = self . bar <EOL> try : <EOL> b . updateProgress ( b . max - self . remaining ) <EOL> except TclError : <EOL> self . stopping = <NUM_LIT:1> <EOL> except : <EOL> deferred . errback ( failure . Failure ( ) ) <EOL> def processAll ( self , root ) : <EOL> assert self . bar and self . iterator , "<STR_LIT>" <EOL> self . root = root <EOL> root . title ( self . title ) <EOL> d = defer . Deferred ( ) <EOL> d . addErrback ( log . err ) <EOL> reactor . callLater ( <NUM_LIT:0.1> , self . processOne , d ) <EOL> return d <EOL> def processOne ( self , deferred ) : <EOL> if self . stopping : <EOL> deferred . callback ( self . root ) <EOL> return <EOL> try : <EOL> self . remaining = self . iterator . next ( ) <EOL> except StopIteration : <EOL> self . stopping = <NUM_LIT:1> <EOL> except : <EOL> deferred . errback ( failure . Failure ( ) ) <EOL> if self . remaining % <NUM_LIT:10> == <NUM_LIT:0> : <EOL> reactor . callLater ( <NUM_LIT:0> , self . updateBar , deferred ) <EOL> if self . remaining % <NUM_LIT:100> == <NUM_LIT:0> : <EOL> log . msg ( self . remaining ) <EOL> reactor . callLater ( <NUM_LIT:0> , self . processOne , deferred ) <EOL> def compiler ( path ) : <EOL> """<STR_LIT>""" <EOL> def justlist ( arg , directory , names ) : <EOL> pynames = [ os . path . join ( directory , n ) for n in names <EOL> if n . endswith ( '<STR_LIT>' ) ] <EOL> arg . extend ( pynames ) <EOL> all = [ ] <EOL> os . path . walk ( path , justlist , all )

remaining = len ( all )

"""<STR_LIT>""" <EOL> from __future__ import generators <EOL> import sys <EOL> import zipfile <EOL> import py_compile <EOL> from twisted . python . procutils import which <EOL> tkdll = '<STR_LIT>' <EOL> if which ( tkdll ) or which ( '<STR_LIT>' % tkdll ) : <EOL> try : <EOL> import Tkinter <EOL> from Tkinter import * <EOL> from twisted . internet import tksupport <EOL> except ImportError : <EOL> pass <EOL> from twisted . internet import reactor , defer <EOL> from twisted . python import failure , log , zipstream , util , usage , log <EOL> import os . path <EOL> class ProgressBar : <EOL> def __init__ ( self , master = None , orientation = "<STR_LIT>" , <EOL> min = <NUM_LIT:0> , max = <NUM_LIT:100> , width = <NUM_LIT:100> , height = <NUM_LIT> , <EOL> doLabel = <NUM_LIT:1> , appearance = "<STR_LIT>" , <EOL> fillColor = "<STR_LIT>" , background = "<STR_LIT>" , <EOL> labelColor = "<STR_LIT>" , labelFont = "<STR_LIT>" , <EOL> labelText = "<STR_LIT>" , labelFormat = "<STR_LIT>" , <EOL> value = <NUM_LIT:0> , bd = <NUM_LIT:2> ) : <EOL> self . master = master <EOL> self . orientation = orientation <EOL> self . min = min <EOL> self . max = max <EOL> self . width = width <EOL> self . height = height <EOL> self . doLabel = doLabel <EOL> self . fillColor = fillColor <EOL> self . labelFont = labelFont <EOL> self . labelColor = labelColor <EOL> self . background = background <EOL> self . labelText = labelText <EOL> self . labelFormat = labelFormat <EOL> self . value = value <EOL> self . frame = Frame ( master , relief = appearance , bd = bd ) <EOL> self . canvas = Canvas ( self . frame , height = height , width = width , bd = <NUM_LIT:0> , <EOL> highlightthickness = <NUM_LIT:0> , background = background ) <EOL> self . scale = self . canvas . create_rectangle ( <NUM_LIT:0> , <NUM_LIT:0> , width , height , <EOL> fill = fillColor ) <EOL> self . label = self . canvas . create_text ( self . canvas . winfo_reqwidth ( ) / <NUM_LIT:2> , <EOL> height / <NUM_LIT:2> , text = labelText , <EOL> anchor = "<STR_LIT:c>" , fill = labelColor , <EOL> font = self . labelFont ) <EOL> self . update ( ) <EOL> self . canvas . pack ( side = '<STR_LIT>' , fill = '<STR_LIT:x>' , expand = '<STR_LIT>' ) <EOL> def pack ( self , * args , ** kwargs ) : <EOL> self . frame . pack ( * args , ** kwargs ) <EOL> def updateProgress ( self , newValue , newMax = None ) : <EOL> if newMax : <EOL> self . max = newMax <EOL> self . value = newValue <EOL> self . update ( ) <EOL> def update ( self ) : <EOL> value = self . value <EOL> if value > self . max : <EOL> value = self . max <EOL> if value < self . min : <EOL> value = self . min <EOL> if self . orientation == "<STR_LIT>" : <EOL> self . canvas . coords ( self . scale , <NUM_LIT:0> , <NUM_LIT:0> , <EOL> float ( value ) / self . max * self . width , self . height ) <EOL> else : <EOL> self . canvas . coords ( self . scale , <NUM_LIT:0> , <EOL> self . height - ( float ( value ) / <EOL> self . max * self . height ) , <EOL> self . width , self . height ) <EOL> self . canvas . itemconfig ( self . scale , fill = self . fillColor ) <EOL> self . canvas . itemconfig ( self . label , fill = self . labelColor ) <EOL> if self . doLabel : <EOL> if value : <EOL> if value >= <NUM_LIT:0> : <EOL> pvalue = int ( ( float ( value ) / float ( self . max ) ) * <EOL> <NUM_LIT> ) <EOL> else : <EOL> pvalue = <NUM_LIT:0> <EOL> self . canvas . itemconfig ( self . label , text = self . labelFormat <EOL> % pvalue ) <EOL> else : <EOL> self . canvas . itemconfig ( self . label , text = '<STR_LIT>' ) <EOL> else : <EOL> self . canvas . itemconfig ( self . label , text = self . labelFormat % <EOL> self . labelText ) <EOL> self . canvas . update_idletasks ( ) <EOL> class Progressor : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , title , * args , ** kwargs ) : <EOL> self . title = title <EOL> self . stopping = <NUM_LIT:0> <EOL> self . bar = None <EOL> self . iterator = None <EOL> self . remaining = <NUM_LIT:1000> <EOL> def setBar ( self , bar , max ) : <EOL> self . bar = bar <EOL> bar . updateProgress ( <NUM_LIT:0> , max ) <EOL> return self <EOL> def setIterator ( self , iterator ) : <EOL> self . iterator = iterator <EOL> return self <EOL> def updateBar ( self , deferred ) : <EOL> b = self . bar <EOL> try : <EOL> b . updateProgress ( b . max - self . remaining ) <EOL> except TclError : <EOL> self . stopping = <NUM_LIT:1> <EOL> except : <EOL> deferred . errback ( failure . Failure ( ) ) <EOL> def processAll ( self , root ) : <EOL> assert self . bar and self . iterator , "<STR_LIT>" <EOL> self . root = root <EOL> root . title ( self . title ) <EOL> d = defer . Deferred ( ) <EOL> d . addErrback ( log . err ) <EOL> reactor . callLater ( <NUM_LIT:0.1> , self . processOne , d ) <EOL> return d <EOL> def processOne ( self , deferred ) : <EOL> if self . stopping : <EOL> deferred . callback ( self . root ) <EOL> return <EOL> try : <EOL> self . remaining = self . iterator . next ( ) <EOL> except StopIteration : <EOL> self . stopping = <NUM_LIT:1> <EOL> except : <EOL> deferred . errback ( failure . Failure ( ) ) <EOL> if self . remaining % <NUM_LIT:10> == <NUM_LIT:0> : <EOL> reactor . callLater ( <NUM_LIT:0> , self . updateBar , deferred ) <EOL> if self . remaining % <NUM_LIT:100> == <NUM_LIT:0> : <EOL> log . msg ( self . remaining ) <EOL> reactor . callLater ( <NUM_LIT:0> , self . processOne , deferred ) <EOL> def compiler ( path ) : <EOL> """<STR_LIT>""" <EOL> def justlist ( arg , directory , names ) : <EOL> pynames = [ os . path . join ( directory , n ) for n in names <EOL> if n . endswith ( '<STR_LIT>' ) ] <EOL> arg . extend ( pynames ) <EOL> all = [ ] <EOL> os . path . walk ( path , justlist , all ) <EOL> remaining = len ( all ) <EOL> i = zip ( all , range ( remaining - <NUM_LIT:1> , - <NUM_LIT:1> , - <NUM_LIT:1> ) ) <EOL> for f , remaining in i : <EOL> py_compile . compile ( f ) <EOL> yield remaining <EOL> class TkunzipOptions ( usage . Options ) : <EOL> optParameters = [ [ "<STR_LIT>" , "<STR_LIT:z>" , "<STR_LIT>" , "<STR_LIT>" ] , <EOL> [ "<STR_LIT>" , "<STR_LIT:t>" , "<STR_LIT:.>" , "<STR_LIT>" ] , <EOL> [ "<STR_LIT>" , "<STR_LIT:c>" , "<STR_LIT>" , "<STR_LIT>" ] , <EOL> ] <EOL> optFlags = [ [ "<STR_LIT>" , "<STR_LIT:C>" , "<STR_LIT>" ] , <EOL> [ "<STR_LIT>" , "<STR_LIT:x>" , """<STR_LIT>""" ] , <EOL> ] <EOL> def countPys ( countl , directory , names ) : <EOL> sofar = countl [ <NUM_LIT:0> ] <EOL> sofar = sofar + len ( [ f for f in names if f . endswith ( '<STR_LIT>' ) ] ) <EOL> countl [ <NUM_LIT:0> ] = sofar <EOL> return sofar <EOL> def countPysRecursive ( path ) : <EOL> countl = [ <NUM_LIT:0> ] <EOL> os . path . walk ( path , countPys , countl ) <EOL> return countl [ <NUM_LIT:0> ] <EOL> def run ( argv = sys . argv ) : <EOL> log . startLogging ( file ( '<STR_LIT>' , '<STR_LIT:w>' ) ) <EOL> opt = TkunzipOptions ( ) <EOL> try : <EOL> opt . parseOptions ( argv [ <NUM_LIT:1> : ] ) <EOL> except usage . UsageError , e : <EOL> print str ( opt ) <EOL> print str ( e ) <EOL> sys . exit ( <NUM_LIT:1> ) <EOL> if opt [ '<STR_LIT>' ] : <EOL> return doItConsolicious ( opt ) <EOL> if opt [ '<STR_LIT>' ] or not '<STR_LIT>' in sys . modules : <EOL> from distutils import sysconfig <EOL> from twisted . scripts import tkunzip <EOL> myfile = tkunzip . __file__ <EOL> exe = os . path . join ( sysconfig . get_config_var ( '<STR_LIT>' ) , '<STR_LIT>' ) <EOL> return os . system ( '<STR_LIT>' % ( exe , myfile , <EOL> '<STR_LIT:U+0020>' . join ( argv [ <NUM_LIT:1> : ] ) ) ) <EOL> return doItTkinterly ( opt ) <EOL> def doItConsolicious ( opt ) : <EOL> sys . stdout = sys . __stdout__ <EOL> sys . stderr = sys . __stderr__ <EOL> if opt [ '<STR_LIT>' ] : <EOL> print '<STR_LIT>' <EOL> for n in zipstream . unzipIter ( opt [ '<STR_LIT>' ] , opt [ '<STR_LIT>' ] ) : <EOL> if n % <NUM_LIT:100> == <NUM_LIT:0> : <EOL> print n , <EOL> if n % <NUM_LIT:1000> == <NUM_LIT:0> : <EOL> print <EOL> print '<STR_LIT>' <EOL> if opt [ '<STR_LIT>' ] : <EOL> print '<STR_LIT>' <EOL> import compileall <EOL> compileall . compile_dir ( opt [ "<STR_LIT>" ] ) <EOL> print '<STR_LIT>' <EOL> def doItTkinterly ( opt ) : <EOL> root = Tkinter . Tk ( ) <EOL> root . withdraw ( ) <EOL> root . title ( '<STR_LIT>' ) <EOL> root . protocol ( '<STR_LIT>' , reactor . stop ) <EOL> tksupport . install ( root ) <EOL> prog = ProgressBar ( root , value = <NUM_LIT:0> , labelColor = "<STR_LIT>" , width = <NUM_LIT:200> ) <EOL> prog . pack ( ) <EOL> d = defer . succeed ( root ) . addErrback ( log . err ) <EOL> def deiconify ( root ) : <EOL> root . deiconify ( ) <EOL> return root <EOL> d . addCallback ( deiconify ) <EOL> if opt [ '<STR_LIT>' ] : <EOL> uz = Progressor ( '<STR_LIT>' ) <EOL> max = zipstream . countZipFileChunks ( opt [ '<STR_LIT>' ] , <NUM_LIT> ) <EOL> uz . setBar ( prog , max ) <EOL> uz . setIterator ( zipstream . unzipIterChunky ( opt [ '<STR_LIT>' ] , <EOL> opt [ '<STR_LIT>' ] ) ) <EOL> d . addCallback ( uz . processAll ) <EOL> if opt [ '<STR_LIT>' ] : <EOL> comp = Progressor ( '<STR_LIT>' ) <EOL> comp . setBar ( prog , countPysRecursive ( opt [ '<STR_LIT>' ] ) ) <EOL> comp . setIterator ( compiler ( opt [ '<STR_LIT>' ] ) ) <EOL> d . addCallback ( comp . processAll ) <EOL> def stop ( ignore ) : <EOL> reactor . stop ( ) <EOL> root . destroy ( ) <EOL> d . addCallback ( stop ) <EOL> reactor . run ( ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> run ( ) </s>

class A : <EOL> def a ( self ) :

return '<STR_LIT:b>'

class A : <EOL> def a ( self ) : <EOL> return '<STR_LIT:b>' <EOL> try : <EOL> object <EOL> except NameError : <EOL> pass <EOL> else : <EOL> class B ( A , object ) : <EOL> def b ( self ) : <EOL> return '<STR_LIT:c>' <EOL> class Inherit ( A ) : <EOL> def a ( self ) : <EOL> return '<STR_LIT:d>' </s>

"""<STR_LIT>""" <EOL> from twisted . trial import unittest <EOL> import os , stat , new <EOL> from twisted . enterprise . adbapi import ConnectionPool , ConnectionLost , safe <EOL> from twisted . enterprise . adbapi import Connection , Transaction <EOL> from twisted . enterprise . adbapi import _unreleasedVersion <EOL> from twisted . internet import reactor , defer , interfaces <EOL> from twisted . python . failure import Failure <EOL> simple_table_schema = """<STR_LIT>""" <EOL> class ADBAPITestBase : <EOL> """<STR_LIT>""" <EOL> openfun_called = { } <EOL> if interfaces . IReactorThreads ( reactor , None ) is None : <EOL> skip = "<STR_LIT>" <EOL> def extraSetUp ( self ) : <EOL> """<STR_LIT>""" <EOL> self . startDB ( ) <EOL> self . dbpool = self . makePool ( cp_openfun = self . openfun ) <EOL> self . dbpool . start ( ) <EOL> def tearDown ( self ) : <EOL> d = self . dbpool . runOperation ( '<STR_LIT>' ) <EOL> d . addCallback ( lambda res : self . dbpool . close ( ) ) <EOL> d . addCallback ( lambda res : self . stopDB ( ) ) <EOL> return d <EOL> def openfun ( self , conn ) : <EOL> self . openfun_called [ conn ] = True <EOL> def checkOpenfunCalled ( self , conn = None ) : <EOL> if not conn : <EOL> self . failUnless ( self . openfun_called ) <EOL> else : <EOL> self . failUnless ( self . openfun_called . has_key ( conn ) ) <EOL> def testPool ( self ) : <EOL> d = self . dbpool . runOperation ( simple_table_schema ) <EOL> if self . test_failures : <EOL> d . addCallback ( self . _testPool_1_1 ) <EOL> d . addCallback ( self . _testPool_1_2 ) <EOL> d . addCallback ( self . _testPool_1_3 ) <EOL> d . addCallback ( self . _testPool_1_4 ) <EOL> d . addCallback ( lambda res : self . flushLoggedErrors ( ) ) <EOL> d . addCallback ( self . _testPool_2 ) <EOL> d . addCallback ( self . _testPool_3 ) <EOL> d . addCallback ( self . _testPool_4 ) <EOL> d . addCallback ( self . _testPool_5 ) <EOL> d . addCallback ( self . _testPool_6 ) <EOL> d . addCallback ( self . _testPool_7 ) <EOL> d . addCallback ( self . _testPool_8 ) <EOL> d . addCallback ( self . _testPool_9 ) <EOL> return d <EOL> def _testPool_1_1 ( self , res ) : <EOL> d = defer . maybeDeferred ( self . dbpool . runQuery , "<STR_LIT>" ) <EOL> d . addCallbacks ( lambda res : self . fail ( '<STR_LIT>' ) , <EOL> lambda f : None ) <EOL> return d <EOL> def _testPool_1_2 ( self , res ) : <EOL> d = defer . maybeDeferred ( self . dbpool . runOperation , <EOL> "<STR_LIT>" ) <EOL> d . addCallbacks ( lambda res : self . fail ( '<STR_LIT>' ) , <EOL> lambda f : None ) <EOL> return d <EOL> def _testPool_1_3 ( self , res ) : <EOL> d = defer . maybeDeferred ( self . dbpool . runInteraction , <EOL> self . bad_interaction ) <EOL> d . addCallbacks ( lambda res : self . fail ( '<STR_LIT>' ) , <EOL> lambda f : None ) <EOL> return d <EOL> def _testPool_1_4 ( self , res ) : <EOL> d = defer . maybeDeferred ( self . dbpool . runWithConnection , <EOL> self . bad_withConnection ) <EOL> d . addCallbacks ( lambda res : self . fail ( '<STR_LIT>' ) , <EOL> lambda f : None ) <EOL> return d <EOL> def _testPool_2 ( self , res ) : <EOL> sql = "<STR_LIT>" <EOL> d = self . dbpool . runQuery ( sql ) <EOL> def _check ( row ) : <EOL> self . failUnless ( int ( row [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] ) == <NUM_LIT:0> , "<STR_LIT>" ) <EOL> self . checkOpenfunCalled ( ) <EOL> d . addCallback ( _check ) <EOL> return d <EOL> def _testPool_3 ( self , res ) : <EOL> sql = "<STR_LIT>" <EOL> inserts = [ ] <EOL> for i in range ( self . num_iterations ) : <EOL> sql = "<STR_LIT>" % i <EOL> inserts . append ( self . dbpool . runOperation ( sql ) ) <EOL> d = defer . gatherResults ( inserts ) <EOL> def _select ( res ) : <EOL> sql = "<STR_LIT>" ; <EOL> d = self . dbpool . runQuery ( sql ) <EOL> return d <EOL> d . addCallback ( _select ) <EOL> def _check ( rows ) : <EOL> self . failUnless ( len ( rows ) == self . num_iterations , <EOL> "<STR_LIT>" ) <EOL> for i in range ( self . num_iterations ) : <EOL> self . failUnless ( len ( rows [ i ] ) == <NUM_LIT:1> , "<STR_LIT>" ) <EOL> self . failUnless ( rows [ i ] [ <NUM_LIT:0> ] == i , "<STR_LIT>" ) <EOL> d . addCallback ( _check ) <EOL> return d <EOL> def _testPool_4 ( self , res ) : <EOL> d = self . dbpool . runInteraction ( self . interaction ) <EOL> d . addCallback ( lambda res : self . assertEquals ( res , "<STR_LIT>" ) ) <EOL> return d <EOL> def _testPool_5 ( self , res ) : <EOL> d = self . dbpool . runWithConnection ( self . withConnection ) <EOL> d . addCallback ( lambda res : self . assertEquals ( res , "<STR_LIT>" ) ) <EOL> return d <EOL> def _testPool_6 ( self , res ) : <EOL> d = self . dbpool . runWithConnection ( self . close_withConnection ) <EOL> return d <EOL> def _testPool_7 ( self , res ) : <EOL> ds = [ ] <EOL> for i in range ( self . num_iterations ) : <EOL> sql = "<STR_LIT>" % i <EOL> ds . append ( self . dbpool . runQuery ( sql ) ) <EOL> dlist = defer . DeferredList ( ds , fireOnOneErrback = True ) <EOL> def _check ( result ) : <EOL> for i in range ( self . num_iterations ) : <EOL> self . failUnless ( result [ i ] [ <NUM_LIT:1> ] [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] == i , "<STR_LIT>" ) <EOL> dlist . addCallback ( _check ) <EOL> return dlist <EOL> def _testPool_8 ( self , res ) : <EOL> ds = [ ] <EOL> for i in range ( self . num_iterations ) : <EOL> sql = "<STR_LIT>" % i <EOL> ds . append ( self . dbpool . runOperation ( sql ) ) <EOL> dlist = defer . DeferredList ( ds , fireOnOneErrback = True ) <EOL> return dlist <EOL> def _testPool_9 ( self , res ) : <EOL> sql = "<STR_LIT>" <EOL> d = self . dbpool . runQuery ( sql ) <EOL> def _check ( row ) : <EOL> self . failUnless ( int ( row [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] ) == <NUM_LIT:0> , <EOL> "<STR_LIT>" ) <EOL> self . checkConnect ( ) <EOL> d . addCallback ( _check ) <EOL> return d <EOL> def checkConnect ( self ) : <EOL> """<STR_LIT>""" <EOL> conn = self . dbpool . connect ( ) <EOL> self . checkOpenfunCalled ( conn ) <EOL> curs = conn . cursor ( ) <EOL> curs . execute ( "<STR_LIT>" ) <EOL> curs . execute ( "<STR_LIT>" ) <EOL> res = curs . fetchall ( ) <EOL> self . failUnlessEqual ( len ( res ) , <NUM_LIT:1> ) <EOL> self . failUnlessEqual ( len ( res [ <NUM_LIT:0> ] ) , <NUM_LIT:1> ) <EOL> self . failUnlessEqual ( res [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] , <NUM_LIT:1> ) <EOL> curs . execute ( "<STR_LIT>" ) <EOL> curs . execute ( "<STR_LIT>" ) <EOL> self . failUnlessEqual ( len ( curs . fetchall ( ) ) , <NUM_LIT:0> ) <EOL> curs . close ( ) <EOL> self . dbpool . disconnect ( conn ) <EOL> def interaction ( self , transaction ) : <EOL> transaction . execute ( "<STR_LIT>" ) <EOL> for i in range ( self . num_iterations ) : <EOL> row = transaction . fetchone ( ) <EOL> self . failUnless ( len ( row ) == <NUM_LIT:1> , "<STR_LIT>" ) <EOL> self . failUnless ( row [ <NUM_LIT:0> ] == i , "<STR_LIT>" ) <EOL> return "<STR_LIT>" <EOL> def bad_interaction ( self , transaction ) : <EOL> if self . can_rollback : <EOL> transaction . execute ( "<STR_LIT>" ) <EOL> transaction . execute ( "<STR_LIT>" ) <EOL> def withConnection ( self , conn ) : <EOL> curs = conn . cursor ( ) <EOL> try : <EOL> curs . execute ( "<STR_LIT>" ) <EOL> for i in range ( self . num_iterations ) : <EOL> row = curs . fetchone ( ) <EOL> self . failUnless ( len ( row ) == <NUM_LIT:1> , "<STR_LIT>" ) <EOL> self . failUnless ( row [ <NUM_LIT:0> ] == i , "<STR_LIT>" ) <EOL> finally : <EOL> curs . close ( ) <EOL> return "<STR_LIT>" <EOL> def close_withConnection ( self , conn ) : <EOL> conn . close ( ) <EOL> def bad_withConnection ( self , conn ) : <EOL> curs = conn . cursor ( ) <EOL> try : <EOL> curs . execute ( "<STR_LIT>" ) <EOL> finally : <EOL> curs . close ( ) <EOL> class ReconnectTestBase : <EOL> """<STR_LIT>""" <EOL> if interfaces . IReactorThreads ( reactor , None ) is None : <EOL> skip = "<STR_LIT>" <EOL> def extraSetUp ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . good_sql is None : <EOL> raise unittest . SkipTest ( '<STR_LIT>' ) <EOL> self . startDB ( ) <EOL> self . dbpool = self . makePool ( cp_max = <NUM_LIT:1> , cp_reconnect = True , <EOL> cp_good_sql = self . good_sql ) <EOL> self . dbpool . start ( ) <EOL> return self . dbpool . runOperation ( simple_table_schema ) <EOL> def tearDown ( self ) : <EOL> d = self . dbpool . runOperation ( '<STR_LIT>' ) <EOL> d . addCallback ( lambda res : self . dbpool . close ( ) ) <EOL> d . addCallback ( lambda res : self . stopDB ( ) ) <EOL> return d <EOL> def testPool ( self ) : <EOL> d = defer . succeed ( None ) <EOL> d . addCallback ( self . _testPool_1 ) <EOL> d . addCallback ( self . _testPool_2 ) <EOL> if not self . early_reconnect : <EOL> d . addCallback ( self . _testPool_3 ) <EOL> d . addCallback ( self . _testPool_4 ) <EOL> d . addCallback ( self . _testPool_5 ) <EOL> return d <EOL> def _testPool_1 ( self , res ) : <EOL> sql = "<STR_LIT>" <EOL> d = self . dbpool . runQuery ( sql ) <EOL> def _check ( row ) : <EOL> self . failUnless ( int ( row [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] ) == <NUM_LIT:0> , "<STR_LIT>" ) <EOL> d . addCallback ( _check ) <EOL> return d <EOL> def _testPool_2 ( self , res ) : <EOL> self . dbpool . connections . values ( ) [ <NUM_LIT:0> ] . close ( ) <EOL> def _testPool_3 ( self , res ) : <EOL> sql = "<STR_LIT>" <EOL> d = defer . maybeDeferred ( self . dbpool . runQuery , sql ) <EOL> d . addCallbacks ( lambda res : self . fail ( '<STR_LIT>' ) , <EOL> lambda f : None ) <EOL> return d <EOL> def _testPool_4 ( self , res ) : <EOL> sql = "<STR_LIT>" <EOL> d = self . dbpool . runQuery ( sql ) <EOL> def _check ( row ) : <EOL> self . failUnless ( int ( row [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] ) == <NUM_LIT:0> , "<STR_LIT>" ) <EOL> d . addCallback ( _check ) <EOL> return d <EOL> def _testPool_5 ( self , res ) : <EOL> self . flushLoggedErrors ( ) <EOL> sql = "<STR_LIT>" <EOL> d = defer . maybeDeferred ( self . dbpool . runQuery , sql ) <EOL> d . addCallbacks ( lambda res : self . fail ( '<STR_LIT>' ) , <EOL> lambda f : self . failIf ( f . check ( ConnectionLost ) ) ) <EOL> return d <EOL> class DBTestConnector : <EOL> """<STR_LIT>""" <EOL> TEST_PREFIX = None <EOL> DB_NAME = "<STR_LIT>" <EOL> DB_USER = '<STR_LIT>' <EOL> DB_PASS = '<STR_LIT>' <EOL> DB_DIR = None <EOL> nulls_ok = True <EOL> trailing_spaces_ok = True <EOL> can_rollback = True <EOL> test_failures = True <EOL> escape_slashes = True <EOL> good_sql = ConnectionPool . good_sql <EOL> early_reconnect = True <EOL> can_clear = True <EOL> num_iterations = <NUM_LIT:50> <EOL> def setUp ( self ) : <EOL> self . DB_DIR = self . mktemp ( ) <EOL> os . mkdir ( self . DB_DIR ) <EOL> if not self . can_connect ( ) : <EOL> raise unittest . SkipTest ( '<STR_LIT>' % self . TEST_PREFIX ) <EOL> return self . extraSetUp ( ) <EOL> def can_connect ( self ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError ( ) <EOL> def startDB ( self ) : <EOL> """<STR_LIT>""" <EOL> pass <EOL> def stopDB ( self ) : <EOL> """<STR_LIT>""" <EOL> pass <EOL> def makePool ( self , ** newkw ) : <EOL> """<STR_LIT>""" <EOL> args , kw = self . getPoolArgs ( ) <EOL> kw = kw . copy ( ) <EOL> kw . update ( newkw ) <EOL> return ConnectionPool ( * args , ** kw ) <EOL> def getPoolArgs ( self ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError ( ) <EOL> class GadflyConnector ( DBTestConnector ) : <EOL> TEST_PREFIX = '<STR_LIT>' <EOL> nulls_ok = False <EOL> can_rollback = False <EOL> escape_slashes = False <EOL> good_sql = '<STR_LIT>' <EOL> num_iterations = <NUM_LIT:1> <EOL> def can_connect ( self ) : <EOL> try : import gadfly <EOL> except : return False <EOL> if not getattr ( gadfly , '<STR_LIT>' , None ) : <EOL> gadfly . connect = gadfly . gadfly <EOL> return True <EOL> def startDB ( self ) : <EOL> import gadfly <EOL> conn = gadfly . gadfly ( ) <EOL> conn . startup ( self . DB_NAME , self . DB_DIR ) <EOL> cursor = conn . cursor ( ) <EOL> cursor . execute ( "<STR_LIT>" ) <EOL> conn . commit ( ) <EOL> conn . close ( ) <EOL> def getPoolArgs ( self ) : <EOL> args = ( '<STR_LIT>' , self . DB_NAME , self . DB_DIR ) <EOL> kw = { '<STR_LIT>' : <NUM_LIT:1> } <EOL> return args , kw <EOL> class SQLiteConnector ( DBTestConnector ) : <EOL> TEST_PREFIX = '<STR_LIT>' <EOL> escape_slashes = False <EOL> num_iterations = <NUM_LIT:1> <EOL> def can_connect ( self ) : <EOL> try : import sqlite <EOL> except : return False <EOL> return True <EOL> def startDB ( self ) : <EOL> self . database = os . path . join ( self . DB_DIR , self . DB_NAME ) <EOL> if os . path . exists ( self . database ) : <EOL> os . unlink ( self . database ) <EOL> def getPoolArgs ( self ) : <EOL> args = ( '<STR_LIT>' , ) <EOL> kw = { '<STR_LIT>' : self . database , '<STR_LIT>' : <NUM_LIT:1> } <EOL> return args , kw <EOL> class PyPgSQLConnector ( DBTestConnector ) : <EOL> TEST_PREFIX = "<STR_LIT>" <EOL> def can_connect ( self ) : <EOL> try : from pyPgSQL import PgSQL <EOL> except : return False <EOL> try : <EOL> conn = PgSQL . connect ( database = self . DB_NAME , user = self . DB_USER , <EOL> password = self . DB_PASS ) <EOL> conn . close ( ) <EOL> return True <EOL> except : <EOL> return False <EOL> def getPoolArgs ( self ) : <EOL> args = ( '<STR_LIT>' , ) <EOL> kw = { '<STR_LIT>' : self . DB_NAME , '<STR_LIT:user>' : self . DB_USER , <EOL> '<STR_LIT:password>' : self . DB_PASS , '<STR_LIT>' : <NUM_LIT:0> } <EOL> return args , kw <EOL> class PsycopgConnector ( DBTestConnector ) : <EOL> TEST_PREFIX = '<STR_LIT>' <EOL> def can_connect ( self ) : <EOL> try : import psycopg <EOL> except : return False <EOL> try : <EOL> conn = psycopg . connect ( database = self . DB_NAME , user = self . DB_USER , <EOL> password = self . DB_PASS ) <EOL> conn . close ( ) <EOL> return True <EOL> except : <EOL> return False <EOL> def getPoolArgs ( self ) : <EOL> args = ( '<STR_LIT>' , ) <EOL> kw = { '<STR_LIT>' : self . DB_NAME , '<STR_LIT:user>' : self . DB_USER , <EOL> '<STR_LIT:password>' : self . DB_PASS , '<STR_LIT>' : <NUM_LIT:0> } <EOL> return args , kw <EOL> class MySQLConnector ( DBTestConnector ) : <EOL> TEST_PREFIX = '<STR_LIT>' <EOL> trailing_spaces_ok = False <EOL> can_rollback = False <EOL> early_reconnect = False <EOL> def can_connect ( self ) : <EOL> try : import MySQLdb <EOL> except : return False <EOL> try : <EOL> conn = MySQLdb . connect ( db = self . DB_NAME , user = self . DB_USER , <EOL> passwd = self . DB_PASS ) <EOL> conn . close ( ) <EOL> return True <EOL> except : <EOL> return False <EOL> def getPoolArgs ( self ) : <EOL> args = ( '<STR_LIT>' , ) <EOL> kw = { '<STR_LIT>' : self . DB_NAME , '<STR_LIT:user>' : self . DB_USER , '<STR_LIT>' : self . DB_PASS } <EOL> return args , kw <EOL> class FirebirdConnector ( DBTestConnector ) : <EOL> TEST_PREFIX = '<STR_LIT>' <EOL> test_failures = False <EOL> escape_slashes = False <EOL> good_sql = None <EOL> can_clear = False <EOL> num_iterations = <NUM_LIT:5> <EOL> def can_connect ( self ) : <EOL> try : import kinterbasdb <EOL> except : return False <EOL> try : <EOL> self . startDB ( ) <EOL> self . stopDB ( ) <EOL> return True <EOL> except : <EOL> return False <EOL> def startDB ( self ) : <EOL> import kinterbasdb <EOL> self . DB_NAME = os . path . join ( self . DB_DIR , DBTestConnector . DB_NAME ) <EOL> os . chmod ( self . DB_DIR , stat . S_IRWXU + stat . S_IRWXG + stat . S_IRWXO ) <EOL> sql = '<STR_LIT>' <EOL> sql %= ( self . DB_NAME , self . DB_USER , self . DB_PASS ) ; <EOL> conn = kinterbasdb . create_database ( sql ) <EOL> conn . close ( ) <EOL> def getPoolArgs ( self ) : <EOL> args = ( '<STR_LIT>' , ) <EOL> kw = { '<STR_LIT>' : self . DB_NAME , '<STR_LIT:host>' : '<STR_LIT:127.0.0.1>' , <EOL> '<STR_LIT:user>' : self . DB_USER , '<STR_LIT:password>' : self . DB_PASS } <EOL> return args , kw <EOL> def stopDB ( self ) : <EOL> import kinterbasdb <EOL> conn = kinterbasdb . connect ( database = self . DB_NAME , <EOL> host = '<STR_LIT:127.0.0.1>' , user = self . DB_USER , <EOL> password = self . DB_PASS ) <EOL> conn . drop_database ( )

def makeSQLTests ( base , suffix , globals ) :

"""<STR_LIT>""" <EOL> from twisted . trial import unittest <EOL> import os , stat , new <EOL> from twisted . enterprise . adbapi import ConnectionPool , ConnectionLost , safe <EOL> from twisted . enterprise . adbapi import Connection , Transaction <EOL> from twisted . enterprise . adbapi import _unreleasedVersion <EOL> from twisted . internet import reactor , defer , interfaces <EOL> from twisted . python . failure import Failure <EOL> simple_table_schema = """<STR_LIT>""" <EOL> class ADBAPITestBase : <EOL> """<STR_LIT>""" <EOL> openfun_called = { } <EOL> if interfaces . IReactorThreads ( reactor , None ) is None : <EOL> skip = "<STR_LIT>" <EOL> def extraSetUp ( self ) : <EOL> """<STR_LIT>""" <EOL> self . startDB ( ) <EOL> self . dbpool = self . makePool ( cp_openfun = self . openfun ) <EOL> self . dbpool . start ( ) <EOL> def tearDown ( self ) : <EOL> d = self . dbpool . runOperation ( '<STR_LIT>' ) <EOL> d . addCallback ( lambda res : self . dbpool . close ( ) ) <EOL> d . addCallback ( lambda res : self . stopDB ( ) ) <EOL> return d <EOL> def openfun ( self , conn ) : <EOL> self . openfun_called [ conn ] = True <EOL> def checkOpenfunCalled ( self , conn = None ) : <EOL> if not conn : <EOL> self . failUnless ( self . openfun_called ) <EOL> else : <EOL> self . failUnless ( self . openfun_called . has_key ( conn ) ) <EOL> def testPool ( self ) : <EOL> d = self . dbpool . runOperation ( simple_table_schema ) <EOL> if self . test_failures : <EOL> d . addCallback ( self . _testPool_1_1 ) <EOL> d . addCallback ( self . _testPool_1_2 ) <EOL> d . addCallback ( self . _testPool_1_3 ) <EOL> d . addCallback ( self . _testPool_1_4 ) <EOL> d . addCallback ( lambda res : self . flushLoggedErrors ( ) ) <EOL> d . addCallback ( self . _testPool_2 ) <EOL> d . addCallback ( self . _testPool_3 ) <EOL> d . addCallback ( self . _testPool_4 ) <EOL> d . addCallback ( self . _testPool_5 ) <EOL> d . addCallback ( self . _testPool_6 ) <EOL> d . addCallback ( self . _testPool_7 ) <EOL> d . addCallback ( self . _testPool_8 ) <EOL> d . addCallback ( self . _testPool_9 ) <EOL> return d <EOL> def _testPool_1_1 ( self , res ) : <EOL> d = defer . maybeDeferred ( self . dbpool . runQuery , "<STR_LIT>" ) <EOL> d . addCallbacks ( lambda res : self . fail ( '<STR_LIT>' ) , <EOL> lambda f : None ) <EOL> return d <EOL> def _testPool_1_2 ( self , res ) : <EOL> d = defer . maybeDeferred ( self . dbpool . runOperation , <EOL> "<STR_LIT>" ) <EOL> d . addCallbacks ( lambda res : self . fail ( '<STR_LIT>' ) , <EOL> lambda f : None ) <EOL> return d <EOL> def _testPool_1_3 ( self , res ) : <EOL> d = defer . maybeDeferred ( self . dbpool . runInteraction , <EOL> self . bad_interaction ) <EOL> d . addCallbacks ( lambda res : self . fail ( '<STR_LIT>' ) , <EOL> lambda f : None ) <EOL> return d <EOL> def _testPool_1_4 ( self , res ) : <EOL> d = defer . maybeDeferred ( self . dbpool . runWithConnection , <EOL> self . bad_withConnection ) <EOL> d . addCallbacks ( lambda res : self . fail ( '<STR_LIT>' ) , <EOL> lambda f : None ) <EOL> return d <EOL> def _testPool_2 ( self , res ) : <EOL> sql = "<STR_LIT>" <EOL> d = self . dbpool . runQuery ( sql ) <EOL> def _check ( row ) : <EOL> self . failUnless ( int ( row [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] ) == <NUM_LIT:0> , "<STR_LIT>" ) <EOL> self . checkOpenfunCalled ( ) <EOL> d . addCallback ( _check ) <EOL> return d <EOL> def _testPool_3 ( self , res ) : <EOL> sql = "<STR_LIT>" <EOL> inserts = [ ] <EOL> for i in range ( self . num_iterations ) : <EOL> sql = "<STR_LIT>" % i <EOL> inserts . append ( self . dbpool . runOperation ( sql ) ) <EOL> d = defer . gatherResults ( inserts ) <EOL> def _select ( res ) : <EOL> sql = "<STR_LIT>" ; <EOL> d = self . dbpool . runQuery ( sql ) <EOL> return d <EOL> d . addCallback ( _select ) <EOL> def _check ( rows ) : <EOL> self . failUnless ( len ( rows ) == self . num_iterations , <EOL> "<STR_LIT>" ) <EOL> for i in range ( self . num_iterations ) : <EOL> self . failUnless ( len ( rows [ i ] ) == <NUM_LIT:1> , "<STR_LIT>" ) <EOL> self . failUnless ( rows [ i ] [ <NUM_LIT:0> ] == i , "<STR_LIT>" ) <EOL> d . addCallback ( _check ) <EOL> return d <EOL> def _testPool_4 ( self , res ) : <EOL> d = self . dbpool . runInteraction ( self . interaction ) <EOL> d . addCallback ( lambda res : self . assertEquals ( res , "<STR_LIT>" ) ) <EOL> return d <EOL> def _testPool_5 ( self , res ) : <EOL> d = self . dbpool . runWithConnection ( self . withConnection ) <EOL> d . addCallback ( lambda res : self . assertEquals ( res , "<STR_LIT>" ) ) <EOL> return d <EOL> def _testPool_6 ( self , res ) : <EOL> d = self . dbpool . runWithConnection ( self . close_withConnection ) <EOL> return d <EOL> def _testPool_7 ( self , res ) : <EOL> ds = [ ] <EOL> for i in range ( self . num_iterations ) : <EOL> sql = "<STR_LIT>" % i <EOL> ds . append ( self . dbpool . runQuery ( sql ) ) <EOL> dlist = defer . DeferredList ( ds , fireOnOneErrback = True ) <EOL> def _check ( result ) : <EOL> for i in range ( self . num_iterations ) : <EOL> self . failUnless ( result [ i ] [ <NUM_LIT:1> ] [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] == i , "<STR_LIT>" ) <EOL> dlist . addCallback ( _check ) <EOL> return dlist <EOL> def _testPool_8 ( self , res ) : <EOL> ds = [ ] <EOL> for i in range ( self . num_iterations ) : <EOL> sql = "<STR_LIT>" % i <EOL> ds . append ( self . dbpool . runOperation ( sql ) ) <EOL> dlist = defer . DeferredList ( ds , fireOnOneErrback = True ) <EOL> return dlist <EOL> def _testPool_9 ( self , res ) : <EOL> sql = "<STR_LIT>" <EOL> d = self . dbpool . runQuery ( sql ) <EOL> def _check ( row ) : <EOL> self . failUnless ( int ( row [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] ) == <NUM_LIT:0> , <EOL> "<STR_LIT>" ) <EOL> self . checkConnect ( ) <EOL> d . addCallback ( _check ) <EOL> return d <EOL> def checkConnect ( self ) : <EOL> """<STR_LIT>""" <EOL> conn = self . dbpool . connect ( ) <EOL> self . checkOpenfunCalled ( conn ) <EOL> curs = conn . cursor ( ) <EOL> curs . execute ( "<STR_LIT>" ) <EOL> curs . execute ( "<STR_LIT>" ) <EOL> res = curs . fetchall ( ) <EOL> self . failUnlessEqual ( len ( res ) , <NUM_LIT:1> ) <EOL> self . failUnlessEqual ( len ( res [ <NUM_LIT:0> ] ) , <NUM_LIT:1> ) <EOL> self . failUnlessEqual ( res [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] , <NUM_LIT:1> ) <EOL> curs . execute ( "<STR_LIT>" ) <EOL> curs . execute ( "<STR_LIT>" ) <EOL> self . failUnlessEqual ( len ( curs . fetchall ( ) ) , <NUM_LIT:0> ) <EOL> curs . close ( ) <EOL> self . dbpool . disconnect ( conn ) <EOL> def interaction ( self , transaction ) : <EOL> transaction . execute ( "<STR_LIT>" ) <EOL> for i in range ( self . num_iterations ) : <EOL> row = transaction . fetchone ( ) <EOL> self . failUnless ( len ( row ) == <NUM_LIT:1> , "<STR_LIT>" ) <EOL> self . failUnless ( row [ <NUM_LIT:0> ] == i , "<STR_LIT>" ) <EOL> return "<STR_LIT>" <EOL> def bad_interaction ( self , transaction ) : <EOL> if self . can_rollback : <EOL> transaction . execute ( "<STR_LIT>" ) <EOL> transaction . execute ( "<STR_LIT>" ) <EOL> def withConnection ( self , conn ) : <EOL> curs = conn . cursor ( ) <EOL> try : <EOL> curs . execute ( "<STR_LIT>" ) <EOL> for i in range ( self . num_iterations ) : <EOL> row = curs . fetchone ( ) <EOL> self . failUnless ( len ( row ) == <NUM_LIT:1> , "<STR_LIT>" ) <EOL> self . failUnless ( row [ <NUM_LIT:0> ] == i , "<STR_LIT>" ) <EOL> finally : <EOL> curs . close ( ) <EOL> return "<STR_LIT>" <EOL> def close_withConnection ( self , conn ) : <EOL> conn . close ( ) <EOL> def bad_withConnection ( self , conn ) : <EOL> curs = conn . cursor ( ) <EOL> try : <EOL> curs . execute ( "<STR_LIT>" ) <EOL> finally : <EOL> curs . close ( ) <EOL> class ReconnectTestBase : <EOL> """<STR_LIT>""" <EOL> if interfaces . IReactorThreads ( reactor , None ) is None : <EOL> skip = "<STR_LIT>" <EOL> def extraSetUp ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . good_sql is None : <EOL> raise unittest . SkipTest ( '<STR_LIT>' ) <EOL> self . startDB ( ) <EOL> self . dbpool = self . makePool ( cp_max = <NUM_LIT:1> , cp_reconnect = True , <EOL> cp_good_sql = self . good_sql ) <EOL> self . dbpool . start ( ) <EOL> return self . dbpool . runOperation ( simple_table_schema ) <EOL> def tearDown ( self ) : <EOL> d = self . dbpool . runOperation ( '<STR_LIT>' ) <EOL> d . addCallback ( lambda res : self . dbpool . close ( ) ) <EOL> d . addCallback ( lambda res : self . stopDB ( ) ) <EOL> return d <EOL> def testPool ( self ) : <EOL> d = defer . succeed ( None ) <EOL> d . addCallback ( self . _testPool_1 ) <EOL> d . addCallback ( self . _testPool_2 ) <EOL> if not self . early_reconnect : <EOL> d . addCallback ( self . _testPool_3 ) <EOL> d . addCallback ( self . _testPool_4 ) <EOL> d . addCallback ( self . _testPool_5 ) <EOL> return d <EOL> def _testPool_1 ( self , res ) : <EOL> sql = "<STR_LIT>" <EOL> d = self . dbpool . runQuery ( sql ) <EOL> def _check ( row ) : <EOL> self . failUnless ( int ( row [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] ) == <NUM_LIT:0> , "<STR_LIT>" ) <EOL> d . addCallback ( _check ) <EOL> return d <EOL> def _testPool_2 ( self , res ) : <EOL> self . dbpool . connections . values ( ) [ <NUM_LIT:0> ] . close ( ) <EOL> def _testPool_3 ( self , res ) : <EOL> sql = "<STR_LIT>" <EOL> d = defer . maybeDeferred ( self . dbpool . runQuery , sql ) <EOL> d . addCallbacks ( lambda res : self . fail ( '<STR_LIT>' ) , <EOL> lambda f : None ) <EOL> return d <EOL> def _testPool_4 ( self , res ) : <EOL> sql = "<STR_LIT>" <EOL> d = self . dbpool . runQuery ( sql ) <EOL> def _check ( row ) : <EOL> self . failUnless ( int ( row [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] ) == <NUM_LIT:0> , "<STR_LIT>" ) <EOL> d . addCallback ( _check ) <EOL> return d <EOL> def _testPool_5 ( self , res ) : <EOL> self . flushLoggedErrors ( ) <EOL> sql = "<STR_LIT>" <EOL> d = defer . maybeDeferred ( self . dbpool . runQuery , sql ) <EOL> d . addCallbacks ( lambda res : self . fail ( '<STR_LIT>' ) , <EOL> lambda f : self . failIf ( f . check ( ConnectionLost ) ) ) <EOL> return d <EOL> class DBTestConnector : <EOL> """<STR_LIT>""" <EOL> TEST_PREFIX = None <EOL> DB_NAME = "<STR_LIT>" <EOL> DB_USER = '<STR_LIT>' <EOL> DB_PASS = '<STR_LIT>' <EOL> DB_DIR = None <EOL> nulls_ok = True <EOL> trailing_spaces_ok = True <EOL> can_rollback = True <EOL> test_failures = True <EOL> escape_slashes = True <EOL> good_sql = ConnectionPool . good_sql <EOL> early_reconnect = True <EOL> can_clear = True <EOL> num_iterations = <NUM_LIT:50> <EOL> def setUp ( self ) : <EOL> self . DB_DIR = self . mktemp ( ) <EOL> os . mkdir ( self . DB_DIR ) <EOL> if not self . can_connect ( ) : <EOL> raise unittest . SkipTest ( '<STR_LIT>' % self . TEST_PREFIX ) <EOL> return self . extraSetUp ( ) <EOL> def can_connect ( self ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError ( ) <EOL> def startDB ( self ) : <EOL> """<STR_LIT>""" <EOL> pass <EOL> def stopDB ( self ) : <EOL> """<STR_LIT>""" <EOL> pass <EOL> def makePool ( self , ** newkw ) : <EOL> """<STR_LIT>""" <EOL> args , kw = self . getPoolArgs ( ) <EOL> kw = kw . copy ( ) <EOL> kw . update ( newkw ) <EOL> return ConnectionPool ( * args , ** kw ) <EOL> def getPoolArgs ( self ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError ( ) <EOL> class GadflyConnector ( DBTestConnector ) : <EOL> TEST_PREFIX = '<STR_LIT>' <EOL> nulls_ok = False <EOL> can_rollback = False <EOL> escape_slashes = False <EOL> good_sql = '<STR_LIT>' <EOL> num_iterations = <NUM_LIT:1> <EOL> def can_connect ( self ) : <EOL> try : import gadfly <EOL> except : return False <EOL> if not getattr ( gadfly , '<STR_LIT>' , None ) : <EOL> gadfly . connect = gadfly . gadfly <EOL> return True <EOL> def startDB ( self ) : <EOL> import gadfly <EOL> conn = gadfly . gadfly ( ) <EOL> conn . startup ( self . DB_NAME , self . DB_DIR ) <EOL> cursor = conn . cursor ( ) <EOL> cursor . execute ( "<STR_LIT>" ) <EOL> conn . commit ( ) <EOL> conn . close ( ) <EOL> def getPoolArgs ( self ) : <EOL> args = ( '<STR_LIT>' , self . DB_NAME , self . DB_DIR ) <EOL> kw = { '<STR_LIT>' : <NUM_LIT:1> } <EOL> return args , kw <EOL> class SQLiteConnector ( DBTestConnector ) : <EOL> TEST_PREFIX = '<STR_LIT>' <EOL> escape_slashes = False <EOL> num_iterations = <NUM_LIT:1> <EOL> def can_connect ( self ) : <EOL> try : import sqlite <EOL> except : return False <EOL> return True <EOL> def startDB ( self ) : <EOL> self . database = os . path . join ( self . DB_DIR , self . DB_NAME ) <EOL> if os . path . exists ( self . database ) : <EOL> os . unlink ( self . database ) <EOL> def getPoolArgs ( self ) : <EOL> args = ( '<STR_LIT>' , ) <EOL> kw = { '<STR_LIT>' : self . database , '<STR_LIT>' : <NUM_LIT:1> } <EOL> return args , kw <EOL> class PyPgSQLConnector ( DBTestConnector ) : <EOL> TEST_PREFIX = "<STR_LIT>" <EOL> def can_connect ( self ) : <EOL> try : from pyPgSQL import PgSQL <EOL> except : return False <EOL> try : <EOL> conn = PgSQL . connect ( database = self . DB_NAME , user = self . DB_USER , <EOL> password = self . DB_PASS ) <EOL> conn . close ( ) <EOL> return True <EOL> except : <EOL> return False <EOL> def getPoolArgs ( self ) : <EOL> args = ( '<STR_LIT>' , ) <EOL> kw = { '<STR_LIT>' : self . DB_NAME , '<STR_LIT:user>' : self . DB_USER , <EOL> '<STR_LIT:password>' : self . DB_PASS , '<STR_LIT>' : <NUM_LIT:0> } <EOL> return args , kw <EOL> class PsycopgConnector ( DBTestConnector ) : <EOL> TEST_PREFIX = '<STR_LIT>' <EOL> def can_connect ( self ) : <EOL> try : import psycopg <EOL> except : return False <EOL> try : <EOL> conn = psycopg . connect ( database = self . DB_NAME , user = self . DB_USER , <EOL> password = self . DB_PASS ) <EOL> conn . close ( ) <EOL> return True <EOL> except : <EOL> return False <EOL> def getPoolArgs ( self ) : <EOL> args = ( '<STR_LIT>' , ) <EOL> kw = { '<STR_LIT>' : self . DB_NAME , '<STR_LIT:user>' : self . DB_USER , <EOL> '<STR_LIT:password>' : self . DB_PASS , '<STR_LIT>' : <NUM_LIT:0> } <EOL> return args , kw <EOL> class MySQLConnector ( DBTestConnector ) : <EOL> TEST_PREFIX = '<STR_LIT>' <EOL> trailing_spaces_ok = False <EOL> can_rollback = False <EOL> early_reconnect = False <EOL> def can_connect ( self ) : <EOL> try : import MySQLdb <EOL> except : return False <EOL> try : <EOL> conn = MySQLdb . connect ( db = self . DB_NAME , user = self . DB_USER , <EOL> passwd = self . DB_PASS ) <EOL> conn . close ( ) <EOL> return True <EOL> except : <EOL> return False <EOL> def getPoolArgs ( self ) : <EOL> args = ( '<STR_LIT>' , ) <EOL> kw = { '<STR_LIT>' : self . DB_NAME , '<STR_LIT:user>' : self . DB_USER , '<STR_LIT>' : self . DB_PASS } <EOL> return args , kw <EOL> class FirebirdConnector ( DBTestConnector ) : <EOL> TEST_PREFIX = '<STR_LIT>' <EOL> test_failures = False <EOL> escape_slashes = False <EOL> good_sql = None <EOL> can_clear = False <EOL> num_iterations = <NUM_LIT:5> <EOL> def can_connect ( self ) : <EOL> try : import kinterbasdb <EOL> except : return False <EOL> try : <EOL> self . startDB ( ) <EOL> self . stopDB ( ) <EOL> return True <EOL> except : <EOL> return False <EOL> def startDB ( self ) : <EOL> import kinterbasdb <EOL> self . DB_NAME = os . path . join ( self . DB_DIR , DBTestConnector . DB_NAME ) <EOL> os . chmod ( self . DB_DIR , stat . S_IRWXU + stat . S_IRWXG + stat . S_IRWXO ) <EOL> sql = '<STR_LIT>' <EOL> sql %= ( self . DB_NAME , self . DB_USER , self . DB_PASS ) ; <EOL> conn = kinterbasdb . create_database ( sql ) <EOL> conn . close ( ) <EOL> def getPoolArgs ( self ) : <EOL> args = ( '<STR_LIT>' , ) <EOL> kw = { '<STR_LIT>' : self . DB_NAME , '<STR_LIT:host>' : '<STR_LIT:127.0.0.1>' , <EOL> '<STR_LIT:user>' : self . DB_USER , '<STR_LIT:password>' : self . DB_PASS } <EOL> return args , kw <EOL> def stopDB ( self ) : <EOL> import kinterbasdb <EOL> conn = kinterbasdb . connect ( database = self . DB_NAME , <EOL> host = '<STR_LIT:127.0.0.1>' , user = self . DB_USER , <EOL> password = self . DB_PASS ) <EOL> conn . drop_database ( ) <EOL> def makeSQLTests ( base , suffix , globals ) : <EOL> """<STR_LIT>""" <EOL> connectors = [ GadflyConnector , SQLiteConnector , PyPgSQLConnector , <EOL> PsycopgConnector , MySQLConnector , FirebirdConnector ] <EOL> for connclass in connectors : <EOL> name = connclass . TEST_PREFIX + suffix <EOL> klass = new . classobj ( name , ( connclass , base , unittest . TestCase ) , base . __dict__ ) <EOL> globals [ name ] = klass <EOL> makeSQLTests ( ADBAPITestBase , '<STR_LIT>' , globals ( ) ) <EOL> makeSQLTests ( ReconnectTestBase , '<STR_LIT>' , globals ( ) ) <EOL> class DeprecationTestCase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_safe ( self ) : <EOL> """<STR_LIT>""" <EOL> result = self . callDeprecated ( _unreleasedVersion , <EOL> safe , "<STR_LIT>" ) <EOL> self . assertEqual ( result , "<STR_LIT>" ) <EOL> class FakePool ( object ) : <EOL> """<STR_LIT>""" <EOL> reconnect = True <EOL> noisy = True <EOL> def __init__ ( self , connectionFactory ) : <EOL> self . connectionFactory = connectionFactory <EOL> def connect ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . connectionFactory ( ) <EOL> def disconnect ( self , connection ) : <EOL> """<STR_LIT>""" <EOL> class ConnectionTestCase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_rollbackErrorLogged ( self ) : <EOL> """<STR_LIT>""" <EOL> class ConnectionRollbackRaise ( object ) : <EOL> def rollback ( self ) : <EOL> raise RuntimeError ( "<STR_LIT>" ) <EOL> pool = FakePool ( ConnectionRollbackRaise ) <EOL> connection = Connection ( pool ) <EOL> self . assertRaises ( ConnectionLost , connection . rollback ) <EOL> errors = self . flushLoggedErrors ( RuntimeError ) <EOL> self . assertEquals ( len ( errors ) , <NUM_LIT:1> ) <EOL> self . assertEquals ( errors [ <NUM_LIT:0> ] . value . args [ <NUM_LIT:0> ] , "<STR_LIT>" ) <EOL> class TransactionTestCase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_reopenLogErrorIfReconnect ( self ) : <EOL> """<STR_LIT>""" <EOL> class ConnectionCursorRaise ( object ) : <EOL> count = <NUM_LIT:0> <EOL> def reconnect ( self ) : <EOL> pass <EOL> def cursor ( self ) : <EOL> if self . count == <NUM_LIT:0> : <EOL> self . count += <NUM_LIT:1> <EOL> raise RuntimeError ( "<STR_LIT>" ) <EOL> pool = FakePool ( None ) <EOL> transaction = Transaction ( pool , ConnectionCursorRaise ( ) ) <EOL> transaction . reopen ( ) <EOL> errors = self . flushLoggedErrors ( RuntimeError ) <EOL> self . assertEquals ( len ( errors ) , <NUM_LIT:1> ) <EOL> self . assertEquals ( errors [ <NUM_LIT:0> ] . value . args [ <NUM_LIT:0> ] , "<STR_LIT>" ) <EOL> class NonThreadPool ( object ) : <EOL> def callInThreadWithCallback ( self , onResult , f , * a , ** kw ) : <EOL> success = True <EOL> try : <EOL> result = f ( * a , ** kw ) <EOL> except Exception , e : <EOL> success = False <EOL> result = Failure ( ) <EOL> onResult ( success , result ) <EOL> class DummyConnectionPool ( ConnectionPool ) : <EOL> """<STR_LIT>""" <EOL> threadpool = NonThreadPool ( ) <EOL> def __init__ ( self ) : <EOL> """<STR_LIT>""" <EOL> self . reactor = reactor <EOL> class EventReactor ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , running ) : <EOL> self . _running = running <EOL> self . triggers = [ ] <EOL> def callWhenRunning ( self , function ) : <EOL> if self . _running : <EOL> function ( ) <EOL> else : <EOL> return self . addSystemEventTrigger ( '<STR_LIT>' , '<STR_LIT>' , function ) <EOL> def addSystemEventTrigger ( self , phase , event , trigger ) : <EOL> handle = ( phase , event , trigger ) <EOL> self . triggers . append ( handle ) <EOL> return handle <EOL> def removeSystemEventTrigger ( self , handle ) : <EOL> self . triggers . remove ( handle ) <EOL> class ConnectionPoolTestCase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_runWithConnectionRaiseOriginalError ( self ) : <EOL> """<STR_LIT>""" <EOL> class ConnectionRollbackRaise ( object ) : <EOL> def __init__ ( self , pool ) : <EOL> pass <EOL> def rollback ( self ) : <EOL> raise RuntimeError ( "<STR_LIT>" ) <EOL> def raisingFunction ( connection ) : <EOL> raise ValueError ( "<STR_LIT:foo>" ) <EOL> pool = DummyConnectionPool ( ) <EOL> pool . connectionFactory = ConnectionRollbackRaise <EOL> d = pool . runWithConnection ( raisingFunction ) <EOL> d = self . assertFailure ( d , ValueError ) <EOL> def cbFailed ( ignored ) : <EOL> errors = self . flushLoggedErrors ( RuntimeError ) <EOL> self . assertEquals ( len ( errors ) , <NUM_LIT:1> ) <EOL> self . assertEquals ( errors [ <NUM_LIT:0> ] . value . args [ <NUM_LIT:0> ] , "<STR_LIT>" ) <EOL> d . addCallback ( cbFailed ) <EOL> return d <EOL> def test_closeLogError ( self ) : <EOL> """<STR_LIT>""" <EOL> class ConnectionCloseRaise ( object ) : <EOL> def close ( self ) : <EOL> raise RuntimeError ( "<STR_LIT>" ) <EOL> pool = DummyConnectionPool ( ) <EOL> pool . _close ( ConnectionCloseRaise ( ) ) <EOL> errors = self . flushLoggedErrors ( RuntimeError ) <EOL> self . assertEquals ( len ( errors ) , <NUM_LIT:1> ) <EOL> self . assertEquals ( errors [ <NUM_LIT:0> ] . value . args [ <NUM_LIT:0> ] , "<STR_LIT>" ) <EOL> def test_runWithInteractionRaiseOriginalError ( self ) : <EOL> """<STR_LIT>""" <EOL> class ConnectionRollbackRaise ( object ) : <EOL> def __init__ ( self , pool ) : <EOL> pass <EOL> def rollback ( self ) : <EOL> raise RuntimeError ( "<STR_LIT>" ) <EOL> class DummyTransaction ( object ) : <EOL> def __init__ ( self , pool , connection ) : <EOL> pass <EOL> def raisingFunction ( transaction ) : <EOL> raise ValueError ( "<STR_LIT:foo>" ) <EOL> pool = DummyConnectionPool ( ) <EOL> pool . connectionFactory = ConnectionRollbackRaise <EOL> pool . transactionFactory = DummyTransaction <EOL> d = pool . runInteraction ( raisingFunction ) <EOL> d = self . assertFailure ( d , ValueError ) <EOL> def cbFailed ( ignored ) : <EOL> errors = self . flushLoggedErrors ( RuntimeError ) <EOL> self . assertEquals ( len ( errors ) , <NUM_LIT:1> ) <EOL> self . assertEquals ( errors [ <NUM_LIT:0> ] . value . args [ <NUM_LIT:0> ] , "<STR_LIT>" ) <EOL> d . addCallback ( cbFailed ) <EOL> return d <EOL> def test_unstartedClose ( self ) : <EOL> """<STR_LIT>""" <EOL> reactor = EventReactor ( False ) <EOL> pool = ConnectionPool ( '<STR_LIT>' , cp_reactor = reactor ) <EOL> self . assertEquals ( reactor . triggers , [ ( '<STR_LIT>' , '<STR_LIT>' , pool . _start ) ] ) <EOL> pool . close ( ) <EOL> self . assertFalse ( reactor . triggers ) <EOL> def test_startedClose ( self ) : <EOL> """<STR_LIT>""" <EOL> reactor = EventReactor ( True ) <EOL> pool = ConnectionPool ( '<STR_LIT>' , cp_reactor = reactor ) <EOL> self . assertEquals ( reactor . triggers , [ ( '<STR_LIT>' , '<STR_LIT>' , pool . finalClose ) ] ) <EOL> pool . close ( ) <EOL> self . assertFalse ( reactor . triggers ) </s>

"""<STR_LIT>""" <EOL> import os <EOL> import sys <EOL> import time <EOL> from twisted . trial import unittest <EOL> from twisted . internet import reactor , protocol , error , abstract , defer <EOL> from twisted . internet import interfaces , base <EOL> try : <EOL> from twisted . internet import ssl <EOL> except ImportError : <EOL> ssl = None <EOL> if ssl and not ssl . supported : <EOL> ssl = None <EOL> from twisted . internet . defer import Deferred , maybeDeferred <EOL> from twisted . python import util , runtime <EOL> class ThreePhaseEventTests ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> """<STR_LIT>""" <EOL> self . trigger = lambda x : None <EOL> self . arg = object ( ) <EOL> self . event = base . _ThreePhaseEvent ( ) <EOL> def test_addInvalidPhase ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertRaises ( <EOL> KeyError , <EOL> self . event . addTrigger , '<STR_LIT>' , self . trigger , self . arg ) <EOL> def test_addBeforeTrigger ( self ) : <EOL> """<STR_LIT>""" <EOL> self . event . addTrigger ( '<STR_LIT>' , self . trigger , self . arg ) <EOL> self . assertEqual ( <EOL> self . event . before , <EOL> [ ( self . trigger , ( self . arg , ) , { } ) ] ) <EOL> def test_addDuringTrigger ( self ) : <EOL> """<STR_LIT>""" <EOL> self . event . addTrigger ( '<STR_LIT>' , self . trigger , self . arg ) <EOL> self . assertEqual ( <EOL> self . event . during , <EOL> [ ( self . trigger , ( self . arg , ) , { } ) ] ) <EOL> def test_addAfterTrigger ( self ) : <EOL> """<STR_LIT>""" <EOL> self . event . addTrigger ( '<STR_LIT>' , self . trigger , self . arg ) <EOL> self . assertEqual ( <EOL> self . event . after , <EOL> [ ( self . trigger , ( self . arg , ) , { } ) ] ) <EOL> def test_removeTrigger ( self ) : <EOL> """<STR_LIT>""" <EOL> handle = self . event . addTrigger ( '<STR_LIT>' , self . trigger , self . arg ) <EOL> self . event . removeTrigger ( handle ) <EOL> self . assertEqual ( self . event . before , [ ] ) <EOL> def test_removeNonexistentTrigger ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertRaises ( ValueError , self . event . removeTrigger , object ( ) ) <EOL> def test_removeRemovedTrigger ( self ) : <EOL> """<STR_LIT>""" <EOL> handle = self . event . addTrigger ( '<STR_LIT>' , self . trigger , self . arg ) <EOL> self . event . removeTrigger ( handle ) <EOL> self . assertRaises ( ValueError , self . event . removeTrigger , handle ) <EOL> def test_removeAlmostValidTrigger ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertRaises ( <EOL> KeyError , <EOL> self . event . removeTrigger , ( '<STR_LIT>' , self . trigger , ( self . arg , ) , { } ) ) <EOL> def test_fireEvent ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . assertEqual ( events , [ ] ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , <EOL> [ ( '<STR_LIT>' , '<STR_LIT>' ) , ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) , ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) , ( '<STR_LIT>' , '<STR_LIT>' ) ] ) <EOL> def test_asynchronousBefore ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> beforeResult = Deferred ( ) <EOL> self . event . addTrigger ( '<STR_LIT>' , lambda : beforeResult ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . assertEqual ( events , [ ] ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , [ ] ) <EOL> beforeResult . callback ( None ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> def test_beforeTriggerException ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> class DummyException ( Exception ) : <EOL> pass <EOL> def raisingTrigger ( ) : <EOL> raise DummyException ( ) <EOL> self . event . addTrigger ( '<STR_LIT>' , raisingTrigger ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> errors = self . flushLoggedErrors ( DummyException ) <EOL> self . assertEqual ( len ( errors ) , <NUM_LIT:1> ) <EOL> def test_duringTriggerException ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> class DummyException ( Exception ) : <EOL> pass <EOL> def raisingTrigger ( ) : <EOL> raise DummyException ( ) <EOL> self . event . addTrigger ( '<STR_LIT>' , raisingTrigger ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> errors = self . flushLoggedErrors ( DummyException ) <EOL> self . assertEqual ( len ( errors ) , <NUM_LIT:1> ) <EOL> def test_synchronousRemoveAlreadyExecutedBefore ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> def removeTrigger ( ) : <EOL> self . event . removeTrigger ( beforeHandle ) <EOL> beforeHandle = self . event . addTrigger ( '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . addTrigger ( '<STR_LIT>' , removeTrigger ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . assertWarns ( <EOL> DeprecationWarning , <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" , <EOL> __file__ , <EOL> self . event . fireEvent ) <EOL> self . assertEqual ( events , [ ( '<STR_LIT>' , '<STR_LIT>' ) , ( '<STR_LIT>' , '<STR_LIT>' ) ] ) <EOL> def test_synchronousRemovePendingBefore ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> self . event . addTrigger ( <EOL> '<STR_LIT>' , lambda : self . event . removeTrigger ( beforeHandle ) ) <EOL> beforeHandle = self . event . addTrigger ( <EOL> '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , [ ( '<STR_LIT>' , '<STR_LIT>' ) ] ) <EOL> def test_synchronousBeforeRemovesDuring ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> self . event . addTrigger ( <EOL> '<STR_LIT>' , lambda : self . event . removeTrigger ( duringHandle ) ) <EOL> duringHandle = self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' ] ) <EOL> def test_asynchronousBeforeRemovesDuring ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> beforeResult = Deferred ( ) <EOL> self . event . addTrigger ( '<STR_LIT>' , lambda : beforeResult ) <EOL> duringHandle = self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . fireEvent ( ) <EOL> self . event . removeTrigger ( duringHandle ) <EOL> beforeResult . callback ( None ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' ] ) <EOL> def test_synchronousBeforeRemovesConspicuouslySimilarDuring ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> def trigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , trigger ) <EOL> self . event . addTrigger ( <EOL> '<STR_LIT>' , lambda : self . event . removeTrigger ( duringTrigger ) ) <EOL> duringTrigger = self . event . addTrigger ( '<STR_LIT>' , trigger ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' ] ) <EOL> def test_synchronousRemovePendingDuring ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> self . event . addTrigger ( <EOL> '<STR_LIT>' , lambda : self . event . removeTrigger ( duringHandle ) ) <EOL> duringHandle = self . event . addTrigger ( <EOL> '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . addTrigger ( <EOL> '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , [ ( '<STR_LIT>' , '<STR_LIT>' ) ] ) <EOL> def test_triggersRunOnce ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . fireEvent ( ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> def test_finishedBeforeTriggersCleared ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> def duringTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> self . assertEqual ( self . event . finishedBefore , [ ] ) <EOL> self . assertEqual ( self . event . state , '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , duringTrigger ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> class SystemEventTestCase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> """<STR_LIT>""" <EOL> self . triggers = [ ] <EOL> def tearDown ( self ) : <EOL> """<STR_LIT>""" <EOL> while self . triggers : <EOL> trigger = self . triggers . pop ( ) <EOL> try : <EOL> reactor . removeSystemEventTrigger ( trigger ) <EOL> except ( ValueError , KeyError ) : <EOL> pass <EOL> def addTrigger ( self , event , phase , func ) : <EOL> """<STR_LIT>""" <EOL> t = reactor . addSystemEventTrigger ( event , phase , func ) <EOL> self . triggers . append ( t ) <EOL> return t <EOL> def removeTrigger ( self , trigger ) : <EOL> """<STR_LIT>""" <EOL> reactor . removeSystemEventTrigger ( trigger ) <EOL> self . triggers . remove ( trigger ) <EOL> def _addSystemEventTriggerTest ( self , phase ) : <EOL> eventType = '<STR_LIT:test>' <EOL> events = [ ] <EOL> def trigger ( ) : <EOL> events . append ( None ) <EOL> self . addTrigger ( phase , eventType , trigger ) <EOL> self . assertEqual ( events , [ ] ) <EOL> reactor . fireSystemEvent ( eventType ) <EOL> self . assertEqual ( events , [ None ] ) <EOL> def test_beforePhase ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _addSystemEventTriggerTest ( '<STR_LIT>' ) <EOL> def test_duringPhase ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _addSystemEventTriggerTest ( '<STR_LIT>' ) <EOL> def test_afterPhase ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _addSystemEventTriggerTest ( '<STR_LIT>' ) <EOL> def test_unknownPhase ( self ) : <EOL> """<STR_LIT>""" <EOL> eventType = '<STR_LIT:test>' <EOL> self . assertRaises ( <EOL> KeyError , self . addTrigger , '<STR_LIT>' , eventType , lambda : None ) <EOL> def test_beforePreceedsDuring ( self ) : <EOL> """<STR_LIT>""" <EOL> eventType = '<STR_LIT:test>' <EOL> events = [ ] <EOL> def beforeTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> def duringTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , beforeTrigger ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , duringTrigger ) <EOL> self . assertEqual ( events , [ ] ) <EOL> reactor . fireSystemEvent ( eventType ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> def test_duringPreceedsAfter ( self ) : <EOL> """<STR_LIT>""" <EOL> eventType = '<STR_LIT:test>' <EOL> events = [ ] <EOL> def duringTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> def afterTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , duringTrigger ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , afterTrigger ) <EOL> self . assertEqual ( events , [ ] ) <EOL> reactor . fireSystemEvent ( eventType ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> def test_beforeReturnsDeferred ( self ) : <EOL> """<STR_LIT>""" <EOL> triggerDeferred = Deferred ( ) <EOL> eventType = '<STR_LIT:test>' <EOL> events = [ ] <EOL> def beforeTrigger ( ) : <EOL> return triggerDeferred <EOL> def duringTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , beforeTrigger ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , duringTrigger ) <EOL> self . assertEqual ( events , [ ] ) <EOL> reactor . fireSystemEvent ( eventType ) <EOL> self . assertEqual ( events , [ ] ) <EOL> triggerDeferred . callback ( None ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' ] ) <EOL> def test_multipleBeforeReturnDeferred ( self ) : <EOL> """<STR_LIT>""" <EOL> firstDeferred = Deferred ( ) <EOL> secondDeferred = Deferred ( ) <EOL> eventType = '<STR_LIT:test>' <EOL> events = [ ] <EOL> def firstBeforeTrigger ( ) : <EOL> return firstDeferred <EOL> def secondBeforeTrigger ( ) : <EOL> return secondDeferred <EOL> def duringTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , firstBeforeTrigger ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , secondBeforeTrigger ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , duringTrigger ) <EOL> self . assertEqual ( events , [ ] ) <EOL> reactor . fireSystemEvent ( eventType ) <EOL> self . assertEqual ( events , [ ] ) <EOL> firstDeferred . callback ( None ) <EOL> self . assertEqual ( events , [ ] ) <EOL> secondDeferred . callback ( None ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' ] ) <EOL> def test_subsequentBeforeTriggerFiresPriorBeforeDeferred ( self ) : <EOL> """<STR_LIT>""" <EOL> eventType = '<STR_LIT:test>' <EOL> events = [ ] <EOL> firstDeferred = Deferred ( ) <EOL> secondDeferred = Deferred ( ) <EOL> def firstBeforeTrigger ( ) : <EOL> return firstDeferred <EOL> def secondBeforeTrigger ( ) : <EOL> firstDeferred . callback ( None ) <EOL> def thirdBeforeTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> return secondDeferred <EOL> def duringTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , firstBeforeTrigger ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , secondBeforeTrigger ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , thirdBeforeTrigger ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , duringTrigger ) <EOL> self . assertEqual ( events , [ ] ) <EOL> reactor . fireSystemEvent ( eventType ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' ] ) <EOL> secondDeferred . callback ( None ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> def test_removeSystemEventTrigger ( self ) : <EOL> """<STR_LIT>""" <EOL> eventType = '<STR_LIT:test>' <EOL> events = [ ] <EOL> def firstBeforeTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> def secondBeforeTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , firstBeforeTrigger ) <EOL> self . removeTrigger ( <EOL> self . addTrigger ( '<STR_LIT>' , eventType , secondBeforeTrigger ) ) <EOL> self . assertEqual ( events , [ ] ) <EOL> reactor . fireSystemEvent ( eventType ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' ] ) <EOL> def test_removeNonExistentSystemEventTrigger ( self ) : <EOL> """<STR_LIT>""" <EOL> b = self . addTrigger ( '<STR_LIT>' , '<STR_LIT:test>' , lambda : None ) <EOL> self . removeTrigger ( b ) <EOL> self . assertRaises ( <EOL> TypeError , reactor . removeSystemEventTrigger , None ) <EOL> self . assertRaises ( <EOL> ValueError , reactor . removeSystemEventTrigger , b ) <EOL> self . assertRaises ( <EOL> KeyError , <EOL> reactor . removeSystemEventTrigger , <EOL> ( b [ <NUM_LIT:0> ] , ( '<STR_LIT>' , ) + b [ <NUM_LIT:1> ] [ <NUM_LIT:1> : ] ) ) <EOL> def test_interactionBetweenDifferentEvents ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> firstEvent = '<STR_LIT>' <EOL> firstDeferred = Deferred ( ) <EOL> def beforeFirstEvent ( ) : <EOL> events . append ( ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> return firstDeferred <EOL> def afterFirstEvent ( ) : <EOL> events . append ( ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> secondEvent = '<STR_LIT>' <EOL> secondDeferred = Deferred ( ) <EOL> def beforeSecondEvent ( ) : <EOL> events . append ( ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> return secondDeferred <EOL> def afterSecondEvent ( ) : <EOL> events . append ( ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . addTrigger ( '<STR_LIT>' , firstEvent , beforeFirstEvent ) <EOL> self . addTrigger ( '<STR_LIT>' , firstEvent , afterFirstEvent ) <EOL> self . addTrigger ( '<STR_LIT>' , secondEvent , beforeSecondEvent ) <EOL> self . addTrigger ( '<STR_LIT>' , secondEvent , afterSecondEvent ) <EOL> self . assertEqual ( events , [ ] ) <EOL> reactor . fireSystemEvent ( firstEvent ) <EOL> self . assertEqual ( events , [ ( '<STR_LIT>' , '<STR_LIT>' ) ] ) <EOL> reactor . fireSystemEvent ( secondEvent ) <EOL> self . assertEqual ( events , [ ( '<STR_LIT>' , '<STR_LIT>' ) , ( '<STR_LIT>' , '<STR_LIT>' ) ] ) <EOL> firstDeferred . callback ( None ) <EOL> self . assertEqual ( events , [ ( '<STR_LIT>' , '<STR_LIT>' ) , ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) ] ) <EOL> secondDeferred . callback ( None ) <EOL> self . assertEqual ( events , [ ( '<STR_LIT>' , '<STR_LIT>' ) , ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) , ( '<STR_LIT>' , '<STR_LIT>' ) ] ) <EOL> class TimeTestCase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_seconds ( self ) : <EOL> """<STR_LIT>""" <EOL> now = reactor . seconds ( ) <EOL> self . assertEquals ( now - now + now , now ) <EOL> def test_callLaterUsesReactorSecondsInDelayedCall ( self ) : <EOL> """<STR_LIT>""" <EOL> oseconds = reactor . seconds <EOL> reactor . seconds = lambda : <NUM_LIT:100> <EOL> try : <EOL> call = reactor . callLater ( <NUM_LIT:5> , lambda : None ) <EOL> self . assertEquals ( call . getTime ( ) , <NUM_LIT> ) <EOL> finally : <EOL> reactor . seconds = oseconds <EOL> def test_callLaterUsesReactorSecondsAsDelayedCallSecondsFactory ( self ) : <EOL> """<STR_LIT>""" <EOL> oseconds = reactor . seconds <EOL> reactor . seconds = lambda : <NUM_LIT:100> <EOL> try : <EOL> call = reactor . callLater ( <NUM_LIT:5> , lambda : None ) <EOL> self . assertEquals ( call . seconds ( ) , <NUM_LIT:100> ) <EOL> finally : <EOL> reactor . seconds = oseconds <EOL> def test_callLater ( self ) : <EOL> """<STR_LIT>""" <EOL> d = Deferred ( ) <EOL> reactor . callLater ( <NUM_LIT:0> , d . callback , None ) <EOL> d . addCallback ( self . assertEqual , None ) <EOL> return d <EOL> def test_cancelDelayedCall ( self ) : <EOL> """<STR_LIT>""" <EOL> called = [ ] <EOL> def function ( ) : <EOL> called . append ( None ) <EOL> call = reactor . callLater ( <NUM_LIT:0> , function ) <EOL> call . cancel ( ) <EOL> d = Deferred ( ) <EOL> def check ( ) : <EOL> try : <EOL> self . assertEqual ( called , [ ] ) <EOL> except : <EOL> d . errback ( ) <EOL> else : <EOL> d . callback ( None ) <EOL> reactor . callLater ( <NUM_LIT:0> , reactor . callLater , <NUM_LIT:0> , check ) <EOL> return d <EOL> def test_cancelCancelledDelayedCall ( self ) : <EOL> """<STR_LIT>""" <EOL> call = reactor . callLater ( <NUM_LIT:0> , lambda : None ) <EOL> call . cancel ( ) <EOL> self . assertRaises ( error . AlreadyCancelled , call . cancel ) <EOL> def test_cancelCalledDelayedCallSynchronous ( self ) : <EOL> """<STR_LIT>""" <EOL> d = Deferred ( ) <EOL> def later ( ) : <EOL> try : <EOL> self . assertRaises ( error . AlreadyCalled , call . cancel ) <EOL> except : <EOL> d . errback ( ) <EOL> else : <EOL> d . callback ( None ) <EOL> call = reactor . callLater ( <NUM_LIT:0> , later ) <EOL> return d <EOL> def test_cancelCalledDelayedCallAsynchronous ( self ) : <EOL> """<STR_LIT>""" <EOL> d = Deferred ( ) <EOL> def check ( ) : <EOL> try : <EOL> self . assertRaises ( error . AlreadyCalled , call . cancel ) <EOL> except : <EOL> d . errback ( ) <EOL> else : <EOL> d . callback ( None ) <EOL> def later ( ) : <EOL> reactor . callLater ( <NUM_LIT:0> , check ) <EOL> call = reactor . callLater ( <NUM_LIT:0> , later ) <EOL> return d <EOL> def testCallLaterTime ( self ) : <EOL> d = reactor . callLater ( <NUM_LIT:10> , lambda : None ) <EOL> try : <EOL> self . failUnless ( d . getTime ( ) - ( time . time ( ) + <NUM_LIT:10> ) < <NUM_LIT:1> ) <EOL> finally : <EOL> d . cancel ( ) <EOL> def testCallLaterOrder ( self ) : <EOL> l = [ ] <EOL> l2 = [ ] <EOL> def f ( x ) : <EOL> l . append ( x ) <EOL> def f2 ( x ) : <EOL> l2 . append ( x ) <EOL> def done ( ) : <EOL> self . assertEquals ( l , range ( <NUM_LIT:20> ) ) <EOL> def done2 ( ) : <EOL> self . assertEquals ( l2 , range ( <NUM_LIT:10> ) ) <EOL> for n in range ( <NUM_LIT:10> ) : <EOL> reactor . callLater ( <NUM_LIT:0> , f , n ) <EOL> for n in range ( <NUM_LIT:10> ) : <EOL> reactor . callLater ( <NUM_LIT:0> , f , n + <NUM_LIT:10> )

reactor . callLater ( <NUM_LIT:0.1> , f2 , n )

"""<STR_LIT>""" <EOL> import os <EOL> import sys <EOL> import time <EOL> from twisted . trial import unittest <EOL> from twisted . internet import reactor , protocol , error , abstract , defer <EOL> from twisted . internet import interfaces , base <EOL> try : <EOL> from twisted . internet import ssl <EOL> except ImportError : <EOL> ssl = None <EOL> if ssl and not ssl . supported : <EOL> ssl = None <EOL> from twisted . internet . defer import Deferred , maybeDeferred <EOL> from twisted . python import util , runtime <EOL> class ThreePhaseEventTests ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> """<STR_LIT>""" <EOL> self . trigger = lambda x : None <EOL> self . arg = object ( ) <EOL> self . event = base . _ThreePhaseEvent ( ) <EOL> def test_addInvalidPhase ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertRaises ( <EOL> KeyError , <EOL> self . event . addTrigger , '<STR_LIT>' , self . trigger , self . arg ) <EOL> def test_addBeforeTrigger ( self ) : <EOL> """<STR_LIT>""" <EOL> self . event . addTrigger ( '<STR_LIT>' , self . trigger , self . arg ) <EOL> self . assertEqual ( <EOL> self . event . before , <EOL> [ ( self . trigger , ( self . arg , ) , { } ) ] ) <EOL> def test_addDuringTrigger ( self ) : <EOL> """<STR_LIT>""" <EOL> self . event . addTrigger ( '<STR_LIT>' , self . trigger , self . arg ) <EOL> self . assertEqual ( <EOL> self . event . during , <EOL> [ ( self . trigger , ( self . arg , ) , { } ) ] ) <EOL> def test_addAfterTrigger ( self ) : <EOL> """<STR_LIT>""" <EOL> self . event . addTrigger ( '<STR_LIT>' , self . trigger , self . arg ) <EOL> self . assertEqual ( <EOL> self . event . after , <EOL> [ ( self . trigger , ( self . arg , ) , { } ) ] ) <EOL> def test_removeTrigger ( self ) : <EOL> """<STR_LIT>""" <EOL> handle = self . event . addTrigger ( '<STR_LIT>' , self . trigger , self . arg ) <EOL> self . event . removeTrigger ( handle ) <EOL> self . assertEqual ( self . event . before , [ ] ) <EOL> def test_removeNonexistentTrigger ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertRaises ( ValueError , self . event . removeTrigger , object ( ) ) <EOL> def test_removeRemovedTrigger ( self ) : <EOL> """<STR_LIT>""" <EOL> handle = self . event . addTrigger ( '<STR_LIT>' , self . trigger , self . arg ) <EOL> self . event . removeTrigger ( handle ) <EOL> self . assertRaises ( ValueError , self . event . removeTrigger , handle ) <EOL> def test_removeAlmostValidTrigger ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertRaises ( <EOL> KeyError , <EOL> self . event . removeTrigger , ( '<STR_LIT>' , self . trigger , ( self . arg , ) , { } ) ) <EOL> def test_fireEvent ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . assertEqual ( events , [ ] ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , <EOL> [ ( '<STR_LIT>' , '<STR_LIT>' ) , ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) , ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) , ( '<STR_LIT>' , '<STR_LIT>' ) ] ) <EOL> def test_asynchronousBefore ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> beforeResult = Deferred ( ) <EOL> self . event . addTrigger ( '<STR_LIT>' , lambda : beforeResult ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . assertEqual ( events , [ ] ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , [ ] ) <EOL> beforeResult . callback ( None ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> def test_beforeTriggerException ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> class DummyException ( Exception ) : <EOL> pass <EOL> def raisingTrigger ( ) : <EOL> raise DummyException ( ) <EOL> self . event . addTrigger ( '<STR_LIT>' , raisingTrigger ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> errors = self . flushLoggedErrors ( DummyException ) <EOL> self . assertEqual ( len ( errors ) , <NUM_LIT:1> ) <EOL> def test_duringTriggerException ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> class DummyException ( Exception ) : <EOL> pass <EOL> def raisingTrigger ( ) : <EOL> raise DummyException ( ) <EOL> self . event . addTrigger ( '<STR_LIT>' , raisingTrigger ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> errors = self . flushLoggedErrors ( DummyException ) <EOL> self . assertEqual ( len ( errors ) , <NUM_LIT:1> ) <EOL> def test_synchronousRemoveAlreadyExecutedBefore ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> def removeTrigger ( ) : <EOL> self . event . removeTrigger ( beforeHandle ) <EOL> beforeHandle = self . event . addTrigger ( '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . addTrigger ( '<STR_LIT>' , removeTrigger ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . assertWarns ( <EOL> DeprecationWarning , <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" , <EOL> __file__ , <EOL> self . event . fireEvent ) <EOL> self . assertEqual ( events , [ ( '<STR_LIT>' , '<STR_LIT>' ) , ( '<STR_LIT>' , '<STR_LIT>' ) ] ) <EOL> def test_synchronousRemovePendingBefore ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> self . event . addTrigger ( <EOL> '<STR_LIT>' , lambda : self . event . removeTrigger ( beforeHandle ) ) <EOL> beforeHandle = self . event . addTrigger ( <EOL> '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , [ ( '<STR_LIT>' , '<STR_LIT>' ) ] ) <EOL> def test_synchronousBeforeRemovesDuring ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> self . event . addTrigger ( <EOL> '<STR_LIT>' , lambda : self . event . removeTrigger ( duringHandle ) ) <EOL> duringHandle = self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' ] ) <EOL> def test_asynchronousBeforeRemovesDuring ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> beforeResult = Deferred ( ) <EOL> self . event . addTrigger ( '<STR_LIT>' , lambda : beforeResult ) <EOL> duringHandle = self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . fireEvent ( ) <EOL> self . event . removeTrigger ( duringHandle ) <EOL> beforeResult . callback ( None ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' ] ) <EOL> def test_synchronousBeforeRemovesConspicuouslySimilarDuring ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> def trigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , trigger ) <EOL> self . event . addTrigger ( <EOL> '<STR_LIT>' , lambda : self . event . removeTrigger ( duringTrigger ) ) <EOL> duringTrigger = self . event . addTrigger ( '<STR_LIT>' , trigger ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' ] ) <EOL> def test_synchronousRemovePendingDuring ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> self . event . addTrigger ( <EOL> '<STR_LIT>' , lambda : self . event . removeTrigger ( duringHandle ) ) <EOL> duringHandle = self . event . addTrigger ( <EOL> '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . addTrigger ( <EOL> '<STR_LIT>' , events . append , ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , [ ( '<STR_LIT>' , '<STR_LIT>' ) ] ) <EOL> def test_triggersRunOnce ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . fireEvent ( ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> def test_finishedBeforeTriggersCleared ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> def duringTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> self . assertEqual ( self . event . finishedBefore , [ ] ) <EOL> self . assertEqual ( self . event . state , '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , events . append , '<STR_LIT>' ) <EOL> self . event . addTrigger ( '<STR_LIT>' , duringTrigger ) <EOL> self . event . fireEvent ( ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> class SystemEventTestCase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> """<STR_LIT>""" <EOL> self . triggers = [ ] <EOL> def tearDown ( self ) : <EOL> """<STR_LIT>""" <EOL> while self . triggers : <EOL> trigger = self . triggers . pop ( ) <EOL> try : <EOL> reactor . removeSystemEventTrigger ( trigger ) <EOL> except ( ValueError , KeyError ) : <EOL> pass <EOL> def addTrigger ( self , event , phase , func ) : <EOL> """<STR_LIT>""" <EOL> t = reactor . addSystemEventTrigger ( event , phase , func ) <EOL> self . triggers . append ( t ) <EOL> return t <EOL> def removeTrigger ( self , trigger ) : <EOL> """<STR_LIT>""" <EOL> reactor . removeSystemEventTrigger ( trigger ) <EOL> self . triggers . remove ( trigger ) <EOL> def _addSystemEventTriggerTest ( self , phase ) : <EOL> eventType = '<STR_LIT:test>' <EOL> events = [ ] <EOL> def trigger ( ) : <EOL> events . append ( None ) <EOL> self . addTrigger ( phase , eventType , trigger ) <EOL> self . assertEqual ( events , [ ] ) <EOL> reactor . fireSystemEvent ( eventType ) <EOL> self . assertEqual ( events , [ None ] ) <EOL> def test_beforePhase ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _addSystemEventTriggerTest ( '<STR_LIT>' ) <EOL> def test_duringPhase ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _addSystemEventTriggerTest ( '<STR_LIT>' ) <EOL> def test_afterPhase ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _addSystemEventTriggerTest ( '<STR_LIT>' ) <EOL> def test_unknownPhase ( self ) : <EOL> """<STR_LIT>""" <EOL> eventType = '<STR_LIT:test>' <EOL> self . assertRaises ( <EOL> KeyError , self . addTrigger , '<STR_LIT>' , eventType , lambda : None ) <EOL> def test_beforePreceedsDuring ( self ) : <EOL> """<STR_LIT>""" <EOL> eventType = '<STR_LIT:test>' <EOL> events = [ ] <EOL> def beforeTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> def duringTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , beforeTrigger ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , duringTrigger ) <EOL> self . assertEqual ( events , [ ] ) <EOL> reactor . fireSystemEvent ( eventType ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> def test_duringPreceedsAfter ( self ) : <EOL> """<STR_LIT>""" <EOL> eventType = '<STR_LIT:test>' <EOL> events = [ ] <EOL> def duringTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> def afterTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , duringTrigger ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , afterTrigger ) <EOL> self . assertEqual ( events , [ ] ) <EOL> reactor . fireSystemEvent ( eventType ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> def test_beforeReturnsDeferred ( self ) : <EOL> """<STR_LIT>""" <EOL> triggerDeferred = Deferred ( ) <EOL> eventType = '<STR_LIT:test>' <EOL> events = [ ] <EOL> def beforeTrigger ( ) : <EOL> return triggerDeferred <EOL> def duringTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , beforeTrigger ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , duringTrigger ) <EOL> self . assertEqual ( events , [ ] ) <EOL> reactor . fireSystemEvent ( eventType ) <EOL> self . assertEqual ( events , [ ] ) <EOL> triggerDeferred . callback ( None ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' ] ) <EOL> def test_multipleBeforeReturnDeferred ( self ) : <EOL> """<STR_LIT>""" <EOL> firstDeferred = Deferred ( ) <EOL> secondDeferred = Deferred ( ) <EOL> eventType = '<STR_LIT:test>' <EOL> events = [ ] <EOL> def firstBeforeTrigger ( ) : <EOL> return firstDeferred <EOL> def secondBeforeTrigger ( ) : <EOL> return secondDeferred <EOL> def duringTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , firstBeforeTrigger ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , secondBeforeTrigger ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , duringTrigger ) <EOL> self . assertEqual ( events , [ ] ) <EOL> reactor . fireSystemEvent ( eventType ) <EOL> self . assertEqual ( events , [ ] ) <EOL> firstDeferred . callback ( None ) <EOL> self . assertEqual ( events , [ ] ) <EOL> secondDeferred . callback ( None ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' ] ) <EOL> def test_subsequentBeforeTriggerFiresPriorBeforeDeferred ( self ) : <EOL> """<STR_LIT>""" <EOL> eventType = '<STR_LIT:test>' <EOL> events = [ ] <EOL> firstDeferred = Deferred ( ) <EOL> secondDeferred = Deferred ( ) <EOL> def firstBeforeTrigger ( ) : <EOL> return firstDeferred <EOL> def secondBeforeTrigger ( ) : <EOL> firstDeferred . callback ( None ) <EOL> def thirdBeforeTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> return secondDeferred <EOL> def duringTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , firstBeforeTrigger ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , secondBeforeTrigger ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , thirdBeforeTrigger ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , duringTrigger ) <EOL> self . assertEqual ( events , [ ] ) <EOL> reactor . fireSystemEvent ( eventType ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' ] ) <EOL> secondDeferred . callback ( None ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> def test_removeSystemEventTrigger ( self ) : <EOL> """<STR_LIT>""" <EOL> eventType = '<STR_LIT:test>' <EOL> events = [ ] <EOL> def firstBeforeTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> def secondBeforeTrigger ( ) : <EOL> events . append ( '<STR_LIT>' ) <EOL> self . addTrigger ( '<STR_LIT>' , eventType , firstBeforeTrigger ) <EOL> self . removeTrigger ( <EOL> self . addTrigger ( '<STR_LIT>' , eventType , secondBeforeTrigger ) ) <EOL> self . assertEqual ( events , [ ] ) <EOL> reactor . fireSystemEvent ( eventType ) <EOL> self . assertEqual ( events , [ '<STR_LIT>' ] ) <EOL> def test_removeNonExistentSystemEventTrigger ( self ) : <EOL> """<STR_LIT>""" <EOL> b = self . addTrigger ( '<STR_LIT>' , '<STR_LIT:test>' , lambda : None ) <EOL> self . removeTrigger ( b ) <EOL> self . assertRaises ( <EOL> TypeError , reactor . removeSystemEventTrigger , None ) <EOL> self . assertRaises ( <EOL> ValueError , reactor . removeSystemEventTrigger , b ) <EOL> self . assertRaises ( <EOL> KeyError , <EOL> reactor . removeSystemEventTrigger , <EOL> ( b [ <NUM_LIT:0> ] , ( '<STR_LIT>' , ) + b [ <NUM_LIT:1> ] [ <NUM_LIT:1> : ] ) ) <EOL> def test_interactionBetweenDifferentEvents ( self ) : <EOL> """<STR_LIT>""" <EOL> events = [ ] <EOL> firstEvent = '<STR_LIT>' <EOL> firstDeferred = Deferred ( ) <EOL> def beforeFirstEvent ( ) : <EOL> events . append ( ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> return firstDeferred <EOL> def afterFirstEvent ( ) : <EOL> events . append ( ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> secondEvent = '<STR_LIT>' <EOL> secondDeferred = Deferred ( ) <EOL> def beforeSecondEvent ( ) : <EOL> events . append ( ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> return secondDeferred <EOL> def afterSecondEvent ( ) : <EOL> events . append ( ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . addTrigger ( '<STR_LIT>' , firstEvent , beforeFirstEvent ) <EOL> self . addTrigger ( '<STR_LIT>' , firstEvent , afterFirstEvent ) <EOL> self . addTrigger ( '<STR_LIT>' , secondEvent , beforeSecondEvent ) <EOL> self . addTrigger ( '<STR_LIT>' , secondEvent , afterSecondEvent ) <EOL> self . assertEqual ( events , [ ] ) <EOL> reactor . fireSystemEvent ( firstEvent ) <EOL> self . assertEqual ( events , [ ( '<STR_LIT>' , '<STR_LIT>' ) ] ) <EOL> reactor . fireSystemEvent ( secondEvent ) <EOL> self . assertEqual ( events , [ ( '<STR_LIT>' , '<STR_LIT>' ) , ( '<STR_LIT>' , '<STR_LIT>' ) ] ) <EOL> firstDeferred . callback ( None ) <EOL> self . assertEqual ( events , [ ( '<STR_LIT>' , '<STR_LIT>' ) , ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) ] ) <EOL> secondDeferred . callback ( None ) <EOL> self . assertEqual ( events , [ ( '<STR_LIT>' , '<STR_LIT>' ) , ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) , ( '<STR_LIT>' , '<STR_LIT>' ) ] ) <EOL> class TimeTestCase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_seconds ( self ) : <EOL> """<STR_LIT>""" <EOL> now = reactor . seconds ( ) <EOL> self . assertEquals ( now - now + now , now ) <EOL> def test_callLaterUsesReactorSecondsInDelayedCall ( self ) : <EOL> """<STR_LIT>""" <EOL> oseconds = reactor . seconds <EOL> reactor . seconds = lambda : <NUM_LIT:100> <EOL> try : <EOL> call = reactor . callLater ( <NUM_LIT:5> , lambda : None ) <EOL> self . assertEquals ( call . getTime ( ) , <NUM_LIT> ) <EOL> finally : <EOL> reactor . seconds = oseconds <EOL> def test_callLaterUsesReactorSecondsAsDelayedCallSecondsFactory ( self ) : <EOL> """<STR_LIT>""" <EOL> oseconds = reactor . seconds <EOL> reactor . seconds = lambda : <NUM_LIT:100> <EOL> try : <EOL> call = reactor . callLater ( <NUM_LIT:5> , lambda : None ) <EOL> self . assertEquals ( call . seconds ( ) , <NUM_LIT:100> ) <EOL> finally : <EOL> reactor . seconds = oseconds <EOL> def test_callLater ( self ) : <EOL> """<STR_LIT>""" <EOL> d = Deferred ( ) <EOL> reactor . callLater ( <NUM_LIT:0> , d . callback , None ) <EOL> d . addCallback ( self . assertEqual , None ) <EOL> return d <EOL> def test_cancelDelayedCall ( self ) : <EOL> """<STR_LIT>""" <EOL> called = [ ] <EOL> def function ( ) : <EOL> called . append ( None ) <EOL> call = reactor . callLater ( <NUM_LIT:0> , function ) <EOL> call . cancel ( ) <EOL> d = Deferred ( ) <EOL> def check ( ) : <EOL> try : <EOL> self . assertEqual ( called , [ ] ) <EOL> except : <EOL> d . errback ( ) <EOL> else : <EOL> d . callback ( None ) <EOL> reactor . callLater ( <NUM_LIT:0> , reactor . callLater , <NUM_LIT:0> , check ) <EOL> return d <EOL> def test_cancelCancelledDelayedCall ( self ) : <EOL> """<STR_LIT>""" <EOL> call = reactor . callLater ( <NUM_LIT:0> , lambda : None ) <EOL> call . cancel ( ) <EOL> self . assertRaises ( error . AlreadyCancelled , call . cancel ) <EOL> def test_cancelCalledDelayedCallSynchronous ( self ) : <EOL> """<STR_LIT>""" <EOL> d = Deferred ( ) <EOL> def later ( ) : <EOL> try : <EOL> self . assertRaises ( error . AlreadyCalled , call . cancel ) <EOL> except : <EOL> d . errback ( ) <EOL> else : <EOL> d . callback ( None ) <EOL> call = reactor . callLater ( <NUM_LIT:0> , later ) <EOL> return d <EOL> def test_cancelCalledDelayedCallAsynchronous ( self ) : <EOL> """<STR_LIT>""" <EOL> d = Deferred ( ) <EOL> def check ( ) : <EOL> try : <EOL> self . assertRaises ( error . AlreadyCalled , call . cancel ) <EOL> except : <EOL> d . errback ( ) <EOL> else : <EOL> d . callback ( None ) <EOL> def later ( ) : <EOL> reactor . callLater ( <NUM_LIT:0> , check ) <EOL> call = reactor . callLater ( <NUM_LIT:0> , later ) <EOL> return d <EOL> def testCallLaterTime ( self ) : <EOL> d = reactor . callLater ( <NUM_LIT:10> , lambda : None ) <EOL> try : <EOL> self . failUnless ( d . getTime ( ) - ( time . time ( ) + <NUM_LIT:10> ) < <NUM_LIT:1> ) <EOL> finally : <EOL> d . cancel ( ) <EOL> def testCallLaterOrder ( self ) : <EOL> l = [ ] <EOL> l2 = [ ] <EOL> def f ( x ) : <EOL> l . append ( x ) <EOL> def f2 ( x ) : <EOL> l2 . append ( x ) <EOL> def done ( ) : <EOL> self . assertEquals ( l , range ( <NUM_LIT:20> ) ) <EOL> def done2 ( ) : <EOL> self . assertEquals ( l2 , range ( <NUM_LIT:10> ) ) <EOL> for n in range ( <NUM_LIT:10> ) : <EOL> reactor . callLater ( <NUM_LIT:0> , f , n ) <EOL> for n in range ( <NUM_LIT:10> ) : <EOL> reactor . callLater ( <NUM_LIT:0> , f , n + <NUM_LIT:10> ) <EOL> reactor . callLater ( <NUM_LIT:0.1> , f2 , n ) <EOL> reactor . callLater ( <NUM_LIT:0> , done ) <EOL> reactor . callLater ( <NUM_LIT:0.1> , done2 ) <EOL> d = Deferred ( ) <EOL> reactor . callLater ( <NUM_LIT> , d . callback , None ) <EOL> return d <EOL> testCallLaterOrder . todo = "<STR_LIT>" <EOL> testCallLaterOrder . skip = "<STR_LIT>" <EOL> def testCallLaterOrder2 ( self ) : <EOL> def seconds ( ) : <EOL> return int ( time . time ( ) ) <EOL> base_original = base . seconds <EOL> runtime_original = runtime . seconds <EOL> base . seconds = seconds <EOL> runtime . seconds = seconds <EOL> def cleanup ( x ) : <EOL> runtime . seconds = runtime_original <EOL> base . seconds = base_original <EOL> return x <EOL> return maybeDeferred ( self . testCallLaterOrder ) . addBoth ( cleanup ) <EOL> testCallLaterOrder2 . todo = "<STR_LIT>" <EOL> testCallLaterOrder2 . skip = "<STR_LIT>" <EOL> def testDelayedCallStringification ( self ) : <EOL> dc = reactor . callLater ( <NUM_LIT:0> , lambda x , y : None , '<STR_LIT:x>' , y = <NUM_LIT:10> ) <EOL> str ( dc ) <EOL> dc . reset ( <NUM_LIT:5> ) <EOL> str ( dc ) <EOL> dc . cancel ( ) <EOL> str ( dc ) <EOL> dc = reactor . callLater ( <NUM_LIT:0> , lambda : None , x = [ ( { '<STR_LIT:hello>' : u'<STR_LIT>' } , <NUM_LIT> ) , reactor ] , * range ( <NUM_LIT:10> ) ) <EOL> str ( dc ) <EOL> dc . cancel ( ) <EOL> str ( dc ) <EOL> def calledBack ( ignored ) : <EOL> str ( dc ) <EOL> d = Deferred ( ) . addCallback ( calledBack ) <EOL> dc = reactor . callLater ( <NUM_LIT:0> , d . callback , None ) <EOL> str ( dc ) <EOL> return d <EOL> def testDelayedCallSecondsOverride ( self ) : <EOL> """<STR_LIT>""" <EOL> def seconds ( ) : <EOL> return <NUM_LIT:10> <EOL> dc = base . DelayedCall ( <NUM_LIT:5> , lambda : None , ( ) , { } , lambda dc : None , <EOL> lambda dc : None , seconds ) <EOL> self . assertEquals ( dc . getTime ( ) , <NUM_LIT:5> ) <EOL> dc . reset ( <NUM_LIT:3> ) <EOL> self . assertEquals ( dc . getTime ( ) , <NUM_LIT> ) <EOL> class CallFromThreadTests ( unittest . TestCase ) : <EOL> def testWakeUp ( self ) : <EOL> d = Deferred ( ) <EOL> def wake ( ) : <EOL> time . sleep ( <NUM_LIT:0.1> ) <EOL> reactor . callFromThread ( d . callback , None ) <EOL> reactor . callInThread ( wake ) <EOL> return d <EOL> if interfaces . IReactorThreads ( reactor , None ) is None : <EOL> testWakeUp . skip = "<STR_LIT>" <EOL> def _stopCallFromThreadCallback ( self ) : <EOL> self . stopped = True <EOL> def _callFromThreadCallback ( self , d ) : <EOL> reactor . callFromThread ( self . _callFromThreadCallback2 , d ) <EOL> reactor . callLater ( <NUM_LIT:0> , self . _stopCallFromThreadCallback ) <EOL> def _callFromThreadCallback2 ( self , d ) : <EOL> try : <EOL> self . assert_ ( self . stopped ) <EOL> except : <EOL> d . errback ( ) <EOL> else : <EOL> d . callback ( None ) <EOL> def testCallFromThreadStops ( self ) : <EOL> """<STR_LIT>""" <EOL> self . stopped = False <EOL> d = defer . Deferred ( ) <EOL> reactor . callFromThread ( self . _callFromThreadCallback , d ) <EOL> return d <EOL> class DelayedTestCase ( unittest . TestCase ) : <EOL> def setUp ( self ) : <EOL> self . finished = <NUM_LIT:0> <EOL> self . counter = <NUM_LIT:0> <EOL> self . timers = { } <EOL> self . deferred = defer . Deferred ( ) <EOL> def tearDown ( self ) : <EOL> for t in self . timers . values ( ) : <EOL> t . cancel ( ) <EOL> def checkTimers ( self ) : <EOL> l1 = self . timers . values ( ) <EOL> l2 = list ( reactor . getDelayedCalls ( ) ) <EOL> missing = [ ] <EOL> for dc in l1 : <EOL> if dc not in l2 : <EOL> missing . append ( dc ) <EOL> if missing : <EOL> self . finished = <NUM_LIT:1> <EOL> self . failIf ( missing , "<STR_LIT>" + repr ( missing ) ) <EOL> def callback ( self , tag ) : <EOL> del self . timers [ tag ] <EOL> self . checkTimers ( ) <EOL> def addCallback ( self , tag ) : <EOL> self . callback ( tag ) <EOL> self . addTimer ( <NUM_LIT:15> , self . callback ) <EOL> def done ( self , tag ) : <EOL> self . finished = <NUM_LIT:1> <EOL> self . callback ( tag ) <EOL> self . deferred . callback ( None ) <EOL> def addTimer ( self , when , callback ) : <EOL> self . timers [ self . counter ] = reactor . callLater ( when * <NUM_LIT> , callback , <EOL> self . counter ) <EOL> self . counter += <NUM_LIT:1> <EOL> self . checkTimers ( ) <EOL> def testGetDelayedCalls ( self ) : <EOL> if not hasattr ( reactor , "<STR_LIT>" ) : <EOL> return <EOL> self . checkTimers ( ) <EOL> self . addTimer ( <NUM_LIT> , self . done ) <EOL> self . addTimer ( <NUM_LIT:20> , self . callback ) <EOL> self . addTimer ( <NUM_LIT:30> , self . callback ) <EOL> which = self . counter <EOL> self . addTimer ( <NUM_LIT> , self . callback ) <EOL> self . addTimer ( <NUM_LIT> , self . addCallback ) <EOL> self . addTimer ( <NUM_LIT> , self . callback ) <EOL> self . timers [ which ] . cancel ( ) <EOL> del self . timers [ which ] <EOL> self . checkTimers ( ) <EOL> self . deferred . addCallback ( lambda x : self . checkTimers ( ) ) <EOL> return self . deferred <EOL> def test_active ( self ) : <EOL> """<STR_LIT>""" <EOL> dcall = reactor . callLater ( <NUM_LIT> , self . deferred . callback , True ) <EOL> self . assertEquals ( dcall . active ( ) , True ) <EOL> def checkDeferredCall ( success ) : <EOL> self . assertEquals ( dcall . active ( ) , False ) <EOL> return success <EOL> self . deferred . addCallback ( checkDeferredCall ) <EOL> return self . deferred <EOL> resolve_helper = """<STR_LIT>""" <EOL> class ChildResolveProtocol ( protocol . ProcessProtocol ) : <EOL> def __init__ ( self , onCompletion ) : <EOL> self . onCompletion = onCompletion <EOL> def connectionMade ( self ) : <EOL> self . output = [ ] <EOL> self . error = [ ] <EOL> def outReceived ( self , out ) : <EOL> self . output . append ( out ) <EOL> def errReceived ( self , err ) : <EOL> self . error . append ( err ) <EOL> def processEnded ( self , reason ) : <EOL> self . onCompletion . callback ( ( reason , self . output , self . error ) ) <EOL> self . onCompletion = None <EOL> class Resolve ( unittest . TestCase ) : <EOL> def testChildResolve ( self ) : <EOL> helperPath = os . path . abspath ( self . mktemp ( ) ) <EOL> helperFile = open ( helperPath , '<STR_LIT:w>' ) <EOL> reactorName = reactor . __module__ <EOL> helperFile . write ( resolve_helper % { '<STR_LIT>' : reactorName } ) <EOL> helperFile . close ( ) <EOL> env = os . environ . copy ( ) <EOL> env [ '<STR_LIT>' ] = os . pathsep . join ( sys . path ) <EOL> helperDeferred = Deferred ( ) <EOL> helperProto = ChildResolveProtocol ( helperDeferred ) <EOL> reactor . spawnProcess ( helperProto , sys . executable , ( "<STR_LIT>" , "<STR_LIT>" , helperPath ) , env ) <EOL> def cbFinished ( ( reason , output , error ) ) : <EOL> output = '<STR_LIT>' . join ( output ) <EOL> if output != '<STR_LIT>' : <EOL> self . fail ( ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) % ( reason . getErrorMessage ( ) , output , '<STR_LIT>' . join ( error ) ) ) <EOL> helperDeferred . addCallback ( cbFinished ) <EOL> return helperDeferred <EOL> if not interfaces . IReactorProcess ( reactor , None ) : <EOL> Resolve . skip = "<STR_LIT>" <EOL> class CallFromThreadTestCase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> if interfaces . IReactorThreads ( reactor , None ) is None : <EOL> skip = "<STR_LIT>" <EOL> def setUp ( self ) : <EOL> self . counter = <NUM_LIT:0> <EOL> self . deferred = Deferred ( ) <EOL> def schedule ( self , * args , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> reactor . callFromThread ( * args , ** kwargs ) <EOL> def test_lotsOfThreadsAreScheduledCorrectly ( self ) : <EOL> """<STR_LIT>""" <EOL> def addAndMaybeFinish ( ) : <EOL> self . counter += <NUM_LIT:1> <EOL> if self . counter == <NUM_LIT:100> : <EOL> self . deferred . callback ( True ) <EOL> for i in xrange ( <NUM_LIT:100> ) : <EOL> self . schedule ( addAndMaybeFinish ) <EOL> return self . deferred <EOL> def test_threadsAreRunInScheduledOrder ( self ) : <EOL> """<STR_LIT>""" <EOL> order = [ ] <EOL> def check ( _ ) : <EOL> self . assertEquals ( order , [ <NUM_LIT:1> , <NUM_LIT:2> , <NUM_LIT:3> ] ) <EOL> self . deferred . addCallback ( check ) <EOL> self . schedule ( order . append , <NUM_LIT:1> ) <EOL> self . schedule ( order . append , <NUM_LIT:2> ) <EOL> self . schedule ( order . append , <NUM_LIT:3> ) <EOL> self . schedule ( reactor . callFromThread , self . deferred . callback , None ) <EOL> return self . deferred <EOL> def test_scheduledThreadsNotRunUntilReactorRuns ( self ) : <EOL> """<STR_LIT>""" <EOL> def incAndFinish ( ) : <EOL> self . counter = <NUM_LIT:1> <EOL> self . deferred . callback ( True ) <EOL> self . schedule ( incAndFinish ) <EOL> self . assertEquals ( self . counter , <NUM_LIT:0> ) <EOL> return self . deferred <EOL> class MyProtocol ( protocol . Protocol ) : <EOL> """<STR_LIT>""" <EOL> class MyFactory ( protocol . Factory ) : <EOL> """<STR_LIT>""" <EOL> protocol = MyProtocol <EOL> class ProtocolTestCase ( unittest . TestCase ) : <EOL> def testFactory ( self ) : <EOL> factory = MyFactory ( ) <EOL> protocol = factory . buildProtocol ( None ) <EOL> self . assertEquals ( protocol . factory , factory ) <EOL> self . assert_ ( isinstance ( protocol , factory . protocol ) ) <EOL> class DummyProducer ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self ) : <EOL> self . events = [ ] <EOL> def resumeProducing ( self ) : <EOL> self . events . append ( '<STR_LIT>' ) <EOL> def stopProducing ( self ) : <EOL> self . events . append ( '<STR_LIT>' ) <EOL> def pauseProducing ( self ) : <EOL> self . events . append ( '<STR_LIT>' ) <EOL> class SillyDescriptor ( abstract . FileDescriptor ) : <EOL> """<STR_LIT>""" <EOL> bufferSize = <NUM_LIT:3> <EOL> connected = True <EOL> def writeSomeData ( self , data ) : <EOL> """<STR_LIT>""" <EOL> return len ( data ) <EOL> def startWriting ( self ) : <EOL> """<STR_LIT>""" <EOL> stopWriting = startWriting <EOL> class ReentrantProducer ( DummyProducer ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , consumer , methodName , * methodArgs ) : <EOL> super ( ReentrantProducer , self ) . __init__ ( ) <EOL> self . consumer = consumer <EOL> self . methodName = methodName <EOL> self . methodArgs = methodArgs <EOL> def resumeProducing ( self ) : <EOL> super ( ReentrantProducer , self ) . resumeProducing ( ) <EOL> getattr ( self . consumer , self . methodName ) ( * self . methodArgs ) <EOL> class TestProducer ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_doubleProducer ( self ) : <EOL> """<STR_LIT>""" <EOL> fd = abstract . FileDescriptor ( ) <EOL> fd . connected = <NUM_LIT:1> <EOL> dp = DummyProducer ( ) <EOL> fd . registerProducer ( dp , <NUM_LIT:0> ) <EOL> self . assertEquals ( dp . events , [ '<STR_LIT>' ] ) <EOL> self . assertRaises ( RuntimeError , fd . registerProducer , DummyProducer ( ) , <NUM_LIT:0> ) <EOL> def test_unconnectedFileDescriptor ( self ) : <EOL> """<STR_LIT>""" <EOL> fd = abstract . FileDescriptor ( ) <EOL> fd . disconnected = <NUM_LIT:1> <EOL> dp = DummyProducer ( ) <EOL> fd . registerProducer ( dp , <NUM_LIT:0> ) <EOL> self . assertEquals ( dp . events , [ '<STR_LIT>' ] ) <EOL> def _dontPausePullConsumerTest ( self , methodName ) : <EOL> descriptor = SillyDescriptor ( ) <EOL> producer = DummyProducer ( ) <EOL> descriptor . registerProducer ( producer , streaming = False ) <EOL> self . assertEqual ( producer . events , [ '<STR_LIT>' ] ) <EOL> del producer . events [ : ] <EOL> getattr ( descriptor , methodName ) ( '<STR_LIT>' ) <EOL> self . assertEqual ( producer . events , [ ] ) <EOL> def test_dontPausePullConsumerOnWrite ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _dontPausePullConsumerTest ( '<STR_LIT>' ) <EOL> def test_dontPausePullConsumerOnWriteSequence ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _dontPausePullConsumerTest ( '<STR_LIT>' ) <EOL> def _reentrantStreamingProducerTest ( self , methodName ) : <EOL> descriptor = SillyDescriptor ( ) <EOL> producer = ReentrantProducer ( descriptor , methodName , '<STR_LIT>' ) <EOL> descriptor . registerProducer ( producer , streaming = True ) <EOL> getattr ( descriptor , methodName ) ( '<STR_LIT>' ) <EOL> self . assertEqual ( producer . events , [ '<STR_LIT>' ] ) <EOL> del producer . events [ : ] <EOL> descriptor . doWrite ( ) <EOL> self . assertEqual ( producer . events , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> del producer . events [ : ] <EOL> descriptor . doWrite ( ) <EOL> self . assertEqual ( producer . events , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> def test_reentrantStreamingProducerUsingWrite ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _reentrantStreamingProducerTest ( '<STR_LIT>' ) <EOL> def test_reentrantStreamingProducerUsingWriteSequence ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . _reentrantStreamingProducerTest ( '<STR_LIT>' ) <EOL> class PortStringification ( unittest . TestCase ) : <EOL> if interfaces . IReactorTCP ( reactor , None ) is not None : <EOL> def testTCP ( self ) : <EOL> p = reactor . listenTCP ( <NUM_LIT:0> , protocol . ServerFactory ( ) ) <EOL> portNo = p . getHost ( ) . port <EOL> self . assertNotEqual ( str ( p ) . find ( str ( portNo ) ) , - <NUM_LIT:1> , <EOL> "<STR_LIT>" % ( portNo , p ) ) <EOL> return p . stopListening ( ) <EOL> if interfaces . IReactorUDP ( reactor , None ) is not None : <EOL> def testUDP ( self ) : <EOL> p = reactor . listenUDP ( <NUM_LIT:0> , protocol . DatagramProtocol ( ) ) <EOL> portNo = p . getHost ( ) . port <EOL> self . assertNotEqual ( str ( p ) . find ( str ( portNo ) ) , - <NUM_LIT:1> , <EOL> "<STR_LIT>" % ( portNo , p ) ) <EOL> return p . stopListening ( ) <EOL> if interfaces . IReactorSSL ( reactor , None ) is not None and ssl : <EOL> def testSSL ( self , ssl = ssl ) : <EOL> pem = util . sibpath ( __file__ , '<STR_LIT>' ) <EOL> p = reactor . listenSSL ( <NUM_LIT:0> , protocol . ServerFactory ( ) , ssl . DefaultOpenSSLContextFactory ( pem , pem ) ) <EOL> portNo = p . getHost ( ) . port <EOL> self . assertNotEqual ( str ( p ) . find ( str ( portNo ) ) , - <NUM_LIT:1> , <EOL> "<STR_LIT>" % ( portNo , p ) ) <EOL> return p . stopListening ( ) </s>

import sys , os <EOL> import new <EOL> from twisted . trial import unittest <EOL> from twisted . python import rebuild <EOL> import crash_test_dummy <EOL> f = crash_test_dummy . foo <EOL> class Foo : pass <EOL> class Bar ( Foo ) : pass <EOL> class Baz ( object ) : pass <EOL> class Buz ( Bar , Baz ) : pass <EOL> class HashRaisesRuntimeError : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self ) : <EOL> self . hashCalled = False <EOL> def __hash__ ( self ) : <EOL> self . hashCalled = True <EOL> raise RuntimeError ( '<STR_LIT>' ) <EOL> unhashableObject = None <EOL> class RebuildTestCase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> self . libPath = self . mktemp ( ) <EOL> os . mkdir ( self . libPath ) <EOL> self . fakelibPath = os . path . join ( self . libPath , '<STR_LIT>' ) <EOL> os . mkdir ( self . fakelibPath ) <EOL> file ( os . path . join ( self . fakelibPath , '<STR_LIT>' ) , '<STR_LIT:w>' ) . close ( ) <EOL> sys . path . insert ( <NUM_LIT:0> , self . libPath ) <EOL> def tearDown ( self ) : <EOL> sys . path . remove ( self . libPath ) <EOL> def testFileRebuild ( self ) : <EOL> from twisted . python . util import sibpath <EOL> import shutil , time <EOL> shutil . copyfile ( sibpath ( __file__ , "<STR_LIT>" ) , <EOL> os . path . join ( self . fakelibPath , "<STR_LIT>" ) ) <EOL> from twisted_rebuild_fakelib import myrebuilder <EOL> a = myrebuilder . A ( ) <EOL> try : <EOL> object <EOL> except NameError : <EOL> pass <EOL> else : <EOL> from twisted . test import test_rebuild <EOL> b = myrebuilder . B ( ) <EOL> class C ( myrebuilder . B ) : <EOL> pass <EOL> test_rebuild . C = C <EOL> c = C ( ) <EOL> i = myrebuilder . Inherit ( ) <EOL> self . assertEquals ( a . a ( ) , '<STR_LIT:a>' ) <EOL> time . sleep ( <NUM_LIT> ) <EOL> shutil . copyfile ( sibpath ( __file__ , "<STR_LIT>" ) , <EOL> os . path . join ( self . fakelibPath , "<STR_LIT>" ) ) <EOL> rebuild . rebuild ( myrebuilder ) <EOL> try : <EOL> object <EOL> except NameError : <EOL> pass <EOL> else : <EOL> b2 = myrebuilder . B ( ) <EOL> self . assertEquals ( b2 . b ( ) , '<STR_LIT:c>' ) <EOL> self . assertEquals ( b . b ( ) , '<STR_LIT:c>' ) <EOL> self . assertEquals ( i . a ( ) , '<STR_LIT:d>' ) <EOL> self . assertEquals ( a . a ( ) , '<STR_LIT:b>' ) <EOL> def testRebuild ( self ) : <EOL> """<STR_LIT>""" <EOL> x = crash_test_dummy . X ( '<STR_LIT:a>' ) <EOL> rebuild . rebuild ( crash_test_dummy , doLog = False ) <EOL> x . do ( ) <EOL> self . failUnlessIdentical ( x . __class__ , crash_test_dummy . X ) <EOL> self . failUnlessIdentical ( f , crash_test_dummy . foo ) <EOL> def testComponentInteraction ( self ) : <EOL> x = crash_test_dummy . XComponent ( ) <EOL> x . setAdapter ( crash_test_dummy . IX , crash_test_dummy . XA ) <EOL> oldComponent = x . getComponent ( crash_test_dummy . IX ) <EOL> rebuild . rebuild ( crash_test_dummy , <NUM_LIT:0> ) <EOL> newComponent = x . getComponent ( crash_test_dummy . IX ) <EOL> newComponent . method ( ) <EOL> self . assertEquals ( newComponent . __class__ , crash_test_dummy . XA ) <EOL> from twisted . python import components <EOL> self . failUnlessRaises ( ValueError , components . registerAdapter , <EOL> crash_test_dummy . XA , crash_test_dummy . X , <EOL> crash_test_dummy . IX ) <EOL> def testUpdateInstance ( self ) : <EOL> global Foo , Buz <EOL> b = Buz ( ) <EOL> class Foo : <EOL> def foo ( self ) : <EOL> pass <EOL> class Buz ( Bar , Baz ) : <EOL> x = <NUM_LIT:10> <EOL> rebuild . updateInstance ( b ) <EOL> assert hasattr ( b , '<STR_LIT:foo>' ) , "<STR_LIT>" <EOL> assert hasattr ( b , '<STR_LIT:x>' ) , "<STR_LIT>" <EOL> def testBananaInteraction ( self ) : <EOL> from twisted . python import rebuild <EOL> from twisted . spread import banana <EOL> rebuild . latestClass ( banana . Banana ) <EOL> def test_hashException ( self ) : <EOL> """<STR_LIT>""" <EOL> global unhashableObject <EOL> unhashableObject = HashRaisesRuntimeError ( ) <EOL> def _cleanup ( ) : <EOL> global unhashableObject <EOL> unhashableObject = None <EOL> self . addCleanup ( _cleanup ) <EOL> rebuild . rebuild ( rebuild ) <EOL> self . assertEquals ( unhashableObject . hashCalled , True ) <EOL> class NewStyleTestCase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> self . m = new . module ( '<STR_LIT>' ) <EOL> sys . modules [ '<STR_LIT>' ] = self . m <EOL> def tearDown ( self ) : <EOL> del sys . modules [ '<STR_LIT>' ] <EOL> del self . m <EOL> def test_slots ( self ) : <EOL> """<STR_LIT>""" <EOL> classDefinition = ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> exec classDefinition in self . m . __dict__ <EOL> inst = self . m . SlottedClass ( ) <EOL> inst . a = <NUM_LIT:7> <EOL> exec classDefinition in self . m . __dict__ <EOL> rebuild . updateInstance ( inst ) <EOL> self . assertEqual ( inst . a , <NUM_LIT:7> ) <EOL> self . assertIdentical ( type ( inst ) , self . m . SlottedClass ) <EOL> if sys . version_info < ( <NUM_LIT:2> , <NUM_LIT:6> ) : <EOL> test_slots . skip = "<STR_LIT>" <EOL> def test_errorSlots ( self ) : <EOL> """<STR_LIT>""" <EOL> classDefinition = ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> exec classDefinition in self . m . __dict__ <EOL> inst = self . m . SlottedClass ( ) <EOL> inst . a = <NUM_LIT:7> <EOL> exec classDefinition in self . m . __dict__ <EOL> self . assertRaises ( rebuild . RebuildError , rebuild . updateInstance , inst ) <EOL> if sys . version_info >= ( <NUM_LIT:2> , <NUM_LIT:6> ) : <EOL> test_errorSlots . skip = "<STR_LIT>" <EOL> def test_typeSubclass ( self ) : <EOL> """<STR_LIT>""" <EOL> classDefinition = ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> exec classDefinition in self . m . __dict__ <EOL> inst = self . m . ListSubclass ( ) <EOL> inst . append ( <NUM_LIT:2> ) <EOL> exec classDefinition in self . m . __dict__

rebuild . updateInstance ( inst )

import sys , os <EOL> import new <EOL> from twisted . trial import unittest <EOL> from twisted . python import rebuild <EOL> import crash_test_dummy <EOL> f = crash_test_dummy . foo <EOL> class Foo : pass <EOL> class Bar ( Foo ) : pass <EOL> class Baz ( object ) : pass <EOL> class Buz ( Bar , Baz ) : pass <EOL> class HashRaisesRuntimeError : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self ) : <EOL> self . hashCalled = False <EOL> def __hash__ ( self ) : <EOL> self . hashCalled = True <EOL> raise RuntimeError ( '<STR_LIT>' ) <EOL> unhashableObject = None <EOL> class RebuildTestCase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> self . libPath = self . mktemp ( ) <EOL> os . mkdir ( self . libPath ) <EOL> self . fakelibPath = os . path . join ( self . libPath , '<STR_LIT>' ) <EOL> os . mkdir ( self . fakelibPath ) <EOL> file ( os . path . join ( self . fakelibPath , '<STR_LIT>' ) , '<STR_LIT:w>' ) . close ( ) <EOL> sys . path . insert ( <NUM_LIT:0> , self . libPath ) <EOL> def tearDown ( self ) : <EOL> sys . path . remove ( self . libPath ) <EOL> def testFileRebuild ( self ) : <EOL> from twisted . python . util import sibpath <EOL> import shutil , time <EOL> shutil . copyfile ( sibpath ( __file__ , "<STR_LIT>" ) , <EOL> os . path . join ( self . fakelibPath , "<STR_LIT>" ) ) <EOL> from twisted_rebuild_fakelib import myrebuilder <EOL> a = myrebuilder . A ( ) <EOL> try : <EOL> object <EOL> except NameError : <EOL> pass <EOL> else : <EOL> from twisted . test import test_rebuild <EOL> b = myrebuilder . B ( ) <EOL> class C ( myrebuilder . B ) : <EOL> pass <EOL> test_rebuild . C = C <EOL> c = C ( ) <EOL> i = myrebuilder . Inherit ( ) <EOL> self . assertEquals ( a . a ( ) , '<STR_LIT:a>' ) <EOL> time . sleep ( <NUM_LIT> ) <EOL> shutil . copyfile ( sibpath ( __file__ , "<STR_LIT>" ) , <EOL> os . path . join ( self . fakelibPath , "<STR_LIT>" ) ) <EOL> rebuild . rebuild ( myrebuilder ) <EOL> try : <EOL> object <EOL> except NameError : <EOL> pass <EOL> else : <EOL> b2 = myrebuilder . B ( ) <EOL> self . assertEquals ( b2 . b ( ) , '<STR_LIT:c>' ) <EOL> self . assertEquals ( b . b ( ) , '<STR_LIT:c>' ) <EOL> self . assertEquals ( i . a ( ) , '<STR_LIT:d>' ) <EOL> self . assertEquals ( a . a ( ) , '<STR_LIT:b>' ) <EOL> def testRebuild ( self ) : <EOL> """<STR_LIT>""" <EOL> x = crash_test_dummy . X ( '<STR_LIT:a>' ) <EOL> rebuild . rebuild ( crash_test_dummy , doLog = False ) <EOL> x . do ( ) <EOL> self . failUnlessIdentical ( x . __class__ , crash_test_dummy . X ) <EOL> self . failUnlessIdentical ( f , crash_test_dummy . foo ) <EOL> def testComponentInteraction ( self ) : <EOL> x = crash_test_dummy . XComponent ( ) <EOL> x . setAdapter ( crash_test_dummy . IX , crash_test_dummy . XA ) <EOL> oldComponent = x . getComponent ( crash_test_dummy . IX ) <EOL> rebuild . rebuild ( crash_test_dummy , <NUM_LIT:0> ) <EOL> newComponent = x . getComponent ( crash_test_dummy . IX ) <EOL> newComponent . method ( ) <EOL> self . assertEquals ( newComponent . __class__ , crash_test_dummy . XA ) <EOL> from twisted . python import components <EOL> self . failUnlessRaises ( ValueError , components . registerAdapter , <EOL> crash_test_dummy . XA , crash_test_dummy . X , <EOL> crash_test_dummy . IX ) <EOL> def testUpdateInstance ( self ) : <EOL> global Foo , Buz <EOL> b = Buz ( ) <EOL> class Foo : <EOL> def foo ( self ) : <EOL> pass <EOL> class Buz ( Bar , Baz ) : <EOL> x = <NUM_LIT:10> <EOL> rebuild . updateInstance ( b ) <EOL> assert hasattr ( b , '<STR_LIT:foo>' ) , "<STR_LIT>" <EOL> assert hasattr ( b , '<STR_LIT:x>' ) , "<STR_LIT>" <EOL> def testBananaInteraction ( self ) : <EOL> from twisted . python import rebuild <EOL> from twisted . spread import banana <EOL> rebuild . latestClass ( banana . Banana ) <EOL> def test_hashException ( self ) : <EOL> """<STR_LIT>""" <EOL> global unhashableObject <EOL> unhashableObject = HashRaisesRuntimeError ( ) <EOL> def _cleanup ( ) : <EOL> global unhashableObject <EOL> unhashableObject = None <EOL> self . addCleanup ( _cleanup ) <EOL> rebuild . rebuild ( rebuild ) <EOL> self . assertEquals ( unhashableObject . hashCalled , True ) <EOL> class NewStyleTestCase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> self . m = new . module ( '<STR_LIT>' ) <EOL> sys . modules [ '<STR_LIT>' ] = self . m <EOL> def tearDown ( self ) : <EOL> del sys . modules [ '<STR_LIT>' ] <EOL> del self . m <EOL> def test_slots ( self ) : <EOL> """<STR_LIT>""" <EOL> classDefinition = ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> exec classDefinition in self . m . __dict__ <EOL> inst = self . m . SlottedClass ( ) <EOL> inst . a = <NUM_LIT:7> <EOL> exec classDefinition in self . m . __dict__ <EOL> rebuild . updateInstance ( inst ) <EOL> self . assertEqual ( inst . a , <NUM_LIT:7> ) <EOL> self . assertIdentical ( type ( inst ) , self . m . SlottedClass ) <EOL> if sys . version_info < ( <NUM_LIT:2> , <NUM_LIT:6> ) : <EOL> test_slots . skip = "<STR_LIT>" <EOL> def test_errorSlots ( self ) : <EOL> """<STR_LIT>""" <EOL> classDefinition = ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> exec classDefinition in self . m . __dict__ <EOL> inst = self . m . SlottedClass ( ) <EOL> inst . a = <NUM_LIT:7> <EOL> exec classDefinition in self . m . __dict__ <EOL> self . assertRaises ( rebuild . RebuildError , rebuild . updateInstance , inst ) <EOL> if sys . version_info >= ( <NUM_LIT:2> , <NUM_LIT:6> ) : <EOL> test_errorSlots . skip = "<STR_LIT>" <EOL> def test_typeSubclass ( self ) : <EOL> """<STR_LIT>""" <EOL> classDefinition = ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> exec classDefinition in self . m . __dict__ <EOL> inst = self . m . ListSubclass ( ) <EOL> inst . append ( <NUM_LIT:2> ) <EOL> exec classDefinition in self . m . __dict__ <EOL> rebuild . updateInstance ( inst ) <EOL> self . assertEqual ( inst [ <NUM_LIT:0> ] , <NUM_LIT:2> ) <EOL> self . assertIdentical ( type ( inst ) , self . m . ListSubclass ) <EOL> def test_instanceSlots ( self ) : <EOL> """<STR_LIT>""" <EOL> classDefinition = ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> exec classDefinition in self . m . __dict__ <EOL> inst = self . m . NotSlottedClass ( ) <EOL> inst . __slots__ = [ '<STR_LIT:a>' ] <EOL> classDefinition = ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> exec classDefinition in self . m . __dict__ <EOL> self . assertRaises ( TypeError , rebuild . updateInstance , inst ) </s>

from twisted . trial import unittest <EOL> from twisted . python import usage <EOL> class WellBehaved ( usage . Options ) : <EOL> optParameters = [ [ '<STR_LIT>' , '<STR_LIT:w>' , '<STR_LIT:default>' , '<STR_LIT>' ] , <EOL> [ '<STR_LIT>' , '<STR_LIT:n>' , '<STR_LIT>' ] , <EOL> [ '<STR_LIT>' , None , '<STR_LIT>' ] , <EOL> [ '<STR_LIT>' , None , '<STR_LIT>' , <EOL> '<STR_LIT>' ] , <EOL> ] <EOL> optFlags = [ [ '<STR_LIT>' , '<STR_LIT:f>' , <EOL> """<STR_LIT>""" ] , <EOL> [ '<STR_LIT>' , '<STR_LIT:o>' ] , <EOL> ] <EOL> def opt_myflag ( self ) : <EOL> self . opts [ '<STR_LIT>' ] = "<STR_LIT>" <EOL> def opt_myparam ( self , value ) : <EOL> self . opts [ '<STR_LIT>' ] = "<STR_LIT>" % ( value , ) <EOL> class ParseCorrectnessTest ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> """<STR_LIT>""" <EOL> self . niceArgV = ( "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) . split ( ) <EOL> self . nice = WellBehaved ( ) <EOL> self . nice . parseOptions ( self . niceArgV ) <EOL> def test_checkParameters ( self ) : <EOL> """<STR_LIT>""" <EOL> self . failUnlessEqual ( self . nice . opts [ '<STR_LIT>' ] , "<STR_LIT>" ) <EOL> self . failUnlessEqual ( self . nice . opts [ '<STR_LIT>' ] , "<STR_LIT>" ) <EOL> self . failUnlessEqual ( self . nice . opts [ '<STR_LIT>' ] , "<STR_LIT>" ) <EOL> self . failUnlessEqual ( self . nice . opts [ '<STR_LIT>' ] , "<STR_LIT>" ) <EOL> def test_checkFlags ( self ) : <EOL> """<STR_LIT>""" <EOL> self . failUnlessEqual ( self . nice . opts [ '<STR_LIT>' ] , <NUM_LIT:1> ) <EOL> self . failUnlessEqual ( self . nice . opts [ '<STR_LIT>' ] , <NUM_LIT:0> ) <EOL> def test_checkCustoms ( self ) : <EOL> """<STR_LIT>""" <EOL> self . failUnlessEqual ( self . nice . opts [ '<STR_LIT>' ] , "<STR_LIT>" ) <EOL> self . failUnlessEqual ( self . nice . opts [ '<STR_LIT>' ] , "<STR_LIT>" ) <EOL> class TypedOptions ( usage . Options ) : <EOL> optParameters = [ <EOL> [ '<STR_LIT>' , None , <NUM_LIT> , '<STR_LIT>' , int ] , <EOL> [ '<STR_LIT>' , None , <NUM_LIT> , '<STR_LIT>' , float ] , <EOL> [ '<STR_LIT>' , None , None , '<STR_LIT>' , int ] , <EOL> [ '<STR_LIT>' , None , None , '<STR_LIT>' , float ] , <EOL> ] <EOL> class TypedTestCase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> self . usage = TypedOptions ( ) <EOL> def test_defaultValues ( self ) : <EOL> """<STR_LIT>""" <EOL> argV = [ ] <EOL> self . usage . parseOptions ( argV ) <EOL> self . failUnlessEqual ( self . usage . opts [ '<STR_LIT>' ] , <NUM_LIT> ) <EOL> self . assert_ ( isinstance ( self . usage . opts [ '<STR_LIT>' ] , int ) ) <EOL> self . failUnlessEqual ( self . usage . opts [ '<STR_LIT>' ] , <NUM_LIT> ) <EOL> self . assert_ ( isinstance ( self . usage . opts [ '<STR_LIT>' ] , float ) ) <EOL> self . failUnlessEqual ( self . usage . opts [ '<STR_LIT>' ] , None ) <EOL> self . failUnlessEqual ( self . usage . opts [ '<STR_LIT>' ] , None ) <EOL> def test_parsingValues ( self ) : <EOL> """<STR_LIT>""" <EOL> argV = ( "<STR_LIT>" <EOL> "<STR_LIT>" ) . split ( ) <EOL> self . usage . parseOptions ( argV ) <EOL> self . failUnlessEqual ( self . usage . opts [ '<STR_LIT>' ] , <NUM_LIT> ) <EOL> self . assert_ ( isinstance ( self . usage . opts [ '<STR_LIT>' ] , int ) ) <EOL> self . failUnlessEqual ( self . usage . opts [ '<STR_LIT>' ] , - <NUM_LIT> ) <EOL> self . assert_ ( isinstance ( self . usage . opts [ '<STR_LIT>' ] , float ) ) <EOL> self . failUnlessEqual ( self . usage . opts [ '<STR_LIT>' ] , <NUM_LIT:32> ) <EOL> self . assert_ ( isinstance ( self . usage . opts [ '<STR_LIT>' ] , int ) ) <EOL> self . failUnlessEqual ( self . usage . opts [ '<STR_LIT>' ] , <NUM_LIT> ) <EOL> self . assert_ ( isinstance ( self . usage . opts [ '<STR_LIT>' ] , float ) ) <EOL> def test_invalidValues ( self ) : <EOL> """<STR_LIT>""" <EOL> argV = "<STR_LIT>" . split ( ) <EOL> self . assertRaises ( usage . UsageError , self . usage . parseOptions , argV ) <EOL> class WrongTypedOptions ( usage . Options ) : <EOL> optParameters = [ <EOL> [ '<STR_LIT>' , None , None , '<STR_LIT>' , '<STR_LIT>' ] <EOL> ] <EOL> class WeirdCallableOptions ( usage . Options ) : <EOL> def _bar ( value ) : <EOL> raise RuntimeError ( "<STR_LIT>" ) <EOL> def _foo ( value ) : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> optParameters = [ <EOL> [ '<STR_LIT>' , None , None , '<STR_LIT>' , _bar ] , <EOL> [ '<STR_LIT>' , None , None , '<STR_LIT>' , _foo ] <EOL> ] <EOL> class WrongTypedTestCase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_nonCallable ( self ) : <EOL> """<STR_LIT>""" <EOL> us = WrongTypedOptions ( ) <EOL> argV = "<STR_LIT>" . split ( ) <EOL> self . assertRaises ( TypeError , us . parseOptions , argV ) <EOL> def test_notCalledInDefault ( self ) : <EOL> """<STR_LIT>""" <EOL> us = WeirdCallableOptions ( ) <EOL> argV = [ ] <EOL> us . parseOptions ( argV ) <EOL> def test_weirdCallable ( self ) : <EOL> """<STR_LIT>""" <EOL> us = WeirdCallableOptions ( ) <EOL> argV = "<STR_LIT>" . split ( ) <EOL> e = self . assertRaises ( usage . UsageError , us . parseOptions , argV ) <EOL> self . assertEquals ( str ( e ) , "<STR_LIT>" ) <EOL> us = WeirdCallableOptions ( ) <EOL> argV = "<STR_LIT>" . split ( ) <EOL> self . assertRaises ( RuntimeError , us . parseOptions , argV ) <EOL> class OutputTest ( unittest . TestCase ) : <EOL> def test_uppercasing ( self ) : <EOL> """<STR_LIT>""" <EOL> opt = WellBehaved ( ) <EOL> e = self . assertRaises ( usage . UsageError , <EOL> opt . parseOptions , [ '<STR_LIT>' ] ) <EOL> self . assertEquals ( str ( e ) , '<STR_LIT>' ) <EOL> class InquisitionOptions ( usage . Options ) : <EOL> optFlags = [ <EOL> ( '<STR_LIT>' , '<STR_LIT:e>' ) , <EOL> ] <EOL> optParameters = [ <EOL> ( '<STR_LIT>' , '<STR_LIT:t>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' ) , <EOL> ] <EOL> class HolyQuestOptions ( usage . Options ) : <EOL> optFlags = [ ( '<STR_LIT>' , '<STR_LIT:h>' , <EOL> '<STR_LIT>' ) , <EOL> ( '<STR_LIT>' , '<STR_LIT:g>' ) , <EOL> ] <EOL> class SubCommandOptions ( usage . Options ) : <EOL> optFlags = [ ( '<STR_LIT>' , None , <EOL> '<STR_LIT>' ) , <EOL> ] <EOL> subCommands = [ <EOL> ( '<STR_LIT>' , '<STR_LIT>' , InquisitionOptions , <EOL> '<STR_LIT>' ) , <EOL> ( '<STR_LIT>' , '<STR_LIT>' , HolyQuestOptions , <EOL> '<STR_LIT>' ) , <EOL> ] <EOL> class SubCommandTest ( unittest . TestCase ) : <EOL> def test_simpleSubcommand ( self ) : <EOL> o = SubCommandOptions ( ) <EOL> o . parseOptions ( [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> self . failUnlessEqual ( o [ '<STR_LIT>' ] , True ) <EOL> self . failUnlessEqual ( o . subCommand , '<STR_LIT>' ) <EOL> self . failUnless ( isinstance ( o . subOptions , InquisitionOptions ) ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , False ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , '<STR_LIT>' ) <EOL> def test_subcommandWithFlagsAndOptions ( self ) : <EOL> o = SubCommandOptions ( ) <EOL> o . parseOptions ( [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> self . failUnlessEqual ( o [ '<STR_LIT>' ] , False ) <EOL> self . failUnlessEqual ( o . subCommand , '<STR_LIT>' ) <EOL> self . failUnless ( isinstance ( o . subOptions , InquisitionOptions ) ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , True ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , '<STR_LIT>' ) <EOL> def test_subcommandAliasWithFlagsAndOptions ( self ) : <EOL> o = SubCommandOptions ( ) <EOL> o . parseOptions ( [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> self . failUnlessEqual ( o [ '<STR_LIT>' ] , False ) <EOL> self . failUnlessEqual ( o . subCommand , '<STR_LIT>' ) <EOL> self . failUnless ( isinstance ( o . subOptions , InquisitionOptions ) ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , True ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , '<STR_LIT>' ) <EOL> def test_anotherSubcommandWithFlagsAndOptions ( self ) : <EOL> o = SubCommandOptions ( ) <EOL> o . parseOptions ( [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> self . failUnlessEqual ( o [ '<STR_LIT>' ] , False ) <EOL> self . failUnlessEqual ( o . subCommand , '<STR_LIT>' ) <EOL> self . failUnless ( isinstance ( o . subOptions , HolyQuestOptions ) ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , False ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , True ) <EOL> def test_noSubcommand ( self ) : <EOL> o = SubCommandOptions ( ) <EOL> o . parseOptions ( [ '<STR_LIT>' ] ) <EOL> self . failUnlessEqual ( o [ '<STR_LIT>' ] , True ) <EOL> self . failUnlessEqual ( o . subCommand , None ) <EOL> self . failIf ( hasattr ( o , '<STR_LIT>' ) ) <EOL> def test_defaultSubcommand ( self ) : <EOL> o = SubCommandOptions ( ) <EOL> o . defaultSubCommand = '<STR_LIT>' <EOL> o . parseOptions ( [ '<STR_LIT>' ] ) <EOL> self . failUnlessEqual ( o [ '<STR_LIT>' ] , True ) <EOL> self . failUnlessEqual ( o . subCommand , '<STR_LIT>' ) <EOL> self . failUnless ( isinstance ( o . subOptions , InquisitionOptions ) ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , False ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , '<STR_LIT>' ) <EOL> def test_subCommandParseOptionsHasParent ( self ) : <EOL> class SubOpt ( usage . Options ) : <EOL> def parseOptions ( self , * a , ** kw ) : <EOL> self . sawParent = self . parent <EOL> usage . Options . parseOptions ( self , * a , ** kw ) <EOL> class Opt ( usage . Options ) : <EOL> subCommands = [ <EOL> ( '<STR_LIT:foo>' , '<STR_LIT:f>' , SubOpt , '<STR_LIT:bar>' ) , <EOL> ] <EOL> o = Opt ( ) <EOL> o . parseOptions ( [ '<STR_LIT:foo>' ] ) <EOL> self . failUnless ( hasattr ( o . subOptions , '<STR_LIT>' ) ) <EOL> self . failUnlessEqual ( o . subOptions . sawParent , o ) <EOL> def test_subCommandInTwoPlaces ( self ) : <EOL> """<STR_LIT>""" <EOL> class SubOpt ( usage . Options ) : <EOL> pass <EOL> class OptFoo ( usage . Options ) : <EOL> subCommands = [ <EOL> ( '<STR_LIT:foo>' , '<STR_LIT:f>' , SubOpt , '<STR_LIT>' ) , <EOL> ] <EOL> class OptBar ( usage . Options ) : <EOL> subCommands = [ <EOL> ( '<STR_LIT:bar>' , '<STR_LIT:b>' , SubOpt , '<STR_LIT>' ) , <EOL> ] <EOL> oFoo = OptFoo ( ) <EOL> oFoo . parseOptions ( [ '<STR_LIT:foo>' ] ) <EOL> oBar = OptBar ( ) <EOL> oBar . parseOptions ( [ '<STR_LIT:bar>' ] )

self . failUnless ( hasattr ( oFoo . subOptions , '<STR_LIT>' ) )

from twisted . trial import unittest <EOL> from twisted . python import usage <EOL> class WellBehaved ( usage . Options ) : <EOL> optParameters = [ [ '<STR_LIT>' , '<STR_LIT:w>' , '<STR_LIT:default>' , '<STR_LIT>' ] , <EOL> [ '<STR_LIT>' , '<STR_LIT:n>' , '<STR_LIT>' ] , <EOL> [ '<STR_LIT>' , None , '<STR_LIT>' ] , <EOL> [ '<STR_LIT>' , None , '<STR_LIT>' , <EOL> '<STR_LIT>' ] , <EOL> ] <EOL> optFlags = [ [ '<STR_LIT>' , '<STR_LIT:f>' , <EOL> """<STR_LIT>""" ] , <EOL> [ '<STR_LIT>' , '<STR_LIT:o>' ] , <EOL> ] <EOL> def opt_myflag ( self ) : <EOL> self . opts [ '<STR_LIT>' ] = "<STR_LIT>" <EOL> def opt_myparam ( self , value ) : <EOL> self . opts [ '<STR_LIT>' ] = "<STR_LIT>" % ( value , ) <EOL> class ParseCorrectnessTest ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> """<STR_LIT>""" <EOL> self . niceArgV = ( "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) . split ( ) <EOL> self . nice = WellBehaved ( ) <EOL> self . nice . parseOptions ( self . niceArgV ) <EOL> def test_checkParameters ( self ) : <EOL> """<STR_LIT>""" <EOL> self . failUnlessEqual ( self . nice . opts [ '<STR_LIT>' ] , "<STR_LIT>" ) <EOL> self . failUnlessEqual ( self . nice . opts [ '<STR_LIT>' ] , "<STR_LIT>" ) <EOL> self . failUnlessEqual ( self . nice . opts [ '<STR_LIT>' ] , "<STR_LIT>" ) <EOL> self . failUnlessEqual ( self . nice . opts [ '<STR_LIT>' ] , "<STR_LIT>" ) <EOL> def test_checkFlags ( self ) : <EOL> """<STR_LIT>""" <EOL> self . failUnlessEqual ( self . nice . opts [ '<STR_LIT>' ] , <NUM_LIT:1> ) <EOL> self . failUnlessEqual ( self . nice . opts [ '<STR_LIT>' ] , <NUM_LIT:0> ) <EOL> def test_checkCustoms ( self ) : <EOL> """<STR_LIT>""" <EOL> self . failUnlessEqual ( self . nice . opts [ '<STR_LIT>' ] , "<STR_LIT>" ) <EOL> self . failUnlessEqual ( self . nice . opts [ '<STR_LIT>' ] , "<STR_LIT>" ) <EOL> class TypedOptions ( usage . Options ) : <EOL> optParameters = [ <EOL> [ '<STR_LIT>' , None , <NUM_LIT> , '<STR_LIT>' , int ] , <EOL> [ '<STR_LIT>' , None , <NUM_LIT> , '<STR_LIT>' , float ] , <EOL> [ '<STR_LIT>' , None , None , '<STR_LIT>' , int ] , <EOL> [ '<STR_LIT>' , None , None , '<STR_LIT>' , float ] , <EOL> ] <EOL> class TypedTestCase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> self . usage = TypedOptions ( ) <EOL> def test_defaultValues ( self ) : <EOL> """<STR_LIT>""" <EOL> argV = [ ] <EOL> self . usage . parseOptions ( argV ) <EOL> self . failUnlessEqual ( self . usage . opts [ '<STR_LIT>' ] , <NUM_LIT> ) <EOL> self . assert_ ( isinstance ( self . usage . opts [ '<STR_LIT>' ] , int ) ) <EOL> self . failUnlessEqual ( self . usage . opts [ '<STR_LIT>' ] , <NUM_LIT> ) <EOL> self . assert_ ( isinstance ( self . usage . opts [ '<STR_LIT>' ] , float ) ) <EOL> self . failUnlessEqual ( self . usage . opts [ '<STR_LIT>' ] , None ) <EOL> self . failUnlessEqual ( self . usage . opts [ '<STR_LIT>' ] , None ) <EOL> def test_parsingValues ( self ) : <EOL> """<STR_LIT>""" <EOL> argV = ( "<STR_LIT>" <EOL> "<STR_LIT>" ) . split ( ) <EOL> self . usage . parseOptions ( argV ) <EOL> self . failUnlessEqual ( self . usage . opts [ '<STR_LIT>' ] , <NUM_LIT> ) <EOL> self . assert_ ( isinstance ( self . usage . opts [ '<STR_LIT>' ] , int ) ) <EOL> self . failUnlessEqual ( self . usage . opts [ '<STR_LIT>' ] , - <NUM_LIT> ) <EOL> self . assert_ ( isinstance ( self . usage . opts [ '<STR_LIT>' ] , float ) ) <EOL> self . failUnlessEqual ( self . usage . opts [ '<STR_LIT>' ] , <NUM_LIT:32> ) <EOL> self . assert_ ( isinstance ( self . usage . opts [ '<STR_LIT>' ] , int ) ) <EOL> self . failUnlessEqual ( self . usage . opts [ '<STR_LIT>' ] , <NUM_LIT> ) <EOL> self . assert_ ( isinstance ( self . usage . opts [ '<STR_LIT>' ] , float ) ) <EOL> def test_invalidValues ( self ) : <EOL> """<STR_LIT>""" <EOL> argV = "<STR_LIT>" . split ( ) <EOL> self . assertRaises ( usage . UsageError , self . usage . parseOptions , argV ) <EOL> class WrongTypedOptions ( usage . Options ) : <EOL> optParameters = [ <EOL> [ '<STR_LIT>' , None , None , '<STR_LIT>' , '<STR_LIT>' ] <EOL> ] <EOL> class WeirdCallableOptions ( usage . Options ) : <EOL> def _bar ( value ) : <EOL> raise RuntimeError ( "<STR_LIT>" ) <EOL> def _foo ( value ) : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> optParameters = [ <EOL> [ '<STR_LIT>' , None , None , '<STR_LIT>' , _bar ] , <EOL> [ '<STR_LIT>' , None , None , '<STR_LIT>' , _foo ] <EOL> ] <EOL> class WrongTypedTestCase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_nonCallable ( self ) : <EOL> """<STR_LIT>""" <EOL> us = WrongTypedOptions ( ) <EOL> argV = "<STR_LIT>" . split ( ) <EOL> self . assertRaises ( TypeError , us . parseOptions , argV ) <EOL> def test_notCalledInDefault ( self ) : <EOL> """<STR_LIT>""" <EOL> us = WeirdCallableOptions ( ) <EOL> argV = [ ] <EOL> us . parseOptions ( argV ) <EOL> def test_weirdCallable ( self ) : <EOL> """<STR_LIT>""" <EOL> us = WeirdCallableOptions ( ) <EOL> argV = "<STR_LIT>" . split ( ) <EOL> e = self . assertRaises ( usage . UsageError , us . parseOptions , argV ) <EOL> self . assertEquals ( str ( e ) , "<STR_LIT>" ) <EOL> us = WeirdCallableOptions ( ) <EOL> argV = "<STR_LIT>" . split ( ) <EOL> self . assertRaises ( RuntimeError , us . parseOptions , argV ) <EOL> class OutputTest ( unittest . TestCase ) : <EOL> def test_uppercasing ( self ) : <EOL> """<STR_LIT>""" <EOL> opt = WellBehaved ( ) <EOL> e = self . assertRaises ( usage . UsageError , <EOL> opt . parseOptions , [ '<STR_LIT>' ] ) <EOL> self . assertEquals ( str ( e ) , '<STR_LIT>' ) <EOL> class InquisitionOptions ( usage . Options ) : <EOL> optFlags = [ <EOL> ( '<STR_LIT>' , '<STR_LIT:e>' ) , <EOL> ] <EOL> optParameters = [ <EOL> ( '<STR_LIT>' , '<STR_LIT:t>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' ) , <EOL> ] <EOL> class HolyQuestOptions ( usage . Options ) : <EOL> optFlags = [ ( '<STR_LIT>' , '<STR_LIT:h>' , <EOL> '<STR_LIT>' ) , <EOL> ( '<STR_LIT>' , '<STR_LIT:g>' ) , <EOL> ] <EOL> class SubCommandOptions ( usage . Options ) : <EOL> optFlags = [ ( '<STR_LIT>' , None , <EOL> '<STR_LIT>' ) , <EOL> ] <EOL> subCommands = [ <EOL> ( '<STR_LIT>' , '<STR_LIT>' , InquisitionOptions , <EOL> '<STR_LIT>' ) , <EOL> ( '<STR_LIT>' , '<STR_LIT>' , HolyQuestOptions , <EOL> '<STR_LIT>' ) , <EOL> ] <EOL> class SubCommandTest ( unittest . TestCase ) : <EOL> def test_simpleSubcommand ( self ) : <EOL> o = SubCommandOptions ( ) <EOL> o . parseOptions ( [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> self . failUnlessEqual ( o [ '<STR_LIT>' ] , True ) <EOL> self . failUnlessEqual ( o . subCommand , '<STR_LIT>' ) <EOL> self . failUnless ( isinstance ( o . subOptions , InquisitionOptions ) ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , False ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , '<STR_LIT>' ) <EOL> def test_subcommandWithFlagsAndOptions ( self ) : <EOL> o = SubCommandOptions ( ) <EOL> o . parseOptions ( [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> self . failUnlessEqual ( o [ '<STR_LIT>' ] , False ) <EOL> self . failUnlessEqual ( o . subCommand , '<STR_LIT>' ) <EOL> self . failUnless ( isinstance ( o . subOptions , InquisitionOptions ) ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , True ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , '<STR_LIT>' ) <EOL> def test_subcommandAliasWithFlagsAndOptions ( self ) : <EOL> o = SubCommandOptions ( ) <EOL> o . parseOptions ( [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> self . failUnlessEqual ( o [ '<STR_LIT>' ] , False ) <EOL> self . failUnlessEqual ( o . subCommand , '<STR_LIT>' ) <EOL> self . failUnless ( isinstance ( o . subOptions , InquisitionOptions ) ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , True ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , '<STR_LIT>' ) <EOL> def test_anotherSubcommandWithFlagsAndOptions ( self ) : <EOL> o = SubCommandOptions ( ) <EOL> o . parseOptions ( [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> self . failUnlessEqual ( o [ '<STR_LIT>' ] , False ) <EOL> self . failUnlessEqual ( o . subCommand , '<STR_LIT>' ) <EOL> self . failUnless ( isinstance ( o . subOptions , HolyQuestOptions ) ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , False ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , True ) <EOL> def test_noSubcommand ( self ) : <EOL> o = SubCommandOptions ( ) <EOL> o . parseOptions ( [ '<STR_LIT>' ] ) <EOL> self . failUnlessEqual ( o [ '<STR_LIT>' ] , True ) <EOL> self . failUnlessEqual ( o . subCommand , None ) <EOL> self . failIf ( hasattr ( o , '<STR_LIT>' ) ) <EOL> def test_defaultSubcommand ( self ) : <EOL> o = SubCommandOptions ( ) <EOL> o . defaultSubCommand = '<STR_LIT>' <EOL> o . parseOptions ( [ '<STR_LIT>' ] ) <EOL> self . failUnlessEqual ( o [ '<STR_LIT>' ] , True ) <EOL> self . failUnlessEqual ( o . subCommand , '<STR_LIT>' ) <EOL> self . failUnless ( isinstance ( o . subOptions , InquisitionOptions ) ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , False ) <EOL> self . failUnlessEqual ( o . subOptions [ '<STR_LIT>' ] , '<STR_LIT>' ) <EOL> def test_subCommandParseOptionsHasParent ( self ) : <EOL> class SubOpt ( usage . Options ) : <EOL> def parseOptions ( self , * a , ** kw ) : <EOL> self . sawParent = self . parent <EOL> usage . Options . parseOptions ( self , * a , ** kw ) <EOL> class Opt ( usage . Options ) : <EOL> subCommands = [ <EOL> ( '<STR_LIT:foo>' , '<STR_LIT:f>' , SubOpt , '<STR_LIT:bar>' ) , <EOL> ] <EOL> o = Opt ( ) <EOL> o . parseOptions ( [ '<STR_LIT:foo>' ] ) <EOL> self . failUnless ( hasattr ( o . subOptions , '<STR_LIT>' ) ) <EOL> self . failUnlessEqual ( o . subOptions . sawParent , o ) <EOL> def test_subCommandInTwoPlaces ( self ) : <EOL> """<STR_LIT>""" <EOL> class SubOpt ( usage . Options ) : <EOL> pass <EOL> class OptFoo ( usage . Options ) : <EOL> subCommands = [ <EOL> ( '<STR_LIT:foo>' , '<STR_LIT:f>' , SubOpt , '<STR_LIT>' ) , <EOL> ] <EOL> class OptBar ( usage . Options ) : <EOL> subCommands = [ <EOL> ( '<STR_LIT:bar>' , '<STR_LIT:b>' , SubOpt , '<STR_LIT>' ) , <EOL> ] <EOL> oFoo = OptFoo ( ) <EOL> oFoo . parseOptions ( [ '<STR_LIT:foo>' ] ) <EOL> oBar = OptBar ( ) <EOL> oBar . parseOptions ( [ '<STR_LIT:bar>' ] ) <EOL> self . failUnless ( hasattr ( oFoo . subOptions , '<STR_LIT>' ) ) <EOL> self . failUnless ( hasattr ( oBar . subOptions , '<STR_LIT>' ) ) <EOL> self . failUnlessIdentical ( oFoo . subOptions . parent , oFoo ) <EOL> self . failUnlessIdentical ( oBar . subOptions . parent , oBar ) <EOL> class HelpStringTest ( unittest . TestCase ) : <EOL> def setUp ( self ) : <EOL> """<STR_LIT>""" <EOL> self . niceArgV = ( "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) . split ( ) <EOL> self . nice = WellBehaved ( ) <EOL> def test_noGoBoom ( self ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> self . nice . __str__ ( ) <EOL> except Exception , e : <EOL> self . fail ( e ) <EOL> def test_whitespaceStripFlagsAndParameters ( self ) : <EOL> """<STR_LIT>""" <EOL> lines = [ s for s in str ( self . nice ) . splitlines ( ) if s . find ( "<STR_LIT>" ) >= <NUM_LIT:0> ] <EOL> self . failUnless ( len ( lines ) > <NUM_LIT:0> ) <EOL> self . failUnless ( lines [ <NUM_LIT:0> ] . find ( "<STR_LIT>" ) >= <NUM_LIT:0> ) <EOL> class PortCoerceTestCase ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_validCoerce ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertEquals ( <NUM_LIT:0> , usage . portCoerce ( "<STR_LIT:0>" ) ) <EOL> self . assertEquals ( <NUM_LIT> , usage . portCoerce ( "<STR_LIT>" ) ) <EOL> self . assertEquals ( <NUM_LIT> , usage . portCoerce ( "<STR_LIT>" ) ) <EOL> def test_errorCoerce ( self ) : <EOL> """<STR_LIT>""" <EOL> self . assertRaises ( ValueError , usage . portCoerce , "<STR_LIT>" ) <EOL> self . assertRaises ( ValueError , usage . portCoerce , "<STR_LIT>" ) <EOL> self . assertRaises ( ValueError , usage . portCoerce , "<STR_LIT>" ) <EOL> self . assertRaises ( ValueError , usage . portCoerce , "<STR_LIT:foo>" ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> unittest . main ( ) </s>

"""<STR_LIT>""" <EOL> import os <EOL> import shutil <EOL> import sys <EOL> from twisted . python import util <EOL> from twisted . python . hashlib import md5 <EOL> from twisted . trial . test import packages <EOL> from twisted . trial import runner , reporter , unittest <EOL> from twisted . trial . itrial import ITestCase <EOL> from twisted . python . modules import getModule <EOL> def testNames ( tests ) : <EOL> """<STR_LIT>""" <EOL> names = [ ] <EOL> for test in unittest . _iterateTests ( tests ) : <EOL> names . append ( test . id ( ) ) <EOL> return names <EOL> class FinderTest ( packages . PackageTest ) : <EOL> def setUp ( self ) : <EOL> packages . PackageTest . setUp ( self ) <EOL> self . loader = runner . TestLoader ( ) <EOL> def tearDown ( self ) : <EOL> packages . PackageTest . tearDown ( self ) <EOL> def test_findPackage ( self ) : <EOL> sample1 = self . loader . findByName ( '<STR_LIT>' ) <EOL> import twisted as sample2 <EOL> self . failUnlessEqual ( sample1 , sample2 ) <EOL> def test_findModule ( self ) : <EOL> sample1 = self . loader . findByName ( '<STR_LIT>' ) <EOL> import sample as sample2 <EOL> self . failUnlessEqual ( sample1 , sample2 ) <EOL> def test_findFile ( self ) : <EOL> path = util . sibpath ( __file__ , '<STR_LIT>' ) <EOL> sample1 = self . loader . findByName ( path ) <EOL> import sample as sample2 <EOL> self . failUnlessEqual ( sample1 , sample2 ) <EOL> def test_findObject ( self ) : <EOL> sample1 = self . loader . findByName ( '<STR_LIT>' ) <EOL> import sample <EOL> self . failUnlessEqual ( sample . FooTest , sample1 ) <EOL> def test_findNonModule ( self ) : <EOL> self . failUnlessRaises ( AttributeError , <EOL> self . loader . findByName , <EOL> '<STR_LIT>' ) <EOL> def test_findNonPackage ( self ) : <EOL> self . failUnlessRaises ( ValueError , <EOL> self . loader . findByName , <EOL> '<STR_LIT>' ) <EOL> def test_findNonFile ( self ) : <EOL> path = util . sibpath ( __file__ , '<STR_LIT>' ) <EOL> self . failUnlessRaises ( ValueError , self . loader . findByName , path ) <EOL> class FileTest ( packages . SysPathManglingTest ) : <EOL> """<STR_LIT>""" <EOL> def test_notFile ( self ) : <EOL> self . failUnlessRaises ( ValueError , <EOL> runner . filenameToModule , '<STR_LIT>' ) <EOL> def test_moduleInPath ( self ) : <EOL> sample1 = runner . filenameToModule ( util . sibpath ( __file__ , '<STR_LIT>' ) ) <EOL> import sample as sample2 <EOL> self . failUnlessEqual ( sample2 , sample1 ) <EOL> def test_moduleNotInPath ( self ) : <EOL> """<STR_LIT>""" <EOL> self . addCleanup ( sys . modules . pop , '<STR_LIT>' , None ) <EOL> self . mangleSysPath ( self . oldPath ) <EOL> sample1 = runner . filenameToModule ( <EOL> os . path . join ( self . parent , '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . mangleSysPath ( self . newPath ) <EOL> from goodpackage import test_sample as sample2 <EOL> self . failUnlessEqual ( os . path . splitext ( sample2 . __file__ ) [ <NUM_LIT:0> ] , <EOL> os . path . splitext ( sample1 . __file__ ) [ <NUM_LIT:0> ] ) <EOL> def test_packageInPath ( self ) : <EOL> package1 = runner . filenameToModule ( os . path . join ( self . parent , <EOL> '<STR_LIT>' ) ) <EOL> import goodpackage <EOL> self . failUnlessEqual ( goodpackage , package1 ) <EOL> def test_packageNotInPath ( self ) : <EOL> """<STR_LIT>""" <EOL> self . addCleanup ( sys . modules . pop , "<STR_LIT>" ) <EOL> self . mangleSysPath ( self . oldPath ) <EOL> package1 = runner . filenameToModule ( <EOL> os . path . join ( self . parent , '<STR_LIT>' ) ) <EOL> self . mangleSysPath ( self . newPath ) <EOL> import goodpackage <EOL> self . failUnlessEqual ( os . path . splitext ( goodpackage . __file__ ) [ <NUM_LIT:0> ] , <EOL> os . path . splitext ( package1 . __file__ ) [ <NUM_LIT:0> ] ) <EOL> def test_directoryNotPackage ( self ) : <EOL> self . failUnlessRaises ( ValueError , runner . filenameToModule , <EOL> util . sibpath ( __file__ , '<STR_LIT>' ) ) <EOL> def test_filenameNotPython ( self ) : <EOL> self . failUnlessRaises ( ValueError , runner . filenameToModule , <EOL> util . sibpath ( __file__ , '<STR_LIT>' ) ) <EOL> def test_filenameMatchesPackage ( self ) : <EOL> filename = os . path . join ( self . parent , '<STR_LIT>' ) <EOL> fd = open ( filename , '<STR_LIT:w>' ) <EOL> fd . write ( packages . testModule ) <EOL> fd . close ( ) <EOL> try : <EOL> module = runner . filenameToModule ( filename ) <EOL> self . failUnlessEqual ( filename , module . __file__ ) <EOL> finally : <EOL> os . remove ( filename ) <EOL> def test_directory ( self ) : <EOL> """<STR_LIT>""" <EOL> path = util . sibpath ( __file__ , '<STR_LIT>' ) <EOL> os . mkdir ( path ) <EOL> f = file ( os . path . join ( path , '<STR_LIT>' ) , "<STR_LIT:w>" ) <EOL> f . close ( ) <EOL> try : <EOL> module = runner . filenameToModule ( path ) <EOL> self . assert_ ( module . __name__ . endswith ( '<STR_LIT>' ) ) <EOL> module = runner . filenameToModule ( path + os . path . sep ) <EOL> self . assert_ ( module . __name__ . endswith ( '<STR_LIT>' ) ) <EOL> finally : <EOL> shutil . rmtree ( path ) <EOL> class LoaderTest ( packages . SysPathManglingTest ) : <EOL> def setUp ( self ) : <EOL> self . loader = runner . TestLoader ( ) <EOL> packages . SysPathManglingTest . setUp ( self ) <EOL> def test_sortCases ( self ) : <EOL> import sample <EOL> suite = self . loader . loadClass ( sample . AlphabetTest ) <EOL> self . failUnlessEqual ( [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] , <EOL> [ test . _testMethodName for test in suite . _tests ] ) <EOL> newOrder = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> sortDict = dict ( zip ( newOrder , range ( <NUM_LIT:3> ) ) ) <EOL> self . loader . sorter = lambda x : sortDict . get ( x . shortDescription ( ) , - <NUM_LIT:1> ) <EOL> suite = self . loader . loadClass ( sample . AlphabetTest ) <EOL> self . failUnlessEqual ( newOrder , <EOL> [ test . _testMethodName for test in suite . _tests ] ) <EOL> def test_loadMethod ( self ) : <EOL> import sample <EOL> suite = self . loader . loadMethod ( sample . FooTest . test_foo ) <EOL> self . failUnlessEqual ( <NUM_LIT:1> , suite . countTestCases ( ) ) <EOL> self . failUnlessEqual ( '<STR_LIT>' , suite . _testMethodName ) <EOL> def test_loadFailingMethod ( self ) : <EOL> import erroneous <EOL> suite = self . loader . loadMethod ( erroneous . TestRegularFail . test_fail ) <EOL> result = reporter . TestResult ( ) <EOL> suite . run ( result ) <EOL> self . failUnlessEqual ( result . testsRun , <NUM_LIT:1> ) <EOL> self . failUnlessEqual ( len ( result . failures ) , <NUM_LIT:1> ) <EOL> def test_loadNonMethod ( self ) : <EOL> import sample <EOL> self . failUnlessRaises ( TypeError , self . loader . loadMethod , sample ) <EOL> self . failUnlessRaises ( TypeError , <EOL> self . loader . loadMethod , sample . FooTest ) <EOL> self . failUnlessRaises ( TypeError , self . loader . loadMethod , "<STR_LIT:string>" ) <EOL> self . failUnlessRaises ( TypeError , <EOL> self . loader . loadMethod , ( '<STR_LIT:foo>' , '<STR_LIT:bar>' ) ) <EOL> def test_loadClass ( self ) : <EOL> import sample <EOL> suite = self . loader . loadClass ( sample . FooTest ) <EOL> self . failUnlessEqual ( <NUM_LIT:2> , suite . countTestCases ( ) ) <EOL> self . failUnlessEqual ( [ '<STR_LIT>' , '<STR_LIT>' ] , <EOL> [ test . _testMethodName for test in suite . _tests ] ) <EOL> def test_loadNonClass ( self ) : <EOL> import sample <EOL> self . failUnlessRaises ( TypeError , self . loader . loadClass , sample ) <EOL> self . failUnlessRaises ( TypeError , <EOL> self . loader . loadClass , sample . FooTest . test_foo ) <EOL> self . failUnlessRaises ( TypeError , self . loader . loadClass , "<STR_LIT:string>" ) <EOL> self . failUnlessRaises ( TypeError , <EOL> self . loader . loadClass , ( '<STR_LIT:foo>' , '<STR_LIT:bar>' ) ) <EOL> def test_loadNonTestCase ( self ) : <EOL> import sample <EOL> self . failUnlessRaises ( ValueError , self . loader . loadClass , <EOL> sample . NotATest ) <EOL> def test_loadModule ( self ) : <EOL> import sample <EOL> suite = self . loader . loadModule ( sample ) <EOL> self . failUnlessEqual ( <NUM_LIT:7> , suite . countTestCases ( ) ) <EOL> def test_loadNonModule ( self ) : <EOL> import sample <EOL> self . failUnlessRaises ( TypeError , <EOL> self . loader . loadModule , sample . FooTest ) <EOL> self . failUnlessRaises ( TypeError , <EOL> self . loader . loadModule , sample . FooTest . test_foo ) <EOL> self . failUnlessRaises ( TypeError , self . loader . loadModule , "<STR_LIT:string>" ) <EOL> self . failUnlessRaises ( TypeError , <EOL> self . loader . loadModule , ( '<STR_LIT:foo>' , '<STR_LIT:bar>' ) ) <EOL> def test_loadPackage ( self ) : <EOL> import goodpackage <EOL> suite = self . loader . loadPackage ( goodpackage )

self . failUnlessEqual ( <NUM_LIT:7> , suite . countTestCases ( ) )

"""<STR_LIT>""" <EOL> import os <EOL> import shutil <EOL> import sys <EOL> from twisted . python import util <EOL> from twisted . python . hashlib import md5 <EOL> from twisted . trial . test import packages <EOL> from twisted . trial import runner , reporter , unittest <EOL> from twisted . trial . itrial import ITestCase <EOL> from twisted . python . modules import getModule <EOL> def testNames ( tests ) : <EOL> """<STR_LIT>""" <EOL> names = [ ] <EOL> for test in unittest . _iterateTests ( tests ) : <EOL> names . append ( test . id ( ) ) <EOL> return names <EOL> class FinderTest ( packages . PackageTest ) : <EOL> def setUp ( self ) : <EOL> packages . PackageTest . setUp ( self ) <EOL> self . loader = runner . TestLoader ( ) <EOL> def tearDown ( self ) : <EOL> packages . PackageTest . tearDown ( self ) <EOL> def test_findPackage ( self ) : <EOL> sample1 = self . loader . findByName ( '<STR_LIT>' ) <EOL> import twisted as sample2 <EOL> self . failUnlessEqual ( sample1 , sample2 ) <EOL> def test_findModule ( self ) : <EOL> sample1 = self . loader . findByName ( '<STR_LIT>' ) <EOL> import sample as sample2 <EOL> self . failUnlessEqual ( sample1 , sample2 ) <EOL> def test_findFile ( self ) : <EOL> path = util . sibpath ( __file__ , '<STR_LIT>' ) <EOL> sample1 = self . loader . findByName ( path ) <EOL> import sample as sample2 <EOL> self . failUnlessEqual ( sample1 , sample2 ) <EOL> def test_findObject ( self ) : <EOL> sample1 = self . loader . findByName ( '<STR_LIT>' ) <EOL> import sample <EOL> self . failUnlessEqual ( sample . FooTest , sample1 ) <EOL> def test_findNonModule ( self ) : <EOL> self . failUnlessRaises ( AttributeError , <EOL> self . loader . findByName , <EOL> '<STR_LIT>' ) <EOL> def test_findNonPackage ( self ) : <EOL> self . failUnlessRaises ( ValueError , <EOL> self . loader . findByName , <EOL> '<STR_LIT>' ) <EOL> def test_findNonFile ( self ) : <EOL> path = util . sibpath ( __file__ , '<STR_LIT>' ) <EOL> self . failUnlessRaises ( ValueError , self . loader . findByName , path ) <EOL> class FileTest ( packages . SysPathManglingTest ) : <EOL> """<STR_LIT>""" <EOL> def test_notFile ( self ) : <EOL> self . failUnlessRaises ( ValueError , <EOL> runner . filenameToModule , '<STR_LIT>' ) <EOL> def test_moduleInPath ( self ) : <EOL> sample1 = runner . filenameToModule ( util . sibpath ( __file__ , '<STR_LIT>' ) ) <EOL> import sample as sample2 <EOL> self . failUnlessEqual ( sample2 , sample1 ) <EOL> def test_moduleNotInPath ( self ) : <EOL> """<STR_LIT>""" <EOL> self . addCleanup ( sys . modules . pop , '<STR_LIT>' , None ) <EOL> self . mangleSysPath ( self . oldPath ) <EOL> sample1 = runner . filenameToModule ( <EOL> os . path . join ( self . parent , '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> self . mangleSysPath ( self . newPath ) <EOL> from goodpackage import test_sample as sample2 <EOL> self . failUnlessEqual ( os . path . splitext ( sample2 . __file__ ) [ <NUM_LIT:0> ] , <EOL> os . path . splitext ( sample1 . __file__ ) [ <NUM_LIT:0> ] ) <EOL> def test_packageInPath ( self ) : <EOL> package1 = runner . filenameToModule ( os . path . join ( self . parent , <EOL> '<STR_LIT>' ) ) <EOL> import goodpackage <EOL> self . failUnlessEqual ( goodpackage , package1 ) <EOL> def test_packageNotInPath ( self ) : <EOL> """<STR_LIT>""" <EOL> self . addCleanup ( sys . modules . pop , "<STR_LIT>" ) <EOL> self . mangleSysPath ( self . oldPath ) <EOL> package1 = runner . filenameToModule ( <EOL> os . path . join ( self . parent , '<STR_LIT>' ) ) <EOL> self . mangleSysPath ( self . newPath ) <EOL> import goodpackage <EOL> self . failUnlessEqual ( os . path . splitext ( goodpackage . __file__ ) [ <NUM_LIT:0> ] , <EOL> os . path . splitext ( package1 . __file__ ) [ <NUM_LIT:0> ] ) <EOL> def test_directoryNotPackage ( self ) : <EOL> self . failUnlessRaises ( ValueError , runner . filenameToModule , <EOL> util . sibpath ( __file__ , '<STR_LIT>' ) ) <EOL> def test_filenameNotPython ( self ) : <EOL> self . failUnlessRaises ( ValueError , runner . filenameToModule , <EOL> util . sibpath ( __file__ , '<STR_LIT>' ) ) <EOL> def test_filenameMatchesPackage ( self ) : <EOL> filename = os . path . join ( self . parent , '<STR_LIT>' ) <EOL> fd = open ( filename , '<STR_LIT:w>' ) <EOL> fd . write ( packages . testModule ) <EOL> fd . close ( ) <EOL> try : <EOL> module = runner . filenameToModule ( filename ) <EOL> self . failUnlessEqual ( filename , module . __file__ ) <EOL> finally : <EOL> os . remove ( filename ) <EOL> def test_directory ( self ) : <EOL> """<STR_LIT>""" <EOL> path = util . sibpath ( __file__ , '<STR_LIT>' ) <EOL> os . mkdir ( path ) <EOL> f = file ( os . path . join ( path , '<STR_LIT>' ) , "<STR_LIT:w>" ) <EOL> f . close ( ) <EOL> try : <EOL> module = runner . filenameToModule ( path ) <EOL> self . assert_ ( module . __name__ . endswith ( '<STR_LIT>' ) ) <EOL> module = runner . filenameToModule ( path + os . path . sep ) <EOL> self . assert_ ( module . __name__ . endswith ( '<STR_LIT>' ) ) <EOL> finally : <EOL> shutil . rmtree ( path ) <EOL> class LoaderTest ( packages . SysPathManglingTest ) : <EOL> def setUp ( self ) : <EOL> self . loader = runner . TestLoader ( ) <EOL> packages . SysPathManglingTest . setUp ( self ) <EOL> def test_sortCases ( self ) : <EOL> import sample <EOL> suite = self . loader . loadClass ( sample . AlphabetTest ) <EOL> self . failUnlessEqual ( [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] , <EOL> [ test . _testMethodName for test in suite . _tests ] ) <EOL> newOrder = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> sortDict = dict ( zip ( newOrder , range ( <NUM_LIT:3> ) ) ) <EOL> self . loader . sorter = lambda x : sortDict . get ( x . shortDescription ( ) , - <NUM_LIT:1> ) <EOL> suite = self . loader . loadClass ( sample . AlphabetTest ) <EOL> self . failUnlessEqual ( newOrder , <EOL> [ test . _testMethodName for test in suite . _tests ] ) <EOL> def test_loadMethod ( self ) : <EOL> import sample <EOL> suite = self . loader . loadMethod ( sample . FooTest . test_foo ) <EOL> self . failUnlessEqual ( <NUM_LIT:1> , suite . countTestCases ( ) ) <EOL> self . failUnlessEqual ( '<STR_LIT>' , suite . _testMethodName ) <EOL> def test_loadFailingMethod ( self ) : <EOL> import erroneous <EOL> suite = self . loader . loadMethod ( erroneous . TestRegularFail . test_fail ) <EOL> result = reporter . TestResult ( ) <EOL> suite . run ( result ) <EOL> self . failUnlessEqual ( result . testsRun , <NUM_LIT:1> ) <EOL> self . failUnlessEqual ( len ( result . failures ) , <NUM_LIT:1> ) <EOL> def test_loadNonMethod ( self ) : <EOL> import sample <EOL> self . failUnlessRaises ( TypeError , self . loader . loadMethod , sample ) <EOL> self . failUnlessRaises ( TypeError , <EOL> self . loader . loadMethod , sample . FooTest ) <EOL> self . failUnlessRaises ( TypeError , self . loader . loadMethod , "<STR_LIT:string>" ) <EOL> self . failUnlessRaises ( TypeError , <EOL> self . loader . loadMethod , ( '<STR_LIT:foo>' , '<STR_LIT:bar>' ) ) <EOL> def test_loadClass ( self ) : <EOL> import sample <EOL> suite = self . loader . loadClass ( sample . FooTest ) <EOL> self . failUnlessEqual ( <NUM_LIT:2> , suite . countTestCases ( ) ) <EOL> self . failUnlessEqual ( [ '<STR_LIT>' , '<STR_LIT>' ] , <EOL> [ test . _testMethodName for test in suite . _tests ] ) <EOL> def test_loadNonClass ( self ) : <EOL> import sample <EOL> self . failUnlessRaises ( TypeError , self . loader . loadClass , sample ) <EOL> self . failUnlessRaises ( TypeError , <EOL> self . loader . loadClass , sample . FooTest . test_foo ) <EOL> self . failUnlessRaises ( TypeError , self . loader . loadClass , "<STR_LIT:string>" ) <EOL> self . failUnlessRaises ( TypeError , <EOL> self . loader . loadClass , ( '<STR_LIT:foo>' , '<STR_LIT:bar>' ) ) <EOL> def test_loadNonTestCase ( self ) : <EOL> import sample <EOL> self . failUnlessRaises ( ValueError , self . loader . loadClass , <EOL> sample . NotATest ) <EOL> def test_loadModule ( self ) : <EOL> import sample <EOL> suite = self . loader . loadModule ( sample ) <EOL> self . failUnlessEqual ( <NUM_LIT:7> , suite . countTestCases ( ) ) <EOL> def test_loadNonModule ( self ) : <EOL> import sample <EOL> self . failUnlessRaises ( TypeError , <EOL> self . loader . loadModule , sample . FooTest ) <EOL> self . failUnlessRaises ( TypeError , <EOL> self . loader . loadModule , sample . FooTest . test_foo ) <EOL> self . failUnlessRaises ( TypeError , self . loader . loadModule , "<STR_LIT:string>" ) <EOL> self . failUnlessRaises ( TypeError , <EOL> self . loader . loadModule , ( '<STR_LIT:foo>' , '<STR_LIT:bar>' ) ) <EOL> def test_loadPackage ( self ) : <EOL> import goodpackage <EOL> suite = self . loader . loadPackage ( goodpackage ) <EOL> self . failUnlessEqual ( <NUM_LIT:7> , suite . countTestCases ( ) ) <EOL> def test_loadNonPackage ( self ) : <EOL> import sample <EOL> self . failUnlessRaises ( TypeError , <EOL> self . loader . loadPackage , sample . FooTest ) <EOL> self . failUnlessRaises ( TypeError , <EOL> self . loader . loadPackage , sample . FooTest . test_foo ) <EOL> self . failUnlessRaises ( TypeError , self . loader . loadPackage , "<STR_LIT:string>" ) <EOL> self . failUnlessRaises ( TypeError , <EOL> self . loader . loadPackage , ( '<STR_LIT:foo>' , '<STR_LIT:bar>' ) ) <EOL> def test_loadModuleAsPackage ( self ) : <EOL> import sample <EOL> self . failUnlessRaises ( TypeError , self . loader . loadPackage , sample ) <EOL> def test_loadPackageRecursive ( self ) : <EOL> import goodpackage <EOL> suite = self . loader . loadPackage ( goodpackage , recurse = True ) <EOL> self . failUnlessEqual ( <NUM_LIT> , suite . countTestCases ( ) ) <EOL> def test_loadAnythingOnModule ( self ) : <EOL> import sample <EOL> suite = self . loader . loadAnything ( sample ) <EOL> self . failUnlessEqual ( sample . __name__ , <EOL> suite . _tests [ <NUM_LIT:0> ] . _tests [ <NUM_LIT:0> ] . __class__ . __module__ ) <EOL> def test_loadAnythingOnClass ( self ) : <EOL> import sample <EOL> suite = self . loader . loadAnything ( sample . FooTest ) <EOL> self . failUnlessEqual ( <NUM_LIT:2> , suite . countTestCases ( ) ) <EOL> def test_loadAnythingOnMethod ( self ) : <EOL> import sample <EOL> suite = self . loader . loadAnything ( sample . FooTest . test_foo ) <EOL> self . failUnlessEqual ( <NUM_LIT:1> , suite . countTestCases ( ) ) <EOL> def test_loadAnythingOnPackage ( self ) : <EOL> import goodpackage <EOL> suite = self . loader . loadAnything ( goodpackage ) <EOL> self . failUnless ( isinstance ( suite , self . loader . suiteFactory ) ) <EOL> self . failUnlessEqual ( <NUM_LIT:7> , suite . countTestCases ( ) ) <EOL> def test_loadAnythingOnPackageRecursive ( self ) : <EOL> import goodpackage <EOL> suite = self . loader . loadAnything ( goodpackage , recurse = True ) <EOL> self . failUnless ( isinstance ( suite , self . loader . suiteFactory ) ) <EOL> self . failUnlessEqual ( <NUM_LIT> , suite . countTestCases ( ) ) <EOL> def test_loadAnythingOnString ( self ) : <EOL> self . failUnlessRaises ( TypeError , <EOL> self . loader . loadAnything , "<STR_LIT>" ) <EOL> def test_importErrors ( self ) : <EOL> import package <EOL> suite = self . loader . loadPackage ( package , recurse = True ) <EOL> result = reporter . Reporter ( ) <EOL> suite . run ( result ) <EOL> self . failUnlessEqual ( False , result . wasSuccessful ( ) ) <EOL> self . failUnlessEqual ( <NUM_LIT:2> , len ( result . errors ) ) <EOL> errors = [ test . id ( ) for test , error in result . errors ] <EOL> errors . sort ( ) <EOL> self . failUnlessEqual ( errors , [ '<STR_LIT>' , <EOL> '<STR_LIT>' ] ) <EOL> def test_differentInstances ( self ) : <EOL> """<STR_LIT>""" <EOL> class DistinctInstances ( unittest . TestCase ) : <EOL> def test_1 ( self ) : <EOL> self . first = '<STR_LIT>' <EOL> def test_2 ( self ) : <EOL> self . assertFalse ( hasattr ( self , '<STR_LIT>' ) ) <EOL> suite = self . loader . loadClass ( DistinctInstances ) <EOL> result = reporter . Reporter ( ) <EOL> suite . run ( result ) <EOL> self . assertTrue ( result . wasSuccessful ( ) ) <EOL> def test_loadModuleWith_test_suite ( self ) : <EOL> """<STR_LIT>""" <EOL> from twisted . trial . test import mockcustomsuite <EOL> suite = self . loader . loadModule ( mockcustomsuite ) <EOL> self . failUnlessEqual ( <NUM_LIT:0> , suite . countTestCases ( ) ) <EOL> self . failUnlessEqual ( "<STR_LIT>" , getattr ( suite , '<STR_LIT:name>' , None ) ) <EOL> def test_loadModuleWith_testSuite ( self ) : <EOL> """<STR_LIT>""" <EOL> from twisted . trial . test import mockcustomsuite2 <EOL> suite = self . loader . loadModule ( mockcustomsuite2 ) <EOL> self . assertEqual ( <NUM_LIT:0> , suite . countTestCases ( ) ) <EOL> self . assertEqual ( "<STR_LIT>" , getattr ( suite , '<STR_LIT:name>' , None ) ) <EOL> def test_loadModuleWithBothCustom ( self ) : <EOL> """<STR_LIT>""" <EOL> from twisted . trial . test import mockcustomsuite3 <EOL> suite = self . loader . loadModule ( mockcustomsuite3 ) <EOL> self . assertEqual ( '<STR_LIT>' , getattr ( suite , '<STR_LIT:name>' , None ) ) <EOL> def test_customLoadRaisesAttributeError ( self ) : <EOL> """<STR_LIT>""" <EOL> def testSuite ( ) : <EOL> raise AttributeError ( '<STR_LIT>' ) <EOL> from twisted . trial . test import mockcustomsuite2 <EOL> mockcustomsuite2 . testSuite , original = ( testSuite , <EOL> mockcustomsuite2 . testSuite ) <EOL> try : <EOL> self . assertRaises ( AttributeError , self . loader . loadModule , <EOL> mockcustomsuite2 ) <EOL> finally : <EOL> mockcustomsuite2 . testSuite = original <EOL> def assertSuitesEqual ( self , test1 , test2 ) : <EOL> names1 = testNames ( test1 ) <EOL> names2 = testNames ( test2 ) <EOL> names1 . sort ( ) <EOL> names2 . sort ( ) <EOL> self . assertEqual ( names1 , names2 ) <EOL> def test_loadByNamesDuplicate ( self ) : <EOL> """<STR_LIT>""" <EOL> module = '<STR_LIT>' <EOL> suite1 = self . loader . loadByNames ( [ module , module ] , True ) <EOL> suite2 = self . loader . loadByName ( module , True ) <EOL> self . assertSuitesEqual ( suite1 , suite2 ) <EOL> def test_loadDifferentNames ( self ) : <EOL> """<STR_LIT>""" <EOL> modules = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> suite1 = self . loader . loadByNames ( modules ) <EOL> suite2 = runner . TestSuite ( map ( self . loader . loadByName , modules ) ) <EOL> self . assertSuitesEqual ( suite1 , suite2 ) <EOL> class ZipLoadingTest ( LoaderTest ) : <EOL> def setUp ( self ) : <EOL> from twisted . test . test_paths import zipit <EOL> LoaderTest . setUp ( self ) <EOL> zipit ( self . parent , self . parent + '<STR_LIT>' ) <EOL> self . parent += '<STR_LIT>' <EOL> self . mangleSysPath ( self . oldPath + [ self . parent ] ) <EOL> class PackageOrderingTest ( packages . SysPathManglingTest ) : <EOL> if sys . version_info < ( <NUM_LIT:2> , <NUM_LIT:4> ) : <EOL> skip = ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> def setUp ( self ) : <EOL> self . loader = runner . TestLoader ( ) <EOL> self . topDir = self . mktemp ( ) <EOL> parent = os . path . join ( self . topDir , "<STR_LIT>" ) <EOL> os . makedirs ( parent ) <EOL> file ( os . path . join ( parent , "<STR_LIT>" ) , "<STR_LIT:wb>" ) . close ( ) <EOL> packages . SysPathManglingTest . setUp ( self , parent ) <EOL> self . mangleSysPath ( self . oldPath + [ self . topDir ] ) <EOL> def _trialSortAlgorithm ( self , sorter ) : <EOL> """<STR_LIT>""" <EOL> pkg = getModule ( '<STR_LIT>' ) <EOL> testModules = [ ] <EOL> for testModule in pkg . walkModules ( ) : <EOL> if testModule . name . split ( "<STR_LIT:.>" ) [ - <NUM_LIT:1> ] . startswith ( "<STR_LIT>" ) : <EOL> testModules . append ( testModule ) <EOL> sortedModules = sorted ( testModules , key = sorter ) <EOL> for modinfo in sortedModules : <EOL> module = modinfo . load ( None ) <EOL> if module is None : <EOL> yield modinfo <EOL> else : <EOL> testClasses = [ ] <EOL> for attrib in modinfo . iterAttributes ( ) : <EOL> if runner . isTestCase ( attrib . load ( ) ) : <EOL> testClasses . append ( attrib ) <EOL> sortedClasses = sorted ( testClasses , key = sorter ) <EOL> for clsinfo in sortedClasses : <EOL> testMethods = [ ] <EOL> for attr in clsinfo . iterAttributes ( ) : <EOL> if attr . name . split ( "<STR_LIT:.>" ) [ - <NUM_LIT:1> ] . startswith ( '<STR_LIT:test>' ) : <EOL> testMethods . append ( attr ) <EOL> sortedMethods = sorted ( testMethods , key = sorter ) <EOL> for methinfo in sortedMethods : <EOL> yield methinfo <EOL> def loadSortedPackages ( self , sorter = runner . name ) : <EOL> """<STR_LIT>""" <EOL> import uberpackage <EOL> self . loader . sorter = sorter <EOL> suite = self . loader . loadPackage ( uberpackage , recurse = True ) <EOL> suite = unittest . decorate ( suite , ITestCase ) <EOL> resultingTests = list ( unittest . _iterateTests ( suite ) ) <EOL> manifest = list ( self . _trialSortAlgorithm ( sorter ) ) <EOL> for number , ( manifestTest , actualTest ) in enumerate ( <EOL> zip ( manifest , resultingTests ) ) : <EOL> self . assertEqual ( <EOL> manifestTest . name , actualTest . id ( ) , <EOL> "<STR_LIT>" % <EOL> ( number , manifestTest . name , actualTest . id ( ) ) ) <EOL> self . assertEqual ( len ( manifest ) , len ( resultingTests ) ) <EOL> def test_sortPackagesDefaultOrder ( self ) : <EOL> self . loadSortedPackages ( ) <EOL> def test_sortPackagesSillyOrder ( self ) : <EOL> def sillySorter ( s ) : <EOL> n = runner . name ( s ) <EOL> d = md5 ( n ) . hexdigest ( ) <EOL> return d <EOL> self . loadSortedPackages ( sillySorter ) </s>

"""<STR_LIT>""" <EOL> import urllib <EOL> from twisted . internet import protocol , reactor , defer <EOL> from twisted . web import http <EOL> class GoogleChecker ( http . HTTPClient ) : <EOL> def connectionMade ( self ) : <EOL> self . sendCommand ( '<STR_LIT:GET>' , self . factory . url ) <EOL> self . sendHeader ( '<STR_LIT>' , self . factory . host ) <EOL> self . sendHeader ( '<STR_LIT>' , self . factory . agent ) <EOL> self . endHeaders ( ) <EOL> def handleHeader ( self , key , value ) : <EOL> key = key . lower ( ) <EOL> if key == '<STR_LIT:location>' : <EOL> self . factory . gotLocation ( value ) <EOL> def handleStatus ( self , version , status , message ) : <EOL> if status != '<STR_LIT>' : <EOL> self . factory . noLocation ( ValueError ( "<STR_LIT>" ) ) <EOL> def handleEndHeaders ( self ) : <EOL> self . factory . noLocation ( ValueError ( "<STR_LIT>" ) ) <EOL> def handleResponsePart ( self , part ) : <EOL> pass <EOL> def handleResponseEnd ( self ) : <EOL> pass <EOL> def connectionLost ( self , reason ) : <EOL> self . factory . noLocation ( reason ) <EOL> class GoogleCheckerFactory ( protocol . ClientFactory ) :

protocol = GoogleChecker

"""<STR_LIT>""" <EOL> import urllib <EOL> from twisted . internet import protocol , reactor , defer <EOL> from twisted . web import http <EOL> class GoogleChecker ( http . HTTPClient ) : <EOL> def connectionMade ( self ) : <EOL> self . sendCommand ( '<STR_LIT:GET>' , self . factory . url ) <EOL> self . sendHeader ( '<STR_LIT>' , self . factory . host ) <EOL> self . sendHeader ( '<STR_LIT>' , self . factory . agent ) <EOL> self . endHeaders ( ) <EOL> def handleHeader ( self , key , value ) : <EOL> key = key . lower ( ) <EOL> if key == '<STR_LIT:location>' : <EOL> self . factory . gotLocation ( value ) <EOL> def handleStatus ( self , version , status , message ) : <EOL> if status != '<STR_LIT>' : <EOL> self . factory . noLocation ( ValueError ( "<STR_LIT>" ) ) <EOL> def handleEndHeaders ( self ) : <EOL> self . factory . noLocation ( ValueError ( "<STR_LIT>" ) ) <EOL> def handleResponsePart ( self , part ) : <EOL> pass <EOL> def handleResponseEnd ( self ) : <EOL> pass <EOL> def connectionLost ( self , reason ) : <EOL> self . factory . noLocation ( reason ) <EOL> class GoogleCheckerFactory ( protocol . ClientFactory ) : <EOL> protocol = GoogleChecker <EOL> def __init__ ( self , words ) : <EOL> self . url = ( '<STR_LIT>' % <EOL> ( urllib . quote_plus ( '<STR_LIT:U+0020>' . join ( words ) ) , <EOL> urllib . quote_plus ( "<STR_LIT>" ) ) ) <EOL> self . agent = "<STR_LIT>" <EOL> self . host = "<STR_LIT>" <EOL> self . deferred = defer . Deferred ( ) <EOL> def clientConnectionFailed ( self , _ , reason ) : <EOL> self . noLocation ( reason ) <EOL> def gotLocation ( self , location ) : <EOL> if self . deferred : <EOL> self . deferred . callback ( location ) <EOL> self . deferred = None <EOL> def noLocation ( self , error ) : <EOL> if self . deferred : <EOL> self . deferred . errback ( error ) <EOL> self . deferred = None <EOL> def checkGoogle ( words ) : <EOL> """<STR_LIT>""" <EOL> factory = GoogleCheckerFactory ( words ) <EOL> reactor . connectTCP ( '<STR_LIT>' , <NUM_LIT> , factory ) <EOL> return factory . deferred </s>

"""<STR_LIT>""" <EOL> import os <EOL> from twisted . trial . unittest import TestCase <EOL> from twisted . web . http import NOT_FOUND <EOL> from twisted . web . script import ResourceScriptDirectory , PythonScript <EOL> from twisted . web . test . _util import _render <EOL> from twisted . web . test . test_web import DummyRequest

class ResourceScriptDirectoryTests ( TestCase ) :

"""<STR_LIT>""" <EOL> import os <EOL> from twisted . trial . unittest import TestCase <EOL> from twisted . web . http import NOT_FOUND <EOL> from twisted . web . script import ResourceScriptDirectory , PythonScript <EOL> from twisted . web . test . _util import _render <EOL> from twisted . web . test . test_web import DummyRequest <EOL> class ResourceScriptDirectoryTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_render ( self ) : <EOL> """<STR_LIT>""" <EOL> resource = ResourceScriptDirectory ( self . mktemp ( ) ) <EOL> request = DummyRequest ( [ '<STR_LIT>' ] ) <EOL> d = _render ( resource , request ) <EOL> def cbRendered ( ignored ) : <EOL> self . assertEqual ( request . responseCode , NOT_FOUND ) <EOL> d . addCallback ( cbRendered ) <EOL> return d <EOL> def test_notFoundChild ( self ) : <EOL> """<STR_LIT>""" <EOL> path = self . mktemp ( ) <EOL> os . makedirs ( path ) <EOL> resource = ResourceScriptDirectory ( path ) <EOL> request = DummyRequest ( [ '<STR_LIT:foo>' ] ) <EOL> child = resource . getChild ( "<STR_LIT:foo>" , request ) <EOL> d = _render ( child , request ) <EOL> def cbRendered ( ignored ) : <EOL> self . assertEqual ( request . responseCode , NOT_FOUND ) <EOL> d . addCallback ( cbRendered ) <EOL> return d <EOL> class PythonScriptTests ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_notFoundRender ( self ) : <EOL> """<STR_LIT>""" <EOL> resource = PythonScript ( self . mktemp ( ) , None ) <EOL> request = DummyRequest ( [ '<STR_LIT>' ] ) <EOL> d = _render ( resource , request ) <EOL> def cbRendered ( ignored ) : <EOL> self . assertEqual ( request . responseCode , NOT_FOUND ) <EOL> d . addCallback ( cbRendered ) <EOL> return d </s>

"""<STR_LIT>""" <EOL> from __future__ import nested_scopes <EOL> from twisted . internet import defer <EOL> from twisted . internet import error <EOL> from twisted . python import log <EOL> from twisted . python . failure import Failure <EOL> from twisted . spread import pb <EOL> from twisted . words . im . locals import ONLINE , OFFLINE , AWAY <EOL> from twisted . words . im import basesupport , interfaces <EOL> from zope . interface import implements <EOL> class TwistedWordsPerson ( basesupport . AbstractPerson ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , name , wordsAccount ) : <EOL> basesupport . AbstractPerson . __init__ ( self , name , wordsAccount ) <EOL> self . status = OFFLINE <EOL> def isOnline ( self ) : <EOL> return ( ( self . status == ONLINE ) or <EOL> ( self . status == AWAY ) ) <EOL> def getStatus ( self ) : <EOL> return self . status <EOL> def sendMessage ( self , text , metadata ) : <EOL> """<STR_LIT>""" <EOL> if metadata : <EOL> d = self . account . client . perspective . directMessage ( self . name , <EOL> text , metadata ) <EOL> d . addErrback ( self . metadataFailed , "<STR_LIT>" + text ) <EOL> return d <EOL> else : <EOL> return self . account . client . perspective . callRemote ( '<STR_LIT>' , self . name , text ) <EOL> def metadataFailed ( self , result , text ) : <EOL> print "<STR_LIT>" , result , "<STR_LIT>" , text <EOL> return self . account . client . perspective . directMessage ( self . name , text ) <EOL> def setStatus ( self , status ) : <EOL> self . status = status <EOL> self . chat . getContactsList ( ) . setContactStatus ( self ) <EOL> class TwistedWordsGroup ( basesupport . AbstractGroup ) : <EOL> implements ( interfaces . IGroup ) <EOL> def __init__ ( self , name , wordsClient ) : <EOL> basesupport . AbstractGroup . __init__ ( self , name , wordsClient ) <EOL> self . joined = <NUM_LIT:0> <EOL> def sendGroupMessage ( self , text , metadata = None ) : <EOL> """<STR_LIT>""" <EOL> if metadata : <EOL> d = self . account . client . perspective . callRemote ( <EOL> '<STR_LIT>' , self . name , text , metadata ) <EOL> d . addErrback ( self . metadataFailed , "<STR_LIT>" + text ) <EOL> return d <EOL> else :

return self . account . client . perspective . callRemote ( '<STR_LIT>' ,

"""<STR_LIT>""" <EOL> from __future__ import nested_scopes <EOL> from twisted . internet import defer <EOL> from twisted . internet import error <EOL> from twisted . python import log <EOL> from twisted . python . failure import Failure <EOL> from twisted . spread import pb <EOL> from twisted . words . im . locals import ONLINE , OFFLINE , AWAY <EOL> from twisted . words . im import basesupport , interfaces <EOL> from zope . interface import implements <EOL> class TwistedWordsPerson ( basesupport . AbstractPerson ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , name , wordsAccount ) : <EOL> basesupport . AbstractPerson . __init__ ( self , name , wordsAccount ) <EOL> self . status = OFFLINE <EOL> def isOnline ( self ) : <EOL> return ( ( self . status == ONLINE ) or <EOL> ( self . status == AWAY ) ) <EOL> def getStatus ( self ) : <EOL> return self . status <EOL> def sendMessage ( self , text , metadata ) : <EOL> """<STR_LIT>""" <EOL> if metadata : <EOL> d = self . account . client . perspective . directMessage ( self . name , <EOL> text , metadata ) <EOL> d . addErrback ( self . metadataFailed , "<STR_LIT>" + text ) <EOL> return d <EOL> else : <EOL> return self . account . client . perspective . callRemote ( '<STR_LIT>' , self . name , text ) <EOL> def metadataFailed ( self , result , text ) : <EOL> print "<STR_LIT>" , result , "<STR_LIT>" , text <EOL> return self . account . client . perspective . directMessage ( self . name , text ) <EOL> def setStatus ( self , status ) : <EOL> self . status = status <EOL> self . chat . getContactsList ( ) . setContactStatus ( self ) <EOL> class TwistedWordsGroup ( basesupport . AbstractGroup ) : <EOL> implements ( interfaces . IGroup ) <EOL> def __init__ ( self , name , wordsClient ) : <EOL> basesupport . AbstractGroup . __init__ ( self , name , wordsClient ) <EOL> self . joined = <NUM_LIT:0> <EOL> def sendGroupMessage ( self , text , metadata = None ) : <EOL> """<STR_LIT>""" <EOL> if metadata : <EOL> d = self . account . client . perspective . callRemote ( <EOL> '<STR_LIT>' , self . name , text , metadata ) <EOL> d . addErrback ( self . metadataFailed , "<STR_LIT>" + text ) <EOL> return d <EOL> else : <EOL> return self . account . client . perspective . callRemote ( '<STR_LIT>' , <EOL> self . name , text ) <EOL> def setTopic ( self , text ) : <EOL> self . account . client . perspective . callRemote ( <EOL> '<STR_LIT>' , <EOL> { '<STR_LIT>' : text , '<STR_LIT>' : self . client . name } , <EOL> self . name ) <EOL> def metadataFailed ( self , result , text ) : <EOL> print "<STR_LIT>" , result , "<STR_LIT>" , text <EOL> return self . account . client . perspective . callRemote ( '<STR_LIT>' , <EOL> self . name , text ) <EOL> def joining ( self ) : <EOL> self . joined = <NUM_LIT:1> <EOL> def leaving ( self ) : <EOL> self . joined = <NUM_LIT:0> <EOL> def leave ( self ) : <EOL> return self . account . client . perspective . callRemote ( '<STR_LIT>' , <EOL> self . name ) <EOL> class TwistedWordsClient ( pb . Referenceable , basesupport . AbstractClientMixin ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , acct , serviceName , perspectiveName , chatui , <EOL> _logonDeferred = None ) : <EOL> self . accountName = "<STR_LIT>" % ( acct . accountName , serviceName , perspectiveName ) <EOL> self . name = perspectiveName <EOL> print "<STR_LIT>" , serviceName , perspectiveName <EOL> self . chat = chatui <EOL> self . account = acct <EOL> self . _logonDeferred = _logonDeferred <EOL> def getPerson ( self , name ) : <EOL> return self . chat . getPerson ( name , self ) <EOL> def getGroup ( self , name ) : <EOL> return self . chat . getGroup ( name , self ) <EOL> def getGroupConversation ( self , name ) : <EOL> return self . chat . getGroupConversation ( self . getGroup ( name ) ) <EOL> def addContact ( self , name ) : <EOL> self . perspective . callRemote ( '<STR_LIT>' , name ) <EOL> def remote_receiveGroupMembers ( self , names , group ) : <EOL> print '<STR_LIT>' , names , group <EOL> self . getGroupConversation ( group ) . setGroupMembers ( names ) <EOL> def remote_receiveGroupMessage ( self , sender , group , message , metadata = None ) : <EOL> print '<STR_LIT>' , sender , group , message , metadata <EOL> self . getGroupConversation ( group ) . showGroupMessage ( sender , message , metadata ) <EOL> def remote_memberJoined ( self , member , group ) : <EOL> print '<STR_LIT>' , member , group <EOL> self . getGroupConversation ( group ) . memberJoined ( member ) <EOL> def remote_memberLeft ( self , member , group ) : <EOL> print '<STR_LIT>' <EOL> self . getGroupConversation ( group ) . memberLeft ( member ) <EOL> def remote_notifyStatusChanged ( self , name , status ) : <EOL> self . chat . getPerson ( name , self ) . setStatus ( status ) <EOL> def remote_receiveDirectMessage ( self , name , message , metadata = None ) : <EOL> self . chat . getConversation ( self . chat . getPerson ( name , self ) ) . showMessage ( message , metadata ) <EOL> def remote_receiveContactList ( self , clist ) : <EOL> for name , status in clist : <EOL> self . chat . getPerson ( name , self ) . setStatus ( status ) <EOL> def remote_setGroupMetadata ( self , dict_ , groupName ) : <EOL> if dict_ . has_key ( "<STR_LIT>" ) : <EOL> self . getGroupConversation ( groupName ) . setTopic ( dict_ [ "<STR_LIT>" ] , dict_ . get ( "<STR_LIT>" , None ) ) <EOL> def joinGroup ( self , name ) : <EOL> self . getGroup ( name ) . joining ( ) <EOL> return self . perspective . callRemote ( '<STR_LIT>' , name ) . addCallback ( self . _cbGroupJoined , name ) <EOL> def leaveGroup ( self , name ) : <EOL> self . getGroup ( name ) . leaving ( ) <EOL> return self . perspective . callRemote ( '<STR_LIT>' , name ) . addCallback ( self . _cbGroupLeft , name ) <EOL> def _cbGroupJoined ( self , result , name ) : <EOL> groupConv = self . chat . getGroupConversation ( self . getGroup ( name ) ) <EOL> groupConv . showGroupMessage ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> self . perspective . callRemote ( '<STR_LIT>' , name ) <EOL> def _cbGroupLeft ( self , result , name ) : <EOL> print '<STR_LIT:left>' , name <EOL> groupConv = self . chat . getGroupConversation ( self . getGroup ( name ) , <NUM_LIT:1> ) <EOL> groupConv . showGroupMessage ( "<STR_LIT>" , "<STR_LIT>" ) <EOL> def connected ( self , perspective ) : <EOL> print '<STR_LIT>' , perspective <EOL> if self . _logonDeferred is not None : <EOL> self . _logonDeferred . callback ( self ) <EOL> self . perspective = perspective <EOL> self . chat . getContactsList ( ) <EOL> pbFrontEnds = { <EOL> "<STR_LIT>" : TwistedWordsClient , <EOL> "<STR_LIT>" : None <EOL> } <EOL> class PBAccount ( basesupport . AbstractAccount ) : <EOL> implements ( interfaces . IAccount ) <EOL> gatewayType = "<STR_LIT>" <EOL> _groupFactory = TwistedWordsGroup <EOL> _personFactory = TwistedWordsPerson <EOL> def __init__ ( self , accountName , autoLogin , username , password , host , port , <EOL> services = None ) : <EOL> """<STR_LIT>""" <EOL> basesupport . AbstractAccount . __init__ ( self , accountName , autoLogin , <EOL> username , password , host , port ) <EOL> self . services = [ ] <EOL> if not services : <EOL> services = [ ( '<STR_LIT>' , '<STR_LIT>' , username ) ] <EOL> for serviceType , serviceName , perspectiveName in services : <EOL> self . services . append ( [ pbFrontEnds [ serviceType ] , serviceName , <EOL> perspectiveName ] ) <EOL> def logOn ( self , chatui ) : <EOL> """<STR_LIT>""" <EOL> if ( not self . _isConnecting ) and ( not self . _isOnline ) : <EOL> self . _isConnecting = <NUM_LIT:1> <EOL> d = self . _startLogOn ( chatui ) <EOL> d . addErrback ( self . _loginFailed ) <EOL> def registerMany ( results ) : <EOL> for success , result in results : <EOL> if success : <EOL> chatui . registerAccountClient ( result ) <EOL> self . _cb_logOn ( result ) <EOL> else : <EOL> log . err ( result ) <EOL> d . addCallback ( registerMany ) <EOL> return d <EOL> else : <EOL> raise error . ConnectionError ( "<STR_LIT>" ) <EOL> def _startLogOn ( self , chatui ) : <EOL> print '<STR_LIT>' , <EOL> d = pb . getObjectAt ( self . host , self . port ) <EOL> d . addCallbacks ( self . _cbConnected , self . _ebConnected , <EOL> callbackArgs = ( chatui , ) ) <EOL> return d <EOL> def _cbConnected ( self , root , chatui ) : <EOL> print '<STR_LIT>' <EOL> print '<STR_LIT>' , <EOL> d = pb . authIdentity ( root , self . username , self . password ) <EOL> d . addCallbacks ( self . _cbIdent , self . _ebConnected , <EOL> callbackArgs = ( chatui , ) ) <EOL> return d <EOL> def _cbIdent ( self , ident , chatui ) : <EOL> if not ident : <EOL> print '<STR_LIT>' <EOL> return self . _ebConnected ( Failure ( Exception ( "<STR_LIT>" ) ) ) <EOL> print '<STR_LIT>' <EOL> dl = [ ] <EOL> for handlerClass , sname , pname in self . services : <EOL> d = defer . Deferred ( ) <EOL> dl . append ( d ) <EOL> handler = handlerClass ( self , sname , pname , chatui , d ) <EOL> ident . callRemote ( '<STR_LIT>' , sname , pname , handler ) . addCallback ( handler . connected ) <EOL> return defer . DeferredList ( dl ) <EOL> def _ebConnected ( self , error ) : <EOL> print '<STR_LIT>' <EOL> return error </s>

"""<STR_LIT>""" <EOL> from twisted . internet import defer <EOL> from twisted . python . hashlib import sha1 <EOL> from twisted . trial import unittest <EOL> from twisted . words . protocols . jabber import client , error , jid , xmlstream <EOL> from twisted . words . protocols . jabber . sasl import SASLInitiatingInitializer <EOL> from twisted . words . xish import utility

IQ_AUTH_GET = '<STR_LIT>'

"""<STR_LIT>""" <EOL> from twisted . internet import defer <EOL> from twisted . python . hashlib import sha1 <EOL> from twisted . trial import unittest <EOL> from twisted . words . protocols . jabber import client , error , jid , xmlstream <EOL> from twisted . words . protocols . jabber . sasl import SASLInitiatingInitializer <EOL> from twisted . words . xish import utility <EOL> IQ_AUTH_GET = '<STR_LIT>' <EOL> IQ_AUTH_SET = '<STR_LIT>' <EOL> NS_BIND = '<STR_LIT>' <EOL> IQ_BIND_SET = '<STR_LIT>' % NS_BIND <EOL> NS_SESSION = '<STR_LIT>' <EOL> IQ_SESSION_SET = '<STR_LIT>' % NS_SESSION <EOL> class CheckVersionInitializerTest ( unittest . TestCase ) : <EOL> def setUp ( self ) : <EOL> a = xmlstream . Authenticator ( ) <EOL> xs = xmlstream . XmlStream ( a ) <EOL> self . init = client . CheckVersionInitializer ( xs ) <EOL> def testSupported ( self ) : <EOL> """<STR_LIT>""" <EOL> self . init . xmlstream . version = ( <NUM_LIT:1> , <NUM_LIT:0> ) <EOL> self . init . initialize ( ) <EOL> def testNotSupported ( self ) : <EOL> """<STR_LIT>""" <EOL> self . init . xmlstream . version = ( <NUM_LIT:0> , <NUM_LIT:0> ) <EOL> exc = self . assertRaises ( error . StreamError , self . init . initialize ) <EOL> self . assertEquals ( '<STR_LIT>' , exc . condition ) <EOL> class InitiatingInitializerHarness ( object ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> self . output = [ ] <EOL> self . pipe = utility . XmlPipe ( ) <EOL> self . xmlstream = self . pipe . sink <EOL> self . authenticator = xmlstream . ConnectAuthenticator ( '<STR_LIT>' ) <EOL> self . xmlstream . authenticator = self . authenticator <EOL> def waitFor ( self , event , handler ) : <EOL> """<STR_LIT>""" <EOL> d = defer . Deferred ( ) <EOL> d . addCallback ( handler ) <EOL> self . pipe . source . addOnetimeObserver ( event , d . callback ) <EOL> return d <EOL> class IQAuthInitializerTest ( InitiatingInitializerHarness , unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> super ( IQAuthInitializerTest , self ) . setUp ( ) <EOL> self . init = client . IQAuthInitializer ( self . xmlstream ) <EOL> self . authenticator . jid = jid . JID ( '<STR_LIT>' ) <EOL> self . authenticator . password = '<STR_LIT>' <EOL> def testPlainText ( self ) : <EOL> """<STR_LIT>""" <EOL> def onAuthGet ( iq ) : <EOL> """<STR_LIT>""" <EOL> response = xmlstream . toResponse ( iq , '<STR_LIT:result>' ) <EOL> response . addElement ( ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> response . query . addElement ( '<STR_LIT:username>' ) <EOL> response . query . addElement ( '<STR_LIT:password>' ) <EOL> response . query . addElement ( '<STR_LIT>' ) <EOL> d = self . waitFor ( IQ_AUTH_SET , onAuthSet ) <EOL> self . pipe . source . send ( response ) <EOL> return d <EOL> def onAuthSet ( iq ) : <EOL> """<STR_LIT>""" <EOL> self . assertEquals ( '<STR_LIT:user>' , unicode ( iq . query . username ) ) <EOL> self . assertEquals ( '<STR_LIT>' , unicode ( iq . query . password ) ) <EOL> self . assertEquals ( '<STR_LIT>' , unicode ( iq . query . resource ) ) <EOL> response = xmlstream . toResponse ( iq , '<STR_LIT:result>' ) <EOL> self . pipe . source . send ( response ) <EOL> d1 = self . waitFor ( IQ_AUTH_GET , onAuthGet ) <EOL> d2 = self . init . initialize ( ) <EOL> return defer . gatherResults ( [ d1 , d2 ] ) <EOL> def testDigest ( self ) : <EOL> """<STR_LIT>""" <EOL> def onAuthGet ( iq ) : <EOL> """<STR_LIT>""" <EOL> response = xmlstream . toResponse ( iq , '<STR_LIT:result>' ) <EOL> response . addElement ( ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> response . query . addElement ( '<STR_LIT:username>' ) <EOL> response . query . addElement ( '<STR_LIT>' ) <EOL> response . query . addElement ( '<STR_LIT>' ) <EOL> d = self . waitFor ( IQ_AUTH_SET , onAuthSet ) <EOL> self . pipe . source . send ( response ) <EOL> return d <EOL> def onAuthSet ( iq ) : <EOL> """<STR_LIT>""" <EOL> self . assertEquals ( '<STR_LIT:user>' , unicode ( iq . query . username ) ) <EOL> self . assertEquals ( sha1 ( '<STR_LIT>' ) . hexdigest ( ) , <EOL> unicode ( iq . query . digest ) . encode ( '<STR_LIT:utf-8>' ) ) <EOL> self . assertEquals ( '<STR_LIT>' , unicode ( iq . query . resource ) ) <EOL> response = xmlstream . toResponse ( iq , '<STR_LIT:result>' ) <EOL> self . pipe . source . send ( response ) <EOL> self . xmlstream . sid = u'<STR_LIT>' <EOL> d1 = self . waitFor ( IQ_AUTH_GET , onAuthGet ) <EOL> d2 = self . init . initialize ( ) <EOL> return defer . gatherResults ( [ d1 , d2 ] ) <EOL> def testFailRequestFields ( self ) : <EOL> """<STR_LIT>""" <EOL> def onAuthGet ( iq ) : <EOL> """<STR_LIT>""" <EOL> response = error . StanzaError ( '<STR_LIT>' ) . toResponse ( iq ) <EOL> self . pipe . source . send ( response ) <EOL> d1 = self . waitFor ( IQ_AUTH_GET , onAuthGet ) <EOL> d2 = self . init . initialize ( ) <EOL> self . assertFailure ( d2 , error . StanzaError ) <EOL> return defer . gatherResults ( [ d1 , d2 ] ) <EOL> def testFailAuth ( self ) : <EOL> """<STR_LIT>""" <EOL> def onAuthGet ( iq ) : <EOL> """<STR_LIT>""" <EOL> response = xmlstream . toResponse ( iq , '<STR_LIT:result>' ) <EOL> response . addElement ( ( '<STR_LIT>' , '<STR_LIT>' ) ) <EOL> response . query . addElement ( '<STR_LIT:username>' ) <EOL> response . query . addElement ( '<STR_LIT:password>' ) <EOL> response . query . addElement ( '<STR_LIT>' ) <EOL> d = self . waitFor ( IQ_AUTH_SET , onAuthSet ) <EOL> self . pipe . source . send ( response ) <EOL> return d <EOL> def onAuthSet ( iq ) : <EOL> """<STR_LIT>""" <EOL> response = error . StanzaError ( '<STR_LIT>' ) . toResponse ( iq ) <EOL> self . pipe . source . send ( response ) <EOL> d1 = self . waitFor ( IQ_AUTH_GET , onAuthGet ) <EOL> d2 = self . init . initialize ( ) <EOL> self . assertFailure ( d2 , error . StanzaError ) <EOL> return defer . gatherResults ( [ d1 , d2 ] ) <EOL> class BindInitializerTest ( InitiatingInitializerHarness , unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> super ( BindInitializerTest , self ) . setUp ( ) <EOL> self . init = client . BindInitializer ( self . xmlstream ) <EOL> self . authenticator . jid = jid . JID ( '<STR_LIT>' ) <EOL> def testBasic ( self ) : <EOL> """<STR_LIT>""" <EOL> def onBind ( iq ) : <EOL> response = xmlstream . toResponse ( iq , '<STR_LIT:result>' ) <EOL> response . addElement ( ( NS_BIND , '<STR_LIT>' ) ) <EOL> response . bind . addElement ( '<STR_LIT>' , <EOL> content = '<STR_LIT>' ) <EOL> self . pipe . source . send ( response ) <EOL> def cb ( result ) : <EOL> self . assertEquals ( jid . JID ( '<STR_LIT>' ) , <EOL> self . authenticator . jid ) <EOL> d1 = self . waitFor ( IQ_BIND_SET , onBind ) <EOL> d2 = self . init . start ( ) <EOL> d2 . addCallback ( cb ) <EOL> return defer . gatherResults ( [ d1 , d2 ] ) <EOL> def testFailure ( self ) : <EOL> """<STR_LIT>""" <EOL> def onBind ( iq ) : <EOL> response = error . StanzaError ( '<STR_LIT>' ) . toResponse ( iq ) <EOL> self . pipe . source . send ( response ) <EOL> d1 = self . waitFor ( IQ_BIND_SET , onBind ) <EOL> d2 = self . init . start ( ) <EOL> self . assertFailure ( d2 , error . StanzaError ) <EOL> return defer . gatherResults ( [ d1 , d2 ] ) <EOL> class SessionInitializerTest ( InitiatingInitializerHarness , unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> super ( SessionInitializerTest , self ) . setUp ( ) <EOL> self . init = client . SessionInitializer ( self . xmlstream ) <EOL> def testSuccess ( self ) : <EOL> """<STR_LIT>""" <EOL> def onSession ( iq ) : <EOL> response = xmlstream . toResponse ( iq , '<STR_LIT:result>' ) <EOL> self . pipe . source . send ( response ) <EOL> d1 = self . waitFor ( IQ_SESSION_SET , onSession ) <EOL> d2 = self . init . start ( ) <EOL> return defer . gatherResults ( [ d1 , d2 ] ) <EOL> def testFailure ( self ) : <EOL> """<STR_LIT>""" <EOL> def onSession ( iq ) : <EOL> response = error . StanzaError ( '<STR_LIT>' ) . toResponse ( iq ) <EOL> self . pipe . source . send ( response ) <EOL> d1 = self . waitFor ( IQ_SESSION_SET , onSession ) <EOL> d2 = self . init . start ( ) <EOL> self . assertFailure ( d2 , error . StanzaError ) <EOL> return defer . gatherResults ( [ d1 , d2 ] ) <EOL> class XMPPAuthenticatorTest ( unittest . TestCase ) : <EOL> """<STR_LIT>""" <EOL> def testBasic ( self ) : <EOL> """<STR_LIT>""" <EOL> self . client_jid = jid . JID ( '<STR_LIT>' ) <EOL> xs = client . XMPPClientFactory ( self . client_jid , <EOL> '<STR_LIT>' ) . buildProtocol ( None ) <EOL> self . assertEqual ( '<STR_LIT>' , xs . authenticator . otherHost ) <EOL> self . assertEqual ( self . client_jid , xs . authenticator . jid ) <EOL> self . assertEqual ( '<STR_LIT>' , xs . authenticator . password ) <EOL> version , tls , sasl , bind , session = xs . initializers <EOL> self . assert_ ( isinstance ( tls , xmlstream . TLSInitiatingInitializer ) ) <EOL> self . assert_ ( isinstance ( sasl , SASLInitiatingInitializer ) ) <EOL> self . assert_ ( isinstance ( bind , client . BindInitializer ) ) <EOL> self . assert_ ( isinstance ( session , client . SessionInitializer ) ) <EOL> self . assertFalse ( tls . required ) <EOL> self . assertTrue ( sasl . required ) <EOL> self . assertFalse ( bind . required ) <EOL> self . assertFalse ( session . required ) </s>

"""<STR_LIT>""" <EOL> from zope . interface import Declaration <EOL> def _flatten ( implements , include_None = <NUM_LIT:0> ) : <EOL> try :

r = implements . flattened ( )

"""<STR_LIT>""" <EOL> from zope . interface import Declaration <EOL> def _flatten ( implements , include_None = <NUM_LIT:0> ) : <EOL> try : <EOL> r = implements . flattened ( ) <EOL> except AttributeError : <EOL> if implements is None : <EOL> r = ( ) <EOL> else : <EOL> r = Declaration ( implements ) . flattened ( ) <EOL> if not include_None : <EOL> return r <EOL> r = list ( r ) <EOL> r . append ( None ) <EOL> return r </s>

"""<STR_LIT>""" <EOL> import doctest <EOL> import unittest <EOL> import sys <EOL> class InterfaceTests ( unittest . TestCase ) : <EOL> def _makeDerivedInterface ( self ) : <EOL> from zope . interface import Interface <EOL> from zope . interface import Attribute <EOL> class _I1 ( Interface ) : <EOL> a1 = Attribute ( "<STR_LIT>" ) <EOL> def f11 ( ) : <EOL> pass <EOL> def f12 ( ) : <EOL> pass <EOL> f12 . optional = <NUM_LIT:1> <EOL> class _I1_ ( _I1 ) : <EOL> pass <EOL> class _I1__ ( _I1_ ) : <EOL> pass <EOL> class _I2 ( _I1__ ) : <EOL> def f21 ( ) : <EOL> pass <EOL> def f22 ( ) : <EOL> pass <EOL> f23 = f22 <EOL> return _I2 <EOL> def testInterfaceSetOnAttributes ( self ) : <EOL> from zope . interface . tests . unitfixtures import FooInterface <EOL> self . assertEqual ( FooInterface [ '<STR_LIT>' ] . interface , <EOL> FooInterface ) <EOL> self . assertEqual ( FooInterface [ '<STR_LIT>' ] . interface , <EOL> FooInterface ) <EOL> def testClassImplements ( self ) : <EOL> from zope . interface . tests . unitfixtures import A <EOL> from zope . interface . tests . unitfixtures import B <EOL> from zope . interface . tests . unitfixtures import C <EOL> from zope . interface . tests . unitfixtures import D <EOL> from zope . interface . tests . unitfixtures import E <EOL> from zope . interface . tests . unitfixtures import I1 <EOL> from zope . interface . tests . unitfixtures import I2 <EOL> from zope . interface . tests . unitfixtures import IC <EOL> self . assert_ ( IC . implementedBy ( C ) ) <EOL> self . assert_ ( I1 . implementedBy ( A ) ) <EOL> self . assert_ ( I1 . implementedBy ( B ) ) <EOL> self . assert_ ( not I1 . implementedBy ( C ) ) <EOL> self . assert_ ( I1 . implementedBy ( D ) ) <EOL> self . assert_ ( I1 . implementedBy ( E ) ) <EOL> self . assert_ ( not I2 . implementedBy ( A ) ) <EOL> self . assert_ ( I2 . implementedBy ( B ) ) <EOL> self . assert_ ( not I2 . implementedBy ( C ) ) <EOL> self . assert_ ( not I2 . implementedBy ( E ) ) <EOL> def testUtil ( self ) : <EOL> from zope . interface import implementedBy <EOL> from zope . interface import providedBy <EOL> from zope . interface . tests . unitfixtures import A <EOL> from zope . interface . tests . unitfixtures import B <EOL> from zope . interface . tests . unitfixtures import C <EOL> from zope . interface . tests . unitfixtures import I1 <EOL> from zope . interface . tests . unitfixtures import I2 <EOL> from zope . interface . tests . unitfixtures import IC <EOL> self . assert_ ( IC in implementedBy ( C ) ) <EOL> self . assert_ ( I1 in implementedBy ( A ) ) <EOL> self . assert_ ( not I1 in implementedBy ( C ) ) <EOL> self . assert_ ( I2 in implementedBy ( B ) ) <EOL> self . assert_ ( not I2 in implementedBy ( C ) ) <EOL> self . assert_ ( IC in providedBy ( C ( ) ) ) <EOL> self . assert_ ( I1 in providedBy ( A ( ) ) ) <EOL> self . assert_ ( not I1 in providedBy ( C ( ) ) ) <EOL> self . assert_ ( I2 in providedBy ( B ( ) ) ) <EOL> self . assert_ ( not I2 in providedBy ( C ( ) ) ) <EOL> def testObjectImplements ( self ) : <EOL> from zope . interface . tests . unitfixtures import A <EOL> from zope . interface . tests . unitfixtures import B <EOL> from zope . interface . tests . unitfixtures import C <EOL> from zope . interface . tests . unitfixtures import D <EOL> from zope . interface . tests . unitfixtures import E <EOL> from zope . interface . tests . unitfixtures import I1 <EOL> from zope . interface . tests . unitfixtures import I2 <EOL> from zope . interface . tests . unitfixtures import IC <EOL> self . assert_ ( IC . providedBy ( C ( ) ) ) <EOL> self . assert_ ( I1 . providedBy ( A ( ) ) ) <EOL> self . assert_ ( I1 . providedBy ( B ( ) ) ) <EOL> self . assert_ ( not I1 . providedBy ( C ( ) ) ) <EOL> self . assert_ ( I1 . providedBy ( D ( ) ) ) <EOL> self . assert_ ( I1 . providedBy ( E ( ) ) ) <EOL> self . assert_ ( not I2 . providedBy ( A ( ) ) ) <EOL> self . assert_ ( I2 . providedBy ( B ( ) ) ) <EOL> self . assert_ ( not I2 . providedBy ( C ( ) ) ) <EOL> self . assert_ ( not I2 . providedBy ( E ( ) ) ) <EOL> def testDeferredClass ( self ) : <EOL> from zope . interface . tests . unitfixtures import A <EOL> from zope . interface . exceptions import BrokenImplementation <EOL> a = A ( ) <EOL> self . assertRaises ( BrokenImplementation , a . ma ) <EOL> def testInterfaceExtendsInterface ( self ) : <EOL> from zope . interface . tests . unitfixtures import BazInterface <EOL> from zope . interface . tests . unitfixtures import BarInterface <EOL> from zope . interface . tests . unitfixtures import BobInterface <EOL> from zope . interface . tests . unitfixtures import FunInterface <EOL> self . assert_ ( BazInterface . extends ( BobInterface ) ) <EOL> self . assert_ ( BazInterface . extends ( BarInterface ) ) <EOL> self . assert_ ( BazInterface . extends ( FunInterface ) ) <EOL> self . assert_ ( not BobInterface . extends ( FunInterface ) ) <EOL> self . assert_ ( not BobInterface . extends ( BarInterface ) ) <EOL> self . assert_ ( BarInterface . extends ( FunInterface ) ) <EOL> self . assert_ ( not BarInterface . extends ( BazInterface ) ) <EOL> def testVerifyImplementation ( self ) : <EOL> from zope . interface . verify import verifyClass <EOL> from zope . interface import Interface <EOL> from zope . interface . tests . unitfixtures import Foo <EOL> from zope . interface . tests . unitfixtures import FooInterface <EOL> from zope . interface . tests . unitfixtures import I1 <EOL> self . assert_ ( verifyClass ( FooInterface , Foo ) ) <EOL> self . assert_ ( Interface . providedBy ( I1 ) ) <EOL> def test_names ( self ) : <EOL> iface = self . _makeDerivedInterface ( ) <EOL> names = list ( iface . names ( ) ) <EOL> names . sort ( ) <EOL> self . assertEqual ( names , [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> all = list ( iface . names ( all = True ) ) <EOL> all . sort ( ) <EOL> self . assertEqual ( all , [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> def test_namesAndDescriptions ( self ) : <EOL> iface = self . _makeDerivedInterface ( ) <EOL> names = [ nd [ <NUM_LIT:0> ] for nd in iface . namesAndDescriptions ( ) ] <EOL> names . sort ( ) <EOL> self . assertEqual ( names , [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> names = [ nd [ <NUM_LIT:0> ] for nd in iface . namesAndDescriptions ( <NUM_LIT:1> ) ] <EOL> names . sort ( ) <EOL> self . assertEqual ( names , [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> for name , d in iface . namesAndDescriptions ( <NUM_LIT:1> ) : <EOL> self . assertEqual ( name , d . __name__ ) <EOL> def test_getDescriptionFor ( self ) : <EOL> iface = self . _makeDerivedInterface ( ) <EOL> self . assertEqual ( iface . getDescriptionFor ( '<STR_LIT>' ) . __name__ , '<STR_LIT>' ) <EOL> self . assertEqual ( iface . getDescriptionFor ( '<STR_LIT>' ) . __name__ , '<STR_LIT>' ) <EOL> self . assertEqual ( iface . queryDescriptionFor ( '<STR_LIT>' , self ) , self ) <EOL> self . assertRaises ( KeyError , iface . getDescriptionFor , '<STR_LIT>' ) <EOL> def test___getitem__ ( self ) : <EOL> iface = self . _makeDerivedInterface ( ) <EOL> self . assertEqual ( iface [ '<STR_LIT>' ] . __name__ , '<STR_LIT>' ) <EOL> self . assertEqual ( iface [ '<STR_LIT>' ] . __name__ , '<STR_LIT>' ) <EOL> self . assertEqual ( iface . get ( '<STR_LIT>' , self ) , self ) <EOL> self . assertRaises ( KeyError , iface . __getitem__ , '<STR_LIT>' ) <EOL> def test___contains__ ( self ) : <EOL> iface = self . _makeDerivedInterface ( ) <EOL> self . failUnless ( '<STR_LIT>' in iface ) <EOL> self . failIf ( '<STR_LIT>' in iface ) <EOL> def test___iter__ ( self ) : <EOL> iface = self . _makeDerivedInterface ( ) <EOL> names = list ( iter ( iface ) ) <EOL> names . sort ( ) <EOL> self . assertEqual ( names , [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> def testAttr ( self ) : <EOL> iface = self . _makeDerivedInterface ( ) <EOL> description = iface . getDescriptionFor ( '<STR_LIT>' ) <EOL> self . assertEqual ( description . __name__ , '<STR_LIT>' ) <EOL> self . assertEqual ( description . __doc__ , '<STR_LIT>' ) <EOL> def testFunctionAttributes ( self ) : <EOL> from zope . interface import Interface <EOL> class ITest ( Interface ) : <EOL> def method ( ) : <EOL> pass <EOL> method . optional = <NUM_LIT:1> <EOL> method = ITest [ '<STR_LIT>' ] <EOL> self . assertEqual ( method . getTaggedValue ( '<STR_LIT>' ) , <NUM_LIT:1> ) <EOL> def testInvariant ( self ) : <EOL> from zope . interface . exceptions import Invalid <EOL> from zope . interface import directlyProvides <EOL> from zope . interface . tests . unitfixtures import BarGreaterThanFoo <EOL> from zope . interface . tests . unitfixtures import ifFooThenBar <EOL> from zope . interface . tests . unitfixtures import IInvariant <EOL> from zope . interface . tests . unitfixtures import InvariantC <EOL> from zope . interface . tests . unitfixtures import ISubInvariant <EOL> o = InvariantC ( ) <EOL> directlyProvides ( o , IInvariant ) <EOL> def errorsEqual ( self , o , error_len , error_msgs , iface = None ) : <EOL> if iface is None : <EOL> iface = IInvariant <EOL> self . assertRaises ( Invalid , iface . validateInvariants , o ) <EOL> e = [ ] <EOL> try : <EOL> iface . validateInvariants ( o , e ) <EOL> except Invalid , error : <EOL> self . assertEquals ( error . args [ <NUM_LIT:0> ] , e ) <EOL> else : <EOL> self . _assert ( <NUM_LIT:0> ) <EOL> self . assertEquals ( len ( e ) , error_len ) <EOL> msgs = [ error . args [ <NUM_LIT:0> ] for error in e ] <EOL> msgs . sort ( ) <EOL> for msg in msgs : <EOL> self . assertEquals ( msg , error_msgs . pop ( <NUM_LIT:0> ) )

self . assertEquals ( IInvariant . getTaggedValue ( '<STR_LIT>' ) ,

"""<STR_LIT>""" <EOL> import doctest <EOL> import unittest <EOL> import sys <EOL> class InterfaceTests ( unittest . TestCase ) : <EOL> def _makeDerivedInterface ( self ) : <EOL> from zope . interface import Interface <EOL> from zope . interface import Attribute <EOL> class _I1 ( Interface ) : <EOL> a1 = Attribute ( "<STR_LIT>" ) <EOL> def f11 ( ) : <EOL> pass <EOL> def f12 ( ) : <EOL> pass <EOL> f12 . optional = <NUM_LIT:1> <EOL> class _I1_ ( _I1 ) : <EOL> pass <EOL> class _I1__ ( _I1_ ) : <EOL> pass <EOL> class _I2 ( _I1__ ) : <EOL> def f21 ( ) : <EOL> pass <EOL> def f22 ( ) : <EOL> pass <EOL> f23 = f22 <EOL> return _I2 <EOL> def testInterfaceSetOnAttributes ( self ) : <EOL> from zope . interface . tests . unitfixtures import FooInterface <EOL> self . assertEqual ( FooInterface [ '<STR_LIT>' ] . interface , <EOL> FooInterface ) <EOL> self . assertEqual ( FooInterface [ '<STR_LIT>' ] . interface , <EOL> FooInterface ) <EOL> def testClassImplements ( self ) : <EOL> from zope . interface . tests . unitfixtures import A <EOL> from zope . interface . tests . unitfixtures import B <EOL> from zope . interface . tests . unitfixtures import C <EOL> from zope . interface . tests . unitfixtures import D <EOL> from zope . interface . tests . unitfixtures import E <EOL> from zope . interface . tests . unitfixtures import I1 <EOL> from zope . interface . tests . unitfixtures import I2 <EOL> from zope . interface . tests . unitfixtures import IC <EOL> self . assert_ ( IC . implementedBy ( C ) ) <EOL> self . assert_ ( I1 . implementedBy ( A ) ) <EOL> self . assert_ ( I1 . implementedBy ( B ) ) <EOL> self . assert_ ( not I1 . implementedBy ( C ) ) <EOL> self . assert_ ( I1 . implementedBy ( D ) ) <EOL> self . assert_ ( I1 . implementedBy ( E ) ) <EOL> self . assert_ ( not I2 . implementedBy ( A ) ) <EOL> self . assert_ ( I2 . implementedBy ( B ) ) <EOL> self . assert_ ( not I2 . implementedBy ( C ) ) <EOL> self . assert_ ( not I2 . implementedBy ( E ) ) <EOL> def testUtil ( self ) : <EOL> from zope . interface import implementedBy <EOL> from zope . interface import providedBy <EOL> from zope . interface . tests . unitfixtures import A <EOL> from zope . interface . tests . unitfixtures import B <EOL> from zope . interface . tests . unitfixtures import C <EOL> from zope . interface . tests . unitfixtures import I1 <EOL> from zope . interface . tests . unitfixtures import I2 <EOL> from zope . interface . tests . unitfixtures import IC <EOL> self . assert_ ( IC in implementedBy ( C ) ) <EOL> self . assert_ ( I1 in implementedBy ( A ) ) <EOL> self . assert_ ( not I1 in implementedBy ( C ) ) <EOL> self . assert_ ( I2 in implementedBy ( B ) ) <EOL> self . assert_ ( not I2 in implementedBy ( C ) ) <EOL> self . assert_ ( IC in providedBy ( C ( ) ) ) <EOL> self . assert_ ( I1 in providedBy ( A ( ) ) ) <EOL> self . assert_ ( not I1 in providedBy ( C ( ) ) ) <EOL> self . assert_ ( I2 in providedBy ( B ( ) ) ) <EOL> self . assert_ ( not I2 in providedBy ( C ( ) ) ) <EOL> def testObjectImplements ( self ) : <EOL> from zope . interface . tests . unitfixtures import A <EOL> from zope . interface . tests . unitfixtures import B <EOL> from zope . interface . tests . unitfixtures import C <EOL> from zope . interface . tests . unitfixtures import D <EOL> from zope . interface . tests . unitfixtures import E <EOL> from zope . interface . tests . unitfixtures import I1 <EOL> from zope . interface . tests . unitfixtures import I2 <EOL> from zope . interface . tests . unitfixtures import IC <EOL> self . assert_ ( IC . providedBy ( C ( ) ) ) <EOL> self . assert_ ( I1 . providedBy ( A ( ) ) ) <EOL> self . assert_ ( I1 . providedBy ( B ( ) ) ) <EOL> self . assert_ ( not I1 . providedBy ( C ( ) ) ) <EOL> self . assert_ ( I1 . providedBy ( D ( ) ) ) <EOL> self . assert_ ( I1 . providedBy ( E ( ) ) ) <EOL> self . assert_ ( not I2 . providedBy ( A ( ) ) ) <EOL> self . assert_ ( I2 . providedBy ( B ( ) ) ) <EOL> self . assert_ ( not I2 . providedBy ( C ( ) ) ) <EOL> self . assert_ ( not I2 . providedBy ( E ( ) ) ) <EOL> def testDeferredClass ( self ) : <EOL> from zope . interface . tests . unitfixtures import A <EOL> from zope . interface . exceptions import BrokenImplementation <EOL> a = A ( ) <EOL> self . assertRaises ( BrokenImplementation , a . ma ) <EOL> def testInterfaceExtendsInterface ( self ) : <EOL> from zope . interface . tests . unitfixtures import BazInterface <EOL> from zope . interface . tests . unitfixtures import BarInterface <EOL> from zope . interface . tests . unitfixtures import BobInterface <EOL> from zope . interface . tests . unitfixtures import FunInterface <EOL> self . assert_ ( BazInterface . extends ( BobInterface ) ) <EOL> self . assert_ ( BazInterface . extends ( BarInterface ) ) <EOL> self . assert_ ( BazInterface . extends ( FunInterface ) ) <EOL> self . assert_ ( not BobInterface . extends ( FunInterface ) ) <EOL> self . assert_ ( not BobInterface . extends ( BarInterface ) ) <EOL> self . assert_ ( BarInterface . extends ( FunInterface ) ) <EOL> self . assert_ ( not BarInterface . extends ( BazInterface ) ) <EOL> def testVerifyImplementation ( self ) : <EOL> from zope . interface . verify import verifyClass <EOL> from zope . interface import Interface <EOL> from zope . interface . tests . unitfixtures import Foo <EOL> from zope . interface . tests . unitfixtures import FooInterface <EOL> from zope . interface . tests . unitfixtures import I1 <EOL> self . assert_ ( verifyClass ( FooInterface , Foo ) ) <EOL> self . assert_ ( Interface . providedBy ( I1 ) ) <EOL> def test_names ( self ) : <EOL> iface = self . _makeDerivedInterface ( ) <EOL> names = list ( iface . names ( ) ) <EOL> names . sort ( ) <EOL> self . assertEqual ( names , [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> all = list ( iface . names ( all = True ) ) <EOL> all . sort ( ) <EOL> self . assertEqual ( all , [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> def test_namesAndDescriptions ( self ) : <EOL> iface = self . _makeDerivedInterface ( ) <EOL> names = [ nd [ <NUM_LIT:0> ] for nd in iface . namesAndDescriptions ( ) ] <EOL> names . sort ( ) <EOL> self . assertEqual ( names , [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> names = [ nd [ <NUM_LIT:0> ] for nd in iface . namesAndDescriptions ( <NUM_LIT:1> ) ] <EOL> names . sort ( ) <EOL> self . assertEqual ( names , [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> for name , d in iface . namesAndDescriptions ( <NUM_LIT:1> ) : <EOL> self . assertEqual ( name , d . __name__ ) <EOL> def test_getDescriptionFor ( self ) : <EOL> iface = self . _makeDerivedInterface ( ) <EOL> self . assertEqual ( iface . getDescriptionFor ( '<STR_LIT>' ) . __name__ , '<STR_LIT>' ) <EOL> self . assertEqual ( iface . getDescriptionFor ( '<STR_LIT>' ) . __name__ , '<STR_LIT>' ) <EOL> self . assertEqual ( iface . queryDescriptionFor ( '<STR_LIT>' , self ) , self ) <EOL> self . assertRaises ( KeyError , iface . getDescriptionFor , '<STR_LIT>' ) <EOL> def test___getitem__ ( self ) : <EOL> iface = self . _makeDerivedInterface ( ) <EOL> self . assertEqual ( iface [ '<STR_LIT>' ] . __name__ , '<STR_LIT>' ) <EOL> self . assertEqual ( iface [ '<STR_LIT>' ] . __name__ , '<STR_LIT>' ) <EOL> self . assertEqual ( iface . get ( '<STR_LIT>' , self ) , self ) <EOL> self . assertRaises ( KeyError , iface . __getitem__ , '<STR_LIT>' ) <EOL> def test___contains__ ( self ) : <EOL> iface = self . _makeDerivedInterface ( ) <EOL> self . failUnless ( '<STR_LIT>' in iface ) <EOL> self . failIf ( '<STR_LIT>' in iface ) <EOL> def test___iter__ ( self ) : <EOL> iface = self . _makeDerivedInterface ( ) <EOL> names = list ( iter ( iface ) ) <EOL> names . sort ( ) <EOL> self . assertEqual ( names , [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> def testAttr ( self ) : <EOL> iface = self . _makeDerivedInterface ( ) <EOL> description = iface . getDescriptionFor ( '<STR_LIT>' ) <EOL> self . assertEqual ( description . __name__ , '<STR_LIT>' ) <EOL> self . assertEqual ( description . __doc__ , '<STR_LIT>' ) <EOL> def testFunctionAttributes ( self ) : <EOL> from zope . interface import Interface <EOL> class ITest ( Interface ) : <EOL> def method ( ) : <EOL> pass <EOL> method . optional = <NUM_LIT:1> <EOL> method = ITest [ '<STR_LIT>' ] <EOL> self . assertEqual ( method . getTaggedValue ( '<STR_LIT>' ) , <NUM_LIT:1> ) <EOL> def testInvariant ( self ) : <EOL> from zope . interface . exceptions import Invalid <EOL> from zope . interface import directlyProvides <EOL> from zope . interface . tests . unitfixtures import BarGreaterThanFoo <EOL> from zope . interface . tests . unitfixtures import ifFooThenBar <EOL> from zope . interface . tests . unitfixtures import IInvariant <EOL> from zope . interface . tests . unitfixtures import InvariantC <EOL> from zope . interface . tests . unitfixtures import ISubInvariant <EOL> o = InvariantC ( ) <EOL> directlyProvides ( o , IInvariant ) <EOL> def errorsEqual ( self , o , error_len , error_msgs , iface = None ) : <EOL> if iface is None : <EOL> iface = IInvariant <EOL> self . assertRaises ( Invalid , iface . validateInvariants , o ) <EOL> e = [ ] <EOL> try : <EOL> iface . validateInvariants ( o , e ) <EOL> except Invalid , error : <EOL> self . assertEquals ( error . args [ <NUM_LIT:0> ] , e ) <EOL> else : <EOL> self . _assert ( <NUM_LIT:0> ) <EOL> self . assertEquals ( len ( e ) , error_len ) <EOL> msgs = [ error . args [ <NUM_LIT:0> ] for error in e ] <EOL> msgs . sort ( ) <EOL> for msg in msgs : <EOL> self . assertEquals ( msg , error_msgs . pop ( <NUM_LIT:0> ) ) <EOL> self . assertEquals ( IInvariant . getTaggedValue ( '<STR_LIT>' ) , <EOL> [ ifFooThenBar ] ) <EOL> self . assertEquals ( IInvariant . validateInvariants ( o ) , None ) <EOL> o . bar = <NUM_LIT> <EOL> self . assertEquals ( IInvariant . validateInvariants ( o ) , None ) <EOL> o . foo = <NUM_LIT> <EOL> self . assertEquals ( IInvariant . validateInvariants ( o ) , None ) <EOL> del o . bar <EOL> errorsEqual ( self , o , <NUM_LIT:1> , [ '<STR_LIT>' ] ) <EOL> self . assertEquals ( ISubInvariant . getTaggedValue ( '<STR_LIT>' ) , <EOL> [ BarGreaterThanFoo ] ) <EOL> o = InvariantC ( ) <EOL> directlyProvides ( o , ISubInvariant ) <EOL> o . foo = <NUM_LIT> <EOL> errorsEqual ( self , o , <NUM_LIT:1> , [ '<STR_LIT>' ] , ISubInvariant ) <EOL> o . foo = <NUM_LIT:2> <EOL> o . bar = <NUM_LIT:1> <EOL> errorsEqual ( self , o , <NUM_LIT:1> , [ '<STR_LIT>' ] , <EOL> ISubInvariant ) <EOL> o . foo = <NUM_LIT:1> <EOL> o . bar = <NUM_LIT:0> <EOL> errorsEqual ( self , o , <NUM_LIT:2> , [ '<STR_LIT>' , <EOL> '<STR_LIT>' ] , <EOL> ISubInvariant ) <EOL> o . foo = <NUM_LIT:1> <EOL> o . bar = <NUM_LIT:2> <EOL> self . assertEquals ( IInvariant . validateInvariants ( o ) , None ) <EOL> o = InvariantC ( ) <EOL> directlyProvides ( o , IInvariant ) <EOL> o . foo = <NUM_LIT> <EOL> old_invariants = IInvariant . getTaggedValue ( '<STR_LIT>' ) <EOL> invariants = old_invariants [ : ] <EOL> invariants . append ( BarGreaterThanFoo ) <EOL> IInvariant . setTaggedValue ( '<STR_LIT>' , invariants ) <EOL> errorsEqual ( self , o , <NUM_LIT:1> , [ '<STR_LIT>' ] ) <EOL> o . foo = <NUM_LIT:2> <EOL> o . bar = <NUM_LIT:1> <EOL> errorsEqual ( self , o , <NUM_LIT:1> , [ '<STR_LIT>' ] ) <EOL> o . foo = <NUM_LIT:1> <EOL> o . bar = <NUM_LIT:0> <EOL> errorsEqual ( self , o , <NUM_LIT:2> , [ '<STR_LIT>' , <EOL> '<STR_LIT>' ] ) <EOL> o . foo = <NUM_LIT:1> <EOL> o . bar = <NUM_LIT:2> <EOL> self . assertEquals ( IInvariant . validateInvariants ( o ) , None ) <EOL> IInvariant . setTaggedValue ( '<STR_LIT>' , old_invariants ) <EOL> def test___doc___element ( self ) : <EOL> from zope . interface import Interface <EOL> from zope . interface import Attribute <EOL> class I ( Interface ) : <EOL> "<STR_LIT>" <EOL> self . assertEqual ( I . __doc__ , "<STR_LIT>" ) <EOL> self . assertEqual ( list ( I ) , [ ] ) <EOL> class I ( Interface ) : <EOL> "<STR_LIT>" <EOL> __doc__ = Attribute ( '<STR_LIT>' ) <EOL> self . assertEqual ( I . __doc__ , "<STR_LIT>" ) <EOL> self . assertEqual ( list ( I ) , [ '<STR_LIT>' ] ) <EOL> def testIssue228 ( self ) : <EOL> from zope . interface import Interface <EOL> if sys . version [ <NUM_LIT:0> ] == '<STR_LIT:3>' : <EOL> return <EOL> class I ( Interface ) : <EOL> "<STR_LIT>" <EOL> class Bad : <EOL> __providedBy__ = None <EOL> self . failUnlessRaises ( AttributeError , I . providedBy , Bad ) <EOL> if sys . version_info >= ( <NUM_LIT:2> , <NUM_LIT:4> ) : <EOL> def test_invariant_as_decorator ( ) : <EOL> """<STR_LIT>""" <EOL> def test_description_cache_management ( ) : <EOL> """<STR_LIT>""" <EOL> def test_suite ( ) : <EOL> suite = unittest . makeSuite ( InterfaceTests ) <EOL> suite . addTest ( doctest . DocTestSuite ( "<STR_LIT>" ) ) <EOL> if sys . version_info >= ( <NUM_LIT:2> , <NUM_LIT:4> ) : <EOL> suite . addTest ( doctest . DocTestSuite ( ) ) <EOL> suite . addTest ( doctest . DocFileSuite ( <EOL> '<STR_LIT>' , <EOL> globs = { '<STR_LIT>' : '<STR_LIT:__main__>' } , <EOL> optionflags = doctest . NORMALIZE_WHITESPACE | doctest . ELLIPSIS , <EOL> ) ) <EOL> suite . addTest ( doctest . DocFileSuite ( <EOL> '<STR_LIT>' , <EOL> globs = { '<STR_LIT>' : '<STR_LIT:__main__>' } , <EOL> optionflags = doctest . NORMALIZE_WHITESPACE | doctest . ELLIPSIS , <EOL> ) ) <EOL> return suite </s>

"""<STR_LIT>""" <EOL> from bs4 . testing import SoupTest , HTMLTreeBuilderSmokeTest

from bs4 . builder import HTMLParserTreeBuilder

"""<STR_LIT>""" <EOL> from bs4 . testing import SoupTest , HTMLTreeBuilderSmokeTest <EOL> from bs4 . builder import HTMLParserTreeBuilder <EOL> class HTMLParserTreeBuilderSmokeTest ( SoupTest , HTMLTreeBuilderSmokeTest ) : <EOL> @ property <EOL> def default_builder ( self ) : <EOL> return HTMLParserTreeBuilder ( ) <EOL> def test_namespaced_system_doctype ( self ) : <EOL> pass <EOL> def test_namespaced_public_doctype ( self ) : <EOL> pass </s>

"""<STR_LIT>""" <EOL> __author__ = '<STR_LIT>' <EOL> import urllib . request , urllib . parse , urllib . error <EOL> import gdata . apps . emailsettings . data <EOL> import gdata . client <EOL> EMAIL_SETTINGS_URI_TEMPLATE = '<STR_LIT>' <EOL> SETTING_ID_LABEL = '<STR_LIT:label>' <EOL> SETTING_ID_FILTER = '<STR_LIT>' <EOL> SETTING_ID_SENDAS = '<STR_LIT>' <EOL> SETTING_ID_WEBCLIP = '<STR_LIT>' <EOL> SETTING_ID_FORWARDING = '<STR_LIT>' <EOL> SETTING_ID_POP = '<STR_LIT>' <EOL> SETTING_ID_IMAP = '<STR_LIT>' <EOL> SETTING_ID_VACATION_RESPONDER = '<STR_LIT>' <EOL> SETTING_ID_SIGNATURE = '<STR_LIT>' <EOL> SETTING_ID_LANGUAGE = '<STR_LIT>' <EOL> SETTING_ID_GENERAL = '<STR_LIT>' <EOL> SETTING_ID_DELEGATION = '<STR_LIT>' <EOL> ACTION_KEEP = '<STR_LIT>' <EOL> ACTION_ARCHIVE = '<STR_LIT>' <EOL> ACTION_DELETE = '<STR_LIT>' <EOL> POP_ENABLE_FOR_ALL_MAIL = '<STR_LIT>' <EOL> POP_ENABLE_FOR_MAIL_FROM_NOW_ON = '<STR_LIT>' <EOL> class EmailSettingsClient ( gdata . client . GDClient ) : <EOL> """<STR_LIT>""" <EOL> host = '<STR_LIT>' <EOL> api_version = '<STR_LIT>' <EOL> auth_service = '<STR_LIT>' <EOL> auth_scopes = gdata . gauth . AUTH_SCOPES [ '<STR_LIT>' ] <EOL> ssl = True <EOL> def __init__ ( self , domain , auth_token = None , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> gdata . client . GDClient . __init__ ( self , auth_token = auth_token , ** kwargs ) <EOL> self . domain = domain <EOL> def make_email_settings_uri ( self , username , setting_id ) : <EOL> """<STR_LIT>""" <EOL> if '<STR_LIT:@>' in username : <EOL> username , domain = username . split ( '<STR_LIT:@>' , <NUM_LIT:1> ) <EOL> else : <EOL> domain = self . domain <EOL> uri = EMAIL_SETTINGS_URI_TEMPLATE % ( self . api_version , domain , <EOL> username , setting_id ) <EOL> return uri <EOL> MakeEmailSettingsUri = make_email_settings_uri <EOL> def create_label ( self , username , name , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_LABEL ) <EOL> new_label = gdata . apps . emailsettings . data . EmailSettingsLabel ( <EOL> uri = uri , name = name ) <EOL> return self . post ( new_label , uri , ** kwargs ) <EOL> CreateLabel = create_label <EOL> def retrieve_labels ( self , username , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_LABEL ) <EOL> return self . GetFeed ( <EOL> uri , <EOL> auth_token = None , <EOL> query = None , <EOL> desired_class = gdata . apps . emailsettings . data . EmailSettingsLabelFeed , <EOL> ** kwargs ) <EOL> RetrieveLabels = retrieve_labels <EOL> def delete_label ( self , username , label , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_LABEL ) <EOL> uri = '<STR_LIT:/>' . join ( [ uri , urllib . parse . quote_plus ( label ) ] ) <EOL> return self . delete ( uri , ** kwargs ) <EOL> DeleteLabel = delete_label <EOL> def create_filter ( self , username , from_address = None , <EOL> to_address = None , subject = None , has_the_word = None , <EOL> does_not_have_the_word = None , has_attachments = None , <EOL> label = None , mark_as_read = None , archive = None , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_FILTER ) <EOL> new_filter = gdata . apps . emailsettings . data . EmailSettingsFilter ( <EOL> uri = uri , from_address = from_address , <EOL> to_address = to_address , subject = subject , <EOL> has_the_word = has_the_word , <EOL> does_not_have_the_word = does_not_have_the_word , <EOL> has_attachments = has_attachments , label = label , <EOL> mark_as_read = mark_as_read , archive = archive )

return self . post ( new_filter , uri , ** kwargs )

"""<STR_LIT>""" <EOL> __author__ = '<STR_LIT>' <EOL> import urllib . request , urllib . parse , urllib . error <EOL> import gdata . apps . emailsettings . data <EOL> import gdata . client <EOL> EMAIL_SETTINGS_URI_TEMPLATE = '<STR_LIT>' <EOL> SETTING_ID_LABEL = '<STR_LIT:label>' <EOL> SETTING_ID_FILTER = '<STR_LIT>' <EOL> SETTING_ID_SENDAS = '<STR_LIT>' <EOL> SETTING_ID_WEBCLIP = '<STR_LIT>' <EOL> SETTING_ID_FORWARDING = '<STR_LIT>' <EOL> SETTING_ID_POP = '<STR_LIT>' <EOL> SETTING_ID_IMAP = '<STR_LIT>' <EOL> SETTING_ID_VACATION_RESPONDER = '<STR_LIT>' <EOL> SETTING_ID_SIGNATURE = '<STR_LIT>' <EOL> SETTING_ID_LANGUAGE = '<STR_LIT>' <EOL> SETTING_ID_GENERAL = '<STR_LIT>' <EOL> SETTING_ID_DELEGATION = '<STR_LIT>' <EOL> ACTION_KEEP = '<STR_LIT>' <EOL> ACTION_ARCHIVE = '<STR_LIT>' <EOL> ACTION_DELETE = '<STR_LIT>' <EOL> POP_ENABLE_FOR_ALL_MAIL = '<STR_LIT>' <EOL> POP_ENABLE_FOR_MAIL_FROM_NOW_ON = '<STR_LIT>' <EOL> class EmailSettingsClient ( gdata . client . GDClient ) : <EOL> """<STR_LIT>""" <EOL> host = '<STR_LIT>' <EOL> api_version = '<STR_LIT>' <EOL> auth_service = '<STR_LIT>' <EOL> auth_scopes = gdata . gauth . AUTH_SCOPES [ '<STR_LIT>' ] <EOL> ssl = True <EOL> def __init__ ( self , domain , auth_token = None , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> gdata . client . GDClient . __init__ ( self , auth_token = auth_token , ** kwargs ) <EOL> self . domain = domain <EOL> def make_email_settings_uri ( self , username , setting_id ) : <EOL> """<STR_LIT>""" <EOL> if '<STR_LIT:@>' in username : <EOL> username , domain = username . split ( '<STR_LIT:@>' , <NUM_LIT:1> ) <EOL> else : <EOL> domain = self . domain <EOL> uri = EMAIL_SETTINGS_URI_TEMPLATE % ( self . api_version , domain , <EOL> username , setting_id ) <EOL> return uri <EOL> MakeEmailSettingsUri = make_email_settings_uri <EOL> def create_label ( self , username , name , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_LABEL ) <EOL> new_label = gdata . apps . emailsettings . data . EmailSettingsLabel ( <EOL> uri = uri , name = name ) <EOL> return self . post ( new_label , uri , ** kwargs ) <EOL> CreateLabel = create_label <EOL> def retrieve_labels ( self , username , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_LABEL ) <EOL> return self . GetFeed ( <EOL> uri , <EOL> auth_token = None , <EOL> query = None , <EOL> desired_class = gdata . apps . emailsettings . data . EmailSettingsLabelFeed , <EOL> ** kwargs ) <EOL> RetrieveLabels = retrieve_labels <EOL> def delete_label ( self , username , label , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_LABEL ) <EOL> uri = '<STR_LIT:/>' . join ( [ uri , urllib . parse . quote_plus ( label ) ] ) <EOL> return self . delete ( uri , ** kwargs ) <EOL> DeleteLabel = delete_label <EOL> def create_filter ( self , username , from_address = None , <EOL> to_address = None , subject = None , has_the_word = None , <EOL> does_not_have_the_word = None , has_attachments = None , <EOL> label = None , mark_as_read = None , archive = None , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_FILTER ) <EOL> new_filter = gdata . apps . emailsettings . data . EmailSettingsFilter ( <EOL> uri = uri , from_address = from_address , <EOL> to_address = to_address , subject = subject , <EOL> has_the_word = has_the_word , <EOL> does_not_have_the_word = does_not_have_the_word , <EOL> has_attachments = has_attachments , label = label , <EOL> mark_as_read = mark_as_read , archive = archive ) <EOL> return self . post ( new_filter , uri , ** kwargs ) <EOL> CreateFilter = create_filter <EOL> def create_send_as ( self , username , name , address , reply_to = None , <EOL> make_default = None , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_SENDAS ) <EOL> new_alias = gdata . apps . emailsettings . data . EmailSettingsSendAsAlias ( <EOL> uri = uri , name = name , address = address , <EOL> reply_to = reply_to , make_default = make_default ) <EOL> return self . post ( new_alias , uri , ** kwargs ) <EOL> CreateSendAs = create_send_as <EOL> def retrieve_send_as ( self , username , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_SENDAS ) <EOL> return self . GetFeed ( <EOL> uri , <EOL> auth_token = None , <EOL> query = None , <EOL> desired_class = gdata . apps . emailsettings . data . EmailSettingsSendAsAliasFeed , <EOL> ** kwargs ) <EOL> RetrieveSendAs = retrieve_send_as <EOL> def update_webclip ( self , username , enable , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_WEBCLIP ) <EOL> new_webclip = gdata . apps . emailsettings . data . EmailSettingsWebClip ( <EOL> uri = uri , enable = enable ) <EOL> return self . update ( new_webclip , ** kwargs ) <EOL> UpdateWebclip = update_webclip <EOL> def update_forwarding ( self , username , enable , forward_to = None , <EOL> action = None , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_FORWARDING ) <EOL> new_forwarding = gdata . apps . emailsettings . data . EmailSettingsForwarding ( <EOL> uri = uri , enable = enable , forward_to = forward_to , action = action ) <EOL> return self . update ( new_forwarding , ** kwargs ) <EOL> UpdateForwarding = update_forwarding <EOL> def retrieve_forwarding ( self , username , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_FORWARDING ) <EOL> return self . GetEntry ( <EOL> uri , <EOL> auth_token = None , <EOL> query = None , <EOL> desired_class = gdata . apps . emailsettings . data . EmailSettingsForwarding , <EOL> ** kwargs ) <EOL> RetrieveForwarding = retrieve_forwarding <EOL> def update_pop ( self , username , enable , enable_for = None , action = None , <EOL> ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_POP ) <EOL> new_pop = gdata . apps . emailsettings . data . EmailSettingsPop ( <EOL> uri = uri , enable = enable , <EOL> enable_for = enable_for , action = action ) <EOL> return self . update ( new_pop , ** kwargs ) <EOL> UpdatePop = update_pop <EOL> def retrieve_pop ( self , username , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_POP ) <EOL> return self . GetEntry ( <EOL> uri , <EOL> auth_token = None , <EOL> query = None , <EOL> desired_class = gdata . apps . emailsettings . data . EmailSettingsPop , <EOL> ** kwargs ) <EOL> RetrievePop = retrieve_pop <EOL> def update_imap ( self , username , enable , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_IMAP ) <EOL> new_imap = gdata . apps . emailsettings . data . EmailSettingsImap ( <EOL> uri = uri , enable = enable ) <EOL> return self . update ( new_imap , ** kwargs ) <EOL> UpdateImap = update_imap <EOL> def retrieve_imap ( self , username , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_IMAP ) <EOL> return self . GetEntry ( <EOL> uri , <EOL> auth_token = None , <EOL> query = None , <EOL> desired_class = gdata . apps . emailsettings . data . EmailSettingsImap , <EOL> ** kwargs ) <EOL> RetrieveImap = retrieve_imap <EOL> def update_vacation ( self , username , enable , subject = None , message = None , <EOL> start_date = None , end_date = None , contacts_only = None , <EOL> domain_only = None , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_VACATION_RESPONDER ) <EOL> new_vacation = gdata . apps . emailsettings . data . EmailSettingsVacationResponder ( <EOL> uri = uri , enable = enable , subject = subject , <EOL> message = message , start_date = start_date , end_date = end_date , <EOL> contacts_only = contacts_only , domain_only = domain_only ) <EOL> return self . update ( new_vacation , ** kwargs ) <EOL> UpdateVacation = update_vacation <EOL> def retrieve_vacation ( self , username , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_VACATION_RESPONDER ) <EOL> return self . GetEntry ( <EOL> uri , <EOL> auth_token = None , <EOL> query = None , <EOL> desired_class = <EOL> gdata . apps . emailsettings . data . EmailSettingsVacationResponder , <EOL> ** kwargs ) <EOL> RetrieveVacation = retrieve_vacation <EOL> def update_signature ( self , username , signature , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_SIGNATURE ) <EOL> new_signature = gdata . apps . emailsettings . data . EmailSettingsSignature ( <EOL> uri = uri , signature = signature ) <EOL> return self . update ( new_signature , ** kwargs ) <EOL> UpdateSignature = update_signature <EOL> def retrieve_signature ( self , username , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_SIGNATURE ) <EOL> return self . GetEntry ( <EOL> uri , <EOL> auth_token = None , <EOL> query = None , <EOL> desired_class = gdata . apps . emailsettings . data . EmailSettingsSignature , <EOL> ** kwargs ) <EOL> RetrieveSignature = retrieve_signature <EOL> def update_language ( self , username , language , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_LANGUAGE ) <EOL> new_language = gdata . apps . emailsettings . data . EmailSettingsLanguage ( <EOL> uri = uri , language = language ) <EOL> return self . update ( new_language , ** kwargs ) <EOL> UpdateLanguage = update_language <EOL> def update_general_settings ( self , username , page_size = None , shortcuts = None , <EOL> arrows = None , snippets = None , use_unicode = None , <EOL> ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_GENERAL ) <EOL> new_general = gdata . apps . emailsettings . data . EmailSettingsGeneral ( <EOL> uri = uri , page_size = page_size , shortcuts = shortcuts , <EOL> arrows = arrows , snippets = snippets , use_unicode = use_unicode ) <EOL> return self . update ( new_general , ** kwargs ) <EOL> UpdateGeneralSettings = update_general_settings <EOL> def add_email_delegate ( self , username , address , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_DELEGATION ) <EOL> new_delegation = gdata . apps . emailsettings . data . EmailSettingsDelegation ( <EOL> uri = uri , address = address ) <EOL> return self . post ( new_delegation , uri , ** kwargs ) <EOL> AddEmailDelegate = add_email_delegate <EOL> def retrieve_email_delegates ( self , username , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_DELEGATION ) <EOL> return self . GetFeed ( <EOL> uri , <EOL> auth_token = None , <EOL> query = None , <EOL> desired_class = gdata . apps . emailsettings . data . EmailSettingsDelegationFeed , <EOL> ** kwargs ) <EOL> RetrieveEmailDelegates = retrieve_email_delegates <EOL> def delete_email_delegate ( self , username , address , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> uri = self . MakeEmailSettingsUri ( username = username , <EOL> setting_id = SETTING_ID_DELEGATION ) <EOL> uri = uri + '<STR_LIT:/>' + address <EOL> return self . delete ( uri , ** kwargs ) <EOL> DeleteEmailDelegate = delete_email_delegate </s>

"""<STR_LIT>""" <EOL> import dbm <EOL> import _thread <EOL> class BaseDB : <EOL> def __init__ ( self , filename , type ) : <EOL> self . type = type <EOL> self . filename = filename <EOL> if self . filename : <EOL> self . db = None <EOL> else : <EOL> self . db = { } <EOL> self . lock = _thread . allocate_lock ( ) <EOL> def create ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . filename : <EOL> self . db = dbm . open ( self . filename , "<STR_LIT:n>" ) <EOL> self . db [ "<STR_LIT>" ] = self . type <EOL> self . db . sync ( ) <EOL> else : <EOL> self . db = { } <EOL> def open ( self ) : <EOL> """<STR_LIT>""" <EOL> if not self . filename : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> self . db = dbm . open ( self . filename , "<STR_LIT:w>" ) <EOL> try : <EOL> if self . db [ "<STR_LIT>" ] != self . type : <EOL> raise ValueError ( "<STR_LIT>" % self . type ) <EOL> except KeyError : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> def __getitem__ ( self , username ) : <EOL> if self . db == None : <EOL> raise AssertionError ( "<STR_LIT>" ) <EOL> self . lock . acquire ( ) <EOL> try : <EOL> valueStr = self . db [ username ] <EOL> finally : <EOL> self . lock . release ( ) <EOL> return self . _getItem ( username , valueStr ) <EOL> def __setitem__ ( self , username , value ) : <EOL> if self . db == None : <EOL> raise AssertionError ( "<STR_LIT>" ) <EOL> valueStr = self . _setItem ( username , value ) <EOL> self . lock . acquire ( ) <EOL> try : <EOL> self . db [ username ] = valueStr <EOL> if self . filename : <EOL> self . db . sync ( ) <EOL> finally : <EOL> self . lock . release ( ) <EOL> def __delitem__ ( self , username ) : <EOL> if self . db == None : <EOL> raise AssertionError ( "<STR_LIT>" ) <EOL> self . lock . acquire ( ) <EOL> try :

del ( self . db [ username ] )

"""<STR_LIT>""" <EOL> import dbm <EOL> import _thread <EOL> class BaseDB : <EOL> def __init__ ( self , filename , type ) : <EOL> self . type = type <EOL> self . filename = filename <EOL> if self . filename : <EOL> self . db = None <EOL> else : <EOL> self . db = { } <EOL> self . lock = _thread . allocate_lock ( ) <EOL> def create ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . filename : <EOL> self . db = dbm . open ( self . filename , "<STR_LIT:n>" ) <EOL> self . db [ "<STR_LIT>" ] = self . type <EOL> self . db . sync ( ) <EOL> else : <EOL> self . db = { } <EOL> def open ( self ) : <EOL> """<STR_LIT>""" <EOL> if not self . filename : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> self . db = dbm . open ( self . filename , "<STR_LIT:w>" ) <EOL> try : <EOL> if self . db [ "<STR_LIT>" ] != self . type : <EOL> raise ValueError ( "<STR_LIT>" % self . type ) <EOL> except KeyError : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> def __getitem__ ( self , username ) : <EOL> if self . db == None : <EOL> raise AssertionError ( "<STR_LIT>" ) <EOL> self . lock . acquire ( ) <EOL> try : <EOL> valueStr = self . db [ username ] <EOL> finally : <EOL> self . lock . release ( ) <EOL> return self . _getItem ( username , valueStr ) <EOL> def __setitem__ ( self , username , value ) : <EOL> if self . db == None : <EOL> raise AssertionError ( "<STR_LIT>" ) <EOL> valueStr = self . _setItem ( username , value ) <EOL> self . lock . acquire ( ) <EOL> try : <EOL> self . db [ username ] = valueStr <EOL> if self . filename : <EOL> self . db . sync ( ) <EOL> finally : <EOL> self . lock . release ( ) <EOL> def __delitem__ ( self , username ) : <EOL> if self . db == None : <EOL> raise AssertionError ( "<STR_LIT>" ) <EOL> self . lock . acquire ( ) <EOL> try : <EOL> del ( self . db [ username ] ) <EOL> if self . filename : <EOL> self . db . sync ( ) <EOL> finally : <EOL> self . lock . release ( ) <EOL> def __contains__ ( self , username ) : <EOL> """<STR_LIT>""" <EOL> if self . db == None : <EOL> raise AssertionError ( "<STR_LIT>" ) <EOL> self . lock . acquire ( ) <EOL> try : <EOL> return username in self . db <EOL> finally : <EOL> self . lock . release ( ) <EOL> def check ( self , username , param ) : <EOL> value = self . __getitem__ ( username ) <EOL> return self . _checkItem ( value , username , param ) <EOL> def keys ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . db == None : <EOL> raise AssertionError ( "<STR_LIT>" ) <EOL> self . lock . acquire ( ) <EOL> try : <EOL> usernames = list ( self . db . keys ( ) ) <EOL> finally : <EOL> self . lock . release ( ) <EOL> usernames = [ u for u in usernames if not u . startswith ( "<STR_LIT>" ) ] <EOL> return usernames </s>

"""<STR_LIT>""" <EOL> from cryptomath import * <EOL> from RC4 import * <EOL> if pycryptoLoaded : <EOL> import Crypto . Cipher . ARC4 <EOL> def new ( key ) : <EOL> return PyCrypto_RC4 ( key ) <EOL> class PyCrypto_RC4 ( RC4 ) :

def __init__ ( self , key ) :

"""<STR_LIT>""" <EOL> from cryptomath import * <EOL> from RC4 import * <EOL> if pycryptoLoaded : <EOL> import Crypto . Cipher . ARC4 <EOL> def new ( key ) : <EOL> return PyCrypto_RC4 ( key ) <EOL> class PyCrypto_RC4 ( RC4 ) : <EOL> def __init__ ( self , key ) : <EOL> RC4 . __init__ ( self , key , "<STR_LIT>" ) <EOL> self . context = Crypto . Cipher . ARC4 . new ( key ) <EOL> def encrypt ( self , plaintext ) : <EOL> return self . context . encrypt ( plaintext ) <EOL> def decrypt ( self , ciphertext ) : <EOL> return self . context . decrypt ( ciphertext ) </s>

"<STR_LIT>" "<STR_LIT>" <EOL> XML_NS = "<STR_LIT>" <EOL> XML_QNP = "<STR_LIT>" . format ( XML_NS ) <EOL> STREAM_NS = "<STR_LIT>" <EOL> STREAM_QNP = "<STR_LIT>" . format ( STREAM_NS ) <EOL> STREAM_ROOT_TAG = STREAM_QNP + "<STR_LIT>" <EOL> BIND_NS = "<STR_LIT>" <EOL> BIND_QNP = "<STR_LIT>" . format ( BIND_NS ) <EOL> SESSION_NS = "<STR_LIT>" <EOL> SESSION_QNP = "<STR_LIT>" . format ( SESSION_NS ) <EOL> STANZA_CLIENT_NS = "<STR_LIT>" <EOL> STANZA_CLIENT_QNP = "<STR_LIT>" . format ( STANZA_CLIENT_NS ) <EOL> STANZA_SERVER_NS = "<STR_LIT>"

STANZA_SERVER_QNP = "<STR_LIT>" . format ( STANZA_SERVER_NS )

"<STR_LIT>" "<STR_LIT>" <EOL> XML_NS = "<STR_LIT>" <EOL> XML_QNP = "<STR_LIT>" . format ( XML_NS ) <EOL> STREAM_NS = "<STR_LIT>" <EOL> STREAM_QNP = "<STR_LIT>" . format ( STREAM_NS ) <EOL> STREAM_ROOT_TAG = STREAM_QNP + "<STR_LIT>" <EOL> BIND_NS = "<STR_LIT>" <EOL> BIND_QNP = "<STR_LIT>" . format ( BIND_NS ) <EOL> SESSION_NS = "<STR_LIT>" <EOL> SESSION_QNP = "<STR_LIT>" . format ( SESSION_NS ) <EOL> STANZA_CLIENT_NS = "<STR_LIT>" <EOL> STANZA_CLIENT_QNP = "<STR_LIT>" . format ( STANZA_CLIENT_NS ) <EOL> STANZA_SERVER_NS = "<STR_LIT>" <EOL> STANZA_SERVER_QNP = "<STR_LIT>" . format ( STANZA_SERVER_NS ) <EOL> STANZA_NAMESPACES = ( STANZA_CLIENT_NS , STANZA_SERVER_NS ) <EOL> STANZA_ERROR_NS = '<STR_LIT>' <EOL> STANZA_ERROR_QNP = "<STR_LIT>" . format ( STANZA_ERROR_NS ) <EOL> STREAM_ERROR_NS = '<STR_LIT>' <EOL> STREAM_ERROR_QNP = "<STR_LIT>" . format ( STREAM_ERROR_NS ) <EOL> PYXMPP_ERROR_NS = '<STR_LIT>' <EOL> PYXMPP_ERROR_QNP = "<STR_LIT>" . format ( PYXMPP_ERROR_NS ) <EOL> SASL_NS = "<STR_LIT>" <EOL> SASL_QNP = "<STR_LIT>" . format ( SASL_NS ) <EOL> TLS_NS = "<STR_LIT>" <EOL> TLS_QNP = "<STR_LIT>" . format ( TLS_NS ) <EOL> XML_LANG_QNAME = XML_QNP + "<STR_LIT>" </s>