rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
sys.stdout.write("\033[32;1m%s\033[0m\n"%commandline) | sys.stdout.write(u"\033[32;1m%s\033[0m\n"%commandline) | def print_cmd_line(commandline, target, source, env) : sys.stdout.write("\033[32;1m%s\033[0m\n"%commandline) sys.stdout.flush() |
except : env.Tool('pc', toolpath=[os.path.dirname(__file__)]) | except : env.Tool('pkgconfig', toolpath=[os.path.dirname(__file__)]) | def ClamModule(env, moduleName, version, description="", url='http://clam-project.org', clamDependencies=[], otherDependencies=[], sources=[], headers=[], ) : try: env.PkgConfigFile except : env.Tool('pc', toolpath=[os.path.dirname(__file__)]) crosscompiling = env.get('crossmingw') windowsTarget = sys.platform == 'win... |
if not env['verbose'] : env.ClamQuietCompilation() | if not env.get('verbose',True) : env.ClamQuietCompilation() | def ClamModule(env, moduleName, version, description="", url='http://clam-project.org', clamDependencies=[], otherDependencies=[], sources=[], headers=[], ) : try: env.PkgConfigFile except : env.Tool('pc', toolpath=[os.path.dirname(__file__)]) crosscompiling = env.get('crossmingw') windowsTarget = sys.platform == 'win... |
installedLib = env.Install(os.path.join(env['prefix_for_packaging'],'lib'), lib) | installedLib = env.Install(os.path.join(env['prefix'],'lib'), lib) | def ClamModule(env, moduleName, version, description="", url='http://clam-project.org', clamDependencies=[], otherDependencies=[], sources=[], headers=[], ) : try: env.PkgConfigFile except : env.Tool('pc', toolpath=[os.path.dirname(__file__)]) crosscompiling = env.get('crossmingw') windowsTarget = sys.platform == 'win... |
env.Install(os.path.join(env['prefix_for_packaging'],'lib','clam'), plugin), env.Install(os.path.join(env['prefix_for_packaging'],'lib','pkgconfig'), pcfile), env.Install(os.path.join(env['prefix_for_packaging'],'include','CLAM',moduleName), headers), | env.Install(os.path.join(env['prefix'],'lib','clam'), plugin), env.Install(os.path.join(env['prefix'],'lib','pkgconfig'), pcfile), env.Install(os.path.join(env['prefix'],'include','CLAM',moduleName), headers), | def ClamModule(env, moduleName, version, description="", url='http://clam-project.org', clamDependencies=[], otherDependencies=[], sources=[], headers=[], ) : try: env.PkgConfigFile except : env.Tool('pc', toolpath=[os.path.dirname(__file__)]) crosscompiling = env.get('crossmingw') windowsTarget = sys.platform == 'win... |
env.LinkerNameLink( os.path.join(env['prefix_for_packaging'],'lib',linkname), installedLib), env.SonameLink( os.path.join(env['prefix_for_packaging'],'lib',soname), installedLib), | env.LinkerNameLink( os.path.join(env['prefix'],'lib',linkname), installedLib), env.SonameLink( os.path.join(env['prefix'],'lib',soname), installedLib), | def ClamModule(env, moduleName, version, description="", url='http://clam-project.org', clamDependencies=[], otherDependencies=[], sources=[], headers=[], ) : try: env.PkgConfigFile except : env.Tool('pc', toolpath=[os.path.dirname(__file__)]) crosscompiling = env.get('crossmingw') windowsTarget = sys.platform == 'win... |
return install, (libraries, plugin, pcfile) | return install, libraries | def ClamModule(env, moduleName, version, description="", url='http://clam-project.org', clamDependencies=[], otherDependencies=[], sources=[], headers=[], ) : try: env.PkgConfigFile except : env.Tool('pc', toolpath=[os.path.dirname(__file__)]) crosscompiling = env.get('crossmingw') windowsTarget = sys.platform == 'win... |
if ( not env.has_key('prefix_for_packaging') or not env['prefix_for_packaging'] or env['prefix_for_packaging']=='.' ) : if env.has_key('prefix') : env['prefix_for_packaging'] = env['prefix'] | def generate_linker_name( target, source, env ) : source_file = os.path.basename( str(source[0]) ) os.system( "ln -sf %s %s"%(source_file,str(target[0]) )) | |
env['prefix_for_packaging'] = env['prefix'] | if env.has_key('prefix') : env['prefix_for_packaging'] = env['prefix'] | def generate_linker_name( target, source, env ) : source_file = os.path.basename( str(source[0]) ) os.system( "ln -sf %s %s"%(source_file,str(target[0]) )) |
class PackageData : def __init__(self, name, version='0.0', extra = [], depends = [] ) : self.name = name self.version = version self.depends = depends self.extra = extra def create_pkg_descriptor( self, env, out_file ) : out = open(out_file, 'w') print >> out, "prefix = %s"%env['prefix'] print >> out, "libdir = ${pr... | def check_pkg_config(context, *args, **kwords): context.Message( 'Checking for pkg-config... ' ) env = context.env crosscompiling = env.get('crossmingw') if not env.has_key('PKG_CONFIG') : env['PKG_CONFIG'] = 'pkg-config' if crosscompiling : env['PKG_CONFIG'] = 'wine pkg-config' if env.has_key('sandbox_path') : pathSep... | |
headers, sources = retrieveSources(env, folders, blacklist) if not env.GetOption('clean') : pkg_data = PackageData( 'clam_%s'%name, version ) pkg_data.create_pkg_descriptor( env, 'clam_%s.pc'%name ) | pcfile = env.PkgConfigFile( package = "clam_%s"%name, version = version, prefix = env['prefix'], description = "C++ Framework for analysis, synthesis and transformation of music audio signals", url = 'http://clam-project.org', requires = ["clam_%s"%module for module in moduleDependencies], cflags = env.Dictionary().get... | def lib_rules(name, version, folders, blacklist, install_dirs, env, moduleDependencies=[]) : headers, sources = retrieveSources(env, folders, blacklist) if not env.GetOption('clean') : # David: I don't understand why you don't want to clean it # -> it is not a builder, it can not be cleaned, TODO: Turn it a builder -... |
return posix_lib_rules( name, version, headers , sources, install_dirs, env ) | return posix_lib_rules( name, version, headers , sources, pcfile, install_dirs, env ) | def lib_rules(name, version, folders, blacklist, install_dirs, env, moduleDependencies=[]) : headers, sources = retrieveSources(env, folders, blacklist) if not env.GetOption('clean') : # David: I don't understand why you don't want to clean it # -> it is not a builder, it can not be cleaned, TODO: Turn it a builder -... |
return win32_lib_rules( name, version, headers , sources, install_dirs, env ) def posix_lib_rules( name, version, headers, sources, install_dirs, env, moduleDependencies=[]) : lib_descriptor = env.File( 'clam_'+name+'.pc' ) versionnumbers = version.split('.') libversion = "%s%s.%s"%(versionnumbers[0], versionnumb... | return win32_lib_rules( name, version, headers , sources, pcfile, install_dirs, env ) def posix_lib_rules( name, version, headers, sources, pcfile, install_dirs, env, moduleDependencies=[]) : versionnumbers = tuple(version.split('.')) | def lib_rules(name, version, folders, blacklist, install_dirs, env, moduleDependencies=[]) : headers, sources = retrieveSources(env, folders, blacklist) if not env.GetOption('clean') : # David: I don't understand why you don't want to clean it # -> it is not a builder, it can not be cleaned, TODO: Turn it a builder -... |
libname = 'libclam_'+name+'.so.%s%s.%s' % (versionnumbers[0], versionnumbers[1], versionnumbers[2]) soname = 'libclam_'+name+'.so.%s%s' % (versionnumbers[0], versionnumbers[1]) | def posix_lib_rules( name, version, headers, sources, install_dirs, env, moduleDependencies=[]) : #for file in sources : # print "file to compile: " + str(file) lib_descriptor = env.File( 'clam_'+name+'.pc' ) # We expect a version like " X.Y-possibleextrachars " versionnumbers = version.split('.') libversion = "%s%s.... | |
soname_lib = env.SonameLink( soname, lib ) linkername_lib = env.LinkerNameLink( linker_name, soname_lib ) env.Depends(lib, ['../%s/libclam_%s.so.%s'%(module,module,versionnumbers[0]) for module in moduleDependencies ]) | soname_lib = env.SonameLink( soname, lib ) linkername_lib = env.LinkerNameLink( linker_name, lib ) | def posix_lib_rules( name, version, headers, sources, install_dirs, env, moduleDependencies=[]) : #for file in sources : # print "file to compile: " + str(file) lib_descriptor = env.File( 'clam_'+name+'.pc' ) # We expect a version like " X.Y-possibleextrachars " versionnumbers = version.split('.') libversion = "%s%s.... |
env.Append( CCFLAGS=['-fno-common'] ) env.Append( SHLINKFLAGS=['-dynamic', '-Wl,-install_name,%s'%(install_dirs.lib + '/' + 'libclam_' + name + '.%s.dylib'%(version))] ) | env.AppendUnique( CCFLAGS=['-fno-common'] ) env.AppendUnique( SHLINKFLAGS=[ '-dynamic', '-Wl,-install_name,%s'%(install_dirs.lib + '/' + 'libclam_' + name + '.%s.dylib'%(version)) ] ) | def posix_lib_rules( name, version, headers, sources, install_dirs, env, moduleDependencies=[]) : #for file in sources : # print "file to compile: " + str(file) lib_descriptor = env.File( 'clam_'+name+'.pc' ) # We expect a version like " X.Y-possibleextrachars " versionnumbers = version.split('.') libversion = "%s%s.... |
install_descriptor = env.Install( install_dirs.lib+'/pkgconfig', lib_descriptor ) install_soname = env.SonameLink( install_dirs.lib + '/' + soname, install_lib ) install_linkername = env.LinkerNameLink( install_dirs.lib+'/'+linker_name, install_lib) | env.Depends(install_lib, [linkername_lib, soname_lib] ) install_descriptor = env.Install( install_dirs.pc, pcfile ) install_soname = env.SonameLink( os.path.join( install_dirs.lib, soname), install_lib ) install_linkername = env.LinkerNameLink( os.path.join(install_dirs.lib,linker_name), install_lib) | def posix_lib_rules( name, version, headers, sources, install_dirs, env, moduleDependencies=[]) : #for file in sources : # print "file to compile: " + str(file) lib_descriptor = env.File( 'clam_'+name+'.pc' ) # We expect a version like " X.Y-possibleextrachars " versionnumbers = version.split('.') libversion = "%s%s.... |
def win32_lib_rules( name, version, headers, sources, install_dirs, env, moduleDependencies =[] ) : crosscompiling=env.get('crossmingw') | def win32_lib_rules( name, version, headers, sources, install_dirs, pcfile, env, moduleDependencies =[] ) : | def win32_lib_rules( name, version, headers, sources, install_dirs, env, moduleDependencies =[] ) : crosscompiling=env.get('crossmingw') lib = env.SharedLibrary( 'clam_' + name, sources) tgt = env.Alias(name, lib) lib_descriptor = env.File( 'clam_'+name+'.pc' ) install_static = env.Install( install_dirs.lib, lib ) inst... |
lib_descriptor = env.File( 'clam_'+name+'.pc' ) install_static = env.Install( install_dirs.lib, lib ) install_descriptor = env.Install( install_dirs.lib+'/pkgconfig', lib_descriptor ) | install_lib = env.Install( install_dirs.lib, lib ) install_descriptor = env.Install( install_dirs.pc, pcfile ) | def win32_lib_rules( name, version, headers, sources, install_dirs, env, moduleDependencies =[] ) : crosscompiling=env.get('crossmingw') lib = env.SharedLibrary( 'clam_' + name, sources) tgt = env.Alias(name, lib) lib_descriptor = env.File( 'clam_'+name+'.pc' ) install_static = env.Install( install_dirs.lib, lib ) inst... |
install_tgt = env.Alias('install_'+name, [install_headers,install_static,install_descriptor]) | install_tgt = env.Alias('install_'+name, [ install_headers, install_lib, install_descriptor ]) | def win32_lib_rules( name, version, headers, sources, install_dirs, env, moduleDependencies =[] ) : crosscompiling=env.get('crossmingw') lib = env.SharedLibrary( 'clam_' + name, sources) tgt = env.Alias(name, lib) lib_descriptor = env.File( 'clam_'+name+'.pc' ) install_static = env.Install( install_dirs.lib, lib ) inst... |
private_repositories = localDefinitions['repositories'].split() | private_repositories = localDefinitions['private_repositories'].split() | def ellapsedTime(): global startTime return time.time() - startTime |
{CMD: 'svn up --accept postpone %s'%repo, INFO: lambda x:'' } | {CMD: 'svn up --accept postpone %s'%repo, INFO: lambda x:'Hola' } | def ellapsedTime(): global startTime return time.time() - startTime |
a lv2:%(port_type)s, lv2:AudioPort; | a lv2:%(port_type)sPort, lv2:AudioPort; | def ttl(self, port_type, firstIndex) : return [ """\ |
a lv2:%(port_type)s, lv2:ControlPort; | a lv2:%(port_type)sPort, lv2:ControlPort; | def ttl(self, port_type, firstIndex) : return [ """\ |
doap:developer [ foaf:name "clam-project"; foaf:homepage <http://clam-project.org> ; foaf:mbox <mailto:clam-devel@lists.clam-project.org> ; ] ; doap:maintainer [ foaf:name "clam-project"; foaf:homepage <http://clam-project.org> ; foaf:mbox <mailto:clam-devel@lists.clam-project.org> ; ] ; lv2:optionalFeature lv2:hardRtC... | def printTTL(self,clamnetwork,uri,name): | |
binary=name.capitalize(), name=name.capitalize(), | binary="clam_lv2_example", name=name, | def printTTL(self,clamnetwork,uri,name): |
else: return dir_path | return dir_path | def dircheck(dir_path): """Create directory if not exist""" dir_path = os.path.abspath(os.path.expanduser(dir_path)) if not os.path.isdir(dir_path): try: os.makedirs(dir_path) except OSError, msg: raise MangaException(msg) else: return dir_path |
parser.add_argument('-s', '--site', required=True, choices=('animea', | parser.add_argument('-f', '--file', type=str, help='%(prog)s config file') parser.add_argument('-s', '--site', choices=('animea', | def cmdparse(): """Returns parsed arguments from command line""" parser = argparse.ArgumentParser() parser.add_argument('-s', '--site', required=True, choices=('animea', 'ble', 'fox', 'reader', 'stream', 'toshokan'), help='manga site to download from') parser.add_argument('-t', '--title', type=str, required=True, help=... |
parser.add_argument('-t', '--title', type=str, required=True, | parser.add_argument('-t', '--title', type=str, | def cmdparse(): """Returns parsed arguments from command line""" parser = argparse.ArgumentParser() parser.add_argument('-s', '--site', required=True, choices=('animea', 'ble', 'fox', 'reader', 'stream', 'toshokan'), help='manga site to download from') parser.add_argument('-t', '--title', type=str, required=True, help=... |
if args.end: | if args.file: if not os.path.isfile(args.file): parser.print_usage() sys.exit('%s: error: config file does not exit' % parser.prog) elif not args.site: parser.print_usage() sys.exit('%s: error: argument -s/--start is required' % parser.prog) elif not args.title: parser.print_usage() sys.exit('%s: error: argument -t/--t... | def cmdparse(): """Returns parsed arguments from command line""" parser = argparse.ArgumentParser() parser.add_argument('-s', '--site', required=True, choices=('animea', 'ble', 'fox', 'reader', 'stream', 'toshokan'), help='manga site to download from') parser.add_argument('-t', '--title', type=str, required=True, help=... |
sys.exit('%s: error: argument -e/--end: should be bigger than ' '-s/--start' % parser.prog) | sys.exit('%s: error: argument -e/--end: should be bigger' 'than -s/--start' % parser.prog) | def cmdparse(): """Returns parsed arguments from command line""" parser = argparse.ArgumentParser() parser.add_argument('-s', '--site', required=True, choices=('animea', 'ble', 'fox', 'reader', 'stream', 'toshokan'), help='manga site to download from') parser.add_argument('-t', '--title', type=str, required=True, help=... |
try: manga = mangaclass[args.site](args.title, args.dir) manga.get(chapter=args.chapter, begin=args.begin, end=args.end, new=args.new) except MangaException, msg: sys.exit(msg) except KeyboardInterrupt: sys.exit('Cancelling download... quit') | if args.file: pass else: try: manga = mangaclass[args.site](args.title, args.dir) manga.get(chapter=args.chapter, begin=args.begin, end=args.end, new=args.new) except MangaException, msg: sys.exit(msg) except KeyboardInterrupt: sys.exit('Cancelling download... quit') | def main(): """Decide the right action from the command line""" mangaclass = {'animea': MangaAnimea, 'ble': MangaBle, 'fox': MangaFox, 'reader': MangaReader, 'stream': MangaStream, 'toshokan': MangaToshokan} args = cmdparse() try: manga = mangaclass[args.site](args.title, args.dir) manga.get(chapter=args.chapter, beg... |
chapters_regex = re.compile(r'href=\'(\S+)\' title="Read.*(\d+) now') | chapters_regex = re.compile(r'href=\'(\S+)\' .* (\d+)</a>') | def _cleanup(self, chapter_dir): """Returns a cleanup chapter directory""" return re.sub(r'/\d+$', '', chapter_dir) |
chapters_regex = re.compile(r'<td><a href="(\S+)">.*(\d+)</a>') | chapters_regex = re.compile(r'href="(\S+)">[\w\s]+\s(\d+)</a>[^</li>]+') | def _pageurl(self, chapter_dir, page=None): """Returns manga image page url""" if page: return '%s%s' % (chapter_dir, page) else: return chapter_dir |
chapters_regex = re.compile(r'href="(\S+)">[\w\s]+\s(\d+)</a>[^</li>]+') | chapters_regex = re.compile(r'href="(\S+)">["\s\w]+\s(\d+)</a>\s') | def _pageurl(self, chapter_dir, page=None): """Returns manga image page url""" if page: return '%s%s' % (chapter_dir, page) else: return chapter_dir |
return '%s/%s.html' % (self.site, self.title) | return '%s/%s.html?skip=1' % (self.site, self.title) | def _infourl(self): """Returns the index page's url of manga title""" return '%s/%s.html' % (self.site, self.title) |
chapters_regex = re.compile(r'</a>\s*<a href="(\S+)" class="chico">' '\s*.* Ch\.([\d\.]+):') pages_regex = re.compile(r'<option value="\d+" .*?>(\d+)</option>') image_regex = re.compile(r'<img src="(\S+)" width="\d+" id="image"') | chapters_regex = re.compile(r'</a>[ \r\n]*<a href="([^ ]+)" class=' r'"chico">[ \r\n]*.*[ ]+Ch\.([\.0-9]+)') pages_regex = re.compile(r'option value="[0-9]+" .*?>([0-9]+)</option') image_regex = re.compile(r'img src="([^ ]+)" width="[0-9]+" id="image"') | def _cleanup(chapter_dir): """Returns a cleanup chapter directory""" return chapter_dir |
chapters_regex = re.compile(r'<a href="(\S+)">(\d+)') pages_regex = re.compile(r'<option value="\S+".*?>(\d{1,2})</option>') image_regex = re.compile(r'this.src=\'(\S+)\'" border="0"') | chapters_regex = re.compile(r'<a href="([^ ]+)">([0-9]+)') pages_regex = re.compile(r'option value="[^ ]+".*?>([0-9]{1,2})</opt') image_regex = re.compile(r'this.src=\'([^ ]+)\'" border="0"') | def _pageurl(self, chapter_dir, page='1'): """Returns manga image page url""" return '%s%s%s.html' % (self.site, chapter_dir, page) |
chapters_regex = re.compile(r'href=\'(\S+)\' .* (\d+)</a>') pages_regex = re.compile(r'<option value="\S+".*?>(\d+)</option>') image_regex = re.compile(r'dir=\'rtl\'><img src="(\S+)"') | chapters_regex = re.compile(r'href=\'([^ ]+)\' .* ([0-9]+)</a>') pages_regex = re.compile(r'<option value="[^ ]+".*?>([0-9]+)</option>') image_regex = re.compile(r'dir=\'rtl\'><img src="([^ ]+)"') | def _cleanup(chapter_dir): """Returns a cleanup chapter directory""" return re.sub(r'/[0-9]+$', '', chapter_dir) |
chapters_regex = re.compile(r'href="(\S+)" title="[\D\s]*(\d+)">') pages_regex = re.compile(r'<option value="\d+">Page (\d+)</option>') image_regex = re.compile(r'<img src="(\S+)" class="image"') | chapters_regex = re.compile(r'href="([^ ]+)" .* Chapter ([\.0-9]+)">') pages_regex = re.compile(r'option value="[0-9]+">Page ([0-9]+)</opt') image_regex = re.compile(r'<img src="([^ ]+)" class="image"') | def _infourl(self): """Returns the index page's url of manga title""" return '%s/series/%s' % (self.site, self.title) |
chapters_regex = re.compile(r'href="(\S+)">["\s\w]+\s(\d+)</a>\s') pages_regex = re.compile(r'<option value="\d+".*?>(\d+)</option>') image_regex = re.compile(r'<img src="(\S+)" .* class="chapter_img"') | chapters_regex = re.compile(r'href="([^ ]+)">.* ([\.0-9]+)</a>\s') pages_regex = re.compile(r'<option value="[0-9]+".*?>([0-9]+)</option>') image_regex = re.compile(r'<img src="([^ ]+)" .* class="chapter_img"') | def _pageurl(self, chapter_dir, page=None): """Returns manga image page url""" if page: return '%s%s' % (chapter_dir, page) else: return chapter_dir |
chapters_regex = re.compile(r'<td><a href="(\S+)" class="chico">' '.+(\d+)</a>') pages_regex = re.compile(r'<option value=.+>\s*(\d+)</option>') image_regex = re.compile(r'<img id="img" src="(\S+)" width="800"') | chapters_regex = re.compile(r'<td><a href="([^ ]+)" class="chico">' r'.+ ([\.0-9]+)</a>') pages_regex = re.compile(r'<option value=.+>\s*([0-9]+)</option>') image_regex = re.compile(r'<img id="img" src="([^ ]+)" width="800"') | def _verify(self, chapter_dir): """Returns boolean status of a chapter validity""" return re.search(self.title, chapter_dir) |
page = re.sub(r'\-[0-9]+/', '-%s/' % page, chapter_dir) return '%s%s' % (self.site, page) | if re.search(r'.html$', chapter_dir): page = re.sub(r'\-[0-9]+/', '-%s/' % page, chapter_dir) return '%s%s' % (self.site, page) else: return '%s%s/%s' % (self.site, chapter_dir, page) | def _pageurl(self, chapter_dir, page='1'): """Returns manga image page url""" page = re.sub(r'\-[0-9]+/', '-%s/' % page, chapter_dir) return '%s%s' % (self.site, page) |
else: return 'akick' | else: return 'You are not welcomed here' | def get_reason(self): if self.reason: return self.reason else: return 'akick' |
ALISTS = [AKICK, AVISITOR, AMODERATOR] | ABAN = alist(bot, 'aban', a_ban, True) APARTICIPANT = alist(bot, 'aparticipant', a_participant, False) ALISTS = [AKICK, AVISITOR, AMODERATOR, ABAN, APARTICIPANT] | def a_moderator(item, reason): item.room.moderate('nick', item.nick, 'role', 'moderator', '') |
write_enter_guard(out, decl) | if output_guards: write_enter_guard(out, decl) else: out.write(" return_val = P%s%s;\n" % (decl.name, decl.argList())) | def write_c_wrapper(out, decl, return_val, write_body): """Write the C wrapper for an MPI function.""" # Write the PMPI prototype here in case mpi.h doesn't define it # (sadly the case with some MPI implementaitons) out.write(decl.pmpi_prototype(default_modifiers)) out.write(";\n") # Now write the wrapper function, wh... |
kwargs['_globals']['Url'] = sconsnode.url.Url | kwargs['_globals']['Url'] = sconsbuilders.url.Url | def __init__(self, *args, **kwargs): libext_builders = {} builder_wrappers = [ BuilderWrapper(self,'Download'), BuilderWrapper(self,'UnTar'), BuilderWrapper(self,'Delete',self.DeleteBuilder), CMakeWrapper (self,'CMake'), BuilderWrapper(self,'Make'), ConfigureWrapper(self,'Configure'), WaitDependenciesWrapper(self), ] |
args = ['-i', source[0].get_abspath()] options = env.get('OPTIONS',['-p1']) options = map(env.subst, options) args.extend(options) | args = [] args.extend([t.value for t in target]) args.extend(env.get('OPTIONS',[])) args = map(env.subst, args) | def CommandArgs(target, source, env): args = ['-i', source[0].get_abspath()] options = env.get('OPTIONS',['-p1']) options = map(env.subst, options) args.extend(options) return args |
pwd = os.path.abspath(target[0].value) | pwd = os.path.abspath(source[0].get_abspath()) | def Command(target, source, env): assert len(source) == 1 pwd = os.path.abspath(target[0].value) command = env.subst('${COMMAND}') args = CommandArgs(target, source, env) returncode = SubProcessBuilder(target, source, env, command, args, pwd) return returncode |
command = env.subst('${COMMAND}') | def Command(target, source, env): assert len(source) == 1 pwd = os.path.abspath(target[0].value) command = env.subst('${COMMAND}') args = CommandArgs(target, source, env) returncode = SubProcessBuilder(target, source, env, command, args, pwd) return returncode | |
returncode = SubProcessBuilder(target, source, env, command, args, pwd) | command = args[0] returncode = SubProcessBuilder(target, source, env, command, args, pwd, [pwd]) | def Command(target, source, env): assert len(source) == 1 pwd = os.path.abspath(target[0].value) command = env.subst('${COMMAND}') args = CommandArgs(target, source, env) returncode = SubProcessBuilder(target, source, env, command, args, pwd) return returncode |
return prefix + env.subst('${COMMAND} '+str(args)) | return prefix + env.subst(str(args)) | def CommandString(target, source, env): """ Information string for Command """ prefix = SubProcessString(target, source, env) args = CommandArgs(target, source, env) return prefix + env.subst('${COMMAND} '+str(args)) |
bin_results = [] for dep in self.bin_rec_deps: bin_results.append( dep.install(opts) ) | bin_deps = 'bin' in opts and 'deps' in opts if bin_deps: bin_results = [] for dep in self.bin_rec_deps: bin_results.append( dep.install(opts) ) bin_results.sort() | def install(self, opts = ['rc']): env = self.env result = [] if 'rc' in opts: result += self.install_rc() |
env.Depends(result, bin_results) | if bin_deps: env.Depends(result, bin_results) | def install(self, opts = ['rc']): env = self.env result = [] if 'rc' in opts: result += self.install_rc() |
for dep in self.bin_rec_deps: bin_results.append( dep.install(['bin','rc']) ) | for dep in self.bin_deps: bin_results.append( dep.install(['bin','deps','rc']) ) | def install (self, opts = ['deps','rc']): """Create the installation targets for project's results files and return them. |
res = any(res.get_path().endswith(exit) for ext in to_install) | res = any(f.get_path().endswith(exit) for ext in to_install) | def install_file_filter(env, f): to_install = [ '.exe', '.dll', '.pdb'] res = hasattr(f,"get_path") if res: res = any(res.get_path().endswith(exit) for ext in to_install) return res |
os.mkdir(GRAPHLIBEXT_INSTALL_PATH) | if not os.path.exists(GRAPHLIBEXT_INSTALL_PATH): os.mkdir(GRAPHLIBEXT_INSTALL_PATH) | def init(self): libext = renv.options.get_option( KEYWORD ) |
def inc_build_dir(self): return map(prj.get_build_dir_for_path, prj.include_path) | def inc_build_dir(prj): return map(prj.get_build_dir_for, prj.include_path) | def inc_build_dir(self): return map(prj.get_build_dir_for_path, prj.include_path) |
env.Execute(SCons.Script.Mkdir(cmake_build_path)) | if not wasdir: env.Execute(SCons.Script.Mkdir(cmake_build_path)) | def CMake(target, source, env): assert len(source) == 1 cmake_prj_path = find_cmake_path(source[0].get_abspath()) cmake_build_path = target[0].get_abspath() wasdir = target[0].isdir() env.Execute(SCons.Script.Mkdir(cmake_build_path)) command = 'cmake' args = [] args.append(cmake_prj_path) args.append(env.subst('${... |
args.append(env.subst('${OPTIONS}')) | def CMake(target, source, env): assert len(source) == 1 cmake_prj_path = find_cmake_path(source[0].get_abspath()) cmake_build_path = target[0].get_abspath() wasdir = target[0].isdir() env.Execute(SCons.Script.Mkdir(cmake_build_path)) command = 'cmake' args = [] args.append(cmake_prj_path) args.append(env.subst('${... | |
('QT_DIR' ,'${IDE_INSTALL_DIR}/qtcreator/${PRJ_USER_FORMAT}/'), | ('QT_DIR' ,'${IDE_INSTALL_DIR}/qtcreator/${PRJ_NAME}/'), | def create_prj (self, prj): |
'${QT_DIR}/${PRJ_USER_FORMAT}.pro' ), | '${QT_DIR}/${PRJ_NAME}.pro' ), | def create_prj (self, prj): |
'${QT_DIR}/${PRJ_USER_FORMAT}.pro.user'), | '${QT_DIR}/${PRJ_NAME}.pro.user'), | def create_prj (self, prj): |
'${OS_DIR}/${PRJ_USER_FORMAT}.qws' ), | '${OS_DIR}/${PRJ_NAME}.qws' ), | def create_prj (self, prj): |
for dep in prj.source_libs_deps + prj.source_bundles_deps: depresult = dep.build() env.Depends(result, depresult) | for dep_result in dep_results: env.Depends(result, dep_result) | def result(self, deps_results=True): """Returns the SCons targets for this project. |
return os.path.join(*path) | return [os.path.join(*path)] | def include_path (self): path = [self.local_dir, 'include'] return os.path.join(*path) |
inc = [lib.include_path for lib in self.source_rec_deps] | inc = [] for lib in self.source_rec_deps: inc += lib.include_path | def deps_include_path (self): inc = [lib.include_path for lib in self.source_rec_deps] return inc |
prj.configure_env() | def result(self, deps_results=True): prj = self env = self.env | |
'CFLAGS' , 'CXXFLAGS' | 'CFLAGS' , 'CXXFLAGS', | def options (self): """Returns a dictionnary with project build options.""" prj = self |
env = env['ENV'] | env = environment | def CMake(target, source, env): assert len(source) == 1 cmake_prj_path = find_cmake_path(source[0].get_abspath()) cmake_build_path = target[0].get_abspath() env.Execute(SCons.Script.Mkdir(cmake_build_path)) cmd = [ env.WhereIs('cmake', path=os.environ['PATH']) ] cmd.append(cmake_prj_path) cmd.append(env.subst('$... |
return self.install_files(self.lib_path, self.install_path, regex) | if regex: res = self.install_files(self.lib_path, self.install_path, regex) else: res = [] return res | def install_bin_libext (self): env = self.env import fnmatch libext = self.get('LIBEXTFACTORY') |
return self.prj.env['ENV'][name] = subst(newpath) | self.prj.env['ENV'][name] = subst(newpath) return None | def __call__(self, name, newpath): subst = self.prj.env.subst return self.prj.env['ENV'][name] = subst(newpath) |
racy.rlibext.register.configure(self, ['cppunit']) | def configure_env(self): racy.rlibext.register.configure(self, ['cppunit']) | |
apply_expression(e, f, f) | apply_expression(e, f, f, mode) | def Edit(target, source, env): # we don't use target and source as usual : we may apply several times this # builder on the same source/target (or the source may be the target), # that's not possible for scons files, expr, mode = EditArgs(target, source, env) for f in files: for e in expr: apply_expression(e, f, f) ... |
deps = tuple(set(deps)) | deps = tuple(sorted(set(deps), key=str)) | def _get_rec_deps(self, callers, attribs = ['source_deps']): """Returns recursive dependencies (libs + bundles). Usefull to get all include path for example. """ if self in callers: cycle = [prj.name for prj in callers[callers.index(self):]] msg = " -> ".join(cycle + [self.name]) raise RacyProjectError(self, ('Cyclic d... |
return rutils.DeepGlob( | sources = rutils.DeepGlob( | def sources(self): """Returns CXX source files of the project""" build_dirs = map(self.get_build_dir_for, self.src_path) |
rec_bin_deps = set(self.bin_rec_deps) - set(bin_deps) | rec_bin_deps = sorted(set(self.bin_rec_deps) - set(bin_deps), key=str) | def configure_env(self): """Configure the SCons environment.""" prj = self env = self.env |
return self.result(deps_results = build_deps) | result = self.result(deps_results = build_deps) result.sort(key=abspath_key) result = self.env.Alias ('build-' + self.full_name, result) return result | def build (self, build_deps=True): """Returns the SCons targets for this project. |
def inc_build_dir(prj): return map(self.get_build_dir_for_path, prj.include_path) | def inc_build_dir(self): return map(prj.get_build_dir_for_path, prj.include_path) | def inc_build_dir(prj): return map(self.get_build_dir_for_path, prj.include_path) |
copy = prj.CopyBuilder('${LOCAL_DIR}', prj.install_pkg_path) env.Depends(copy, write) | def install (self, opts = ['rc','deps']): prj = self env = self.env | |
result = copy | result = write | def install (self, opts = ['rc','deps']): prj = self env = self.env |
env['ENV']['DOX_DOT_PATH'] = dot | env['ENV']['DOX_DOT_PATH'] = os.path.split(dot)[0] | def result(self, deps_results=True): prj = self env = self.env |
'LINKFLAGS' , 'CXXFLAGS' | 'CFLAGS' , 'CXXFLAGS' 'LINKFLAGS' , | def options (self): """Returns a dictionnary with project build options.""" prj = self |
'PreprendENVPath' : PreprendENVPathWrapper(self), | 'PreprendENVPath' : PrependENVPathWrapper(self), | def __init__(self, *args, **kwargs): generate_functions = {} builder_wrappers = [ BuilderWrapper (self,'Download'), BuilderWrapper (self,'UnTar'), BuilderWrapper (self,'UnZip'), BuilderWrapper (self,'Delete',self.DeleteBuilder), BuilderWrapper (self,'Copy' ,self.CopyBuilder), BuilderWrapper (self,'Mkdir' ,self.M... |
raise e except urllib2.URLError, e: raise e | raise Exception, "Url Error: {0} [{1}]".format(e.reason , self.name) except urllib2.URLError, e: raise Exception, "Url Error: {0} [{1}]".format(e.reason , self.name) | def exists(self): res = False try: self.url = urllib2.urlopen(self.name) res = True except urllib2.HTTPError, e: raise e except urllib2.URLError, e: raise e return res |
patterns = user_pattern | patterns += user_pattern | def set_stdout(self, user_pattern=None): if sys.stdout.isatty(): if user_pattern: patterns = user_pattern else: patterns = base.scons_patterns if platform.system() == "Windows": patterns += base.msvs_patterns else: patterns += base.gcc_patterns patterns += base.default_patterns sys.stdout = ColorStdOutProxy(self.stdout... |
patterns = base.scons_patterns | patterns += base.scons_patterns | def set_stdout(self, user_pattern=None): if sys.stdout.isatty(): if user_pattern: patterns = user_pattern else: patterns = base.scons_patterns if platform.system() == "Windows": patterns += base.msvs_patterns else: patterns += base.gcc_patterns patterns += base.default_patterns sys.stdout = ColorStdOutProxy(self.stdout... |
def get_includes(self, builddir = True): | def get_files(self, path, ext, builddir = True): | def get_includes(self, builddir = True): """Returns HXX source files of the project""" kwargs = {} if builddir: kwargs['replace_dir'] = map(self.get_build_dir_for, self.include_path) else: kwargs['replace_dir'] = self.include_path |
kwargs['replace_dir'] = map(self.get_build_dir_for, self.include_path) | kwargs['replace_dir'] = map(self.get_build_dir_for, path) | def get_includes(self, builddir = True): """Returns HXX source files of the project""" kwargs = {} if builddir: kwargs['replace_dir'] = map(self.get_build_dir_for, self.include_path) else: kwargs['replace_dir'] = self.include_path |
kwargs['replace_dir'] = self.include_path sources = rutils.DeepGlob( | kwargs['replace_dir'] = path sources = rutils.DeepGlob( ext, path, **kwargs) return sources def get_includes(self, builddir = True): """Returns HXX source files of the project""" return self.get_files( self.include_path, | def get_includes(self, builddir = True): """Returns HXX source files of the project""" kwargs = {} if builddir: kwargs['replace_dir'] = map(self.get_build_dir_for, self.include_path) else: kwargs['replace_dir'] = self.include_path |
self.include_path, **kwargs ) + self.extra_sources + self.special_source return sources | builddir ) | def get_includes(self, builddir = True): """Returns HXX source files of the project""" kwargs = {} if builddir: kwargs['replace_dir'] = map(self.get_build_dir_for, self.include_path) else: kwargs['replace_dir'] = self.include_path |
kwargs = {} if builddir: kwargs['replace_dir'] = map(self.get_build_dir_for, self.src_path) else: kwargs['replace_dir'] = self.src_path sources = rutils.DeepGlob( | return self.get_files( self.src_path, | def get_sources(self, builddir = True): """Returns CXX source files of the project""" kwargs = {} if builddir: kwargs['replace_dir'] = map(self.get_build_dir_for, self.src_path) else: kwargs['replace_dir'] = self.src_path |
self.src_path, **kwargs ) + self.extra_sources + self.special_source return sources | builddir ) | def get_sources(self, builddir = True): """Returns CXX source files of the project""" kwargs = {} if builddir: kwargs['replace_dir'] = map(self.get_build_dir_for, self.src_path) else: kwargs['replace_dir'] = self.src_path |
sources = cached_property(get_sources) | @cached_property def sources(self): return self.get_sources() + self.extra_sources + self.special_source | def get_sources(self, builddir = True): """Returns CXX source files of the project""" kwargs = {} if builddir: kwargs['replace_dir'] = map(self.get_build_dir_for, self.src_path) else: kwargs['replace_dir'] = self.src_path |
racy_db_file = get_option('RACY_DBFILE', default=racy_db_file_default) | racy_db_file = get_option('RACY_DBFILE') if not racy_db_file: racy_db_file = racy_db_file_default | def __init__(self, *args, **kwargs): from os.path import abspath, dirname, join |
if hasattr(attr,'__iter__'): | if isinstance(attr,basestring) or hasattr(attr,'__iter__'): | def __init__(self, name, debug, infosource=None): platform_init = getattr(self, racy.renv.system(), self.platform_not_managed) |
msg = ("libext members must be a simple type (list, dict, str" "...), a callable, or a property. '{attr}' attribute is" "invalid in '{lib}' __init__.py file.") raise LibExtException, msg.format(lib=self.name, attr=name) | msg = ("libext members must be a allowed type (list, dict, str" "), a callable, or a property. '{attr}' attribute type " "({attrtype}) is invalid in '{lib}' __init__.py file.") raise LibExtException, msg.format( lib=self.name, attr=name, attrtype=type(attr)) | def __init__(self, name, debug, infosource=None): platform_init = getattr(self, racy.renv.system(), self.platform_not_managed) |
expr = map(env.subst, expr) | expr = map(functools.partial(env.subst, raw=1), expr) | def EditArgs(target, source, env): files = [] files.extend(env.get('FILES',[])) files = map(env.subst, files) expr = [] expr.extend(env.get('EXPR',[])) expr = map(env.subst, expr) return files, expr |
action = os.symlink if os.path.exists(dst): os.unlink(dst) | action = os.symlink if os.path.exists(dst): os.unlink(dst) try: action(src, dst) except exceptions.OSError, e: if not e.strerror == 'File exists': raise e | def copy (src, dst, preserve_links=True, preserve_relative_links_only = True): #never true if symlinks not supported import shutil import os action = None if preserve_links and os.path.islink(src): linktarget = os.readlink( src ) if preserve_relative_links_only and os.path.isabs(linktarget): action = shutil.copy else... |
action = shutil.copy action(src, dst) | shutil.copy(src, dst) | def copy (src, dst, preserve_links=True, preserve_relative_links_only = True): #never true if symlinks not supported import shutil import os action = None if preserve_links and os.path.islink(src): linktarget = os.readlink( src ) if preserve_relative_links_only and os.path.isabs(linktarget): action = shutil.copy else... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.