code stringlengths 9 256k |
|---|
<s> """<STR_LIT>""" <EOL> from __future__ import generators <EOL> import sys <EOL> import os <EOL> assert sys . version_info >= ( <NUM_LIT:2> , <NUM_LIT:2> , <NUM_LIT:0> ) , "<STR_LIT>" <EOL> from types import ModuleType <EOL> class Package ( object ) : <EOL> def __init__ ( self , name , exportdefs , metainfo ) : <EOL>... |
<s> from py . test import raises <EOL> from py . magic import patch , revert <EOL> def test_patch_revert ( ) : <EOL> class a : <EOL> pass <EOL> raises ( AttributeError , "<STR_LIT>" ) <EOL> a . i = <NUM_LIT> <EOL> patch ( a , '<STR_LIT:i>' , <NUM_LIT> ) <EOL> assert a . i == <NUM_LIT> <EOL> revert ( a , '<STR_LIT:i>' )... |
<s> import py , itertools <EOL> from py . __ . path import common <EOL> COUNTER = itertools . count ( ) <EOL> class RemotePath ( common . FSPathBase ) : <EOL> sep = '<STR_LIT:/>' <EOL> def __init__ ( self , channel , id , basename = None ) : <EOL> self . _channel = channel <EOL> self . _id = id <EOL> self . _basename =... |
<s> import py <EOL> from py . __ . rest . convert import convert_dot , latexformula2png <EOL> import sys <EOL> import docutils <EOL> from docutils import nodes <EOL> from docutils . parsers . rst import directives , states , roles <EOL> from docutils . parsers . rst . directives import images <EOL> if hasattr ( images ... |
<s> import py <EOL> def getfuncargnames ( function ) : <EOL> argnames = py . std . inspect . getargs ( function . func_code ) [ <NUM_LIT:0> ] <EOL> startindex = hasattr ( function , '<STR_LIT>' ) and <NUM_LIT:1> or <NUM_LIT:0> <EOL> numdefaults = len ( function . func_defaults or ( ) ) <EOL> if numdefaults : <EOL> retu... |
<s> """<STR_LIT>""" <EOL> import py <EOL> import sys <EOL> def pytest_addoption ( parser ) : <EOL> group = parser . getgroup ( "<STR_LIT>" ) <EOL> group . addoption ( '<STR_LIT>' , <EOL> action = "<STR_LIT:store_true>" , dest = "<STR_LIT>" , <EOL> help = "<STR_LIT>" ) , <EOL> group . addoption ( '<STR_LIT>' , <EOL> act... |
<s> import py <EOL> def setglobals ( request ) : <EOL> oldconfig = py . test . config <EOL> oldcom = py . _com . comregistry <EOL> print "<STR_LIT>" <EOL> py . test . config = None <EOL> py . _com . comregistry = py . _com . Registry ( ) <EOL> def resetglobals ( ) : <EOL> print "<STR_LIT>" , oldconfig <EOL> py . test .... |
<s> """<STR_LIT>""" <EOL> from pypy . annotation . model import SomePBC , s_ImpossibleValue , unionof <EOL> from pypy . annotation . model import SomeInteger , isdegenerated , SomeTuple , SomeString <EOL> from pypy . annotation import description <EOL> class Attribute : <EOL> def __init__ ( self , name , bookkeeper ) :... |
<s> import py <EOL> from pypy . config . pypyoption import get_pypy_config , set_pypy_opt_level <EOL> from pypy . config . config import Config , ConfigError <EOL> from pypy . config . translationoption import set_opt_level <EOL> thisdir = py . magic . autopath ( ) . dirpath ( ) <EOL> def test_required ( ) : <EOL> conf... |
<s> """<STR_LIT>""" <EOL> from pypy . interpreter . astcompiler import ast , misc <EOL> from pypy . interpreter . pyparser . error import SyntaxError <EOL> SYM_BLANK = <NUM_LIT:0> <EOL> SYM_GLOBAL = <NUM_LIT:1> <EOL> SYM_ASSIGNED = <NUM_LIT:2> <EOL> SYM_PARAM = <NUM_LIT:2> << <NUM_LIT:1> <EOL> SYM_USED = <NUM_LIT:2> <<... |
<s> """<STR_LIT>""" <EOL> import pdb <EOL> def fire ( operationerr ) : <EOL> if not operationerr . debug_excs : <EOL> return <EOL> exc , val , tb = operationerr . debug_excs [ - <NUM_LIT:1> ] <EOL> pdb . post_mortem ( tb ) </s>
|
<s> from pypy . interpreter . pyparser import automata <EOL> from pypy . interpreter . pyparser . pygram import tokens <EOL> from pypy . interpreter . pyparser . pytoken import python_opmap <EOL> from pypy . interpreter . pyparser . error import TokenError , TokenIndentationError <EOL> from pypy . interpreter . pyparse... |
<s> import unittest <EOL> from pypy . interpreter import eval <EOL> from pypy . interpreter . function import Function , Method , descr_function_get <EOL> from pypy . interpreter . pycode import PyCode <EOL> from pypy . interpreter . argument import Arguments <EOL> class AppTestFunctionIntrospection : <EOL> def test_at... |
<s> import py <EOL> from pypy . jit . backend . cli . test . test_zrpy_basic import CliTranslatedJitMixin <EOL> from pypy . jit . metainterp . test import test_send <EOL> class TestSend ( CliTranslatedJitMixin , test_send . TestOOtype ) : <EOL> def test_recursive_call_to_portal_from_blackhole ( self ) : <EOL> py . test... |
<s> """<STR_LIT>""" <EOL> import autopath <EOL> import py <EOL> import sys <EOL> from pypy . jit . metainterp . test . oparser import parse , split_logs_into_loops <EOL> from pypy . jit . metainterp . history import ConstInt <EOL> from pypy . rpython . lltypesystem import llmemory , lltype <EOL> def main ( loopnum , lo... |
<s> import py <EOL> from pypy . jit . metainterp . history import ResOperation , BoxInt , ConstInt , BoxPtr , ConstPtr , BasicFailDescr , LoopToken <EOL> from pypy . jit . metainterp . resoperation import rop <EOL> from pypy . jit . backend . x86 . runner import CPU <EOL> def test_bug_rshift ( ) : <EOL> v1 = BoxInt ( )... |
<s> """<STR_LIT>""" <EOL> import os <EOL> import time <EOL> from pypy . rlib . debug import debug_print <EOL> counters = """<STR_LIT>""" <EOL> def _setup ( ) : <EOL> names = counters . split ( ) <EOL> for i , name in enumerate ( names ) : <EOL> globals ( ) [ name ] = i <EOL> global ncounters <EOL> ncounters = len ( nam... |
<s> import py <EOL> from pypy . rlib . jit import JitDriver , OPTIMIZER_SIMPLE , OPTIMIZER_FULL <EOL> from pypy . rlib . objectmodel import compute_hash <EOL> from pypy . jit . metainterp . warmspot import ll_meta_interp , get_stats <EOL> from pypy . rpython . lltypesystem import lltype <EOL> from pypy . jit . metainte... |
<s> class BrainInterpreter ( object ) : <EOL> def __init__ ( self ) : <EOL> self . table = [ <NUM_LIT:0> ] * <NUM_LIT> <EOL> self . pointer = <NUM_LIT:0> <EOL> def interp_char ( self , code , code_pointer , input , output ) : <EOL> char_code = code [ code_pointer ] <EOL> if char_code == '<STR_LIT:>>' : <EOL> self . poi... |
<s> import py <EOL> from pypy . jit . tl . tlopcode import compile , NEW , RETURN <EOL> from pypy . jit . tl . test import test_tl <EOL> from pypy . jit . tl . tlc import ConstantPool <EOL> def test_constant_pool ( ) : <EOL> pool = ConstantPool ( ) <EOL> bytecode = compile ( """<STR_LIT>""" , pool ) <EOL> expected = te... |
<s> import _rawffi <EOL> from _ctypes . basics import _CData , _CDataMeta , keepalive_key , store_reference , ensure_objects , CArgObject <EOL> import inspect <EOL> def round_up ( size , alignment ) : <EOL> return ( size + alignment - <NUM_LIT:1> ) & - alignment <EOL> def size_alignment_pos ( fields ) : <EOL> import ct... |
<s> import py <EOL> import sys <EOL> from ctypes import * <EOL> def setup_module ( mod ) : <EOL> import conftest <EOL> mod . dll = CDLL ( str ( conftest . sofile ) ) <EOL> class CHECKED ( c_int ) : <EOL> def _check_retval_ ( value ) : <EOL> return str ( value . value ) <EOL> _check_retval_ = staticmethod ( _check_retva... |
<s> """<STR_LIT>""" <EOL> import py <EOL> from ctypes import * <EOL> from support import BaseCTypesTestChecker <EOL> def setup_module ( mod ) : <EOL> import conftest <EOL> _ctypes_test = str ( conftest . sofile ) <EOL> mod . ctdll = CDLL ( _ctypes_test ) <EOL> class TestValues ( BaseCTypesTestChecker ) : <EOL> def test... |
<s> </s>
|
<s> from ctypes import c_void_p , c_int , c_double , c_int64 , c_char_p , cdll <EOL> from ctypes import POINTER , byref , string_at , CFUNCTYPE , cast <EOL> import datetime <EOL> import sys <EOL> import time <EOL> import weakref <EOL> from threading import _get_ident as thread_get_ident <EOL> apilevel = "<STR_LIT>" <EO... |
<s> from Numeric import zeros , array , ArrayType <EOL> from Numeric import Float , TOWER_TYPES , TOWER_TYPES_VALUES <EOL> def assertRaises ( block , exception = Exception , shout = '<STR_LIT>' ) : <EOL> try : <EOL> block ( ) <EOL> except exception : <EOL> pass <EOL> else : <EOL> assert False , shout <EOL> """<STR_LIT>... |
<s> import autopath <EOL> class AppTestVars : <EOL> def test_vars_no_arguments ( self ) : <EOL> assert vars ( ) == locals ( ) <EOL> def test_vars_too_many_arguments ( self ) : <EOL> raises ( TypeError , vars , <NUM_LIT:0> , <NUM_LIT:1> ) <EOL> def test_vars_correct_arguments ( self ) : <EOL> class a ( object ) : <EOL> ... |
<s> import py <EOL> from pypy . conftest import gettestobjspace , option <EOL> class AppTestCProfile ( object ) : <EOL> def setup_class ( cls ) : <EOL> space = gettestobjspace ( usemodules = ( '<STR_LIT>' , ) ) <EOL> cls . w_expected_output = space . wrap ( expected_output ) <EOL> cls . space = space <EOL> cls . w_file... |
<s> from pypy . interpreter . mixedmodule import MixedModule <EOL> class Module ( MixedModule ) : <EOL> """<STR_LIT>""" <EOL> appleveldefs = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> } <EOL> interpleveldefs = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> '... |
<s> """<STR_LIT>""" <EOL> from pypy . interpreter . mixedmodule import MixedModule <EOL> class Module ( MixedModule ) : <EOL> """<STR_LIT>""" <EOL> interpleveldefs = { <EOL> } <EOL> appleveldefs = { <EOL> '<STR_LIT>' : '<STR_LIT>' , <EOL> } </s>
|
<s> from pypy . interpreter . mixedmodule import MixedModule <EOL> import errno <EOL> class Module ( MixedModule ) : <EOL> """<STR_LIT>""" <EOL> appleveldefs = { } <EOL> interpleveldefs = { "<STR_LIT>" : "<STR_LIT>" } <EOL> for name in dir ( errno ) : <EOL> if name . startswith ( '<STR_LIT>' ) or name in Module . inter... |
<s> from numarray import NumArray <EOL> from pypy . interpreter . baseobjspace import ObjSpace , W_Root <EOL> from pypy . interpreter . error import OperationError <EOL> def minimum ( space , w_a , w_b ) : <EOL> if not isinstance ( w_a , NumArray ) or not isinstance ( w_b , NumArray ) : <EOL> raise OperationError ( spa... |
<s> from pypy . module . pypyjit import policy <EOL> pypypolicy = policy . PyPyJitPolicy ( ) <EOL> def test_id_any ( ) : <EOL> from pypy . objspace . std . default import id__ANY <EOL> assert not pypypolicy . look_inside_function ( id__ANY ) <EOL> def test_bigint ( ) : <EOL> from pypy . rlib . rbigint import rbigint <E... |
<s> """<STR_LIT>""" <EOL> import struct <EOL> class error ( Exception ) : <EOL> """<STR_LIT>""" <EOL> def pack_into ( fmt , buf , offset , * args ) : <EOL> data = struct . pack ( fmt , * args ) <EOL> buffer ( buf ) [ offset : offset + len ( data ) ] = data <EOL> def unpack_from ( fmt , buf , offset = <NUM_LIT:0> ) : <E... |
<s> from pypy . tool . udir import udir <EOL> from pypy . module . thread . test . support import GenericTestThread <EOL> class AppTestThread ( GenericTestThread ) : <EOL> def setup_class ( cls ) : <EOL> GenericTestThread . setup_class . im_func ( cls ) <EOL> tmpdir = str ( udir . ensure ( '<STR_LIT>' , dir = <NUM_LIT:... |
<s> """<STR_LIT>""" <EOL> try : <EOL> import zlib <EOL> except ImportError : <EOL> import py ; py . test . skip ( "<STR_LIT>" ) <EOL> try : <EOL> from pypy . module . zlib import interp_zlib <EOL> except ImportError : <EOL> import py ; py . test . skip ( "<STR_LIT>" ) <EOL> from pypy . conftest import gettestobjspace <... |
<s> from pypy . interpreter import gateway <EOL> from pypy . objspace . std . objspace import W_Object , OperationError <EOL> from pypy . objspace . std . objspace import registerimplementation , register_all <EOL> from pypy . objspace . std . floatobject import W_FloatObject , _hash_float <EOL> import math <EOL> class... |
<s> from pypy . objspace . std . objspace import * <EOL> class W_ObjectObject ( W_Object ) : <EOL> """<STR_LIT>""" <EOL> from pypy . objspace . std . objecttype import object_typedef as typedef <EOL> register_all ( vars ( ) ) </s>
|
<s> from pypy . objspace . std . dictbucket import BucketDictImplementation <EOL> from pypy . objspace . std . test import test_dictmultiobject <EOL> Base = test_dictmultiobject . TestRDictImplementation <EOL> class TestBucketDictImplementation ( Base ) : <EOL> ImplementionClass = BucketDictImplementation <EOL> Devolve... |
<s> from pypy . objspace . std . sliceobject import normalize_simple_slice <EOL> class TestW_SliceObject : <EOL> def test_indices ( self ) : <EOL> space = self . space <EOL> w = space . wrap <EOL> w_None = space . w_None <EOL> w_slice = space . newslice ( w_None , w_None , w_None ) <EOL> assert w_slice . indices3 ( spa... |
<s> from pypy . objspace import trace <EOL> from pypy . tool import pydis <EOL> from pypy . interpreter import gateway <EOL> class Test_TraceObjSpace : <EOL> def setup_method ( self , method ) : <EOL> trace . create_trace_space ( self . space ) <EOL> def teardown_method ( self , method ) : <EOL> self . space . reset_tr... |
<s> from pypy . rlib . parsing . lexer import Token , SourcePos <EOL> from pypy . rlib . parsing . parsing import * <EOL> class EvaluateVisitor ( object ) : <EOL> def visit_additive ( self , node ) : <EOL> if len ( node . children ) == <NUM_LIT:1> : <EOL> return node . children [ <NUM_LIT:0> ] . visit ( self ) <EOL> el... |
<s> from pypy . rpython . lltypesystem import lltype , rffi <EOL> from pypy . rpython . tool import rffi_platform as platform <EOL> from pypy . rlib . rsdl . constants import _constants <EOL> from pypy . rlib . rsdl . eci import get_rsdl_compilation_info <EOL> from pypy . rlib . objectmodel import we_are_translated <EO... |
<s> import termios <EOL> from termios import * <EOL> def tcgetattr ( fd ) : <EOL> lst = list ( termios . tcgetattr ( fd ) ) <EOL> cc = lst [ - <NUM_LIT:1> ] <EOL> next_cc = [ ] <EOL> for c in cc : <EOL> if isinstance ( c , int ) : <EOL> next_cc . append ( chr ( c ) ) <EOL> else : <EOL> next_cc . append ( c ) <EOL> lst ... |
<s> from pypy . rlib . rrandom import Random , N , r_uint <EOL> import _random <EOL> def test_init_from_seed ( ) : <EOL> rnd = Random ( <NUM_LIT:1000> ) <EOL> assert rnd . state [ : <NUM_LIT> ] == [ <NUM_LIT:1000> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <EOL> <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <E... |
<s> from pypy . rpython . lltypesystem . lltype import pyobjectptr , malloc , free , typeOf <EOL> from pypy . rpython . lltypesystem . llmemory import weakref_create , weakref_deref <EOL> setfield = setattr <EOL> from operator import setitem as setarrayitem <EOL> from pypy . rlib . rgc import collect <EOL> from pypy . ... |
<s> from pypy . rpython . lltypesystem import lltype , llmemory , llarena <EOL> import struct <EOL> memory_alignment = struct . calcsize ( "<STR_LIT:P>" ) <EOL> primitive_to_fmt = { lltype . Signed : "<STR_LIT:l>" , <EOL> lltype . Unsigned : "<STR_LIT:L>" , <EOL> lltype . Char : "<STR_LIT:c>" , <EOL> lltype . UniChar :... |
<s> from pypy . rpython . test . tool import BaseRtypingTest , LLRtypeMixin , OORtypeMixin <EOL> import time , sys <EOL> class BaseTestTime ( BaseRtypingTest ) : <EOL> def test_time_time ( self ) : <EOL> def fn ( ) : <EOL> return time . time ( ) <EOL> t0 = time . time ( ) <EOL> res0 = self . interpret ( fn , [ ] ) <EOL... |
<s> from pypy . rpython . ootypesystem import ootype <EOL> def TUPLE_TYPE ( field_lltypes ) : <EOL> if len ( field_lltypes ) == <NUM_LIT:0> : <EOL> return ootype . Void <EOL> else : <EOL> fields = [ ( '<STR_LIT>' % i , TYPE ) for i , TYPE in enumerate ( field_lltypes ) ] <EOL> hints = { '<STR_LIT>' : True , <EOL> '<STR... |
<s> import types <EOL> import sys <EOL> from pypy . tool . pairtype import pair , pairtype <EOL> from pypy . annotation import model as annmodel <EOL> from pypy . annotation import description <EOL> from pypy . objspace . flow . model import Constant <EOL> from pypy . rpython . lltypesystem . lltype import typeOf , Voi... |
<s> import sys <EOL> from pypy . translator . translator import TranslationContext <EOL> from pypy . rpython . test import snippet <EOL> from pypy . rpython . test . tool import BaseRtypingTest , LLRtypeMixin , OORtypeMixin <EOL> from pypy . rlib . rarithmetic import r_int , r_uint , r_longlong , r_singlefloat , isnan ... |
<s> import os <EOL> def collect_one_testdir ( testdirs , reldir , tests ) : <EOL> if ( reldir . startswith ( '<STR_LIT>' ) or <EOL> reldir . startswith ( '<STR_LIT>' ) or <EOL> reldir . startswith ( '<STR_LIT>' ) or <EOL> reldir . startswith ( '<STR_LIT>' ) or <EOL> reldir . startswith ( '<STR_LIT>' ) or <EOL> reldir .... |
<s> """<STR_LIT>""" <EOL> from pypy . tool . ansi_print import ansi_log , raise_nicer_exception <EOL> from pypy . objspace . flow . model import Constant , Variable <EOL> import sys <EOL> import py <EOL> log = py . log . Producer ( "<STR_LIT:error>" ) <EOL> py . log . setconsumer ( "<STR_LIT:error>" , ansi_log ) <EOL> ... |
<s> import py <EOL> release_URL = '<STR_LIT>' <EOL> releases = [ r [ : - <NUM_LIT:2> ] for r in py . std . os . popen ( '<STR_LIT>' + release_URL ) . readlines ( ) if '<STR_LIT:x>' not in r ] <EOL> f = file ( '<STR_LIT>' , '<STR_LIT:w>' ) <EOL> print >> f , '<STR_LIT>' <EOL> for release in releases : <EOL> for s in py ... |
<s> """<STR_LIT>""" <EOL> try : <EOL> from thread import _local as tlsobject <EOL> except ImportError : <EOL> class tlsobject ( object ) : <EOL> pass </s>
|
<s> import py <EOL> from pypy . translator . translator import TranslationContext , graphof <EOL> from pypy . translator . simplify import get_funcobj <EOL> from pypy . translator . backendopt . canraise import RaiseAnalyzer <EOL> from pypy . translator . backendopt . all import backend_optimizations <EOL> from pypy . ... |
<s> import types <EOL> from pypy . objspace . flow . model import FunctionGraph <EOL> from pypy . rpython . lltypesystem import lltype <EOL> from pypy . translator . c . support import cdecl <EOL> from pypy . rpython . lltypesystem . rstr import STR , mallocstr <EOL> from pypy . rpython . lltypesystem import rstr <EOL>... |
<s> import autopath <EOL> import sys <EOL> import math <EOL> import py <EOL> from py . test import raises <EOL> from pypy import conftest <EOL> from pypy . translator . test import snippet <EOL> from pypy . translator . translator import TranslationContext <EOL> from pypy . rlib . rarithmetic import r_uint , r_ulonglon... |
<s> import py <EOL> from pypy . translator . cli . test . runtest import compile_function <EOL> from pypy . translator . oosupport . test_template . backendopt import BaseTestOptimizedSwitch <EOL> class TestOptimizedSwitch ( BaseTestOptimizedSwitch ) : <EOL> def getcompiled ( self , fn , annotation ) : <EOL> return com... |
<s> import py <EOL> from pypy . translator . cli . test . runtest import CliTest <EOL> from pypy . rpython . test . test_rweakref import BaseTestRweakref <EOL> class TestCliWeakRef ( CliTest , BaseTestRweakref ) : <EOL> pass </s>
|
<s> from pypy . rpython . lltypesystem import lltype <EOL> from pypy . rpython . lltypesystem . llmemory import cast_ptr_to_adr , raw_memclear , raw_memcopy , sizeof , itemoffsetof <EOL> TP = lltype . GcArray ( lltype . Signed ) <EOL> def longername ( a , b , size ) : <EOL> if <NUM_LIT:1> : <EOL> baseofs = itemoffsetof... |
<s> """<STR_LIT>""" <EOL> import sys , os , new <EOL> import autopath <EOL> from pypy . config . config import to_optparse , OptionDescription , BoolOption , ArbitraryOption , StrOption , IntOption , Config , ChoiceOption , OptHelpFormatter <EOL> from pypy . config . translationoption import get_combined_translation_co... |
<s> import py <EOL> from pypy . translator . jvm . test . runtest import JvmTest <EOL> from pypy . rpython . test . test_rfloat import BaseTestRfloat <EOL> class TestJvmFloat ( JvmTest , BaseTestRfloat ) : <EOL> def test_parse_float ( self ) : <EOL> ex = [ '<STR_LIT>' , '<STR_LIT:U+0020>' , '<STR_LIT:0>' , '<STR_LIT:1>... |
<s> from pybench import Test <EOL> import os <EOL> import package . submodule <EOL> class SecondImport ( Test ) : <EOL> version = <NUM_LIT:0.1> <EOL> operations = <NUM_LIT:5> * <NUM_LIT:5> <EOL> rounds = <NUM_LIT> <EOL> def test ( self ) : <EOL> for i in xrange ( self . rounds ) : <EOL> import os <EOL> import os <EOL> ... |
<s> import py <EOL> from pypy . rpython . llinterp import LLInterpreter <EOL> from pypy . translator . translator import TranslationContext , graphof <EOL> from pypy . translator . oosupport . treebuilder import build_trees , SubOperation <EOL> from pypy . conftest import option <EOL> from pypy . rpython . test . test_... |
<s> from pypy . translator . platform import host , CompilationError <EOL> from pypy . translator . tool . cbuild import ExternalCompilationInfo <EOL> from pypy . tool . udir import udir <EOL> from StringIO import StringIO <EOL> import sys <EOL> def test_echo ( ) : <EOL> res = host . execute ( '<STR_LIT>' , '<STR_LIT>'... |
<s> """<STR_LIT>""" <EOL> import autopath <EOL> import py <EOL> from pypy . tool . udir import udir <EOL> from pypy . objspace . flow . model import * <EOL> from pypy . translator . geninterplevel import translate_as_module <EOL> from pypy . translator . test import snippet <EOL> from pypy . interpreter . error import ... |
<s> def test_one ( ) : <EOL> assert <NUM_LIT:1> == <NUM_LIT:10> / <NUM_LIT:10> <EOL> def test_two ( ) : <EOL> assert <NUM_LIT:2> == <NUM_LIT:3> <EOL> def test_three ( ) : <EOL> assert "<STR_LIT:hello>" == "<STR_LIT>" <EOL> def test_many ( ) : <EOL> for i in range ( <NUM_LIT:100> ) : <EOL> yield test_one , <EOL> class T... |
<s> cache_builtins = <NUM_LIT:1> <EOL> embed_pos_in_docstring = <NUM_LIT:0> <EOL> gcc_branch_hints = <NUM_LIT:1> <EOL> pre_import = None <EOL> docstrings = True <EOL> incref_local_binop = <NUM_LIT:0> <EOL> generate_cleanup_code = <NUM_LIT:0> <EOL> annotate = <NUM_LIT:0> <EOL> convert_range = <NUM_LIT:1> <EOL> lookup_mo... |
<s> import Errors <EOL> from Regexps import BOL , EOL , EOF <EOL> class Scanner : <EOL> """<STR_LIT>""" <EOL> lexicon = None <EOL> stream = None <EOL> name = '<STR_LIT>' <EOL> buffer = '<STR_LIT>' <EOL> buf_start_pos = <NUM_LIT:0> <EOL> next_pos = <NUM_LIT:0> <EOL> cur_pos = <NUM_LIT:0> <EOL> cur_line = <NUM_LIT:1> <EO... |
<s> __revision__ = "<STR_LIT>" <EOL> import string <EOL> import sys <EOL> import unittest <EOL> import SCons . Executor <EOL> class MyEnvironment : <EOL> def __init__ ( self , ** kw ) : <EOL> self . _dict = { } <EOL> self . _dict . update ( kw ) <EOL> def __getitem__ ( self , key ) : <EOL> return self . _dict [ key ] <... |
<s> """<STR_LIT>""" <EOL> __revision__ = "<STR_LIT>" <EOL> import posix <EOL> from SCons . Platform import TempFileMunge <EOL> def generate ( env ) : <EOL> posix . generate ( env ) <EOL> env [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> env [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> env [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> env [ '<STR_L... |
<s> __revision__ = "<STR_LIT>" <EOL> import TestCmd <EOL> import SCons . Scanner . RC <EOL> import unittest <EOL> import sys <EOL> import os <EOL> import os . path <EOL> import SCons . Node . FS <EOL> import SCons . Warnings <EOL> import UserDict <EOL> test = TestCmd . TestCmd ( workdir = '<STR_LIT>' ) <EOL> os . chdir... |
<s> """<STR_LIT>""" <EOL> __revision__ = "<STR_LIT>" <EOL> import os . path <EOL> import SCons . Action <EOL> import SCons . Builder <EOL> import SCons . Util <EOL> def generate ( env ) : <EOL> """<STR_LIT>""" <EOL> def SubversionFactory ( repos , module = '<STR_LIT>' , env = env ) : <EOL> """<STR_LIT:U+0020>""" <EOL> ... |
<s> """<STR_LIT>""" <EOL> __revision__ = "<STR_LIT>" <EOL> import SCons . Util <EOL> import fortran <EOL> def generate ( env ) : <EOL> """<STR_LIT>""" <EOL> fortran . generate ( env ) <EOL> for dialect in [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] : <EOL> env [ '<STR_LIT:%s>' % dialect ] = '<STR_LIT>' <E... |
<s> """<STR_LIT>""" <EOL> __revision__ = "<STR_LIT>" <EOL> import os . path <EOL> import re <EOL> import string <EOL> import SCons . Action <EOL> import SCons . Builder <EOL> import SCons . Errors <EOL> import SCons . Platform . win32 <EOL> import SCons . Tool <EOL> import SCons . Tool . msvs <EOL> import SCons . Util ... |
<s> """<STR_LIT>""" <EOL> __revision__ = "<STR_LIT>" <EOL> import SCons <EOL> import os . path <EOL> cplusplus = __import__ ( '<STR_LIT>' , globals ( ) , locals ( ) , [ ] ) <EOL> def get_cppc ( env ) : <EOL> cxx = env . get ( '<STR_LIT>' , None ) <EOL> if cxx : <EOL> cppcPath = os . path . dirname ( cxx ) <EOL> else : ... |
<s> __revision__ = "<STR_LIT>" <EOL> import sys <EOL> import unittest <EOL> import SCons . Warnings <EOL> class TestOutput : <EOL> def __call__ ( self , x ) : <EOL> args = x [ <NUM_LIT:0> ] <EOL> if len ( args ) == <NUM_LIT:1> : <EOL> args = args [ <NUM_LIT:0> ] <EOL> self . out = str ( args ) <EOL> class WarningsTestC... |
<s> import doctest <EOL> import unittest <EOL> from babel . messages import plurals <EOL> def suite ( ) : <EOL> suite = unittest . TestSuite ( ) <EOL> suite . addTest ( doctest . DocTestSuite ( plurals ) ) <EOL> return suite <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> unittest . main ( defaultTest = '<STR_LIT>' )... |
<s> """<STR_LIT>""" <EOL> from optparse import OptionParser <EOL> from vobject import icalendar , base <EOL> import sys <EOL> try : <EOL> import PyICU <EOL> except : <EOL> PyICU = None <EOL> from datetime import datetime <EOL> def change_tz ( cal , new_timezone , default , utc_only = False , utc_tz = icalendar . utc ) ... |
<s> from django . core . exceptions import ImproperlyConfigured <EOL> from django . utils . importlib import import_module <EOL> import sys <EOL> def import_by_path ( dotted_path , error_prefix = '<STR_LIT>' ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> module_path , class_name = dotted_path . rsplit ( '<STR_LIT:.>' , <N... |
<s> """<STR_LIT>""" <EOL> from . import TestCase <EOL> import bitmath <EOL> import mock <EOL> import struct <EOL> try : <EOL> from contextlib import ExitStack , contextmanager <EOL> except ImportError : <EOL> from contextlib import nested <EOL> else : <EOL> @ contextmanager <EOL> def nested ( * contexts ) : <EOL> """<S... |
<s> LOCK_SERVO_PIN = <NUM_LIT> <EOL> LOCK_SERVO_UNLOCKED = <NUM_LIT> <EOL> LOCK_SERVO_LOCKED = <NUM_LIT> <EOL> BUTTON_PIN = <NUM_LIT> <EOL> BUTTON_DOWN = False <EOL> BUTTON_UP = True <EOL> POSITIVE_THRESHOLD = <NUM_LIT> <EOL> TRAINING_FILE = '<STR_LIT>' <EOL> POSITIVE_DIR = '<STR_LIT>' <EOL> NEGATIVE_DIR = '<STR_LIT>' ... |
<s> """<STR_LIT>""" <EOL> from hangups import message_parser , hangouts_pb2 <EOL> def parse_text ( text ) : <EOL> parser = message_parser . ChatMessageParser ( ) <EOL> return [ ( s . text , s . params ) for s in parser . parse ( text ) ] <EOL> def test_parse_linebreaks ( ) : <EOL> text = '<STR_LIT>' <EOL> expected = [ ... |
<s> import github3 as github <EOL> import os <EOL> import argparse <EOL> gh_user = os . getenv ( '<STR_LIT>' , None ) <EOL> gh_pass = os . getenv ( '<STR_LIT>' , None ) <EOL> gh_token = os . getenv ( '<STR_LIT>' , None ) <EOL> gh = github . GitHub ( username = gh_user , password = gh_pass , token = gh_token ) <EOL> def... |
<s> from nagios_cli . commands import configure , generic , objects , tail <EOL> DEFAULT = reduce ( lambda a , b : a + b , map ( lambda module : module . DEFAULT , <EOL> ( generic , configure , objects , tail ) ) ) </s>
|
<s> from django . conf . urls . defaults import patterns <EOL> from django . conf . urls . defaults import url <EOL> from apps . events . views import EventIndex <EOL> from apps . events . views import EventDetail <EOL> urlpatterns = patterns ( <EOL> '<STR_LIT>' , <EOL> url ( r'<STR_LIT>' , view = EventIndex . as_view ... |
<s> import json <EOL> def make_series_key ( key , tags , attributes ) : <EOL> """<STR_LIT>""" <EOL> return json . dumps ( { '<STR_LIT:key>' : key , '<STR_LIT>' : tags , '<STR_LIT>' : attributes } ) </s>
|
<s> import numpy as np <EOL> dtype = np . float64 <EOL> int_dtype = np . int64 <EOL> debug = False </s>
|
<s> from tensorprob import ScipyLBFGSBOptimizer , MigradOptimizer <EOL> import numpy as np <EOL> import tensorflow as tf <EOL> from nose . tools import raises <EOL> def test_scipy_lbfgsb ( ) : <EOL> sess = tf . Session ( ) <EOL> x = tf . Variable ( np . float64 ( <NUM_LIT:2> ) , name = '<STR_LIT:x>' ) <EOL> sess . run ... |
<s> import json <EOL> import time <EOL> import urllib <EOL> import urllib2 <EOL> import argparse <EOL> def get_credentials ( utoken , atoken , credsfile ) : <EOL> if utoken is None and atoken is None : <EOL> try : <EOL> creds = json . load ( open ( credsfile , '<STR_LIT:r>' ) ) <EOL> utoken = creds [ '<STR_LIT>' ] <EOL... |
<s> import sys <EOL> import os <EOL> import re <EOL> sys . path . insert ( <NUM_LIT:0> , os . path . abspath ( '<STR_LIT:..>' ) ) <EOL> from django . conf import settings <EOL> with open ( '<STR_LIT>' , '<STR_LIT:r>' ) as settings_file : <EOL> settings_str = settings_file . read ( ) <EOL> match = re . search ( '<STR_LI... |
<s> """<STR_LIT>""" <EOL> from django . core . management . base import BaseCommand <EOL> from django . conf import settings <EOL> from tethys_apps . app_harvester import SingletonAppHarvester <EOL> from tethys_apps . terminal_colors import TerminalColors <EOL> from sqlalchemy import create_engine <EOL> ALL_APPS = '<ST... |
<s> """<STR_LIT>""" <EOL> from django . db import models <EOL> from django . contrib . auth . models import User <EOL> from django . db . models . signals import pre_save , post_save , pre_delete , post_delete <EOL> from django . dispatch import receiver <EOL> from django . utils import timezone <EOL> from tethys_compu... |
<s> """<STR_LIT>""" <EOL> from django . core . urlresolvers import reverse <EOL> from django . test import TestCase <EOL> from django . test . client import Client <EOL> from django . contrib . auth . models import User <EOL> class LoginTestCase ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> """<... |
<s> from __future__ import unicode_literals <EOL> from itertools import izip <EOL> from django . db import migrations , connection <EOL> from django . db . utils import ProgrammingError , InternalError <EOL> def query_to_dicts ( query_string , * query_args ) : <EOL> """<STR_LIT>""" <EOL> cursor = connection . cursor ( ... |
<s> """<STR_LIT>""" <EOL> from __future__ import division , print_function , absolute_import <EOL> import tflearn <EOL> from tflearn . data_utils import to_categorical , pad_sequences <EOL> from tflearn . datasets import imdb <EOL> from tflearn . layers . core import input_data , dropout , fully_connected <EOL> from tf... |
<s> from __future__ import absolute_import <EOL> from . conv import conv_2d , max_pool_2d , avg_pool_2d , conv_1d , max_pool_1d , avg_pool_1d , shallow_residual_block , deep_residual_block <EOL> from . core import input_data , dropout , custom_layer , reshape , flatten , activation , fully_connected , single_unit <EOL>... |
<s> from mingus . server import main <EOL> main ( ) <EOL> '''<STR_LIT>''' </s>
|
<s> import jip <EOL> import os <EOL> import jip . grids as cl <EOL> from jip . db import Job <EOL> import sys <EOL> if __name__ == "<STR_LIT:__main__>" : <EOL> num_runs = <NUM_LIT:10> if len ( sys . argv ) == <NUM_LIT:1> else int ( sys . argv [ <NUM_LIT:1> ] ) <EOL> db_file = os . path . abspath ( "<STR_LIT>" ) <EOL> j... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.