)<[^<]*)*<\/script>/gi,bO=/^(?:select|textarea)/i,bP=/\s+/,bQ=/([?&])_=[^&]*/,bR=/^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,bS=f.fn.load,bT={},bU={},bV,bW,bX=["*/"]+["*"];try{bV=e.href}catch(bY){bV=c.createElement("a"),bV.href="",bV=bV.href}bW=bR.exec(bV.toLowerCase())||[],f.fn.extend({load:function(a,c,d){if(typeof a!="string"&&bS)return bS.apply(this,arguments);if(!this.length)return this;var e=a.indexOf(" ");if(e>=0){var g=a.slice(e,a.length);a=a.slice(0,e)}var h="GET";c&&(f.isFunction(c)?(d=c,c=b):typeof c=="object"&&(c=f.param(c,f.ajaxSettings.traditional),h="POST"));var i=this;f.ajax({url:a,type:h,dataType:"html",data:c,complete:function(a,b,c){c=a.responseText,a.isResolved()&&(a.done(function(a){c=a}),i.html(g?f("").append(c.replace(bN,"")).find(g):c)),d&&i.each(d,[c,b,a])}});return this},serialize:function(){return f.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?f.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||bO.test(this.nodeName)||bI.test(this.type))}).map(function(a,b){var c=f(this).val();return c==null?null:f.isArray(c)?f.map(c,function(a,c){return{name:b.name,value:a.replace(bF,"\r\n")}}):{name:b.name,value:c.replace(bF,"\r\n")}}).get()}}),f.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(a,b){f.fn[b]=function(a){return this.on(b,a)}}),f.each(["get","post"],function(a,c){f[c]=function(a,d,e,g){f.isFunction(d)&&(g=g||e,e=d,d=b);return f.ajax({type:c,url:a,data:d,success:e,dataType:g})}}),f.extend({getScript:function(a,c){return f.get(a,b,c,"script")},getJSON:function(a,b,c){return f.get(a,b,c,"json")},ajaxSetup:function(a,b){b?b_(a,f.ajaxSettings):(b=a,a=f.ajaxSettings),b_(a,b);return a},ajaxSettings:{url:bV,isLocal:bJ.test(bW[1]),global:!0,type:"GET",contentType:"application/x-www-form-urlencoded",processData:!0,async:!0,accepts:{xml:"application/xml, text/xml",html:"text/html",text:"text/plain",json:"application/json, text/javascript","*":bX},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText"},converters:{"* text":a.String,"text html":!0,"text json":f.parseJSON,"text xml":f.parseXML},flatOptions:{context:!0,url:!0}},ajaxPrefilter:bZ(bT),ajaxTransport:bZ(bU),ajax:function(a,c){function w(a,c,l,m){if(s!==2){s=2,q&&clearTimeout(q),p=b,n=m||"",v.readyState=a>0?4:0;var o,r,u,w=c,x=l?cb(d,v,l):b,y,z;if(a>=200&&a<300||a===304){if(d.ifModified){if(y=v.getResponseHeader("Last-Modified"))f.lastModified[k]=y;if(z=v.getResponseHeader("Etag"))f.etag[k]=z}if(a===304)w="notmodified",o=!0;else try{r=cc(d,x),w="success",o=!0}catch(A){w="parsererror",u=A}}else{u=w;if(!w||a)w="error",a<0&&(a=0)}v.status=a,v.statusText=""+(c||w),o?h.resolveWith(e,[r,w,v]):h.rejectWith(e,[v,w,u]),v.statusCode(j),j=b,t&&g.trigger("ajax"+(o?"Success":"Error"),[v,d,o?r:u]),i.fireWith(e,[v,w]),t&&(g.trigger("ajaxComplete",[v,d]),--f.active||f.event.trigger("ajaxStop"))}}typeof a=="object"&&(c=a,a=b),c=c||{};var d=f.ajaxSetup({},c),e=d.context||d,g=e!==d&&(e.nodeType||e instanceof f)?f(e):f.event,h=f.Deferred(),i=f.Callbacks("once memory"),j=d.statusCode||{},k,l={},m={},n,o,p,q,r,s=0,t,u,v={readyState:0,setRequestHeader:function(a,b){if(!s){var c=a.toLowerCase();a=m[c]=m[c]||a,l[a]=b}return this},getAllResponseHeaders:function(){return s===2?n:null},getResponseHeader:function(a){var c;if(s===2){if(!o){o={};while(c=bH.exec(n))o[c[1].toLowerCase()]=c[2]}c=o[a.toLowerCase()]}return c===b?null:c},overrideMimeType:function(a){s||(d.mimeType=a);return this},abort:function(a){a=a||"abort",p&&p.abort(a),w(0,a);return this}};h.promise(v),v.success=v.done,v.error=v.fail,v.complete=i.add,v.statusCode=function(a){if(a){var b;if(s<2)for(b in a)j[b]=[j[b],a[b]];else b=a[v.status],v.then(b,b)}return this},d.url=((a||d.url)+"").replace(bG,"").replace(bL,bW[1]+"//"),d.dataTypes=f.trim(d.dataType||"*").toLowerCase().split(bP),d.crossDomain==null&&(r=bR.exec(d.url.toLowerCase()),d.crossDomain=!(!r||r[1]==bW[1]&&r[2]==bW[2]&&(r[3]||(r[1]==="http:"?80:443))==(bW[3]||(bW[1]==="http:"?80:443)))),d.data&&d.processData&&typeof d.data!="string"&&(d.data=f.param(d.data,d.traditional)),b$(bT,d,c,v);if(s===2)return!1;t=d.global,d.type=d.type.toUpperCase(),d.hasContent=!bK.test(d.type),t&&f.active++===0&&f.event.trigger("ajaxStart");if(!d.hasContent){d.data&&(d.url+=(bM.test(d.url)?"&":"?")+d.data,delete d.data),k=d.url;if(d.cache===!1){var x=f.now(),y=d.url.replace(bQ,"$1_="+x);d.url=y+(y===d.url?(bM.test(d.url)?"&":"?")+"_="+x:"")}}(d.data&&d.hasContent&&d.contentType!==!1||c.contentType)&&v.setRequestHeader("Content-Type",d.contentType),d.ifModified&&(k=k||d.url,f.lastModified[k]&&v.setRequestHeader("If-Modified-Since",f.lastModified[k]),f.etag[k]&&v.setRequestHeader("If-None-Match",f.etag[k])),v.setRequestHeader("Accept",d.dataTypes[0]&&d.accepts[d.dataTypes[0]]?d.accepts[d.dataTypes[0]]+(d.dataTypes[0]!=="*"?", "+bX+"; q=0.01":""):d.accepts["*"]);for(u in d.headers)v.setRequestHeader(u,d.headers[u]);if(d.beforeSend&&(d.beforeSend.call(e,v,d)===!1||s===2)){v.abort();return!1}for(u in{success:1,error:1,complete:1})v[u](d[u]);p=b$(bU,d,c,v);if(!p)w(-1,"No Transport");else{v.readyState=1,t&&g.trigger("ajaxSend",[v,d]),d.async&&d.timeout>0&&(q=setTimeout(function(){v.abort("timeout")},d.timeout));try{s=1,p.send(l,w)}catch(z){if(s<2)w(-1,z);else throw z}}return v},param:function(a,c){var d=[],e=function(a,b){b=f.isFunction(b)?b():b,d[d.length]=encodeURIComponent(a)+"="+encodeURIComponent(b)};c===b&&(c=f.ajaxSettings.traditional);if(f.isArray(a)||a.jquery&&!f.isPlainObject(a))f.each(a,function(){e(this.name,this.value)});else for(var g in a)ca(g,a[g],c,e);return d.join("&").replace(bD,"+")}}),f.extend({active:0,lastModified:{},etag:{}});var cd=f.now(),ce=/(\=)\?(&|$)|\?\?/i;f.ajaxSetup({jsonp:"callback",jsonpCallback:function(){return f.expando+"_"+cd++}}),f.ajaxPrefilter("json jsonp",function(b,c,d){var e=b.contentType==="application/x-www-form-urlencoded"&&typeof b.data=="string";if(b.dataTypes[0]==="jsonp"||b.jsonp!==!1&&(ce.test(b.url)||e&&ce.test(b.data))){var g,h=b.jsonpCallback=f.isFunction(b.jsonpCallback)?b.jsonpCallback():b.jsonpCallback,i=a[h],j=b.url,k=b.data,l="$1"+h+"$2";b.jsonp!==!1&&(j=j.replace(ce,l),b.url===j&&(e&&(k=k.replace(ce,l)),b.data===k&&(j+=(/\?/.test(j)?"&":"?")+b.jsonp+"="+h))),b.url=j,b.data=k,a[h]=function(a){g=[a]},d.always(function(){a[h]=i,g&&f.isFunction(i)&&a[h](g[0])}),b.converters["script json"]=function(){g||f.error(h+" was not called");return g[0]},b.dataTypes[0]="json";return"script"}}),f.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/javascript|ecmascript/},converters:{"text script":function(a){f.globalEval(a);return a}}}),f.ajaxPrefilter("script",function(a){a.cache===b&&(a.cache=!1),a.crossDomain&&(a.type="GET",a.global=!1)}),f.ajaxTransport("script",function(a){if(a.crossDomain){var d,e=c.head||c.getElementsByTagName("head")[0]||c.documentElement;return{send:function(f,g){d=c.createElement("script"),d.async="async",a.scriptCharset&&(d.charset=a.scriptCharset),d.src=a.url,d.onload=d.onreadystatechange=function(a,c){if(c||!d.readyState||/loaded|complete/.test(d.readyState))d.onload=d.onreadystatechange=null,e&&d.parentNode&&e.removeChild(d),d=b,c||g(200,"success")},e.insertBefore(d,e.firstChild)},abort:function(){d&&d.onload(0,1)}}}});var cf=a.ActiveXObject?function(){for(var a in ch)ch[a](0,1)}:!1,cg=0,ch;f.ajaxSettings.xhr=a.ActiveXObject?function(){return!this.isLocal&&ci()||cj()}:ci,function(a){f.extend(f.support,{ajax:!!a,cors:!!a&&"withCredentials"in a})}(f.ajaxSettings.xhr()),f.support.ajax&&f.ajaxTransport(function(c){if(!c.crossDomain||f.support.cors){var d;return{send:function(e,g){var h=c.xhr(),i,j;c.username?h.open(c.type,c.url,c.async,c.username,c.password):h.open(c.type,c.url,c.async);if(c.xhrFields)for(j in c.xhrFields)h[j]=c.xhrFields[j];c.mimeType&&h.overrideMimeType&&h.overrideMimeType(c.mimeType),!c.crossDomain&&!e["X-Requested-With"]&&(e["X-Requested-With"]="XMLHttpRequest");try{for(j in e)h.setRequestHeader(j,e[j])}catch(k){}h.send(c.hasContent&&c.data||null),d=function(a,e){var j,k,l,m,n;try{if(d&&(e||h.readyState===4)){d=b,i&&(h.onreadystatechange=f.noop,cf&&delete ch[i]);if(e)h.readyState!==4&&h.abort();else{j=h.status,l=h.getAllResponseHeaders(),m={},n=h.responseXML,n&&n.documentElement&&(m.xml=n),m.text=h.responseText;try{k=h.statusText}catch(o){k=""}!j&&c.isLocal&&!c.crossDomain?j=m.text?200:404:j===1223&&(j=204)}}}catch(p){e||g(-1,p)}m&&g(j,k,m,l)},!c.async||h.readyState===4?d():(i=++cg,cf&&(ch||(ch={},f(a).unload(cf)),ch[i]=d),h.onreadystatechange=d)},abort:function(){d&&d(0,1)}}}});var ck={},cl,cm,cn=/^(?:toggle|show|hide)$/,co=/^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,cp,cq=[["height","marginTop","marginBottom","paddingTop","paddingBottom"],["width","marginLeft","marginRight","paddingLeft","paddingRight"],["opacity"]],cr;f.fn.extend({show:function(a,b,c){var d,e;if(a||a===0)return this.animate(cu("show",3),a,b,c);for(var g=0,h=this.length;g=i.duration+this.startTime){this.now=this.end,this.pos=this.state=1,this.update(),i.animatedProperties[this.prop]=!0;for(b in i.animatedProperties)i.animatedProperties[b]!==!0&&(g=!1);if(g){i.overflow!=null&&!f.support.shrinkWrapBlocks&&f.each(["","X","Y"],function(a,b){h.style["overflow"+b]=i.overflow[a]}),i.hide&&f(h).hide();if(i.hide||i.show)for(b in i.animatedProperties)f.style(h,b,i.orig[b]),f.removeData(h,"fxshow"+b,!0),f.removeData(h,"toggle"+b,!0);d=i.complete,d&&(i.complete=!1,d.call(h))}return!1}i.duration==Infinity?this.now=e:(c=e-this.startTime,this.state=c/i.duration,this.pos=f.easing[i.animatedProperties[this.prop]](this.state,c,0,1,i.duration),this.now=this.start+(this.end-this.start)*this.pos),this.update();return!0}},f.extend(f.fx,{tick:function(){var a,b=f.timers,c=0;for(;c-1,k={},l={},m,n;j?(l=e.position(),m=l.top,n=l.left):(m=parseFloat(h)||0,n=parseFloat(i)||0),f.isFunction(b)&&(b=b.call(a,c,g)),b.top!=null&&(k.top=b.top-g.top+m),b.left!=null&&(k.left=b.left-g.left+n),"using"in b?b.using.call(a,k):e.css(k)}},f.fn.extend({position:function(){if(!this[0])return null;var a=this[0],b=this.offsetParent(),c=this.offset(),d=cx.test(b[0].nodeName)?{top:0,left:0}:b.offset();c.top-=parseFloat(f.css(a,"marginTop"))||0,c.left-=parseFloat(f.css(a,"marginLeft"))||0,d.top+=parseFloat(f.css(b[0],"borderTopWidth"))||0,d.left+=parseFloat(f.css(b[0],"borderLeftWidth"))||0;return{top:c.top-d.top,left:c.left-d.left}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||c.body;while(a&&!cx.test(a.nodeName)&&f.css(a,"position")==="static")a=a.offsetParent;return a})}}),f.each(["Left","Top"],function(a,c){var d="scroll"+c;f.fn[d]=function(c){var e,g;if(c===b){e=this[0];if(!e)return null;g=cy(e);return g?"pageXOffset"in g?g[a?"pageYOffset":"pageXOffset"]:f.support.boxModel&&g.document.documentElement[d]||g.document.body[d]:e[d]}return this.each(function(){g=cy(this),g?g.scrollTo(a?f(g).scrollLeft():c,a?c:f(g).scrollTop()):this[d]=c})}}),f.each(["Height","Width"],function(a,c){var d=c.toLowerCase();f.fn["inner"+c]=function(){var a=this[0];return a?a.style?parseFloat(f.css(a,d,"padding")):this[d]():null},f.fn["outer"+c]=function(a){var b=this[0];return b?b.style?parseFloat(f.css(b,d,a?"margin":"border")):this[d]():null},f.fn[d]=function(a){var e=this[0];if(!e)return a==null?null:this;if(f.isFunction(a))return this.each(function(b){var c=f(this);c[d](a.call(this,b,c[d]()))});if(f.isWindow(e)){var g=e.document.documentElement["client"+c],h=e.document.body;return e.document.compatMode==="CSS1Compat"&&g||h&&h["client"+c]||g}if(e.nodeType===9)return Math.max(e.documentElement["client"+c],e.body["scroll"+c],e.documentElement["scroll"+c],e.body["offset"+c],e.documentElement["offset"+c]);if(a===b){var i=f.css(e,d),j=parseFloat(i);return f.isNumeric(j)?j:i}return this.css(d,typeof a=="string"?a:a+"px")}}),a.jQuery=a.$=f,typeof define=="function"&&define.amd&&define.amd.jQuery&&define("jquery",[],function(){return f})})(window); Paver-1.2.1/paver/docs/_static/up.png 0000644 0001750 0001750 00000000553 12152705750 017602 0 ustar almad almad 0000000 0000000 PNG
IHDR a sRGB bKGD C pHYs
B(x tIME!.<̓E IDAT8͓NABP\EG{%<|x c cr6@t;b$;3&)h1!Hz z@=)p
3۵e2/ߴ (
%^ND^
}3H1DoǪISFұ?, G`{v^ X[b]&HC3{:sO& ?,[eL# IENDB` Paver-1.2.1/paver/docs/_static/down.png 0000644 0001750 0001750 00000000553 12152705750 020125 0 ustar almad almad 0000000 0000000 PNG
IHDR a sRGB bKGD C pHYs
B(x tIME"U{ IDAT8ҡNCAJ, ++@4> /U^,~T&3M^^^PM6ٹs*RJa)eG* W<"F
Fg78G>q OIp:sAj5GنyD^+yU:p_%G@D|a Os(yM,"msx:.b@D|` Vٟ۲иeKſ/G! IENDB` Paver-1.2.1/paver/docs/_static/minus.png 0000644 0001750 0001750 00000000307 12152705750 020306 0 ustar almad almad 0000000 0000000 PNG
IHDR &q pHYs tIME <8 tEXtComment ̖ RIDATc include marker settings.
"""
_runcog(options)
@task
def uncog(options):
"""Remove the Cog generated code from files. Often, you will want to
do this before committing code under source control, because you
don't generally want generated code in your version control system.
This takes the same options as the cog task. Look there for
more information.
"""
_runcog(options, True)
Paver-1.2.1/paver/virtual.py 0000644 0001750 0001750 00000014710 12152711177 016132 0 ustar almad almad 0000000 0000000 """Tasks for managing virtualenv environments."""
from paver.easy import task, options, dry, debug
from paver.release import setup_meta
try:
import virtualenv as venv
except ImportError:
has_virtualenv = False
else:
has_virtualenv = True
_pip_then_easy_install_tmpl = """
try:
subprocess.call(
[join(%(bin_dir_var)s, 'pip'), 'install']
+ %(cmd_options)r
+ %%(packages)r
)
except OSError:
subprocess.call(
[join(%(bin_dir_var)s, 'easy_install')]
+ %(cmd_options)r
+ %%(packages)r
)
"""
_easy_install_tmpl = """
subprocess.call(
[join(%(bin_dir_var)s, 'easy_install')]
+ %(cmd_options)r
+ %%(packages)r
)
"""
def _create_bootstrap(script_name, packages_to_install, paver_command_line,
install_paver=True, more_text="", dest_dir='.',
no_site_packages=None, system_site_packages=None,
unzip_setuptools=False, distribute=None, index_url=None,
no_index=False, find_links=None, prefer_easy_install=False):
# configure package installation template
install_cmd_options = []
if index_url:
install_cmd_options.extend(['--index-url', index_url])
if no_index:
install_cmd_options.extend(['--no-index'])
if find_links:
for link in find_links:
install_cmd_options.extend(
['--find-links', link])
install_cmd_tmpl = (_easy_install_tmpl if prefer_easy_install
else _pip_then_easy_install_tmpl)
confd_install_cmd_tmpl = (install_cmd_tmpl %
{'bin_dir_var': 'bin_dir', 'cmd_options': install_cmd_options})
# make copy to local scope to add paver to packages to install
packages_to_install = packages_to_install[:]
if install_paver:
packages_to_install.insert(0, 'paver==%s' % setup_meta['version'])
install_cmd = confd_install_cmd_tmpl % {'packages': packages_to_install}
options = ""
# if deprecated 'no_site_packages' was specified and 'system_site_packages'
# wasn't, set it from that value
if system_site_packages is None and no_site_packages is not None:
system_site_packages = not no_site_packages
if system_site_packages is not None:
options += (" options.system_site_packages = %s\n" %
bool(system_site_packages))
if unzip_setuptools:
options += " options.unzip_setuptools = True\n"
if distribute is not None:
options += " options.use_distribute = %s\n" % bool(distribute)
options += "\n"
extra_text = """def adjust_options(options, args):
args[:] = ['%s']
%s
def after_install(options, home_dir):
if sys.platform == 'win32':
bin_dir = join(home_dir, 'Scripts')
else:
bin_dir = join(home_dir, 'bin')
%s""" % (dest_dir, options, install_cmd)
if paver_command_line:
command_list = list(paver_command_line.split())
extra_text += " subprocess.call([join(bin_dir, 'paver'),%s)" % repr(command_list)[1:]
extra_text += more_text
bootstrap_contents = venv.create_bootstrap_script(extra_text)
fn = script_name
debug("Bootstrap script extra text: " + extra_text)
def write_script():
open(fn, "w").write(bootstrap_contents)
dry("Write bootstrap script %s" % fn, write_script)
def _boostrap_constraint():
try:
import virtualenv as venv
except ImportError:
from paver.runtime import PaverImportError
raise PaverImportError("`virtualenv` is needed to use paver's virtualenv tasks")
@task
def bootstrap():
"""Creates a virtualenv bootstrap script.
The script will create a bootstrap script that populates a
virtualenv in the current directory. The environment will
have paver, the packages of your choosing and will run
the paver command of your choice.
This task looks in the virtualenv options for:
script_name
name of the generated script
packages_to_install
packages to install with pip/easy_install. The version of paver that
you are using is included automatically. This should be a list of
strings.
paver_command_line
run this paver command line after installation (just the command
line arguments, not the paver command itself).
dest_dir
the destination directory for the virtual environment (defaults to
'.')
no_site_packages
don't give access to the global site-packages dir to the virtual
environment (default; deprecated)
system_site_packages
give access to the global site-packages dir to the virtual
environment
unzip_setuptools
unzip Setuptools when installing it (defaults to False)
distribute
use Distribute instead of Setuptools. Set environment variable
VIRTUALENV_DISTRIBUTE to make it the default.
index_url
base URL of Python Package Index
no_index
ignore package index (only looking at find_links URL(s) instead)
find_links
additional URL(s) to search for packages. This should be a list of
strings.
prefer_easy_install
prefer easy_install to pip for package installation if both are
installed (defaults to False)
"""
vopts = options.virtualenv
_create_bootstrap(vopts.get("script_name", "bootstrap.py"),
vopts.get("packages_to_install", []),
vopts.get("paver_command_line", None),
dest_dir=vopts.get("dest_dir", '.'),
no_site_packages=vopts.get("no_site_packages", None),
system_site_packages=vopts.get("system_site_packages",
None),
unzip_setuptools=vopts.get("unzip_setuptools", False),
distribute=vopts.get("distribute", None),
index_url=vopts.get("index_url", None),
no_index=vopts.get("no_index", False),
find_links=vopts.get("find_links", []),
prefer_easy_install=vopts.get("prefer_easy_install",
False))
bootstrap.paver_constraint = _boostrap_constraint
def virtualenv(dir):
"""Run decorated task in specified virtual environment."""
def inner(func):
func = task(func)
func.use_virtualenv = True
func.virtualenv_dir = dir
return func
return inner
Paver-1.2.1/paver/deps/ 0000755 0001750 0001750 00000000000 12152711214 015012 5 ustar almad almad 0000000 0000000 Paver-1.2.1/paver/deps/__init__.py 0000644 0001750 0001750 00000000000 12152711177 017121 0 ustar almad almad 0000000 0000000 Paver-1.2.1/paver/deps/path2.py 0000644 0001750 0001750 00000105505 12152711177 016420 0 ustar almad almad 0000000 0000000 #
# Copyright (c) 2010 Mikhail Gusarov
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
""" path.py - An object representing a path to a file or directory.
Original author:
Jason Orendorff
Contributors:
Mikhail Gusarov
Marc Abramowitz
Example:
from path import path
d = path('/home/guido/bin')
for f in d.files('*.py'):
f.chmod(0755)
This module requires Python 2.3 or later.
"""
from __future__ import generators
import __builtin__
import sys
import warnings
import os
import fnmatch
import glob
import shutil
import codecs
import hashlib
import errno
__version__ = '2.4'
__all__ = ['path']
PRE_PY3 = sys.version_info[0] < 3
# Platform-specific support for path.owner
if os.name == 'nt':
try:
import win32security
except ImportError:
win32security = None
else:
try:
import pwd
except ImportError:
pwd = None
# Pre-2.3 support. Are unicode filenames supported?
_base = str
_getcwd = os.getcwd
try:
if os.path.supports_unicode_filenames:
_base = unicode
_getcwd = os.getcwdu
except AttributeError:
pass
# Pre-2.3 workaround for basestring.
try:
basestring
except NameError:
basestring = (str, unicode)
# Universal newline support
_textmode = 'U'
if hasattr(__builtin__, 'file') and not hasattr(file, 'newlines'):
_textmode = 'r'
class TreeWalkWarning(Warning):
pass
class path(_base):
""" Represents a filesystem path.
For documentation on individual methods, consult their
counterparts in os.path.
"""
# --- Special Python methods.
def __repr__(self):
return 'path(%s)' % _base.__repr__(self)
# Adding a path and a string yields a path.
def __add__(self, more):
try:
resultStr = _base.__add__(self, more)
except TypeError: # Python bug
resultStr = NotImplemented
# On python 2, unicode result breaks os.path.join
# if we are inheriting from str
# see https://github.com/paver/paver/issues/78
if isinstance(resultStr, unicode) and not os.path.supports_unicode_filenames:
resultStr = resultStr.encode('utf-8')
if resultStr is NotImplemented:
return resultStr
return self.__class__(resultStr)
def __radd__(self, other):
if isinstance(other, basestring):
return self.__class__(other.__add__(self))
else:
return NotImplemented
# The / operator joins paths.
def __div__(self, rel):
""" fp.__div__(rel) == fp / rel == fp.joinpath(rel)
Join two path components, adding a separator character if
needed.
"""
return self.__class__(os.path.join(self, rel))
# Make the / operator work even when true division is enabled.
__truediv__ = __div__
def __enter__(self):
self._old_dir = self.getcwd()
os.chdir(self)
def __exit__(self, *_):
os.chdir(self._old_dir)
def getcwd(cls):
""" Return the current working directory as a path object. """
return cls(_getcwd())
getcwd = classmethod(getcwd)
#
# --- Operations on path strings.
def abspath(self): return self.__class__(os.path.abspath(self))
def normcase(self): return self.__class__(os.path.normcase(self))
def normpath(self): return self.__class__(os.path.normpath(self))
def realpath(self): return self.__class__(os.path.realpath(self))
def expanduser(self): return self.__class__(os.path.expanduser(self))
def expandvars(self): return self.__class__(os.path.expandvars(self))
def dirname(self): return self.__class__(os.path.dirname(self))
def basename(self): return self.__class__(os.path.basename(self))
def expand(self):
""" Clean up a filename by calling expandvars(),
expanduser(), and normpath() on it.
This is commonly everything needed to clean up a filename
read from a configuration file, for example.
"""
return self.expandvars().expanduser().normpath()
def _get_namebase(self):
base, ext = os.path.splitext(self.name)
return base
def _get_ext(self):
f, ext = os.path.splitext(_base(self))
return ext
def _get_drive(self):
drive, r = os.path.splitdrive(self)
return self.__class__(drive)
parent = property(
dirname, None, None,
""" This path's parent directory, as a new path object.
For example, path('/usr/local/lib/libpython.so').parent == path('/usr/local/lib')
""")
name = property(
basename, None, None,
""" The name of this file or directory without the full path.
For example, path('/usr/local/lib/libpython.so').name == 'libpython.so'
""")
namebase = property(
_get_namebase, None, None,
""" The same as path.name, but with one file extension stripped off.
For example, path('/home/guido/python.tar.gz').name == 'python.tar.gz',
but path('/home/guido/python.tar.gz').namebase == 'python.tar'
""")
ext = property(
_get_ext, None, None,
""" The file extension, for example '.py'. """)
drive = property(
_get_drive, None, None,
""" The drive specifier, for example 'C:'.
This is always empty on systems that don't use drive specifiers.
""")
def splitpath(self):
""" p.splitpath() -> Return (p.parent, p.name). """
parent, child = os.path.split(self)
return self.__class__(parent), child
def splitdrive(self):
""" p.splitdrive() -> Return (p.drive, ).
Split the drive specifier from this path. If there is
no drive specifier, p.drive is empty, so the return value
is simply (path(''), p). This is always the case on Unix.
"""
drive, rel = os.path.splitdrive(self)
return self.__class__(drive), rel
def splitext(self):
""" p.splitext() -> Return (p.stripext(), p.ext).
Split the filename extension from this path and return
the two parts. Either part may be empty.
The extension is everything from '.' to the end of the
last path segment. This has the property that if
(a, b) == p.splitext(), then a + b == p.
"""
filename, ext = os.path.splitext(self)
return self.__class__(filename), ext
def stripext(self):
""" p.stripext() -> Remove one file extension from the path.
For example, path('/home/guido/python.tar.gz').stripext()
returns path('/home/guido/python.tar').
"""
return self.splitext()[0]
if hasattr(os.path, 'splitunc'):
def splitunc(self):
unc, rest = os.path.splitunc(self)
return self.__class__(unc), rest
def _get_uncshare(self):
unc, r = os.path.splitunc(self)
return self.__class__(unc)
uncshare = property(
_get_uncshare, None, None,
""" The UNC mount point for this path.
This is empty for paths on local drives. """)
def joinpath(self, *args):
""" Join two or more path components, adding a separator
character (os.sep) if needed. Returns a new path
object.
"""
return self.__class__(os.path.join(self, *args))
def splitall(self):
r""" Return a list of the path components in this path.
The first item in the list will be a path. Its value will be
either os.curdir, os.pardir, empty, or the root directory of
this path (for example, '/' or 'C:\\'). The other items in
the list will be strings.
path.path.joinpath(*result) will yield the original path.
"""
parts = []
loc = self
while loc != os.curdir and loc != os.pardir:
prev = loc
loc, child = prev.splitpath()
if loc == prev:
break
parts.append(child)
parts.append(loc)
parts.reverse()
return parts
def relpath(self):
""" Return this path as a relative path,
based from the current working directory.
"""
cwd = self.__class__(os.getcwd())
return cwd.relpathto(self)
def relpathto(self, dest):
""" Return a relative path from self to dest.
If there is no relative path from self to dest, for example if
they reside on different drives in Windows, then this returns
dest.abspath().
"""
origin = self.abspath()
dest = self.__class__(dest).abspath()
orig_list = origin.normcase().splitall()
# Don't normcase dest! We want to preserve the case.
dest_list = dest.splitall()
if orig_list[0] != os.path.normcase(dest_list[0]):
# Can't get here from there.
return dest
# Find the location where the two paths start to differ.
i = 0
for start_seg, dest_seg in zip(orig_list, dest_list):
if start_seg != os.path.normcase(dest_seg):
break
i += 1
# Now i is the point where the two paths diverge.
# Need a certain number of "os.pardir"s to work up
# from the origin to the point of divergence.
segments = [os.pardir] * (len(orig_list) - i)
# Need to add the diverging part of dest_list.
segments += dest_list[i:]
if len(segments) == 0:
# If they happen to be identical, use os.curdir.
relpath = os.curdir
else:
relpath = os.path.join(*segments)
return self.__class__(relpath)
# --- Listing, searching, walking, and matching
def listdir(self, pattern=None):
""" D.listdir() -> List of items in this directory.
Use D.files() or D.dirs() instead if you want a listing
of just files or just subdirectories.
The elements of the list are path objects.
With the optional 'pattern' argument, this only lists
items whose names match the given pattern.
"""
names = os.listdir(self)
if pattern is not None:
names = fnmatch.filter(names, pattern)
return [self / child for child in names]
def dirs(self, pattern=None):
""" D.dirs() -> List of this directory's subdirectories.
The elements of the list are path objects.
This does not walk recursively into subdirectories
(but see path.walkdirs).
With the optional 'pattern' argument, this only lists
directories whose names match the given pattern. For
example, d.dirs('build-*').
"""
return [p for p in self.listdir(pattern) if p.isdir()]
def files(self, pattern=None):
""" D.files() -> List of the files in this directory.
The elements of the list are path objects.
This does not walk into subdirectories (see path.walkfiles).
With the optional 'pattern' argument, this only lists files
whose names match the given pattern. For example,
d.files('*.pyc').
"""
return [p for p in self.listdir(pattern) if p.isfile()]
def walk(self, pattern=None, errors='strict'):
""" D.walk() -> iterator over files and subdirs, recursively.
The iterator yields path objects naming each child item of
this directory and its descendants. This requires that
D.isdir().
This performs a depth-first traversal of the directory tree.
Each directory is returned just before all its children.
The errors= keyword argument controls behavior when an
error occurs. The default is 'strict', which causes an
exception. The other allowed values are 'warn', which
reports the error via warnings.warn(), and 'ignore'.
"""
if errors not in ('strict', 'warn', 'ignore'):
raise ValueError("invalid errors parameter")
try:
childList = self.listdir()
except Exception:
if errors == 'ignore':
return
elif errors == 'warn':
warnings.warn(
"Unable to list directory '%s': %s"
% (self, sys.exc_info()[1]),
TreeWalkWarning)
return
else:
raise
for child in childList:
if pattern is None or child.fnmatch(pattern):
yield child
try:
isdir = child.isdir()
except Exception:
if errors == 'ignore':
isdir = False
elif errors == 'warn':
warnings.warn(
"Unable to access '%s': %s"
% (child, sys.exc_info()[1]),
TreeWalkWarning)
isdir = False
else:
raise
if isdir:
for item in child.walk(pattern, errors):
yield item
def walkdirs(self, pattern=None, errors='strict'):
""" D.walkdirs() -> iterator over subdirs, recursively.
With the optional 'pattern' argument, this yields only
directories whose names match the given pattern. For
example, mydir.walkdirs('*test') yields only directories
with names ending in 'test'.
The errors= keyword argument controls behavior when an
error occurs. The default is 'strict', which causes an
exception. The other allowed values are 'warn', which
reports the error via warnings.warn(), and 'ignore'.
"""
if errors not in ('strict', 'warn', 'ignore'):
raise ValueError("invalid errors parameter")
try:
dirs = self.dirs()
except Exception:
if errors == 'ignore':
return
elif errors == 'warn':
warnings.warn(
"Unable to list directory '%s': %s"
% (self, sys.exc_info()[1]),
TreeWalkWarning)
return
else:
raise
for child in dirs:
if pattern is None or child.fnmatch(pattern):
yield child
for subsubdir in child.walkdirs(pattern, errors):
yield subsubdir
def walkfiles(self, pattern=None, errors='strict'):
""" D.walkfiles() -> iterator over files in D, recursively.
The optional argument, pattern, limits the results to files
with names that match the pattern. For example,
mydir.walkfiles('*.tmp') yields only files with the .tmp
extension.
"""
if errors not in ('strict', 'warn', 'ignore'):
raise ValueError("invalid errors parameter")
try:
childList = self.listdir()
except Exception:
if errors == 'ignore':
return
elif errors == 'warn':
warnings.warn(
"Unable to list directory '%s': %s"
% (self, sys.exc_info()[1]),
TreeWalkWarning)
return
else:
raise
for child in childList:
try:
isfile = child.isfile()
isdir = not isfile and child.isdir()
except:
if errors == 'ignore':
continue
elif errors == 'warn':
warnings.warn(
"Unable to access '%s': %s"
% (self, sys.exc_info()[1]),
TreeWalkWarning)
continue
else:
raise
if isfile:
if pattern is None or child.fnmatch(pattern):
yield child
elif isdir:
for f in child.walkfiles(pattern, errors):
yield f
def fnmatch(self, pattern):
""" Return True if self.name matches the given pattern.
pattern - A filename pattern with wildcards,
for example '*.py'.
"""
return fnmatch.fnmatch(self.name, pattern)
def glob(self, pattern):
""" Return a list of path objects that match the pattern.
pattern - a path relative to this directory, with wildcards.
For example, path('/users').glob('*/bin/*') returns a list
of all the files users have in their bin directories.
"""
cls = self.__class__
return [cls(s) for s in glob.glob(_base(self / pattern))]
#
# --- Reading or writing an entire file at once.
def open(self, mode='r'):
""" Open this file. Return a file object. """
return open(self, mode)
def bytes(self):
""" Open this file, read all bytes, return them as a string. """
f = self.open('rb')
try:
return f.read()
finally:
f.close()
def write_bytes(self, bytes, append=False):
""" Open this file and write the given bytes to it.
Default behavior is to overwrite any existing file.
Call p.write_bytes(bytes, append=True) to append instead.
"""
if append:
mode = 'ab'
else:
mode = 'wb'
f = self.open(mode)
try:
f.write(bytes)
finally:
f.close()
def text(self, encoding=None, errors='strict'):
r""" Open this file, read it in, return the content as a string.
This uses 'U' mode in Python 2.3 and later, so '\r\n' and '\r'
are automatically translated to '\n'.
Optional arguments:
encoding - The Unicode encoding (or character set) of
the file. If present, the content of the file is
decoded and returned as a unicode object; otherwise
it is returned as an 8-bit str.
errors - How to handle Unicode errors; see help(str.decode)
for the options. Default is 'strict'.
"""
if encoding is None:
# 8-bit
f = self.open(_textmode)
try:
return f.read()
finally:
f.close()
else:
# Unicode
f = codecs.open(self, 'r', encoding, errors)
# (Note - Can't use 'U' mode here, since codecs.open
# doesn't support 'U' mode, even in Python 2.3.)
try:
t = f.read()
finally:
f.close()
return (t.replace(u'\r\n', u'\n')
.replace(u'\r\x85', u'\n')
.replace(u'\r', u'\n')
.replace(u'\x85', u'\n')
.replace(u'\u2028', u'\n'))
def write_text(self, text, encoding=None, errors='strict', linesep=os.linesep, append=False):
r""" Write the given text to this file.
The default behavior is to overwrite any existing file;
to append instead, use the 'append=True' keyword argument.
There are two differences between path.write_text() and
path.write_bytes(): newline handling and Unicode handling.
See below.
Parameters:
- text - str/unicode - The text to be written.
- encoding - str - The Unicode encoding that will be used.
This is ignored if 'text' isn't a Unicode string.
- errors - str - How to handle Unicode encoding errors.
Default is 'strict'. See help(unicode.encode) for the
options. This is ignored if 'text' isn't a Unicode
string.
- linesep - keyword argument - str/unicode - The sequence of
characters to be used to mark end-of-line. The default is
os.linesep. You can also specify None; this means to
leave all newlines as they are in 'text'.
- append - keyword argument - bool - Specifies what to do if
the file already exists (True: append to the end of it;
False: overwrite it.) The default is False.
--- Newline handling.
write_text() converts all standard end-of-line sequences
('\n', '\r', and '\r\n') to your platform's default end-of-line
sequence (see os.linesep; on Windows, for example, the
end-of-line marker is '\r\n').
If you don't like your platform's default, you can override it
using the 'linesep=' keyword argument. If you specifically want
write_text() to preserve the newlines as-is, use 'linesep=None'.
This applies to Unicode text the same as to 8-bit text, except
there are three additional standard Unicode end-of-line sequences:
u'\x85', u'\r\x85', and u'\u2028'.
(This is slightly different from when you open a file for
writing with fopen(filename, "w") in C or open(filename, 'w')
in Python.)
--- Unicode
If 'text' isn't Unicode, then apart from newline handling, the
bytes are written verbatim to the file. The 'encoding' and
'errors' arguments are not used and must be omitted.
If 'text' is Unicode, it is first converted to bytes using the
specified 'encoding' (or the default encoding if 'encoding'
isn't specified). The 'errors' argument applies only to this
conversion.
"""
if isinstance(text, unicode):
if linesep is not None:
# Convert all standard end-of-line sequences to
# ordinary newline characters.
text = (text.replace(u'\r\n', u'\n')
.replace(u'\r\x85', u'\n')
.replace(u'\r', u'\n')
.replace(u'\x85', u'\n')
.replace(u'\u2028', u'\n'))
text = text.replace(u'\n', linesep)
if encoding is None:
encoding = sys.getdefaultencoding()
bytes = text.encode(encoding, errors)
else:
# It is an error to specify an encoding if 'text' is
# an 8-bit string.
assert encoding is None
if linesep is not None:
text = (text.replace('\r\n', '\n')
.replace('\r', '\n'))
bytes = text.replace('\n', linesep)
self.write_bytes(bytes, append)
def lines(self, encoding=None, errors='strict', retain=True):
r""" Open this file, read all lines, return them in a list.
Optional arguments:
encoding - The Unicode encoding (or character set) of
the file. The default is None, meaning the content
of the file is read as 8-bit characters and returned
as a list of (non-Unicode) str objects.
errors - How to handle Unicode errors; see help(str.decode)
for the options. Default is 'strict'
retain - If true, retain newline characters; but all newline
character combinations ('\r', '\n', '\r\n') are
translated to '\n'. If false, newline characters are
stripped off. Default is True.
This uses 'U' mode in Python 2.3 and later.
"""
if encoding is None and retain:
f = self.open(_textmode)
try:
return f.readlines()
finally:
f.close()
else:
return self.text(encoding, errors).splitlines(retain)
def write_lines(self, lines, encoding=None, errors='strict',
linesep=os.linesep, append=False):
r""" Write the given lines of text to this file.
By default this overwrites any existing file at this path.
This puts a platform-specific newline sequence on every line.
See 'linesep' below.
lines - A list of strings.
encoding - A Unicode encoding to use. This applies only if
'lines' contains any Unicode strings.
errors - How to handle errors in Unicode encoding. This
also applies only to Unicode strings.
linesep - The desired line-ending. This line-ending is
applied to every line. If a line already has any
standard line ending ('\r', '\n', '\r\n', u'\x85',
u'\r\x85', u'\u2028'), that will be stripped off and
this will be used instead. The default is os.linesep,
which is platform-dependent ('\r\n' on Windows, '\n' on
Unix, etc.) Specify None to write the lines as-is,
like file.writelines().
Use the keyword argument append=True to append lines to the
file. The default is to overwrite the file. Warning:
When you use this with Unicode data, if the encoding of the
existing data in the file is different from the encoding
you specify with the encoding= parameter, the result is
mixed-encoding data, which can really confuse someone trying
to read the file later.
"""
if append:
mode = 'ab'
else:
mode = 'wb'
f = self.open(mode)
try:
for line in lines:
isUnicode = isinstance(line, unicode)
if linesep is not None:
# Strip off any existing line-end and add the
# specified linesep string.
if isUnicode:
if line[-2:] in (u'\r\n', u'\x0d\x85'):
line = line[:-2]
elif line[-1:] in (u'\r', u'\n',
u'\x85', u'\u2028'):
line = line[:-1]
else:
if line[-2:] == '\r\n':
line = line[:-2]
elif line[-1:] in ('\r', '\n'):
line = line[:-1]
line += linesep
if isUnicode:
if encoding is None:
encoding = sys.getdefaultencoding()
line = line.encode(encoding, errors)
f.write(line)
finally:
f.close()
def read_md5(self):
""" Calculate the md5 hash for this file.
This reads through the entire file.
"""
return self.read_hash('md5')
def _hash(self, hash_name):
f = self.open('rb')
try:
m = hashlib.new(hash_name)
while True:
d = f.read(8192)
if not d:
break
m.update(d)
return m
finally:
f.close()
def read_hash(self, hash_name):
""" Calculate given hash for this file.
List of supported hashes can be obtained from hashlib package. This
reads the entire file.
"""
return self._hash(hash_name).digest()
def read_hexhash(self, hash_name):
""" Calculate given hash for this file, returning hexdigest.
List of supported hashes can be obtained from hashlib package. This
reads the entire file.
"""
return self._hash(hash_name).hexdigest()
# --- Methods for querying the filesystem.
# N.B. On some platforms, the os.path functions may be implemented in C
# (e.g. isdir on Windows, Python 3.2.2), and compiled functions don't get
# bound. Playing it safe and wrapping them all in method calls.
def isabs(self): return os.path.isabs(self)
def exists(self): return os.path.exists(self)
def isdir(self): return os.path.isdir(self)
def isfile(self): return os.path.isfile(self)
def islink(self): return os.path.islink(self)
def ismount(self): return os.path.ismount(self)
if hasattr(os.path, 'samefile'):
def samefile(self, otherfile): return os.path.samefile(self, otherfile)
def getatime(self): return os.path.getatime(self)
atime = property(
getatime, None, None,
""" Last access time of the file. """)
def getmtime(self): return os.path.getmtime(self)
mtime = property(
getmtime, None, None,
""" Last-modified time of the file. """)
if hasattr(os.path, 'getctime'):
def getctime(self): return os.path.getctime(self)
ctime = property(
getctime, None, None,
""" Creation time of the file. """)
def getsize(self): return os.path.getsize(self)
size = property(
getsize, None, None,
""" Size of the file, in bytes. """)
if hasattr(os, 'access'):
def access(self, mode):
""" Return true if current user has access to this path.
mode - One of the constants os.F_OK, os.R_OK, os.W_OK, os.X_OK
"""
return os.access(self, mode)
def stat(self):
""" Perform a stat() system call on this path. """
return os.stat(self)
def lstat(self):
""" Like path.stat(), but do not follow symbolic links. """
return os.lstat(self)
def get_owner(self):
r""" Return the name of the owner of this file or directory.
This follows symbolic links.
On Windows, this returns a name of the form ur'DOMAIN\User Name'.
On Windows, a group can own a file or directory.
"""
if os.name == 'nt':
if win32security is None:
raise Exception("path.owner requires win32all to be installed")
desc = win32security.GetFileSecurity(
self, win32security.OWNER_SECURITY_INFORMATION)
sid = desc.GetSecurityDescriptorOwner()
account, domain, typecode = win32security.LookupAccountSid(None, sid)
return domain + u'\\' + account
else:
if pwd is None:
raise NotImplementedError("path.owner is not implemented on this platform.")
st = self.stat()
return pwd.getpwuid(st.st_uid).pw_name
owner = property(
get_owner, None, None,
""" Name of the owner of this file or directory. """)
if hasattr(os, 'statvfs'):
def statvfs(self):
""" Perform a statvfs() system call on this path. """
return os.statvfs(self)
if hasattr(os, 'pathconf'):
def pathconf(self, name):
return os.pathconf(self, name)
#
# --- Modifying operations on files and directories
def utime(self, times):
""" Set the access and modified times of this file. """
os.utime(self, times)
def chmod(self, mode):
os.chmod(self, mode)
if hasattr(os, 'chown'):
def chown(self, uid, gid):
os.chown(self, uid, gid)
def rename(self, new):
os.rename(self, new)
def renames(self, new):
os.renames(self, new)
#
# --- Create/delete operations on directories
def mkdir(self, mode=0777):
if not self.exists():
os.mkdir(self, mode)
def mkdir_p(self, mode=0777):
try:
self.mkdir(mode)
except OSError, e:
if e.errno != errno.EEXIST:
raise
def makedirs(self, mode=0777):
if not self.exists():
os.makedirs(self, mode)
def makedirs_p(self, mode=0777):
try:
self.makedirs(mode)
except OSError, e:
if e.errno != errno.EEXIST:
raise
def rmdir(self):
if self.exists():
os.rmdir(self)
def rmdir_p(self):
try:
self.rmdir()
except OSError, e:
if e.errno != errno.ENOTEMPTY and e.errno != errno.EEXIST:
raise
def removedirs(self):
if self.exists():
os.removedirs(self)
def removedirs_p(self):
try:
self.removedirs()
except OSError, e:
if e.errno != errno.ENOTEMPTY and e.errno != errno.EEXIST:
raise
# --- Modifying operations on files
def touch(self):
""" Set the access/modified times of this file to the current time.
Create the file if it does not exist.
"""
fd = os.open(self, os.O_WRONLY | os.O_CREAT, 0666)
os.close(fd)
os.utime(self, None)
def remove(self):
if self.exists():
os.remove(self)
def remove_p(self):
try:
self.unlink()
except OSError, e:
if e.errno != errno.ENOENT:
raise
def unlink(self):
if self.exists():
os.unlink(self)
def unlink_p(self):
self.remove_p()
# --- Links
if hasattr(os, 'link'):
def link(self, newpath):
""" Create a hard link at 'newpath', pointing to this file. """
os.link(self, newpath)
if hasattr(os, 'symlink'):
def symlink(self, newlink):
""" Create a symbolic link at 'newlink', pointing here. """
os.symlink(self, newlink)
if hasattr(os, 'readlink'):
def readlink(self):
""" Return the path to which this symbolic link points.
The result may be an absolute or a relative path.
"""
return self.__class__(os.readlink(self))
def readlinkabs(self):
""" Return the path to which this symbolic link points.
The result is always an absolute path.
"""
p = self.readlink()
if p.isabs():
return p
else:
return (self.parent / p).abspath()
#
# --- High-level functions from shutil
copyfile = shutil.copyfile
copymode = shutil.copymode
copystat = shutil.copystat
copy = shutil.copy
copy2 = shutil.copy2
copytree = shutil.copytree
if hasattr(shutil, 'move'):
move = shutil.move
def rmtree(self, *args, **kw):
if self.exists():
shutil.rmtree(self, *args, **kw)
def rmtree_p(self):
try:
self.rmtree()
except OSError, e:
if e.errno != errno.ENOENT:
raise
#
# --- Special stuff from os
if hasattr(os, 'chroot'):
def chroot(self):
os.chroot(self)
if hasattr(os, 'startfile'):
def startfile(self):
os.startfile(self)
Paver-1.2.1/paver/deps/six.py 0000644 0001750 0001750 00000024421 12152711177 016202 0 ustar almad almad 0000000 0000000 """Utilities for writing code that runs on Python 2 and 3"""
import operator
import sys
import types
__author__ = "Benjamin Peterson "
__version__ = "1.2.0"
# True if we are running on Python 3.
PY3 = sys.version_info[0] == 3
if PY3:
string_types = str,
integer_types = int,
class_types = type,
text_type = str
binary_type = bytes
MAXSIZE = sys.maxsize
else:
string_types = basestring,
integer_types = (int, long)
class_types = (type, types.ClassType)
text_type = unicode
binary_type = str
if sys.platform.startswith("java"):
# Jython always uses 32 bits.
MAXSIZE = int((1 << 31) - 1)
else:
# It's possible to have sizeof(long) != sizeof(Py_ssize_t).
class X(object):
def __len__(self):
return 1 << 31
try:
len(X())
except OverflowError:
# 32-bit
MAXSIZE = int((1 << 31) - 1)
else:
# 64-bit
MAXSIZE = int((1 << 63) - 1)
del X
def _add_doc(func, doc):
"""Add documentation to a function."""
func.__doc__ = doc
def _import_module(name):
"""Import module, returning the module after the last dot."""
__import__(name)
return sys.modules[name]
class _LazyDescr(object):
def __init__(self, name):
self.name = name
def __get__(self, obj, tp):
result = self._resolve()
setattr(obj, self.name, result)
# This is a bit ugly, but it avoids running this again.
delattr(tp, self.name)
return result
class MovedModule(_LazyDescr):
def __init__(self, name, old, new=None):
super(MovedModule, self).__init__(name)
if PY3:
if new is None:
new = name
self.mod = new
else:
self.mod = old
def _resolve(self):
return _import_module(self.mod)
class MovedAttribute(_LazyDescr):
def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
super(MovedAttribute, self).__init__(name)
if PY3:
if new_mod is None:
new_mod = name
self.mod = new_mod
if new_attr is None:
if old_attr is None:
new_attr = name
else:
new_attr = old_attr
self.attr = new_attr
else:
self.mod = old_mod
if old_attr is None:
old_attr = name
self.attr = old_attr
def _resolve(self):
module = _import_module(self.mod)
return getattr(module, self.attr)
class _MovedItems(types.ModuleType):
"""Lazy loading of moved objects"""
_moved_attributes = [
MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
MovedAttribute("map", "itertools", "builtins", "imap", "map"),
MovedAttribute("reload_module", "__builtin__", "imp", "reload"),
MovedAttribute("reduce", "__builtin__", "functools"),
MovedAttribute("StringIO", "StringIO", "io"),
MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
MovedModule("builtins", "__builtin__"),
MovedModule("configparser", "ConfigParser"),
MovedModule("copyreg", "copy_reg"),
MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
MovedModule("http_cookies", "Cookie", "http.cookies"),
MovedModule("html_entities", "htmlentitydefs", "html.entities"),
MovedModule("html_parser", "HTMLParser", "html.parser"),
MovedModule("http_client", "httplib", "http.client"),
MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
MovedModule("cPickle", "cPickle", "pickle"),
MovedModule("queue", "Queue"),
MovedModule("reprlib", "repr"),
MovedModule("socketserver", "SocketServer"),
MovedModule("tkinter", "Tkinter"),
MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
MovedModule("tkinter_colorchooser", "tkColorChooser",
"tkinter.colorchooser"),
MovedModule("tkinter_commondialog", "tkCommonDialog",
"tkinter.commondialog"),
MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
MovedModule("tkinter_font", "tkFont", "tkinter.font"),
MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
"tkinter.simpledialog"),
MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
MovedModule("winreg", "_winreg"),
]
for attr in _moved_attributes:
setattr(_MovedItems, attr.name, attr)
del attr
moves = sys.modules["six.moves"] = _MovedItems("moves")
def add_move(move):
"""Add an item to six.moves."""
setattr(_MovedItems, move.name, move)
def remove_move(name):
"""Remove item from six.moves."""
try:
delattr(_MovedItems, name)
except AttributeError:
try:
del moves.__dict__[name]
except KeyError:
raise AttributeError("no such move, %r" % (name,))
if PY3:
_meth_func = "__func__"
_meth_self = "__self__"
_func_code = "__code__"
_func_defaults = "__defaults__"
_iterkeys = "keys"
_itervalues = "values"
_iteritems = "items"
else:
_meth_func = "im_func"
_meth_self = "im_self"
_func_code = "func_code"
_func_defaults = "func_defaults"
_iterkeys = "iterkeys"
_itervalues = "itervalues"
_iteritems = "iteritems"
try:
advance_iterator = next
except NameError:
def advance_iterator(it):
return it.next()
next = advance_iterator
if PY3:
def get_unbound_function(unbound):
return unbound
Iterator = object
def callable(obj):
return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
else:
def get_unbound_function(unbound):
return unbound.im_func
class Iterator(object):
def next(self):
return type(self).__next__(self)
callable = callable
_add_doc(get_unbound_function,
"""Get the function out of a possibly unbound function""")
get_method_function = operator.attrgetter(_meth_func)
get_method_self = operator.attrgetter(_meth_self)
get_function_code = operator.attrgetter(_func_code)
get_function_defaults = operator.attrgetter(_func_defaults)
def iterkeys(d):
"""Return an iterator over the keys of a dictionary."""
return iter(getattr(d, _iterkeys)())
def itervalues(d):
"""Return an iterator over the values of a dictionary."""
return iter(getattr(d, _itervalues)())
def iteritems(d):
"""Return an iterator over the (key, value) pairs of a dictionary."""
return iter(getattr(d, _iteritems)())
if PY3:
def b(s):
return s.encode("latin-1")
def u(s):
return s
if sys.version_info[1] <= 1:
def int2byte(i):
return bytes((i,))
else:
# This is about 2x faster than the implementation above on 3.2+
int2byte = operator.methodcaller("to_bytes", 1, "big")
import io
StringIO = io.StringIO
BytesIO = io.BytesIO
else:
def b(s):
return s
def u(s):
return unicode(s, "unicode_escape")
int2byte = chr
import StringIO
StringIO = BytesIO = StringIO.StringIO
_add_doc(b, """Byte literal""")
_add_doc(u, """Text literal""")
if PY3:
import builtins
exec_ = getattr(builtins, "exec")
def reraise(tp, value, tb=None):
if value.__traceback__ is not tb:
raise value.with_traceback(tb)
raise value
print_ = getattr(builtins, "print")
del builtins
else:
def exec_(code, globs=None, locs=None):
"""Execute code in a namespace."""
if globs is None:
frame = sys._getframe(1)
globs = frame.f_globals
if locs is None:
locs = frame.f_locals
del frame
elif locs is None:
locs = globs
exec("""exec code in globs, locs""")
exec_("""def reraise(tp, value, tb=None):
raise tp, value, tb
""")
def print_(*args, **kwargs):
"""The new-style print function."""
fp = kwargs.pop("file", sys.stdout)
if fp is None:
return
def write(data):
if not isinstance(data, basestring):
data = str(data)
fp.write(data)
want_unicode = False
sep = kwargs.pop("sep", None)
if sep is not None:
if isinstance(sep, unicode):
want_unicode = True
elif not isinstance(sep, str):
raise TypeError("sep must be None or a string")
end = kwargs.pop("end", None)
if end is not None:
if isinstance(end, unicode):
want_unicode = True
elif not isinstance(end, str):
raise TypeError("end must be None or a string")
if kwargs:
raise TypeError("invalid keyword arguments to print()")
if not want_unicode:
for arg in args:
if isinstance(arg, unicode):
want_unicode = True
break
if want_unicode:
newline = unicode("\n")
space = unicode(" ")
else:
newline = "\n"
space = " "
if sep is None:
sep = space
if end is None:
end = newline
for i, arg in enumerate(args):
if i:
write(sep)
write(arg)
write(end)
_add_doc(reraise, """Reraise an exception.""")
def with_metaclass(meta, base=object):
"""Create a base class with a metaclass."""
return meta("NewBase", (base,), {})
Paver-1.2.1/paver/deps/path3.py 0000644 0001750 0001750 00000104636 12152711177 016425 0 ustar almad almad 0000000 0000000 #
# Copyright (c) 2010 Mikhail Gusarov
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
""" path.py - An object representing a path to a file or directory.
Original author:
Jason Orendorff
Contributors:
Mikhail Gusarov
Marc Abramowitz
Example:
from path import path
d = path('/home/guido/bin')
for f in d.files('*.py'):
f.chmod(0755)
This module requires Python 2.3 or later.
"""
import sys
import warnings
import os
import fnmatch
import glob
import shutil
import codecs
import hashlib
import errno
__version__ = '2.4'
__all__ = ['path']
# Platform-specific support for path.owner
if os.name == 'nt':
try:
import win32security
except ImportError:
win32security = None
else:
try:
import pwd
except ImportError:
pwd = None
# Pre-2.3 support. Are unicode filenames supported?
_base = str
_getcwd = os.getcwd
try:
if os.path.supports_unicode_filenames:
_base = str
_getcwd = os.getcwd
except AttributeError:
pass
# Pre-2.3 workaround for basestring.
try:
str
except NameError:
str = (str, str)
# Universal newline support
_textmode = 'U'
if hasattr(__builtins__, 'file') and not hasattr(file, 'newlines'):
_textmode = 'r'
class TreeWalkWarning(Warning):
pass
class path(_base):
""" Represents a filesystem path.
For documentation on individual methods, consult their
counterparts in os.path.
"""
# --- Special Python methods.
def __repr__(self):
return 'path(%s)' % _base.__repr__(self)
# Adding a path and a string yields a path.
def __add__(self, more):
try:
resultStr = _base.__add__(self, more)
except TypeError: # Python bug
resultStr = NotImplemented
if resultStr is NotImplemented:
return resultStr
return self.__class__(resultStr)
def __radd__(self, other):
if isinstance(other, str):
return self.__class__(other.__add__(self))
else:
return NotImplemented
# The / operator joins paths.
def __div__(self, rel):
""" fp.__div__(rel) == fp / rel == fp.joinpath(rel)
Join two path components, adding a separator character if
needed.
"""
return self.__class__(os.path.join(self, rel))
# Make the / operator work even when true division is enabled.
__truediv__ = __div__
def __enter__(self):
self._old_dir = self.getcwd()
os.chdir(self)
def __exit__(self, *_):
os.chdir(self._old_dir)
def getcwd(cls):
""" Return the current working directory as a path object. """
return cls(_getcwd())
getcwd = classmethod(getcwd)
#
# --- Operations on path strings.
def abspath(self): return self.__class__(os.path.abspath(self))
def normcase(self): return self.__class__(os.path.normcase(self))
def normpath(self): return self.__class__(os.path.normpath(self))
def realpath(self): return self.__class__(os.path.realpath(self))
def expanduser(self): return self.__class__(os.path.expanduser(self))
def expandvars(self): return self.__class__(os.path.expandvars(self))
def dirname(self): return self.__class__(os.path.dirname(self))
def basename(self): return self.__class__(os.path.basename(self))
def expand(self):
""" Clean up a filename by calling expandvars(),
expanduser(), and normpath() on it.
This is commonly everything needed to clean up a filename
read from a configuration file, for example.
"""
return self.expandvars().expanduser().normpath()
def _get_namebase(self):
base, ext = os.path.splitext(self.name)
return base
def _get_ext(self):
f, ext = os.path.splitext(_base(self))
return ext
def _get_drive(self):
drive, r = os.path.splitdrive(self)
return self.__class__(drive)
parent = property(
dirname, None, None,
""" This path's parent directory, as a new path object.
For example, path('/usr/local/lib/libpython.so').parent == path('/usr/local/lib')
""")
name = property(
basename, None, None,
""" The name of this file or directory without the full path.
For example, path('/usr/local/lib/libpython.so').name == 'libpython.so'
""")
namebase = property(
_get_namebase, None, None,
""" The same as path.name, but with one file extension stripped off.
For example, path('/home/guido/python.tar.gz').name == 'python.tar.gz',
but path('/home/guido/python.tar.gz').namebase == 'python.tar'
""")
ext = property(
_get_ext, None, None,
""" The file extension, for example '.py'. """)
drive = property(
_get_drive, None, None,
""" The drive specifier, for example 'C:'.
This is always empty on systems that don't use drive specifiers.
""")
def splitpath(self):
""" p.splitpath() -> Return (p.parent, p.name). """
parent, child = os.path.split(self)
return self.__class__(parent), child
def splitdrive(self):
""" p.splitdrive() -> Return (p.drive, ).
Split the drive specifier from this path. If there is
no drive specifier, p.drive is empty, so the return value
is simply (path(''), p). This is always the case on Unix.
"""
drive, rel = os.path.splitdrive(self)
return self.__class__(drive), rel
def splitext(self):
""" p.splitext() -> Return (p.stripext(), p.ext).
Split the filename extension from this path and return
the two parts. Either part may be empty.
The extension is everything from '.' to the end of the
last path segment. This has the property that if
(a, b) == p.splitext(), then a + b == p.
"""
filename, ext = os.path.splitext(self)
return self.__class__(filename), ext
def stripext(self):
""" p.stripext() -> Remove one file extension from the path.
For example, path('/home/guido/python.tar.gz').stripext()
returns path('/home/guido/python.tar').
"""
return self.splitext()[0]
if hasattr(os.path, 'splitunc'):
def splitunc(self):
unc, rest = os.path.splitunc(self)
return self.__class__(unc), rest
def _get_uncshare(self):
unc, r = os.path.splitunc(self)
return self.__class__(unc)
uncshare = property(
_get_uncshare, None, None,
""" The UNC mount point for this path.
This is empty for paths on local drives. """)
def joinpath(self, *args):
""" Join two or more path components, adding a separator
character (os.sep) if needed. Returns a new path
object.
"""
return self.__class__(os.path.join(self, *args))
def splitall(self):
r""" Return a list of the path components in this path.
The first item in the list will be a path. Its value will be
either os.curdir, os.pardir, empty, or the root directory of
this path (for example, '/' or 'C:\\'). The other items in
the list will be strings.
path.path.joinpath(*result) will yield the original path.
"""
parts = []
loc = self
while loc != os.curdir and loc != os.pardir:
prev = loc
loc, child = prev.splitpath()
if loc == prev:
break
parts.append(child)
parts.append(loc)
parts.reverse()
return parts
def relpath(self):
""" Return this path as a relative path,
based from the current working directory.
"""
cwd = self.__class__(os.getcwd())
return cwd.relpathto(self)
def relpathto(self, dest):
""" Return a relative path from self to dest.
If there is no relative path from self to dest, for example if
they reside on different drives in Windows, then this returns
dest.abspath().
"""
origin = self.abspath()
dest = self.__class__(dest).abspath()
orig_list = origin.normcase().splitall()
# Don't normcase dest! We want to preserve the case.
dest_list = dest.splitall()
if orig_list[0] != os.path.normcase(dest_list[0]):
# Can't get here from there.
return dest
# Find the location where the two paths start to differ.
i = 0
for start_seg, dest_seg in zip(orig_list, dest_list):
if start_seg != os.path.normcase(dest_seg):
break
i += 1
# Now i is the point where the two paths diverge.
# Need a certain number of "os.pardir"s to work up
# from the origin to the point of divergence.
segments = [os.pardir] * (len(orig_list) - i)
# Need to add the diverging part of dest_list.
segments += dest_list[i:]
if len(segments) == 0:
# If they happen to be identical, use os.curdir.
relpath = os.curdir
else:
relpath = os.path.join(*segments)
return self.__class__(relpath)
# --- Listing, searching, walking, and matching
def listdir(self, pattern=None):
""" D.listdir() -> List of items in this directory.
Use D.files() or D.dirs() instead if you want a listing
of just files or just subdirectories.
The elements of the list are path objects.
With the optional 'pattern' argument, this only lists
items whose names match the given pattern.
"""
names = os.listdir(self)
if pattern is not None:
names = fnmatch.filter(names, pattern)
return [self / child for child in names]
def dirs(self, pattern=None):
""" D.dirs() -> List of this directory's subdirectories.
The elements of the list are path objects.
This does not walk recursively into subdirectories
(but see path.walkdirs).
With the optional 'pattern' argument, this only lists
directories whose names match the given pattern. For
example, d.dirs('build-*').
"""
return [p for p in self.listdir(pattern) if p.isdir()]
def files(self, pattern=None):
""" D.files() -> List of the files in this directory.
The elements of the list are path objects.
This does not walk into subdirectories (see path.walkfiles).
With the optional 'pattern' argument, this only lists files
whose names match the given pattern. For example,
d.files('*.pyc').
"""
return [p for p in self.listdir(pattern) if p.isfile()]
def walk(self, pattern=None, errors='strict'):
""" D.walk() -> iterator over files and subdirs, recursively.
The iterator yields path objects naming each child item of
this directory and its descendants. This requires that
D.isdir().
This performs a depth-first traversal of the directory tree.
Each directory is returned just before all its children.
The errors= keyword argument controls behavior when an
error occurs. The default is 'strict', which causes an
exception. The other allowed values are 'warn', which
reports the error via warnings.warn(), and 'ignore'.
"""
if errors not in ('strict', 'warn', 'ignore'):
raise ValueError("invalid errors parameter")
try:
childList = self.listdir()
except Exception:
if errors == 'ignore':
return
elif errors == 'warn':
warnings.warn(
"Unable to list directory '%s': %s"
% (self, sys.exc_info()[1]),
TreeWalkWarning)
return
else:
raise
for child in childList:
if pattern is None or child.fnmatch(pattern):
yield child
try:
isdir = child.isdir()
except Exception:
if errors == 'ignore':
isdir = False
elif errors == 'warn':
warnings.warn(
"Unable to access '%s': %s"
% (child, sys.exc_info()[1]),
TreeWalkWarning)
isdir = False
else:
raise
if isdir:
for item in child.walk(pattern, errors):
yield item
def walkdirs(self, pattern=None, errors='strict'):
""" D.walkdirs() -> iterator over subdirs, recursively.
With the optional 'pattern' argument, this yields only
directories whose names match the given pattern. For
example, mydir.walkdirs('*test') yields only directories
with names ending in 'test'.
The errors= keyword argument controls behavior when an
error occurs. The default is 'strict', which causes an
exception. The other allowed values are 'warn', which
reports the error via warnings.warn(), and 'ignore'.
"""
if errors not in ('strict', 'warn', 'ignore'):
raise ValueError("invalid errors parameter")
try:
dirs = self.dirs()
except Exception:
if errors == 'ignore':
return
elif errors == 'warn':
warnings.warn(
"Unable to list directory '%s': %s"
% (self, sys.exc_info()[1]),
TreeWalkWarning)
return
else:
raise
for child in dirs:
if pattern is None or child.fnmatch(pattern):
yield child
for subsubdir in child.walkdirs(pattern, errors):
yield subsubdir
def walkfiles(self, pattern=None, errors='strict'):
""" D.walkfiles() -> iterator over files in D, recursively.
The optional argument, pattern, limits the results to files
with names that match the pattern. For example,
mydir.walkfiles('*.tmp') yields only files with the .tmp
extension.
"""
if errors not in ('strict', 'warn', 'ignore'):
raise ValueError("invalid errors parameter")
try:
childList = self.listdir()
except Exception:
if errors == 'ignore':
return
elif errors == 'warn':
warnings.warn(
"Unable to list directory '%s': %s"
% (self, sys.exc_info()[1]),
TreeWalkWarning)
return
else:
raise
for child in childList:
try:
isfile = child.isfile()
isdir = not isfile and child.isdir()
except:
if errors == 'ignore':
continue
elif errors == 'warn':
warnings.warn(
"Unable to access '%s': %s"
% (self, sys.exc_info()[1]),
TreeWalkWarning)
continue
else:
raise
if isfile:
if pattern is None or child.fnmatch(pattern):
yield child
elif isdir:
for f in child.walkfiles(pattern, errors):
yield f
def fnmatch(self, pattern):
""" Return True if self.name matches the given pattern.
pattern - A filename pattern with wildcards,
for example '*.py'.
"""
return fnmatch.fnmatch(self.name, pattern)
def glob(self, pattern):
""" Return a list of path objects that match the pattern.
pattern - a path relative to this directory, with wildcards.
For example, path('/users').glob('*/bin/*') returns a list
of all the files users have in their bin directories.
"""
cls = self.__class__
return [cls(s) for s in glob.glob(_base(self / pattern))]
#
# --- Reading or writing an entire file at once.
def open(self, mode='r'):
""" Open this file. Return a file object. """
return open(self, mode)
def bytes(self):
""" Open this file, read all bytes, return them as a string. """
f = self.open('rb')
try:
return f.read()
finally:
f.close()
def write_bytes(self, bytes, append=False):
""" Open this file and write the given bytes to it.
Default behavior is to overwrite any existing file.
Call p.write_bytes(bytes, append=True) to append instead.
"""
if append:
mode = 'ab'
else:
mode = 'wb'
f = self.open(mode)
try:
f.write(bytes)
finally:
f.close()
def text(self, encoding=None, errors='strict'):
r""" Open this file, read it in, return the content as a string.
This uses 'U' mode in Python 2.3 and later, so '\r\n' and '\r'
are automatically translated to '\n'.
Optional arguments:
encoding - The Unicode encoding (or character set) of
the file. If present, the content of the file is
decoded and returned as a unicode object; otherwise
it is returned as an 8-bit str.
errors - How to handle Unicode errors; see help(str.decode)
for the options. Default is 'strict'.
"""
if encoding is None:
# 8-bit
f = self.open(_textmode)
try:
return f.read()
finally:
f.close()
else:
# Unicode
f = codecs.open(self, 'r', encoding, errors)
# (Note - Can't use 'U' mode here, since codecs.open
# doesn't support 'U' mode, even in Python 2.3.)
try:
t = f.read()
finally:
f.close()
return (t.replace('\r\n', '\n')
.replace('\r\x85', '\n')
.replace('\r', '\n')
.replace('\x85', '\n')
.replace('\u2028', '\n'))
def write_text(self, text, encoding=None, errors='strict', linesep=os.linesep, append=False):
r""" Write the given text to this file.
The default behavior is to overwrite any existing file;
to append instead, use the 'append=True' keyword argument.
There are two differences between path.write_text() and
path.write_bytes(): newline handling and Unicode handling.
See below.
Parameters:
- text - str/unicode - The text to be written.
- encoding - str - The Unicode encoding that will be used.
This is ignored if 'text' isn't a Unicode string.
- errors - str - How to handle Unicode encoding errors.
Default is 'strict'. See help(unicode.encode) for the
options. This is ignored if 'text' isn't a Unicode
string.
- linesep - keyword argument - str/unicode - The sequence of
characters to be used to mark end-of-line. The default is
os.linesep. You can also specify None; this means to
leave all newlines as they are in 'text'.
- append - keyword argument - bool - Specifies what to do if
the file already exists (True: append to the end of it;
False: overwrite it.) The default is False.
--- Newline handling.
write_text() converts all standard end-of-line sequences
('\n', '\r', and '\r\n') to your platform's default end-of-line
sequence (see os.linesep; on Windows, for example, the
end-of-line marker is '\r\n').
If you don't like your platform's default, you can override it
using the 'linesep=' keyword argument. If you specifically want
write_text() to preserve the newlines as-is, use 'linesep=None'.
This applies to Unicode text the same as to 8-bit text, except
there are three additional standard Unicode end-of-line sequences:
u'\x85', u'\r\x85', and u'\u2028'.
(This is slightly different from when you open a file for
writing with fopen(filename, "w") in C or open(filename, 'w')
in Python.)
--- Unicode
If 'text' isn't Unicode, then apart from newline handling, the
bytes are written verbatim to the file. The 'encoding' and
'errors' arguments are not used and must be omitted.
If 'text' is Unicode, it is first converted to bytes using the
specified 'encoding' (or the default encoding if 'encoding'
isn't specified). The 'errors' argument applies only to this
conversion.
"""
if isinstance(text, str):
if linesep is not None:
# Convert all standard end-of-line sequences to
# ordinary newline characters.
text = (text.replace('\r\n', '\n')
.replace('\r\x85', '\n')
.replace('\r', '\n')
.replace('\x85', '\n')
.replace('\u2028', '\n'))
text = text.replace('\n', linesep)
if encoding is None:
encoding = sys.getdefaultencoding()
bytes = text.encode(encoding, errors)
else:
# It is an error to specify an encoding if 'text' is
# an 8-bit string.
assert encoding is None
if linesep is not None:
text = (text.replace('\r\n', '\n')
.replace('\r', '\n'))
bytes = text.replace('\n', linesep)
self.write_bytes(bytes, append)
def lines(self, encoding=None, errors='strict', retain=True):
r""" Open this file, read all lines, return them in a list.
Optional arguments:
encoding - The Unicode encoding (or character set) of
the file. The default is None, meaning the content
of the file is read as 8-bit characters and returned
as a list of (non-Unicode) str objects.
errors - How to handle Unicode errors; see help(str.decode)
for the options. Default is 'strict'
retain - If true, retain newline characters; but all newline
character combinations ('\r', '\n', '\r\n') are
translated to '\n'. If false, newline characters are
stripped off. Default is True.
This uses 'U' mode in Python 2.3 and later.
"""
if encoding is None and retain:
f = self.open(_textmode)
try:
return f.readlines()
finally:
f.close()
else:
return self.text(encoding, errors).splitlines(retain)
def write_lines(self, lines, encoding=None, errors='strict',
linesep=os.linesep, append=False):
r""" Write the given lines of text to this file.
By default this overwrites any existing file at this path.
This puts a platform-specific newline sequence on every line.
See 'linesep' below.
lines - A list of strings.
encoding - A Unicode encoding to use. This applies only if
'lines' contains any Unicode strings.
errors - How to handle errors in Unicode encoding. This
also applies only to Unicode strings.
linesep - The desired line-ending. This line-ending is
applied to every line. If a line already has any
standard line ending ('\r', '\n', '\r\n', u'\x85',
u'\r\x85', u'\u2028'), that will be stripped off and
this will be used instead. The default is os.linesep,
which is platform-dependent ('\r\n' on Windows, '\n' on
Unix, etc.) Specify None to write the lines as-is,
like file.writelines().
Use the keyword argument append=True to append lines to the
file. The default is to overwrite the file. Warning:
When you use this with Unicode data, if the encoding of the
existing data in the file is different from the encoding
you specify with the encoding= parameter, the result is
mixed-encoding data, which can really confuse someone trying
to read the file later.
"""
if append:
mode = 'ab'
else:
mode = 'wb'
f = self.open(mode)
try:
for line in lines:
isUnicode = isinstance(line, str)
if linesep is not None:
# Strip off any existing line-end and add the
# specified linesep string.
if isUnicode:
if line[-2:] in ('\r\n', '\x0d\x85'):
line = line[:-2]
elif line[-1:] in ('\r', '\n',
'\x85', '\u2028'):
line = line[:-1]
else:
if line[-2:] == '\r\n':
line = line[:-2]
elif line[-1:] in ('\r', '\n'):
line = line[:-1]
line += linesep
if isUnicode:
if encoding is None:
encoding = sys.getdefaultencoding()
line = line.encode(encoding, errors)
f.write(line)
finally:
f.close()
def read_md5(self):
""" Calculate the md5 hash for this file.
This reads through the entire file.
"""
return self.read_hash('md5')
def _hash(self, hash_name):
f = self.open('rb')
try:
m = hashlib.new(hash_name)
while True:
d = f.read(8192)
if not d:
break
m.update(d)
return m
finally:
f.close()
def read_hash(self, hash_name):
""" Calculate given hash for this file.
List of supported hashes can be obtained from hashlib package. This
reads the entire file.
"""
return self._hash(hash_name).digest()
def read_hexhash(self, hash_name):
""" Calculate given hash for this file, returning hexdigest.
List of supported hashes can be obtained from hashlib package. This
reads the entire file.
"""
return self._hash(hash_name).hexdigest()
# --- Methods for querying the filesystem.
# N.B. On some platforms, the os.path functions may be implemented in C
# (e.g. isdir on Windows, Python 3.2.2), and compiled functions don't get
# bound. Playing it safe and wrapping them all in method calls.
def isabs(self): return os.path.isabs(self)
def exists(self): return os.path.exists(self)
def isdir(self): return os.path.isdir(self)
def isfile(self): return os.path.isfile(self)
def islink(self): return os.path.islink(self)
def ismount(self): return os.path.ismount(self)
if hasattr(os.path, 'samefile'):
def samefile(self, otherfile): return os.path.samefile(self, otherfile)
def getatime(self): return os.path.getatime(self)
atime = property(
getatime, None, None,
""" Last access time of the file. """)
def getmtime(self): return os.path.getmtime(self)
mtime = property(
getmtime, None, None,
""" Last-modified time of the file. """)
if hasattr(os.path, 'getctime'):
def getctime(self): return os.path.getctime(self)
ctime = property(
getctime, None, None,
""" Creation time of the file. """)
def getsize(self): return os.path.getsize(self)
size = property(
getsize, None, None,
""" Size of the file, in bytes. """)
if hasattr(os, 'access'):
def access(self, mode):
""" Return true if current user has access to this path.
mode - One of the constants os.F_OK, os.R_OK, os.W_OK, os.X_OK
"""
return os.access(self, mode)
def stat(self):
""" Perform a stat() system call on this path. """
return os.stat(self)
def lstat(self):
""" Like path.stat(), but do not follow symbolic links. """
return os.lstat(self)
def get_owner(self):
r""" Return the name of the owner of this file or directory.
This follows symbolic links.
On Windows, this returns a name of the form ur'DOMAIN\User Name'.
On Windows, a group can own a file or directory.
"""
if os.name == 'nt':
if win32security is None:
raise Exception("path.owner requires win32all to be installed")
desc = win32security.GetFileSecurity(
self, win32security.OWNER_SECURITY_INFORMATION)
sid = desc.GetSecurityDescriptorOwner()
account, domain, typecode = win32security.LookupAccountSid(None, sid)
return domain + '\\' + account
else:
if pwd is None:
raise NotImplementedError("path.owner is not implemented on this platform.")
st = self.stat()
return pwd.getpwuid(st.st_uid).pw_name
owner = property(
get_owner, None, None,
""" Name of the owner of this file or directory. """)
if hasattr(os, 'statvfs'):
def statvfs(self):
""" Perform a statvfs() system call on this path. """
return os.statvfs(self)
if hasattr(os, 'pathconf'):
def pathconf(self, name):
return os.pathconf(self, name)
#
# --- Modifying operations on files and directories
def utime(self, times):
""" Set the access and modified times of this file. """
os.utime(self, times)
def chmod(self, mode):
os.chmod(self, mode)
if hasattr(os, 'chown'):
def chown(self, uid, gid):
os.chown(self, uid, gid)
def rename(self, new):
os.rename(self, new)
def renames(self, new):
os.renames(self, new)
#
# --- Create/delete operations on directories
def mkdir(self, mode=0o777):
if not self.exists():
os.mkdir(self, mode)
def mkdir_p(self, mode=0o777):
try:
self.mkdir(mode)
except OSError as e:
if e.errno != errno.EEXIST:
raise
def makedirs(self, mode=0o777):
if not self.exists():
os.makedirs(self, mode)
def makedirs_p(self, mode=0o777):
try:
self.makedirs(mode)
except OSError as e:
if e.errno != errno.EEXIST:
raise
def rmdir(self):
if self.exists():
os.rmdir(self)
def rmdir_p(self):
try:
self.rmdir()
except OSError as e:
if e.errno != errno.ENOTEMPTY and e.errno != errno.EEXIST:
raise
def removedirs(self):
if self.exists():
os.removedirs(self)
def removedirs_p(self):
try:
self.removedirs()
except OSError as e:
if e.errno != errno.ENOTEMPTY and e.errno != errno.EEXIST:
raise
# --- Modifying operations on files
def touch(self):
""" Set the access/modified times of this file to the current time.
Create the file if it does not exist.
"""
fd = os.open(self, os.O_WRONLY | os.O_CREAT, 0o666)
os.close(fd)
os.utime(self, None)
def remove(self):
if self.exists():
os.remove(self)
def remove_p(self):
try:
self.unlink()
except OSError as e:
if e.errno != errno.ENOENT:
raise
def unlink(self):
if not self.exists():
os.unlink(self)
def unlink_p(self):
self.remove_p()
# --- Links
if hasattr(os, 'link'):
def link(self, newpath):
""" Create a hard link at 'newpath', pointing to this file. """
os.link(self, newpath)
if hasattr(os, 'symlink'):
def symlink(self, newlink):
""" Create a symbolic link at 'newlink', pointing here. """
os.symlink(self, newlink)
if hasattr(os, 'readlink'):
def readlink(self):
""" Return the path to which this symbolic link points.
The result may be an absolute or a relative path.
"""
return self.__class__(os.readlink(self))
def readlinkabs(self):
""" Return the path to which this symbolic link points.
The result is always an absolute path.
"""
p = self.readlink()
if p.isabs():
return p
else:
return (self.parent / p).abspath()
#
# --- High-level functions from shutil
copyfile = shutil.copyfile
copymode = shutil.copymode
copystat = shutil.copystat
copy = shutil.copy
copy2 = shutil.copy2
copytree = shutil.copytree
if hasattr(shutil, 'move'):
move = shutil.move
def rmtree(self, *args, **kw):
if self.exists():
shutil.rmtree(self, *args, **kw)
def rmtree_p(self):
try:
self.rmtree()
except OSError as e:
if e.errno != errno.ENOENT:
raise
#
# --- Special stuff from os
if hasattr(os, 'chroot'):
def chroot(self):
os.chroot(self)
if hasattr(os, 'startfile'):
def startfile(self):
os.startfile(self)
Paver-1.2.1/paver/git.py 0000644 0001750 0001750 00000006123 12152711177 015226 0 ustar almad almad 0000000 0000000 """Convenience functions for working with git.
This module does not include any tasks, only functions.
At this point, these functions do not use any kind of library. They require
the git binary on the path."""
from paver.easy import sh
import os, re
def _format_path(provided_path):
return provided_path or os.getcwd()
def _split_remote_branch_name(provided_name):
return provided_name.split("/")[1]
def clone(url, dest_folder):
sh("git clone %(url)s %(path)s" % dict(url=url, path=dest_folder) )
def pull(destination, remote="origin", branch="master"):
"""Perform a git pull. Destination must be absolute path.
"""
sh("cd %(destination)s; git pull %(remote)s %(branch)s" % dict(
destination=destination, remote=remote, branch=branch) )
def branch_list(path="", remote_branches_only=False, __override__=None):
"""
Lists git branches for the repository specified (or CWD).
If remote_branches_only is specified will list branches that exist
on the remote. These branches may, or may not, have corresponding remote
tracking branches.
Returns a Python tuple. The first item in the tuple will be the current
branch, and the other item will be a list of branches for the repository.
Optional parameter path: the path to the git repo. Else uses os.getcwd()
"""
remote_branches = ""
if remote_branches_only:
remote_branches = "-r"
if __override__ == None:
git_output = sh( "cd %(repo_path)s; git branch %(remote)s" % dict(
repo_path = _format_path(path), remote = remote_branches ), capture=True )
else:
git_output = __override__
if git_output == None:
return None, [] # should only hit this condition in testing...
current_branch = ""
branches = []
found_a_match = False
regex = re.compile(r"(\*?)\W*(.+)")
for line in git_output.split("\n"):
match_obj = regex.match(line)
if match_obj:
found_a_match = True
if match_obj.group(1):
current_branch = match_obj.group(2).strip()
if match_obj.group(2).strip():
branches.append( match_obj.group(2).strip() )
if found_a_match is False:
raise "git branch did not return output expected. Returned %s" % git_output
return current_branch, branches
def branch_checkout(branch_name, path=""):
"""Checkout a git branch.
Take the branch name to checkout, and optional path parameter
(the path to the git repo. Else uses os.getcwd())
"""
sh( "cd %(repo_path)s; git checkout %(branch_name)s" % dict(
repo_path = _format_path(path),
branch_name=branch_name) )
def branch_track_remote(remote_branch_name, local_branch_name=None, path=""):
local_branch_name = ( local_branch_name or _split_remote_branch_name(remote_branch_name) )
sh( "cd %(repo_path)s; git checkout -b %(branch_name)s --track %(remote_branch_name)s" % dict(
repo_path = _format_path(path),
branch_name=local_branch_name,
remote_branch_name=remote_branch_name) )
Paver-1.2.1/paver/setuputils.py 0000644 0001750 0001750 00000022443 12152711177 016667 0 ustar almad almad 0000000 0000000 """Integrates distutils/setuptools with Paver."""
import re
import os
import sys
from os.path import *
from fnmatch import fnmatchcase
from distutils.util import convert_path
from distutils import log
try:
from setuptools import dist
except ImportError:
from distutils import dist
from distutils.errors import DistutilsModuleError
_Distribution = dist.Distribution
from paver.deps.six import print_
from paver.options import Bunch
try:
import setuptools
import pkg_resources
has_setuptools = True
except ImportError:
has_setuptools = False
# our commands can have '.' in them, so we'll monkeypatch this
# expression
dist.command_re = re.compile (r'^[a-zA-Z]([a-zA-Z0-9_\.]*)$')
from paver import tasks
__ALL__ = ['find_package_data']
# find_package_data is an Ian Bicking creation.
# Provided as an attribute, so you can append to these instead
# of replicating them:
standard_exclude = ('*.py', '*.pyc', '*~', '.*', '*.bak', '*.swp*')
standard_exclude_directories = ('.*', 'CVS', '_darcs', './build',
'./dist', 'EGG-INFO', '*.egg-info')
def _dispatch_setuptools_install(distribution, command_name):
"""
setuptools hack:
- handle dependencies in `install_requires` by calling fetch_build_eggs()
"""
#check if it has some requirements and try to install them
if distribution.install_requires:
try:
distribution.fetch_build_eggs(distribution.install_requires)
except Exception:
pass
#run command
distribution.run_command(command_name)
# storage of extra dispatchers for distutils/setuptools commands
_extra_command_dispatch = {
'setuptools.command.install.install': _dispatch_setuptools_install,
}
def find_package_data(
where='.', package='',
exclude=standard_exclude,
exclude_directories=standard_exclude_directories,
only_in_packages=True,
show_ignored=False):
"""
Return a dictionary suitable for use in ``package_data``
in a distutils ``setup.py`` file.
The dictionary looks like::
{'package': [files]}
Where ``files`` is a list of all the files in that package that
don't match anything in ``exclude``.
If ``only_in_packages`` is true, then top-level directories that
are not packages won't be included (but directories under packages
will).
Directories matching any pattern in ``exclude_directories`` will
be ignored; by default directories with leading ``.``, ``CVS``,
and ``_darcs`` will be ignored.
If ``show_ignored`` is true, then all the files that aren't
included in package data are shown on stderr (for debugging
purposes).
Note patterns use wildcards, or can be exact paths (including
leading ``./``), and all searching is case-insensitive.
This function is by Ian Bicking.
"""
out = {}
stack = [(convert_path(where), '', package, only_in_packages)]
while stack:
where, prefix, package, only_in_packages = stack.pop(0)
for name in os.listdir(where):
fn = join(where, name)
if isdir(fn):
bad_name = False
for pattern in exclude_directories:
if (fnmatchcase(name, pattern)
or fn.lower() == pattern.lower()):
bad_name = True
if show_ignored:
print_("Directory %s ignored by pattern %s"
% (fn, pattern), file=sys.stderr)
break
if bad_name:
continue
if isfile(join(fn, '__init__.py')):
if not package:
new_package = name
else:
new_package = package + '.' + name
stack.append((fn, '', new_package, False))
else:
stack.append((fn, prefix + name + '/', package, only_in_packages))
elif package or not only_in_packages:
# is a file
bad_name = False
for pattern in exclude:
if (fnmatchcase(name, pattern)
or fn.lower() == pattern.lower()):
bad_name = True
if show_ignored:
print_("File %s ignored by pattern %s"
% (fn, pattern), file=sys.stderr)
break
if bad_name:
continue
out.setdefault(package, []).append(prefix+name)
return out
class DistutilsTask(tasks.Task):
def __init__(self, distribution, command_name, command_class):
name_sections = str(command_class).split(".")
if name_sections[-2] == name_sections[-1]:
del name_sections[-2]
self.name = ".".join(name_sections)
self.__name__ = self.name
self.distribution = distribution
self.command_name = command_name
self.shortname = _get_shortname(command_name)
self.command_class = command_class
self.option_names = set()
self.needs = []
self.might_call = []
self._parser = None
self.share_options_with = []
self.user_options = command_class.user_options
self.negative_opt = getattr(command_class, "negative_opt", {})
# Parse distutils config files.
distribution.parse_config_files()
def __call__(self, *args, **kw):
options = tasks.environment.options.get(self.shortname, {})
opt_dict = self.distribution.get_option_dict(self.command_name)
for (name, value) in options.items():
opt_dict[name.replace('-', '_')] = ("command line", value)
# see if we don't have extra dispatcher for command
cmd_class = str(self.command_class)
if cmd_class in _extra_command_dispatch:
_extra_command_dispatch[cmd_class](self.distribution, self.command_name)
else:
self.distribution.run_command(self.command_name)
@property
def description(self):
return self.command_class.description
def _get_shortname(taskname):
dotindex = taskname.rfind(".")
if dotindex > -1:
command_name = taskname[dotindex+1:]
else:
command_name = taskname
return command_name
class DistutilsTaskFinder(object):
def get_task(self, taskname):
dist = _get_distribution()
command_name = _get_shortname(taskname)
try:
command_class = dist.get_command_class(command_name)
except DistutilsModuleError:
return None
return DistutilsTask(dist, command_name, command_class)
def get_tasks(self):
dist = _get_distribution()
if has_setuptools:
for ep in pkg_resources.iter_entry_points('distutils.commands'):
try:
cmdclass = ep.load(False) # don't require extras, we're not running
dist.cmdclass[ep.name] = cmdclass
except:
# on the Mac, at least, installing from the tarball
# via zc.buildout fails due to a problem in the
# py2app command
tasks.environment.info("Could not load entry point: %s", ep)
dist.get_command_list()
return set(DistutilsTask(dist, key, value)
for key, value in dist.cmdclass.items())
def _get_distribution():
try:
return tasks.environment.distribution
except AttributeError:
dist = _Distribution(attrs=tasks.environment.options.get('setup', {}))
tasks.environment.distribution = dist
dist.script_name = tasks.environment.pavement_file
return dist
def install_distutils_tasks():
"""Makes distutils and setuptools commands available as Paver tasks."""
env = tasks.environment
if not hasattr(env, "_distutils_tasks_installed"):
env.task_finders.append(DistutilsTaskFinder())
env._distutils_tasks_installed = True
def setup(**kw):
"""Updates options.setup with the keyword arguments provided,
and installs the distutils tasks for this pavement. You can
use paver.setuputils.setup as a direct replacement for
the distutils.core.setup or setuptools.setup in a traditional
setup.py."""
install_distutils_tasks()
setup_section = tasks.environment.options.setdefault("setup", Bunch())
setup_section.update(kw)
def _error(message, *args):
"""Displays an error message to the user."""
tasks.environment.error(message, *args)
def _info(message, *args):
"""Displays a message to the user. If the quiet option is specified, the
message will not be displayed."""
tasks.environment.info(message, *args)
def _debug(message, *args):
"""Displays a message to the user, but only if the verbose flag is
set."""
tasks.environment.debug(message, *args)
def _base_log(level, message, *args):
"""Displays a message at the given log level"""
tasks.environment._log(level, message, args)
# monkeypatch the distutils logging to go through Paver's logging
log.log = _base_log
log.debug = _debug
log.info = _info
log.warn = _error
log.error = _error
log.fatal = _error
if has_setuptools:
__ALL__.extend(["find_packages"])
from setuptools import find_packages
else:
import distutils.core
Paver-1.2.1/paver/command.py 0000644 0001750 0001750 00000000322 12152711177 016054 0 ustar almad almad 0000000 0000000 """Paver's command-line driver"""
import warnings
warnings.warn("paver.command is deprecated. Please re-run the generate_setup task.",
stacklevel=2)
import paver.tasks
def main():
paver.tasks.main()
Paver-1.2.1/paver/tests/ 0000755 0001750 0001750 00000000000 12152711214 015221 5 ustar almad almad 0000000 0000000 Paver-1.2.1/paver/tests/__init__.py 0000644 0001750 0001750 00000000000 12152711177 017330 0 ustar almad almad 0000000 0000000 Paver-1.2.1/paver/tests/test_doctools.py 0000644 0001750 0001750 00000011555 12152711177 020477 0 ustar almad almad 0000000 0000000 from __future__ import with_statement
import sys
from nose.plugins.skip import SkipTest
from paver.deps.six import print_
from paver.easy import *
from paver import doctools, tasks, options
def _no25():
if sys.version_info[:2] == (2, 5):
raise SkipTest('No cog integration in Python 2.5')
def test_sections_from_file():
simpletext = """# [[[section foo]]]
#Foo!
# [[[endsection]]]
"""
f = doctools.SectionedFile(from_string=simpletext)
assert len(f) == 1, "Sections found: %s" % f
assert f['foo'] == "#Foo!\n", "Foo section contained: '%s'" % f['foo']
def display(msg, *args):
print_(msg % args)
doctools.debug = display
def test_nested_sections():
myfile = """
[[[section bar]]]
Hi there.
[[[section baz]]]
Yo.
[[[endsection]]]
[[[endsection]]]
"""
f = doctools.SectionedFile(from_string=myfile)
assert len(f) == 2
assert f['bar'] == """ Hi there.
Yo.
""", "Bar was: '%s'" % (f['bar'])
assert f['bar.baz'] == """ Yo.
"""
def test_section_doesnt_end():
myfile = """
[[[section bar]]]
Yo.
"""
try:
f = doctools.SectionedFile(from_string=myfile)
assert False, "Expected a BuildFailure"
except BuildFailure:
e = sys.exc_info()[1]
assert str(e) == """No end marker for section 'bar'
(in file 'None', starts at line 2)""", "error was: %s" % (str(e))
def test_section_already_defined():
myfile = """
[[[section foo]]]
First one.
[[[endsection]]]
[[[section foo]]]
Second one.
[[[endsection]]]
"""
try:
f = doctools.SectionedFile(from_string=myfile)
assert False, "Expected a BuildFailure"
except BuildFailure:
e = sys.exc_info()[1]
assert str(e) == """section 'foo' redefined
(in file 'None', first section at line 2, second at line 6)""", \
"error was: %s" % (str(e))
def test_endmarker_without_start():
myfile = """
[[[section foo]]]
This is a good section.
[[[endsection]]]
[[[endsection]]]
"""
try:
f = doctools.SectionedFile(from_string=myfile)
assert False, "Expected a BuildFailure"
except BuildFailure:
e = sys.exc_info()[1]
assert str(e) == """End section marker with no starting marker
(in file 'None', at line 6)""", \
"error was: %s" % (str(e))
def test_whole_file():
myfile = """
[[[section bar]]]
Hi there.
[[[section baz]]]
Yo.
[[[endsection]]]
[[[endsection]]]
"""
f = doctools.SectionedFile(from_string=myfile)
assert f.all == """
Hi there.
Yo.
""", "All was: %s" % (f.all)
def test_bad_section():
f = doctools.SectionedFile(from_string="")
try:
f['foo']
assert False, "Should have a BuildFailure"
except BuildFailure:
e = sys.exc_info()[1]
assert str(e) == "No section 'foo' in file 'None'", \
"Error: '%s'" % (str(e))
def test_include_lookup():
basedir = path(__file__).dirname() / "data"
include = doctools.Includer(basedir, include_markers={})
everything = include("t1.py")
assert everything == """# file 't1.py'
print "Hi!"
print "More"
""", "Everything was: '%s'" % (everything)
first = include("t1.py", "first")
assert first == """# section 'first' in file 't1.py'
print "Hi!"
""", "First was '%s'" % (first)
second = include("t2.py", "second.inner")
assert second == """# section 'second.inner' in file 't2.py'
print sys.path
""", "Second was '%s'" % (second)
def test_cogging():
if not paver.doctools.has_cog:
raise SkipTest("Cog must be installed for this test")
_no25()
env = tasks.Environment(doctools)
tasks.environment = env
opt = env.options
opt.cog = options.Bunch()
basedir = path(__file__).dirname()
opt.cog.basedir = basedir
opt.cog.pattern = "*.rst"
opt.cog.includedir = basedir / "data"
env.options = opt
doctools.cog()
textfile = basedir / "data/textfile.rst"
with open(textfile) as f:
data = f.read()
print_(data)
assert "print sys.path" in data
doctools.uncog()
with open(textfile) as f:
data = f.read()
assert "print sys.path" not in data
def test_cogging_with_markers_removed():
if not paver.doctools.has_cog:
raise SkipTest("Cog must be installed for this test")
_no25()
env = tasks.Environment(doctools)
tasks.environment = env
opt = env.options
opt.cog = Bunch()
basedir = path(__file__).dirname()
opt.cog.basedir = basedir
opt.cog.pattern = "*.rst"
opt.cog.includedir = basedir / "data"
opt.cog.delete_code = True
env.options = opt
textfile = basedir / "data/textfile.rst"
with open(textfile) as f:
original_data = f.read()
try:
doctools.cog()
with open(textfile) as f:
data = f.read()
print_(data)
assert "[[[cog" not in data
finally:
with open(textfile, "w") as f:
f.write(original_data)
Paver-1.2.1/paver/tests/test_easy.py 0000644 0001750 0001750 00000004334 12152711177 017607 0 ustar almad almad 0000000 0000000 import sys
from paver.deps.six import b
from mock import patch, Mock
from paver import easy
from subprocess import PIPE, STDOUT
@patch('subprocess.Popen')
def test_sh_raises_BuildFailure(popen):
popen.return_value.returncode = 1
popen.return_value.communicate.return_value = [b('some stderr')]
try:
easy.sh('foo')
except easy.BuildFailure:
e = sys.exc_info()[1]
args = e.args
assert args == ('Subprocess return code: 1', )
else:
assert False, 'Failed to raise BuildFailure'
assert popen.called
assert popen.call_args[0][0] == 'foo'
assert popen.call_args[1]['shell'] == True
assert 'stdout' not in popen.call_args[1]
@patch('paver.easy.error')
@patch('subprocess.Popen')
def test_sh_with_capture_raises_BuildFailure(popen, error):
popen.return_value.returncode = 1
popen.return_value.communicate.return_value = [b('some stderr')]
try:
easy.sh('foo', capture=True)
except easy.BuildFailure:
e = sys.exc_info()[1]
args = e.args
assert args == ('Subprocess return code: 1', )
else:
assert False, 'Failed to raise BuildFailure'
assert popen.called
assert popen.call_args[0][0] == 'foo'
assert popen.call_args[1]['shell'] == True
assert popen.call_args[1]['stdout'] == PIPE
assert popen.call_args[1]['stderr'] == STDOUT
assert error.called
assert error.call_args == (('some stderr', ), {})
@patch('subprocess.Popen')
def test_sh_ignores_error(popen):
popen.return_value.communicate.return_value = [b('some stderr')]
popen.return_value.returncode = 1
easy.sh('foo', ignore_error=True)
assert popen.called
assert popen.call_args[0][0] == 'foo'
assert popen.call_args[1]['shell'] == True
assert 'stdout' not in popen.call_args[1]
@patch('subprocess.Popen')
def test_sh_ignores_error_with_capture(popen):
popen.return_value.returncode = 1
popen.return_value.communicate.return_value = [b('some stderr')]
easy.sh('foo', capture=True, ignore_error=True)
assert popen.called
assert popen.call_args[0][0] == 'foo'
assert popen.call_args[1]['shell'] == True
assert popen.call_args[1]['stdout'] == PIPE
assert popen.call_args[1]['stderr'] == STDOUT
Paver-1.2.1/paver/tests/other_pavement.py 0000644 0001750 0001750 00000000217 12152711177 020623 0 ustar almad almad 0000000 0000000 from paver.easy import *
from paver.tests import test_tasks
options(foo=1)
@task
def t1(options):
test_tasks.OP_T1_CALLED = options.foo
Paver-1.2.1/paver/tests/utils.py 0000644 0001750 0001750 00000001641 12152711177 016745 0 ustar almad almad 0000000 0000000 import types
import paver.deps.six as six
from paver import setuputils, tasks
class FakeModule(object):
def __init__(self, **kw):
for name, value in kw.items():
setattr(self, name, value)
def patched_print(self, output):
self.patch_captured.append(output)
class FakeExitException(Exception):
""" Fake out tasks.Environment._exit to avoid interupting tests """
def patched_exit(self, code):
self.exit_code = 1
raise FakeExitException(code)
def _set_environment(patch_print=False, **kw):
pavement = FakeModule(**kw)
env = tasks.Environment(pavement)
tasks.environment = env
if six.PY3:
method_args = (env,)
else:
method_args = (env, tasks.Environment)
env._exit = types.MethodType(patched_exit, *method_args)
if patch_print:
env._print = types.MethodType(patched_print, *method_args)
env.patch_captured = []
return env
Paver-1.2.1/paver/tests/data/ 0000755 0001750 0001750 00000000000 12152711214 016132 5 ustar almad almad 0000000 0000000 Paver-1.2.1/paver/tests/data/t2.py 0000644 0001750 0001750 00000000152 12152711177 017037 0 ustar almad almad 0000000 0000000 #[[[section second]]]
import sys
#[[[section inner]]]
print sys.path
#[[[endsection]]]
#[[[endsection]]]
Paver-1.2.1/paver/tests/data/t1.py 0000644 0001750 0001750 00000000101 12152711177 017030 0 ustar almad almad 0000000 0000000 #[[[section first]]]
print "Hi!"
#[[[endsection]]]
print "More"
Paver-1.2.1/paver/tests/data/textfile.rst 0000644 0001750 0001750 00000000316 12152711177 020520 0 ustar almad almad 0000000 0000000 This is an example file that will use cog to include stuff.
For example, here's some Python code::
# [[[cog include('t2.py', 'second') ]]]
# [[[end]]]
It should be included there. We'll see.
Paver-1.2.1/paver/tests/test_svn.py 0000644 0001750 0001750 00000003531 12152711177 017452 0 ustar almad almad 0000000 0000000 from mock import patch
from paver import svn
@patch('paver.svn.sh')
def test_simple_checkout(sh):
svn.checkout("http://foo", "bar")
assert sh.called
assert sh.call_args[0][0] == "svn co http://foo bar"
@patch('paver.svn.sh')
def test_checkout_with_revision(sh):
svn.checkout("http://foober", "baz", revision="1212")
assert sh.called
assert sh.call_args[0][0] == "svn co -r 1212 http://foober baz", sh.call_args[0][0]
@patch('paver.svn.sh')
def test_simple_update(sh):
svn.update("bar")
assert sh.called
assert sh.call_args[0][0] == "svn up bar"
sh.reset()
svn.update()
assert sh.called
assert sh.call_args[0][0] == "svn up "
@patch('paver.svn.sh')
def test_update_with_revision(sh):
svn.update(revision="1234")
assert sh.called
assert sh.call_args[0][0] == "svn up -r 1234 "
@patch('paver.svn.sh')
def test_simple_export(sh):
svn.export("http://foo", "bar")
assert sh.called
assert sh.call_args[0][0] == "svn export http://foo bar"
@patch('paver.svn.sh')
def test_export_with_revision(sh):
svn.export("http://foo", "bar", revision="1234")
assert sh.called
assert sh.call_args[0][0] == "svn export -r 1234 http://foo bar"
@patch('paver.svn.sh')
def test_svn_info(sh):
sh.return_value="""Path: dojotoolkit/dojo
URL: http://svn.dojotoolkit.org/src/dojo/trunk
Repository Root: http://svn.dojotoolkit.org/src
Repository UUID: 560b804f-0ae3-0310-86f3-f6aa0a117693
Revision: 13301
Node Kind: directory
Schedule: normal
Last Changed Author: jaredj
Last Changed Rev: 13299
Last Changed Date: 2008-04-10 11:44:52 -0400 (Thu, 10 Apr 2008)
"""
output = svn.info()
assert sh.called
assert output.path == "dojotoolkit/dojo"
assert output.url == "http://svn.dojotoolkit.org/src/dojo/trunk"
assert output.last_changed_date == "2008-04-10 11:44:52 -0400 (Thu, 10 Apr 2008)"
Paver-1.2.1/paver/tests/test_options.py 0000644 0001750 0001750 00000006445 12152711177 020346 0 ustar almad almad 0000000 0000000 from paver import options, tasks
def test_basic_namespace_as_dictionary():
ns = options.Namespace(foo=1, bar=2)
assert ns.foo == 1
assert ns['bar'] == 2
ns.bar = 3
assert ns['bar'] == 3
ns.new = 4
assert ns.new == 4
def test_default_namespace_searching():
ns = options.Namespace()
ns.val = 0
ns.foo = options.Bunch(foo=1, bar=2, baz=3, blorg=6)
ns.bar = options.Bunch(foo=4, baz=5, bop=7, val=8)
assert ns.val == 0, "Top namespace has priority"
assert ns.foo == options.Bunch(foo=1, bar=2, baz=3, blorg=6)
assert ns.foo.foo == 1
assert ns.bar.foo == 4
assert ns.baz == 5
assert ns.blorg == 6
try:
ns['does not exist']
assert False, "expected key error for missing item"
except KeyError:
pass
del ns['val']
assert ns.val == 8, "Now getting val from inner dict"
del ns.bar.val
try:
a = ns['val']
assert False, "expected exception for deleted item %s" % (ns)
except KeyError:
pass
del ns.foo
assert ns._sections == ['bar']
def test_clear():
ns = options.Namespace(foo=options.Bunch(bar=1))
ns.order('foo')
ns.clear()
assert len(ns) == 0
assert len(ns._sections) == 0
assert ns._ordering == None
def test_search_order_is_adjustable():
ns = options.Namespace(
bar=options.Bunch(val=1, blorg=4)
)
ns.baz=options.Bunch(val=2, bop=5)
ns.foo=options.Bunch(val=3, bam=6)
assert ns.blorg == 4
assert ns.val == 3
ns.order('baz')
assert ns.val == 2
assert ns.bop == 5
try:
ns.bam
assert False, "expected attribute error for item not in search"
except AttributeError:
pass
ns.order('bar', 'baz')
assert ns.val == 1
assert ns.blorg == 4
assert ns.bop == 5
ns.order('baz', add_rest=True)
assert ns.val == 2
assert ns.bam == 6
def test_update():
ns = options.Namespace()
ns.update(foo=options.Bunch(val=2))
assert ns._sections == ['foo'], str(ns._sections)
ns.update([('bar', options.Bunch(val=2))])
assert ns._sections == ['bar', 'foo'], str(ns._sections)
ns.update(dict(baz=options.Bunch(val=3)))
assert ns._sections == ['baz', 'bar', 'foo'], str(ns._sections)
ns(hi='there')
assert ns.hi == 'there'
def test_setdefault():
ns = options.Namespace()
ns.setdefault('foo', options.Bunch())
assert ns._sections == ['foo'], ns._sections
def test_callables_in_bunch():
b = options.Bunch(foo = lambda: "hi")
assert b.foo == "hi", "foo was: %s" % b.foo
def test_setdotted_values():
ns = options.Namespace()
ns.foo = options.Bunch()
ns.setdotted("foo.bar", "baz")
assert ns.foo.bar == "baz"
ns.setdotted("bligger.bar", "flilling")
assert ns.bligger.bar == "flilling"
ns.val = 10
try:
ns.setdotted("val.yo", 42)
assert False, "Expected exception when a value is found instead of bunch"
except options.OptionsError:
pass
def test_add_dict_to_order():
ns = options.Namespace()
ns.foo = options.Bunch(val="yo")
ns.bar = options.Bunch(val="there")
assert ns.val == "there"
ns.order('foo')
assert ns.val == "yo"
ns.order(dict(val="new"), add_rest=True)
assert ns.val == "new", "Got %s" % (ns.val)
Paver-1.2.1/paver/tests/test_setuputils.py 0000644 0001750 0001750 00000010164 12152711177 021065 0 ustar almad almad 0000000 0000000 from distutils.core import Command
from paver.deps.six import print_
from paver.setuputils import install_distutils_tasks, \
DistutilsTaskFinder, _get_distribution, \
DistutilsTask
from paver import tasks, options
from paver.tests.utils import _set_environment
class _sdist(Command):
called = False
foo_set = False
fin = None
user_options = [("foo", "f", "Foo"), ("no-foo", None, "No Foo")]
boolean_options = ['foo']
negative_opt = {'no-foo' : 'foo'}
def initialize_options(self):
self.foo = False
def finalize_options(self):
pass
def run(self):
_sdist.called = True
_sdist.foo_set = self.foo
_sdist.fin = self.get_finalized_command("sdist")
@classmethod
def reset(cls):
cls.called = False
cls.foo_set = False
cls.fin = None
class _sdist_with_default_foo(_sdist):
def initialize_options(self):
self.foo = True
#----------------------------------------------------------------------
def test_override_distutils_command():
@tasks.task
def sdist():
pass
env = _set_environment(sdist=sdist)
env.options = options.Bunch(setup=options.Bunch())
install_distutils_tasks()
d = _get_distribution()
d.cmdclass['sdist'] = _sdist
tasks._process_commands(['sdist', 'paver.tests.test_setuputils.sdist', '-f'])
assert sdist.called
assert _sdist.called
assert _sdist.foo_set
assert isinstance(_sdist.fin, _sdist)
def test_distutils_task_finder():
env = _set_environment()
env.options = options.Bunch(setup=options.Bunch())
dist = _get_distribution()
dutf = DistutilsTaskFinder()
task = dutf.get_task('distutils.command.install')
assert task
task = dutf.get_task('install')
assert task
task = dutf.get_task('foo')
assert task is None
def test_task_with_distutils_dep():
_sdist.reset()
@tasks.task
@tasks.needs("paver.tests.test_setuputils.sdist")
def sdist():
assert _sdist.called
env = _set_environment(sdist=sdist)
env.options = options.Bunch(setup=options.Bunch())
install_distutils_tasks()
d = _get_distribution()
d.cmdclass['sdist'] = _sdist
task_obj = env.get_task('sdist')
assert task_obj == sdist
needs_obj = env.get_task(task_obj.needs[0])
assert isinstance(needs_obj, DistutilsTask)
assert needs_obj.command_class == _sdist
tasks._process_commands(['sdist', "-f"])
assert sdist.called
assert _sdist.called
cmd = d.get_command_obj('sdist')
print_("Cmd is: %s" % cmd)
assert cmd.foo
assert _sdist.foo_set
def test_distutils_tasks_should_not_get_extra_options():
_sdist.reset()
env = _set_environment()
env.options = options.Bunch(setup=options.Bunch())
install_distutils_tasks()
d = _get_distribution()
d.cmdclass['sdist'] = _sdist
tasks._process_commands(['sdist'])
assert _sdist.called
assert not _sdist.foo_set
opts = d.get_option_dict('sdist')
assert 'foo' not in opts
def test_needs_sdist_without_options():
"""Test that a custom sdist can be used in needs() w/o options.setup"""
_sdist.reset()
@tasks.task
@tasks.needs("paver.tests.test_setuputils.sdist")
def sdist():
assert _sdist.called
@tasks.task
@tasks.needs("sdist")
def t1():
pass
env = _set_environment(sdist=sdist, t1=t1)
env.options = options.Bunch()
install_distutils_tasks()
d = _get_distribution()
d.cmdclass['sdist'] = _sdist
tasks._process_commands(['t1'])
assert sdist.called
assert _sdist.called
assert t1.called
cmd = d.get_command_obj('sdist')
assert not cmd.foo
assert not _sdist.foo_set
def test_negative_opts_handled_for_distutils():
_sdist.reset()
env = _set_environment()
env.options = options.Bunch(setup=options.Bunch())
install_distutils_tasks()
d = _get_distribution()
d.cmdclass['sdist'] = _sdist_with_default_foo
tasks._process_commands(['sdist', '--no-foo'])
assert _sdist.called
assert not _sdist.foo_set
Paver-1.2.1/paver/tests/test_tasks.py 0000644 0001750 0001750 00000054165 12152711177 020002 0 ustar almad almad 0000000 0000000 from __future__ import with_statement
import os
from pprint import pprint
from paver.deps.six import print_
from paver import setuputils, misctasks, tasks, options
from paver.tests.utils import _set_environment, FakeExitException
OP_T1_CALLED = 0
subpavement = os.path.join(os.path.dirname(__file__), "other_pavement.py")
def test_basic_dependencies():
@tasks.task
def t1():
pass
t1.called = False
t1.t2_was_called = False
@tasks.task
@tasks.needs('t1')
def t2():
assert t1.called
t1.t2_was_called = True
_set_environment(t1 = t1, t2=t2)
assert hasattr(tasks.environment.pavement, 't1')
t2()
assert t1.t2_was_called
@tasks.task
def global_t1():
pass
def test_longname_resolution_in_dependencies():
global_t1.called = False
global_t1.t2_was_called = False
@tasks.task
@tasks.needs('paver.tests.test_tasks.global_t1')
def t2():
assert global_t1.called
global_t1.t2_was_called = True
_set_environment(t2=t2)
t2()
assert global_t1.t2_was_called
def test_chained_dependencies():
called = [False, False, False, False]
@tasks.task
def t1():
assert called == [False, False, False, False]
called[0] = True
@tasks.task
@tasks.needs('t1')
def t2():
assert called == [True, False, False, False]
called[1] = True
@tasks.task
def t3():
assert called == [True, True, False, False]
called[2] = True
@tasks.task
@tasks.needs('t2', 't3')
def t4():
assert called == [True, True, True, False]
called[3] = True
_set_environment(t1=t1,t2=t2,t3=t3,t4=t4)
t4()
assert called == [True, True, True, True], "Called was: %s" % (called)
def test_backwards_compatible_needs():
@tasks.task
def t():
pass
@tasks.task
@tasks.needs(['t'])
def t2():
pass
@tasks.task
@tasks.needs('t')
def t3():
pass
env = _set_environment(t=t, t2=t2, t3=t3)
t3()
assert t.called
t.called = False
t2()
assert t.called
def test_tasks_dont_repeat():
called = [0, 0, 0, 0]
@tasks.task
def t1():
assert called == [0, 0, 0, 0]
called[0] += 1
@tasks.task
@tasks.needs('t1')
def t2():
assert called == [1, 0, 0, 0]
called[1] += 1
@tasks.task
@tasks.needs('t1')
def t3():
assert called == [1, 1, 0, 0]
called[2] += 1
@tasks.task
@tasks.needs('t2', 't3')
def t4():
assert called == [1, 1, 1, 0]
called[3] += 1
_set_environment(t1=t1,t2=t2,t3=t3,t4=t4)
t4()
assert called == [1, 1, 1, 1]
def test_basic_command_line():
@tasks.task
def t1():
pass
_set_environment(t1=t1)
try:
tr, args = tasks._parse_command_line(['foo'])
print_(tr)
assert False, "Expected BuildFailure exception for unknown task"
except tasks.BuildFailure:
pass
task, args = tasks._parse_command_line(['t1'])
assert task == t1
task, args = tasks._parse_command_line(['t1', 't2'])
assert task == t1
assert args == ['t2']
def test_list_tasks():
from paver import doctools
@tasks.task
def t1():
pass
_set_environment(t1=t1, doctools=doctools)
task_list = tasks.environment.get_tasks()
assert t1 in task_list
assert doctools.html in task_list
def test_environment_insertion():
@tasks.task
def t1(env):
pass
_set_environment(t1=t1)
t1()
assert t1.called
def test_add_options_to_environment():
@tasks.task
def t1(options):
assert options.foo == 1
@tasks.task
def t2(options, env):
assert options.foo == 1
assert env.options == options
environment = _set_environment(t1=t1, t2=t2)
environment.options.foo = 1
t1()
t2()
assert t1.called
assert t2.called
def test_shortname_access():
environment = _set_environment(tasks=tasks)
task = environment.get_task("help")
assert task is not None
def test_longname_access():
environment = _set_environment(tasks=tasks)
task = environment.get_task("paver.tasks.help")
assert task is not None
task = environment.get_task("nosuchmodule.nosuchtask")
assert task is None
task = environment.get_task("paver.tasks.nosuchtask")
assert task is None
def test_task_command_line_options():
@tasks.task
@tasks.cmdopts([('foo=', 'f', 'Foobeedoobee!')])
def t1(options):
assert options.foo == "1"
assert options.t1.foo == "1"
environment = _set_environment(t1=t1)
tasks._process_commands(['t1', '--foo', '1'])
assert t1.called
def test_setting_of_options_with_equals():
@tasks.task
def t1(options):
assert options.foo == '1'
assert not hasattr(options, 'bar')
@tasks.task
def t2(options):
assert options.foo == '1'
assert options.bar == '2'
environment = _set_environment(t1=t1, t2=t2)
tasks._process_commands(['foo=1', 't1', 'bar=2', 't2'])
assert t1.called
assert t2.called
def test_options_inherited_via_needs():
@tasks.task
@tasks.cmdopts([('foo=', 'f', "Foo!")])
def t1(options):
assert options.t1.foo == "1"
@tasks.task
@tasks.needs('t1')
@tasks.cmdopts([('bar=', 'b', "Bar!")])
def t2(options):
assert options.t2.bar == '2'
environment = _set_environment(t1=t1, t2=t2)
tasks._process_commands("t2 --foo 1 -b 2".split())
assert t1.called
assert t2.called
def test_options_inherited_via_needs_even_from_grandparents():
@tasks.task
@tasks.cmdopts([('foo=', 'f', "Foo!")])
def t1(options):
assert options.t1.foo == "1"
@tasks.task
@tasks.needs('t1')
@tasks.cmdopts([('bar=', 'b', "Bar!")])
def t2(options):
assert options.t2.bar == '2'
@tasks.task
@tasks.needs('t2')
@tasks.cmdopts([('spam=', 's', "Spam!")])
def t3(options):
assert options.t3.spam == '3'
environment = _set_environment(t1=t1, t2=t2, t3=t3)
tasks._process_commands("t3 --foo 1 -b 2 -s 3".split())
assert t1.called
assert t2.called
assert t3.called
def test_options_shouldnt_overlap():
@tasks.task
@tasks.cmdopts([('foo=', 'f', "Foo!")])
def t1(options):
assert False
@tasks.task
@tasks.needs('t1')
@tasks.cmdopts([('force=', 'f', "Force!")])
def t2(options):
assert False
environment = _set_environment(t1=t1, t2=t2)
try:
tasks._process_commands("t2 -f 1".split())
assert False, "should have gotten a PavementError"
except tasks.PavementError:
pass
def test_options_shouldnt_overlap_when_bad_task_specified():
@tasks.task
@tasks.cmdopts([('foo=', 'f', "Foo!")])
def t1(options):
assert False
@tasks.task
@tasks.needs('t1')
@tasks.cmdopts([('force=', 'f', "Force!")], share_with=['nonexisting_task'])
def t2(options):
assert False
environment = _set_environment(t1=t1, t2=t2)
try:
tasks._process_commands("t2 -f 1".split())
assert False, "should have gotten a PavementError"
except tasks.PavementError:
pass
def test_options_may_overlap_if_explicitly_allowed():
@tasks.task
@tasks.cmdopts([('foo=', 'f', "Foo!")])
def t1(options):
assert options.t1.foo == "1"
@tasks.task
@tasks.needs('t1')
@tasks.cmdopts([('foo=', 'f', "Foo!")], share_with=['t1'])
def t2(options):
assert options.t2.foo == "1"
environment = _set_environment(t1=t1, t2=t2)
tasks._process_commands("t2 -f 1".split())
assert t1.called
assert t2.called
def test_exactly_same_parameters_must_be_specified_in_order_to_allow_sharing():
@tasks.task
@tasks.cmdopts([('foo=', 'f', "Foo!")])
def t1(options):
assert False
@tasks.task
@tasks.needs('t1')
@tasks.cmdopts([('force=', 'f', "Force!")], share_with=['t1'])
def t2(options):
assert False
environment = _set_environment(t1=t1, t2=t2)
try:
tasks._process_commands("t2 -f 1".split())
assert False, "should have gotten a PavementError"
except tasks.PavementError:
pass
def test_dest_parameter_should_map_opt_to_property():
from optparse import make_option as opt
@tasks.task
@tasks.cmdopts([opt('-f', '--force', dest='force')])
def t1(options):
assert options.force == '1'
@tasks.task
@tasks.cmdopts([opt('-f', '--force', dest='foo_force')])
def t2(options):
assert options.foo_force == '1'
environment = _set_environment(t1=t1, t2=t2)
tasks._process_commands("t1 -f 1".split())
tasks._process_commands("t2 -f 1".split())
assert t1.called
assert t2.called
def test_dotted_options():
environment = _set_environment()
tasks._process_commands(['this.is.cool=1'])
assert environment.options.this['is'].cool == '1'
def test_dry_run():
environment = _set_environment()
tasks._process_commands(['-n'])
assert environment.dry_run
def test_consume_args():
@tasks.task
@tasks.consume_args
def t1(options):
assert options.args == ["1", "t2", "3"]
@tasks.task
def t2(options):
assert False, "Should not have run t2 because of consume_args"
env = _set_environment(t1=t1, t2=t2)
tasks._process_commands("t1 1 t2 3".split())
assert t1.called
@tasks.task
@tasks.consume_args
def t3(options):
assert options.args[0] == '-v'
assert options.args[1] == '1'
env = _set_environment(t3=t3)
tasks._process_commands("t3 -v 1".split())
assert t3.called
def test_consume_nargs():
# consume all args on first task
@tasks.task
@tasks.consume_nargs()
def t11(options):
assert options.args == ["1", "t12", "3"]
@tasks.task
def t12(options):
assert False, ("Should not have run t12 because of previous "
"consume_nargs()")
env = _set_environment(t11=t11, t12=t12)
tasks._process_commands("t11 1 t12 3".split())
assert t11.called
# consume some args (specified numbers) on first and second task
@tasks.task
@tasks.consume_nargs(2)
def t21(options):
assert options.args == ["1", "2"]
@tasks.task
@tasks.consume_nargs(3)
def t22(options):
assert options.args == ["3", "4", "5"]
env = _set_environment(t21=t21, t22=t22)
tasks._process_commands("t21 1 2 t22 3 4 5".split())
assert t21.called
assert t22.called
# not enougth args consumable on called task, and other task not called
env = _set_environment(t21=t21, t12=t12)
try:
tr, args = tasks._parse_command_line("t21 t12".split())
print_(tr)
assert False, "Expected BuildFailure exception for not enougth args"
except tasks.BuildFailure:
pass
# too much args passed, and unconsumed args are not tasks
tr, args = tasks._parse_command_line("t21 1 2 3 4 5".split())
assert args == ["3", "4", "5"]
# consume some args (specified numbers) on first and all other on second task
@tasks.task
@tasks.consume_nargs(2)
def t31(options):
assert options.args == ["1", "2"]
@tasks.task
@tasks.consume_nargs()
def t32(options):
assert options.args == ["3", "4", "t33", "5"]
@tasks.task
@tasks.consume_nargs()
def t33(options):
assert False, ("Should not have run t33 because of previous "
"consume_nargs()")
env = _set_environment(t31=t31, t32=t32, t33=t33)
tasks._process_commands("t31 1 2 t32 3 4 t33 5".split())
assert t31.called
assert t32.called
def test_optional_args_in_tasks():
@tasks.task
def t1(options, optarg=None):
assert optarg is None
@tasks.task
def t2(options, optarg1='foo', optarg2='bar'):
assert optarg1 == 'foo'
assert optarg2 == 'bar'
env = _set_environment(t1=t1, t2=t2)
tasks._process_commands(['t1', 't2'])
assert t1.called
assert t2.called
def test_debug_logging():
@tasks.task
def t1(debug):
debug("Hi %s", "there")
env = _set_environment(t1=t1, patch_print=True)
tasks._process_commands(['-v', 't1'])
assert env.patch_captured[-1] == "Hi there"
env.patch_captured = []
tasks._process_commands(['t1'])
assert env.patch_captured[-1] != "Hi there"
def test_base_logging():
@tasks.task
def t1(info):
info("Hi %s", "you")
env = _set_environment(t1=t1, patch_print=True)
tasks._process_commands(['t1'])
assert env.patch_captured[-1] == 'Hi you'
env.patch_captured = []
tasks._process_commands(['-q', 't1'])
assert not env.patch_captured
def test_error_show_up_no_matter_what():
@tasks.task
def t1(error):
error("Hi %s", "error")
env = _set_environment(t1=t1, patch_print=True)
tasks._process_commands(['t1'])
assert env.patch_captured[-1] == "Hi error"
env.patch_captured = []
tasks._process_commands(['-q', 't1'])
assert env.patch_captured[-1] == "Hi error"
def test_all_messages_for_a_task_are_captured():
@tasks.task
def t1(debug, error):
debug("This is debug msg")
error("This is error msg")
raise tasks.BuildFailure("Yo, problem, yo")
env = _set_environment(t1=t1, patch_print=True)
try:
tasks._process_commands(['t1'])
except FakeExitException:
assert "This is debug msg" in "\n".join(env.patch_captured)
assert env.exit_code == 1
def test_messages_with_formatting_and_no_args_still_work():
@tasks.task
def t1(error):
error("This is a %s message")
env = _set_environment(t1=t1, patch_print=True)
tasks._process_commands(['t1'])
assert env.patch_captured[-1] == "This is a %s message"
env.patch_captured = []
tasks._process_commands(['-q', 't1'])
assert env.patch_captured[-1] == "This is a %s message"
def test_alternate_pavement_option():
env = _set_environment()
tasks._parse_global_options([])
assert env.pavement_file == 'pavement.py'
env = _set_environment()
tasks._parse_global_options(['--file=foo.py'])
set_pavement = env.pavement_file
assert set_pavement == 'foo.py'
env = _set_environment()
tasks._parse_global_options(['-f', 'foo.py'])
set_pavement = env.pavement_file
assert set_pavement == 'foo.py'
def test_captured_output_shows_up_on_exception():
@tasks.task
def t1(debug, error):
debug("Dividing by zero!")
1/0
env = _set_environment(t1=t1, patch_print=True, patch_exit=1)
try:
tasks._process_commands(['t1'])
assert False and "Expecting FakeExitException"
except FakeExitException:
assert "Dividing by zero!" in "\n".join(env.patch_captured)
assert env.exit_code == 1
def test_calling_subpavement():
@tasks.task
def private_t1(options):
options.foo = 2
tasks.call_pavement(subpavement, "t1")
# our options should not be mangled
assert options.foo == 2
env = _set_environment(private_t1=private_t1)
tasks._process_commands(['private_t1'])
# the value should be set by the other pavement, which runs
# in the same process
assert OP_T1_CALLED == 1
class MyTaskFinder(object):
def get_task(self, name):
if name == "foo":
return self.foo
return None
def get_tasks(self):
return set([self.foo])
@tasks.task
def foo(self):
self.foo_called = True
def test_task_finders():
env = _set_environment()
mtf = MyTaskFinder()
env.task_finders.append(mtf)
t = env.get_task("foo")
assert t == mtf.foo
all_tasks = env.get_tasks()
assert mtf.foo in all_tasks
def test_calling_a_function_rather_than_task():
def foo():
pass
env = _set_environment(foo=foo)
try:
tasks._process_commands(['foo'])
assert False, "Expected a BuildFailure when calling something that is not a task."
except tasks.BuildFailure:
pass
def test_depending_on_a_function_rather_than_task():
def bar():
pass
@tasks.task
@tasks.needs('bar')
def foo():
pass
env = _set_environment(foo=foo, bar=bar)
try:
tasks._process_commands(['foo'])
assert False, "Expected a BuildFailure when depending on something that is not a task."
except tasks.BuildFailure:
pass
def test_description_retrieval_trial():
@tasks.task
def t1():
""" Task it is """
assert t1.description == "Task it is"
def test_description_empty_without_docstring():
@tasks.task
def t1():
pass
assert t1.description == ""
def test_description_retrieval_first_sentence():
@tasks.task
def t1():
""" Task it is. Not with another sentence. """
assert t1.description == "Task it is"
def test_description_retrieval_first_sentence_even_with_version_numbers():
@tasks.task
def t1():
""" Task it is, installs Django 1.0. Not with another sentence. """
assert t1.description == "Task it is, installs Django 1.0"
def test_auto_task_is_not_run_with_noauto():
@tasks.no_auto
@tasks.task
def t1():
pass
@tasks.task
def auto():
pass
_set_environment(auto=auto, t1=t1)
tasks._process_commands(['t1'], auto_pending=True)
assert t1.called
assert not auto.called, "t1 is decorated with no_auto, it should not be called"
def test_auto_task_is_run_when_present():
@tasks.task
def t1():
pass
@tasks.task
def auto():
pass
_set_environment(auto=auto, t1=t1)
tasks._process_commands(['t1'], auto_pending=True)
assert t1.called
assert auto.called
def test_task_can_be_called_repeatedly():
@tasks.consume_args
@tasks.task
def t1(options, info):
info(options.args[0])
env = _set_environment(t1=t1, patch_print=True)
tasks._process_commands(['t1', 'spam'])
tasks._process_commands(['t1', 'eggs'])
assert 'eggs' == env.patch_captured[~0]
assert 'spam' == env.patch_captured[~2]
def test_options_passed_to_task():
from optparse import make_option
@tasks.task
@tasks.cmdopts([
make_option("-f", "--foo", help="foo")
])
def t1(options):
assert options.foo == "1"
assert options.t1.foo == "1"
environment = _set_environment(t1=t1)
tasks._process_commands(['t1', '--foo', '1'])
assert t1.called
# We could mock stdout/err, but seriously -- to integration test for this one
# once integration test suite is merged into master
#def test_hiding_from_help():
# @tasks.task
# @tasks.no_help
# def hidden_task(options):
# pass
#
# environment = _set_environment(hidden_task=hidden_task, help=tasks.help)
# args = tasks._parse_global_options(['-h'])
# output = tasks._process_commands(args)
#
# assert 'hidden_task' not in output
def test_calling_task_with_option_arguments():
@tasks.task
@tasks.cmdopts([('foo=', 'f', "Foo!")])
def t1(options):
assert options.foo == 'true story'
env = _set_environment(t1=t1)
env.call_task('t1', options={
'foo' : 'true story'
})
def test_calling_task_with_arguments_do_not_overwrite_it_for_other_tasks():
@tasks.task
@tasks.cmdopts([('foo=', 'f', "Foo!")])
def t3(options):
assert options.foo == 'cool story'
@tasks.task
@tasks.cmdopts([('foo=', 'f', "Foo!")])
def t2(options):
assert options.foo == 'true'
@tasks.task
@tasks.needs('t2')
def t1(options):
env.call_task('t3', options={
'foo' : 'cool story'
})
env = _set_environment(t1=t1, t2=t2, t3=t3)
tasks._process_commands(['t1', '--foo', 'true'])
def test_options_might_be_provided_if_task_might_be_called():
@tasks.task
@tasks.cmdopts([('foo=', 'f', "Foo!")])
def t1(options):
assert options.foo == "YOUHAVEBEENFOOD"
@tasks.task
@tasks.might_call('t1')
def t2(options):
pass
environment = _set_environment(t1=t1, t2=t2)
tasks._process_commands("t2 -f YOUHAVEBEENFOOD".split())
def test_calling_task_with_arguments():
@tasks.task
@tasks.consume_args
def t2(args):
assert args[0] == 'SOPA'
@tasks.task
def t1(options):
env.call_task('t2', args=['SOPA'])
env = _set_environment(t1=t1, t2=t2)
tasks._process_commands(['t1'])
def test_calling_nonconsuming_task_with_arguments():
@tasks.task
def t2():
pass
@tasks.task
def t1():
env.call_task('t2')
env = _set_environment(t1=t1, t2=t2)
try:
env.call_task('t1', args=['fail'])
except tasks.BuildFailure:
pass
else:
assert False, ("Task without @consume_args canot be called with them "
"(BuildFailure should be raised)")
def test_options_may_overlap_between_multiple_tasks_even_when_specified_in_reverse_order():
@tasks.task
@tasks.cmdopts([('foo=', 'f', "Foo!")], share_with=['t2', 't3'])
def t1(options):
assert options.t1.foo == "1"
@tasks.task
@tasks.needs('t1')
@tasks.cmdopts([('foo=', 'f', "Foo!")])
def t2(options):
assert options.t2.foo == "1"
@tasks.task
@tasks.needs('t1')
@tasks.cmdopts([('foo=', 'f', "Foo!")])
def t3(options):
assert options.t3.foo == "1"
environment = _set_environment(t1=t1, t2=t2, t3=t3)
tasks._process_commands("t2 -f 1".split())
assert t1.called
assert t2.called
tasks._process_commands("t3 -f 1".split())
assert t1.called
assert t3.called
def test_options_might_be_shared_both_way():
@tasks.task
@tasks.cmdopts([('foo=', 'f', "Foo!")], share_with=['t2'])
def t1(options):
assert options.t1.foo == "1"
@tasks.task
@tasks.needs('t1')
@tasks.cmdopts([('foo=', 'f', "Foo!")], share_with=['t1'])
def t2(options):
assert options.t2.foo == "1"
environment = _set_environment(t1=t1, t2=t2)
tasks._process_commands("t2 -f 1".split())
assert t1.called
assert t2.called
Paver-1.2.1/paver/tests/test_git.py 0000644 0001750 0001750 00000003627 12152711177 017435 0 ustar almad almad 0000000 0000000 from mock import patch
from paver import git
import os
@patch('paver.git.sh')
def test_simple_clone(sh):
git.clone("git://foo/foo.git", "bar")
assert sh.called
assert sh.call_args[0][0] == "git clone git://foo/foo.git bar"
@patch('paver.git.sh')
def test_simple_pull(sh):
git.pull("repo_path", "origin_remote", "master_branch")
assert sh.called
assert sh.call_args[0][0] == "cd repo_path; git pull origin_remote master_branch"
@patch('paver.git.sh')
def test_simple_branch_checkout(sh):
git.branch_checkout("my_branch", path="repo_path")
assert sh.called
assert sh.call_args[0][0] == "cd repo_path; git checkout my_branch"
@patch('paver.git.sh')
def test_branch_chekout_cwd(sh):
"""it should get the CWD and assume that is the repo"""
git.branch_checkout("my_branch")
assert sh.called
assert sh.call_args[0][0] == "cd %(current_path)s; git checkout my_branch" % dict(
current_path=os.getcwd()
)
@patch('paver.git.sh')
def test_branch_list_correctly_parses_git_output(sh):
output = git.branch_list(path="repo_path", __override__="""
* git_support
master
virtualenv_in_folder
""")
assert output == ("git_support", ["git_support", "master", "virtualenv_in_folder"])
@patch('paver.git.sh')
def test_branch_list_correctly_parses_remote_branch_output(sh):
output = git.branch_list(path="repo_path",
remote_branches_only = True,
__override__="""
github/gh-pages
github/git_support
github/master""")
assert output == ('',
["github/gh-pages", "github/git_support", "github/master"])
@patch('paver.git.sh')
def test_branch_track_remote(sh):
git.branch_track_remote("origin/alpha_two", path="repo_path")
assert sh.called
assert sh.call_args[0][0] == "cd %(current_path)s; git checkout -b alpha_two --track origin/alpha_two" % dict(
current_path="repo_path"
)
Paver-1.2.1/paver/tests/test_path.py 0000644 0001750 0001750 00000001421 12152711177 017574 0 ustar almad almad 0000000 0000000 # -*- coding: utf-8 -*-
import paver.path
import sys
import os.path
def test_join_on_unicode_path():
# This is why we should drop 2.5 asap :]
# b'' strings are not supported in 2.5, while u'' string are not supported in 3.2
# -- even syntactically, so if will not help you here
if sys.version_info[0] < 3:
expected = 'something/\xc3\xb6'
unicode_o = '\xc3\xb6'.decode('utf-8')
# path.py on py2 is inheriting from str instead of unicode under this
# circumstances, therefore we have to expect string
if os.path.supports_unicode_filenames:
expected.decode('utf-8')
else:
expected = 'something/ö'
unicode_o = 'ö'
assert expected == os.path.join(paver.path.path('something'), unicode_o)
Paver-1.2.1/paver/easy.py 0000644 0001750 0001750 00000007160 12152711177 015406 0 ustar almad almad 0000000 0000000 import subprocess
import sys
from paver import tasks
#needed for paver.easy.* import
from paver.options import Bunch
def dry(message, func, *args, **kw):
"""Wraps a function that performs a destructive operation, so that
nothing will happen when a dry run is requested.
Runs func with the given arguments and keyword arguments. If this
is a dry run, print the message rather than running the function."""
if message is not None:
info(message)
if tasks.environment.dry_run:
return
return func(*args, **kw)
def error(message, *args):
"""Displays an error message to the user."""
tasks.environment.error(message, *args)
def info(message, *args):
"""Displays a message to the user. If the quiet option is specified, the
message will not be displayed."""
tasks.environment.info(message, *args)
def debug(message, *args):
"""Displays a message to the user, but only if the verbose flag is
set."""
tasks.environment.debug(message, *args)
def sh(command, capture=False, ignore_error=False, cwd=None):
"""Runs an external command. If capture is True, the output of the
command will be captured and returned as a string. If the command
has a non-zero return code raise a BuildFailure. You can pass
ignore_error=True to allow non-zero return codes to be allowed to
pass silently, silently into the night. If you pass cwd='some/path'
paver will chdir to 'some/path' before exectuting the command.
If the dry_run option is True, the command will not
actually be run."""
def runpipe():
kwargs = { 'shell': True, 'cwd': cwd}
if capture:
kwargs['stderr'] = subprocess.STDOUT
kwargs['stdout'] = subprocess.PIPE
p = subprocess.Popen(command, **kwargs)
p_stdout = p.communicate()[0]
if p_stdout is not None:
p_stdout = p_stdout.decode(sys.getdefaultencoding(), 'ignore')
if p.returncode and not ignore_error:
if capture and p_stdout is not None:
error(p_stdout)
raise BuildFailure("Subprocess return code: %d" % p.returncode)
if capture:
return p_stdout
return dry(command, runpipe)
class _SimpleProxy(object):
__initialized = False
def __init__(self, rootobj, name):
self.__rootobj = rootobj
self.__name = name
self.__initialized = True
def __get_object(self):
return getattr(self.__rootobj, self.__name)
def __getattr__(self, attr):
return getattr(self.__get_object(), attr)
def __setattr__(self, attr, value):
if self.__initialized:
setattr(self.__get_object(), attr, value)
else:
super(_SimpleProxy, self).__setattr__(attr, value)
def __call__(self, *args, **kw):
return self.__get_object()(*args, **kw)
def __str__(self):
return str(self.__get_object())
def __repr__(self):
return repr(self.__get_object())
environment = _SimpleProxy(tasks, "environment")
options = _SimpleProxy(environment, "options")
call_task = _SimpleProxy(environment, "call_task")
call_pavement = tasks.call_pavement
task = tasks.task
needs = tasks.needs
might_call = tasks.might_call
cmdopts = tasks.cmdopts
consume_args = tasks.consume_args
consume_nargs = tasks.consume_nargs
no_auto = tasks.no_auto
no_help = tasks.no_help
BuildFailure = tasks.BuildFailure
PavementError = tasks.PavementError
# these are down here to avoid circular dependencies. Ideally, nothing would
# be using paver.easy other than pavements.
from paver.path import path, pushd
import paver.misctasks
Paver-1.2.1/paver/release.py 0000644 0001750 0001750 00000003233 12152711177 016062 0 ustar almad almad 0000000 0000000 """Release metadata for Paver."""
from paver.options import Bunch
from paver.tasks import VERSION
setup_meta=Bunch(
name='Paver',
version=VERSION,
description='Easy build, distribution and deployment scripting',
long_description="""Paver is a Python-based build/distribution/deployment scripting tool along the
lines of Make or Rake. What makes Paver unique is its integration with
commonly used Python libraries. Common tasks that were easy before remain
easy. More importantly, dealing with *your* applications specific needs and
requirements is also easy.""",
author='Kevin Dangoor',
author_email='dangoor+paver@gmail.com',
maintainer='Lukas Linhart',
maintainer_email='bugs@almad.net',
url='http://github.com/paver/paver',
packages=['paver', 'paver.deps'],
tests_require=['nose', 'virtualenv', 'mock', 'cogapp'],
classifiers=[
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.5",
"Programming Language :: Python :: 2.6",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.2",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: Implementation :: CPython",
"Environment :: Console",
"Topic :: Documentation",
"Topic :: Utilities",
"Topic :: Software Development :: Build Tools",
])
Paver-1.2.1/paver/tasks.py 0000644 0001750 0001750 00000071676 12152711177 015607 0 ustar almad almad 0000000 0000000 from __future__ import with_statement
import sys
import os
import copy
import optparse
import re
import types
import inspect
import itertools
import traceback
from os.path import *
import paver.deps.six as six
from paver.deps.six import print_
from paver.version import VERSION
# using six.moves is complicated because we include it and it's thus not at
# the top level
if six.PY3:
xrange = range
class PavementError(Exception):
"""Exception that represents a problem in the pavement.py file
rather than the process of running a build."""
pass
class BuildFailure(Exception):
"""Represents a problem with some part of the build's execution."""
pass
class Environment(object):
_task_in_progress = None
_task_output = None
_all_tasks = None
_dry_run = False
verbose = False
interactive = False
quiet = False
_file = "pavement.py"
def __init__(self, pavement=None):
self.pavement = pavement
self.task_finders = []
try:
# for the time being, at least, tasks.py can be used on its
# own!
from paver import options
self.options = options.Namespace()
self.options.dry_run = False
self.options.pavement_file = self.pavement_file
except ImportError:
pass
def info(self, message, *args):
self._log(2, message, args)
def debug(self, message, *args):
self._log(1, message, args)
def error(self, message, *args):
self._log(3, message, args)
def _log(self, level, message, args):
# This conditional fixes an issue which arises if the message contains
# formatting directives but no args are provided.
if args:
output = message % args
else:
output = message
if self._task_output is not None:
self._task_output.append(output)
if level > 2 or (level > 1 and not self.quiet) or \
self.verbose:
self._print(output)
def _print(self, output):
print_(output)
sys.stdout.flush()
def _exit(self, code):
sys.exit(1)
def _set_dry_run(self, dr):
self._dry_run = dr
try:
self.options.dry_run = dr
except AttributeError:
pass
def _get_dry_run(self):
return self._dry_run
dry_run = property(_get_dry_run, _set_dry_run)
def _set_pavement_file(self, pavement_file):
self._file = pavement_file
try:
self.options.pavement_file = pavement_file
except AttributeError:
pass
def _get_pavement_file(self):
return self._file
pavement_file = property(_get_pavement_file, _set_pavement_file)
file = property(fset=_set_pavement_file)
def get_task(self, taskname):
task = getattr(self.pavement, taskname, None)
# delegate to task finders next
if not task:
for finder in self.task_finders:
task = finder.get_task(taskname)
if task:
break
# try to look up by full name
if not task:
task = _import_task(taskname)
# if there's nothing by full name, look up by
# short name
if not task:
all_tasks = self.get_tasks()
matches = [t for t in all_tasks
if t.shortname == taskname]
if len(matches) > 1:
matched_names = [t.name for t in matches]
raise BuildFailure("Ambiguous task name %s (%s)" %
(taskname, matched_names))
elif matches:
task = matches[0]
return task
def call_task(self, task_name, args=None, options=None):
task = self.get_task(task_name)
if hasattr(task, 'paver_constraint'):
task.paver_constraint()
if options:
for option in options:
task._set_value_to_task(task_name, option, None, options[option])
if args and task.consume_args > 0:
args = _consume_nargs(task, args)
elif args and (task.consume_args == 0):
raise BuildFailure("Task %s is not decorated with @consume_(n)args,"
"but has been called with them")
task()
def _run_task(self, task_name, needs, func):
(funcargs, varargs, varkw, defaults) = inspect.getargspec(func)
kw = dict()
for i in xrange(0, len(funcargs)):
arg = funcargs[i]
if arg == 'env':
kw['env'] = self
# Keyword arguments do now need to be in the environment
elif (defaults is not None and
(i - (len(funcargs) - len(defaults))) >= 0):
pass
else:
try:
kw[arg] = getattr(self, arg)
except AttributeError:
raise PavementError("Task %s requires an argument (%s) that is "
"not present in the environment" % (task_name, arg))
if not self._task_in_progress:
self._task_in_progress = task_name
self._task_output = []
running_top_level = True
else:
running_top_level = False
def do_task():
self.info("---> " + task_name)
for req in needs:
task = self.get_task(req)
if not task:
raise PavementError("Requirement %s for task %s not found" %
(req, task_name))
if not isinstance(task, Task):
raise PavementError("Requirement %s for task %s is not a Task"
% (req, task_name))
if not task.called:
task()
return func(**kw)
if running_top_level:
try:
return do_task()
except Exception:
e = sys.exc_info()[1]
self._print("""
Captured Task Output:
---------------------
""")
self._print("\n".join(map(str, self._task_output)))
if isinstance(e, BuildFailure):
self._print("\nBuild failed running %s: %s" %
(self._task_in_progress, e))
else:
self._print(traceback.format_exc())
self._task_in_progress = None
self._task_output = None
self._exit(1)
else:
return do_task()
def get_tasks(self):
if self._all_tasks:
return self._all_tasks
result = set()
modules = set()
def scan_module(module):
modules.add(module)
for name in dir(module):
item = getattr(module, name, None)
if isinstance(item, Task):
result.add(item)
if isinstance(item, types.ModuleType) and item not in modules:
scan_module(item)
scan_module(self.pavement)
for finder in self.task_finders:
result.update(finder.get_tasks())
self._all_tasks = result
return result
environment_stack = []
environment = Environment()
def _consume_nargs(task, args):
"""Set up args in environment function of number of args task consumes.
"""
if task.consume_args > 0:
if (args is None) or (task.consume_args != float('inf') and \
(len(args) < task.consume_args)):
args_consumed = ""
if task.consume_args == float('inf'):
args_consumed = "all arguments"
else:
args_consumed = "exactly %i argument" % task.consume_args
args_consumed += "s" if (task.consume_args > 1) else ""
args_passed = "none" if args is None \
else "got only %i" % len(args)
raise BuildFailure("%s consumes %s, %s" % \
(task.name, args_consumed, args_passed))
_args = args if task.consume_args == float('inf') \
else args[:task.consume_args]
try:
environment.options.args = _args
except AttributeError:
pass
environment.args = _args
return [] if task.consume_args == float('inf') \
else args[task.consume_args:]
def _import_task(taskname):
"""Looks up a dotted task name and imports the module as necessary
to get at the task."""
parts = taskname.split('.')
if len(parts) < 2:
return None
func_name = parts[-1]
full_mod_name = ".".join(parts[:-1])
mod_name = parts[-2]
try:
module = __import__(full_mod_name, globals(), locals(), [mod_name])
except ImportError:
return None
return getattr(module, func_name, None)
class Task(object):
called = False
consume_args = 0
no_auto = False
__doc__ = ""
def __init__(self, func):
super(Task, self).__init__()
self.func = func
self.needs = []
self.might_call = []
self.__name__ = func.__name__
self.shortname = func.__name__
self.name = "%s.%s" % (func.__module__, func.__name__)
self.option_names = set()
self.user_options = []
self.negative_opt = {}
self.share_options_with = []
self._parser = None
self.use_virtualenv = None
self.virtualenv_dir = None
try:
self.__doc__ = func.__doc__
except AttributeError:
pass
def __call__(self, *args, **kw):
if self.use_virtualenv and self.virtualenv_dir:
#TODO: Environment recovery?
activate_this = join(self.virtualenv_dir, "bin", "activate_this.py")
with open(activate_this) as f:
s = f.read()
code = compile(s, activate_this, 'exec')
exec(code, dict(__file__=activate_this))
retval = environment._run_task(self.name, self.needs, self.func)
self.called = True
return retval
def __repr__(self):
return "Task: " + self.__name__
def _make_option_from_tuple(self, option):
# option is (longname, short, desc)
longname = option[0]
if longname and longname.endswith('='):
action = "store"
longname = longname[:-1]
else:
action = "store_true"
destination = longname.replace('-', '_')
opts = []
if option[1]:
opts.append('-' + option[1])
if longname:
opts.append('--' + longname)
return optparse.make_option(*opts,
**dict(action=action, dest=destination, help=option[2]))
@property
def parser(self):
if getattr(self, '_parser', None):
return self._parser
self._parser = parser = optparse.OptionParser(add_help_option=False,
usage="%%prog %s [options]" % self.name)
parser.disable_interspersed_args()
parser.add_option('-h', '--help', action="store_true",
help="display this help information")
needs_tasks = [(environment.get_task(task), task) for task in self.needs_closure]
# backward compatibility: tasks that inherit from Task and override constructor
if getattr(self, "might_call", None):
needs_tasks.extend((environment.get_task(task), task) for task in self.might_call)
shared_tasks = {}
parser.mirrored_options = {}
parser.options_to_hide_from_help = []
for task, task_name in itertools.chain([(self, self.name)], needs_tasks):
if not task:
raise PavementError("Task %s needed by %s does not exist"
% (task_name, self))
for option in task.user_options:
add_options = True
try:
if not isinstance(option, optparse.Option):
option = self._make_option_from_tuple(option)
environment.debug("Task %s: adding option %s" %
(self.name, str(option)))
try:
longname = option._long_opts[0]
except IndexError:
longname = None
try:
shortname = option._short_opts[0]
except IndexError:
shortname = None
# XXX: this probably needs refactored to handle commands with multiple
# long or short options
task_share_options_with = task.share_options_with or []
task_shares = [environment.get_task(t).name for t in task_share_options_with if environment.get_task(t)]
if self.share_options_with or task_shares:
options = (shortname, longname)
# either I am sharing with dependent task
# ...or it can share with me
if (
options in shared_tasks and (shared_tasks[options] or self.share_options_with)
) \
or \
(
self.name in [environment.get_task(t).name for t in task_share_options_with if environment.get_task(t)]
):
environment.debug("Task %s: NOT adding option %s," \
"already present; setting up mirror" %
(self.name, option))
if option.dest not in parser.mirrored_options:
parser.mirrored_options[option.dest] = []
parser.mirrored_options[option.dest].append(task_name)
add_options = False
if options not in shared_tasks:
shared_tasks[options] = set()
if task_share_options_with:
shared_tasks[options] |= set(task_share_options_with)
if add_options:
try:
parser.add_option(option)
except optparse.OptionConflictError:
raise PavementError("""In setting command options for %r,
option %s for %r is already in use
by another task in the dependency chain.""" % (self, option, task))
# add just names; longname now contains --initial-dashes
self.option_names.add((task.shortname, longname[2:], option.dest))
if getattr(task, 'no_help', False):
if shortname:
parser.options_to_hide_from_help.append(shortname)
elif longname:
parser.options_to_hide_from_help.append(longname)
except IndexError:
raise PavementError("Invalid option format provided for %r: %s"
% (self, option))
return parser
def display_help(self, parser=None):
if not parser:
parser = self.parser
for opt_str in parser.options_to_hide_from_help:
try:
parser.remove_option(opt_str)
except ValueError:
environment.error("Option %s added for hiding, but it's not in parser...?" % opt_str)
name = self.name
print_("\n%s" % name)
print_("-" * len(name))
parser.print_help()
print_()
print_(self.__doc__)
print_()
def _set_value_to_task(self, task_name, option_name, dist_option_name, value):
import paver.options
try:
optholder = environment.options[task_name]
except KeyError:
optholder = paver.options.Bunch()
environment.options[task_name] = optholder
if value is not None:
if dist_option_name in getattr(self, "negative_opt"):
optholder[self.negative_opt[dist_option_name].replace('-', '_')] = False
else:
optholder[option_name] = value
def parse_args(self, args):
import paver.options
environment.debug("Task %s: Parsing args %s" % (self.name, args))
environment.options.setdefault(self.shortname, paver.options.Bunch())
parser = self.parser
options, args = parser.parse_args(args)
if options.help:
self.display_help(parser)
sys.exit(0)
for task_name, option_name, option_dest in self.option_names:
if option_name != option_dest:
dist_option_name = copy.copy(option_name)
option_name = option_dest
else:
dist_option_name = option_name
option_name = option_name.replace('-', '_')
value = getattr(options, option_name, getattr(options, option_dest))
self._set_value_to_task(task_name, option_name, dist_option_name, value)
if option_name in parser.mirrored_options:
for task_name in parser.mirrored_options[option_name]:
self._set_value_to_task(task_name, option_name, dist_option_name, value)
return args
@property
def description(self):
if self.__doc__:
return re.split("\.\s+", self.__doc__, maxsplit=1)[0].strip()
else:
return ""
@property
def needs_closure(self):
stack = [] + self.needs
rv = []
while stack:
top = stack.pop()
if top not in rv:
rv.append(top)
needs = []
if environment.get_task(top):
deptask = environment.get_task(top)
if not isinstance(deptask, Task):
raise BuildFailure("Dependency %s is not a Task (only tasks allowed in @needs)" % deptask)
needs = deptask.needs
for t in needs:
stack.append(t)
return rv
def task(func):
"""Specifies that this function is a task.
Note that this decorator does not actually replace the function object.
It just keeps track of the task and sets an is_task flag on the
function object."""
if isinstance(func, Task):
return func
task = Task(func)
return task
def needs(*args):
"""Specifies tasks upon which this task depends.
req can be a string or a list of strings with the names
of the tasks. You can call this decorator multiple times
and the various requirements are added on. You can also
call with the requirements as a list of arguments.
The requirements are called in the order presented in the
list."""
def entangle(func):
req = args
func = task(func)
needs_list = func.needs
if len(req) == 1:
req = req[0]
if isinstance(req, six.string_types):
needs_list.append(req)
elif isinstance(req, (list, tuple)):
needs_list.extend(req)
else:
raise PavementError("'needs' decorator requires a list or string "
"but got %s" % req)
return func
return entangle
def cmdopts(options, share_with=None):
"""Sets the command line options that can be set for this task.
This uses the same format as the distutils command line option
parser. It's a list of tuples, each with three elements:
long option name, short option, description.
If the long option name ends with '=', that means that the
option takes a value. Otherwise the option is just boolean.
All of the options will be stored in the options dict with
the name of the task. Each value that gets stored in that
dict will be stored with a key that is based on the long option
name (the only difference is that - is replaced by _).
"""
def entangle(func):
func = task(func)
func.user_options = options
func.share_options_with = share_with
return func
return entangle
def might_call(*args):
"""
"""
def entangle(func):
req = args
func = task(func)
might_call = func.might_call
if len(req) == 1:
req = req[0]
if isinstance(req, six.string_types):
might_call.append(req)
elif isinstance(req, (list, tuple)):
might_call.extend(req)
else:
raise PavementError("'might_call' decorator requires a list or string "
"but got %s" % req)
return func
return entangle
def consume_nargs(nb_args=None):
"""All specified command line arguments that appear after this task on the
command line will be placed in options.args.
By default, if :data:`nb_args` is not specified, all arguments will
be consumed.
:param nb_args: number of arguments the decorated function consumes
:type nb_args: ``int``
"""
def consume_args_wrapper(func):
func = task(func)
func.consume_args = nb_args if nb_args is not None else float('inf')
return func
return consume_args_wrapper
def consume_args(func):
"""Any command line arguments that appear after this task on the
command line will be placed in options.args."""
return consume_nargs()(func)
def no_auto(func):
"""Specify that this task does not depend on the auto task,
and don't run the auto task just for this one."""
func = task(func)
func.no_auto = True
return func
def no_help(func):
"""Do not show this task in paver help."""
func = task(func)
func.no_help = True
return func
def _preparse(args):
task = None
taskname = None
while args:
arg = args.pop(0)
if '=' in arg:
key, value = arg.split("=")
try:
environment.options.setdotted(key, value)
except AttributeError:
raise BuildFailure("""This appears to be a standalone Paver
tasks.py, so the build environment does not support options. The command
line (%s) attempts to set an option.""" % (args))
elif arg.startswith('-'):
args.insert(0, arg)
break
else:
taskname = arg
task = environment.get_task(taskname)
if task is None:
raise BuildFailure("Unknown task: %s" % taskname)
break
return task, taskname, args
def _parse_global_options(args):
# this is where global options should be dealt with
parser = optparse.OptionParser(usage=
"""Usage: %prog [global options] taskname [task options] """
"""[taskname [taskoptions]]""", version="Paver %s" % (VERSION),
add_help_option=False)
environment.help_function = parser.print_help
parser.add_option('-n', '--dry-run', action='store_true',
help="don't actually do anything")
parser.add_option('-v', "--verbose", action="store_true",
help="display all logging output")
parser.add_option('-q', '--quiet', action="store_true",
help="display only errors")
parser.add_option("-i", "--interactive", action="store_true",
help="enable prompting")
parser.add_option("-f", "--file", metavar="FILE",
help="read tasks from FILE [%default]")
parser.add_option('-h', "--help", action="store_true",
help="display this help information")
parser.add_option("--propagate-traceback", action="store_true",
help="propagate traceback, do not hide it under BuildFailure"
"(for debugging)")
parser.set_defaults(file=environment.pavement_file)
parser.disable_interspersed_args()
options, args = parser.parse_args(args)
if options.help:
args.insert(0, "help")
for key, value in vars(options).items():
setattr(environment, key, value)
return args
def _parse_command_line(args):
task, taskname, args = _preparse(args)
if not task:
args = _parse_global_options(args)
if not args:
return None, []
taskname = args.pop(0)
task = environment.get_task(taskname)
if not task:
raise BuildFailure("Unknown task: %s" % taskname)
if not isinstance(task, Task):
raise BuildFailure("%s is not a Task" % taskname)
if task.consume_args > 0:
args = _consume_nargs(task, args)
else:
args = task.parse_args(args)
return task, args
def _cmp_task_names(a, b):
a = a.name
b = b.name
a_in_pavement = a.startswith("pavement.")
b_in_pavement = b.startswith("pavement.")
if a_in_pavement and not b_in_pavement:
return 1
if b_in_pavement and not a_in_pavement:
return -1
# trick taken from python3porting.org
return (a > b) - (b < a)
if six.PY3:
import functools
_task_names_key = functools.cmp_to_key(_cmp_task_names)
def _group_by_module(items):
groups = []
current_group_name = None
current_group = None
maxlen = 5
for item in items:
name = item.name
dotpos = name.rfind(".")
group_name = name[:dotpos]
maxlen = max(len(item.shortname), maxlen)
if current_group_name != group_name:
current_group = []
current_group_name = group_name
groups.append([group_name, current_group])
current_group.append(item)
return maxlen, groups
@task
@no_auto
@consume_args
def help(args, help_function):
"""This help display."""
if args:
task_name = args[0]
task = environment.get_task(task_name)
if not task:
print_("Task not found: %s" % (task_name))
return
task.display_help()
return
help_function()
task_list = environment.get_tasks()
if six.PY3:
task_list = sorted(task_list, key=_task_names_key)
else:
task_list = sorted(task_list, cmp=_cmp_task_names)
maxlen, task_list = _group_by_module(task_list)
fmt = " %-" + str(maxlen) + "s - %s"
for group_name, group in task_list:
print_("\nTasks from %s:" % (group_name))
for task in group:
if not getattr(task, "no_help", False):
print_(fmt % (task.shortname, task.description))
def _process_commands(args, auto_pending=False):
first_loop = True
while True:
task, args = _parse_command_line(args)
if auto_pending:
if task and not task.no_auto:
environment.call_task('auto')
auto_pending=False
if task is None:
if first_loop:
task = environment.get_task('default')
if not task:
break
else:
break
task()
first_loop = False
def call_pavement(new_pavement, args):
if isinstance(args, six.string_types):
args = args.split()
global environment
environment_stack.append(environment)
environment = Environment()
cwd = os.getcwd()
dirname, basename = split(new_pavement)
environment.pavement_file = basename
try:
if dirname:
os.chdir(dirname)
_launch_pavement(args)
finally:
os.chdir(cwd)
environment = environment_stack.pop()
def _launch_pavement(args):
mod = types.ModuleType("pavement")
environment.pavement = mod
if not exists(environment.pavement_file):
environment.pavement_file = None
six.exec_("from paver.easy import *\n", mod.__dict__)
_process_commands(args)
return
mod.__file__ = environment.pavement_file
try:
pf = open(environment.pavement_file)
try:
source = pf.read()
finally:
pf.close()
exec(compile(source, environment.pavement_file, 'exec'), mod.__dict__)
auto_task = getattr(mod, 'auto', None)
auto_pending = isinstance(auto_task, Task)
from paver.misctasks import generate_setup, minilib
resident_tasks = {
'help': help,
'generate_setup': generate_setup,
'minilib': minilib,
}
mod.__dict__.update(resident_tasks)
_process_commands(args, auto_pending=auto_pending)
except PavementError:
e = sys.exc_info()[1]
# this is hacky, but it is needed if problem would occur within
# argument parsing, which is actually quite common
if getattr(environment.options, "propagate_traceback", False) \
or '--propagate-traceback' in args:
raise
print_("\n\n*** Problem with pavement:\n%s\n%s\n\n" % (
abspath(environment.pavement_file), e))
def main(args=None):
global environment
if args is None:
args = sys.argv[1:]
environment = Environment()
# need to parse args to recover pavement-file to read before executing
try:
args = _parse_global_options(args)
_launch_pavement(args)
except BuildFailure:
e = sys.exc_info()[1]
environment.error("Build failed: %s", e)
sys.exit(1)
Paver-1.2.1/paver/version.py 0000644 0001750 0001750 00000000020 12152711177 016116 0 ustar almad almad 0000000 0000000 VERSION='1.2.1'
Paver-1.2.1/paver/misctasks.py 0000644 0001750 0001750 00000006764 12152711177 016457 0 ustar almad almad 0000000 0000000 """Miscellaneous tasks that don't fit into one of the other groupings."""
import pkgutil
import zipfile
import paver.deps.six as six
from os.path import join, dirname, exists, abspath
from paver.easy import dry, task
from paver.tasks import VERSION, cmdopts
_docsdir = join(dirname(__file__), "docs")
if exists(_docsdir):
@task
def paverdocs():
"""Open your web browser and display Paver's documentation."""
import webbrowser
webbrowser.open("file://%s" % join(abspath(_docsdir), 'index.html') )
@task
@cmdopts([('versioned_name', '', 'Determine if minilib uses version in its name')],
share_with=['generate_setup'])
def minilib(options):
"""Create a Paver mini library that contains enough for a simple
pavement.py to be installed using a generated setup.py. This
is a good temporary measure until more people have deployed paver.
The output file is 'paver-minilib.zip' in the current directory.
Options:
versioned_name
if set to True, paver version will be added into minilib's filename
(ie paver-minilib-1.1.0.zip)
purpose is to avoid import error while using different versions of minilib
with easy_install
(default False)
extra_files
list of other paver modules to include (don't include the .py
extension). By default, the following modules are included:
defaults, path, release, setuputils, misctasks, options,
tasks, easy
"""
filelist = ['__init__', 'defaults', 'release', 'path',
'setuputils', "misctasks", "options", "tasks", "easy",
'deps/__init__', 'deps/path2', 'deps/path3', 'deps/six']
filelist.extend(options.get('extra_files', []))
output_version = ""
if 'versioned_name' in options:
output_version = "-%s" % VERSION
output_file = 'paver-minilib%s.zip' % output_version
def generate_zip():
# Write the mini library to a buffer.
buf = six.BytesIO()
destfile = zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED)
for filename in filelist:
destfile.writestr("paver/%s.py" % filename,
pkgutil.get_data('paver', "%s.py" % filename))
destfile.close()
# Write the buffer to disk.
f = open(output_file, "wb")
f.write(buf.getvalue())
f.close()
dry("Generate %s" % output_file, generate_zip)
@task
@cmdopts([('versioned_name', '', 'Determine if setup refers to minilib with version in its name')],
share_with=['minilib'])
def generate_setup(options):
"""Generates a setup.py file that uses paver behind the scenes. This
setup.py file will look in the directory that the user is running it
in for a paver-minilib.zip and will add that to sys.path if available.
Otherwise, it will just assume that paver is available."""
if 'versioned_name' in options:
minilib_name = "paver-minilib-%s.zip" % VERSION
is_versioned_msg = ', referring versioned minilib: %s' % minilib_name
else:
is_versioned_msg = ""
minilib_name = 'paver-minilib.zip'
def write_setup():
setup = open("setup.py", "w")
setup.write("""try:
import paver.tasks
except ImportError:
from os.path import exists
if exists("%(minilib_name)s"):
import sys
sys.path.insert(0, "%(minilib_name)s")
import paver.tasks
paver.tasks.main()
""" % {'minilib_name': minilib_name})
setup.close()
dry("Write setup.py%s" % is_versioned_msg, write_setup)
Paver-1.2.1/paver/bzr.py 0000644 0001750 0001750 00000003435 12152711177 015243 0 ustar almad almad 0000000 0000000 """Convenience functions for working with bzr.
This module does not include any tasks, only functions."""
import sys
if sys.version_info[0] == 3:
raise ImportError("Bazaar-NG is not available for Python 3")
from paver.options import Bunch
from bzrlib.builtins import cmd_branch, cmd_checkout, cmd_update, cmd_pull, cmd_version_info
from StringIO import StringIO
__all__ = ["checkout", "update", "branch", "pull", "info"]
def do_bzr_cmd(cmd_class, output=True, **kwarg):
if output:
import bzrlib.ui
from bzrlib.ui.text import TextUIFactory
bzrlib.ui.ui_factory = TextUIFactory()
cmd = cmd_class()
if output:
cmd._setup_outf()
else:
cmd.outf = StringIO()
cmd.run(**kwarg)
return cmd.outf
def checkout(url, dest, revision=None):
"""Checkout from the URL to the destination."""
do_bzr_cmd(cmd_checkout, branch_location=url, to_location=dest, revision=revision)
def update(path='.'):
"""Update the given path."""
do_bzr_cmd(cmd_update, dir=path)
def branch(url, dest, revision=None):
"""Branch from the given URL to the destination."""
do_bzr_cmd(cmd_branch, from_location=url, to_location=dest, revision=revision)
def pull(url, revision=None):
"""Pull from the given URL at the optional revision."""
do_bzr_cmd(cmd_pull, location=url, revision=revision)
def info(location=None):
"""Retrieve the info at location."""
data = Bunch()
sio = do_bzr_cmd(cmd_version_info, False, location=location)
sio.seek(0)
for line in sio.readlines():
if not ":" in line:
continue
key, value = line.split(":", 1)
key = key.lower().replace(" ", "_").replace("-", "_")
data[key] = value.strip()
return data
Paver-1.2.1/paver/defaults.py 0000644 0001750 0001750 00000001036 12152711177 016250 0 ustar almad almad 0000000 0000000 """The namespace for the pavement to run in, also imports default tasks."""
import warnings
warnings.warn("""paver.defaults is deprecated. Import from paver.easy instead.
Note that you will need to add additional declarations for exactly
equivalent behavior. Specifically:
from paver.easy import *
import paver.misctasks
from paver import setuputils
setuputils.install_distutils_tasks()
""", DeprecationWarning, 2)
from paver.easy import *
from paver.misctasks import *
from paver import setuputils
setuputils.install_distutils_tasks()
Paver-1.2.1/paver/ssh.py 0000644 0001750 0001750 00000000407 12152711177 015237 0 ustar almad almad 0000000 0000000 """Functions for accessing remote hosts.
At present, these are implemented by calling ssh's command line programs.
"""
from paver.easy import sh
def scp(source, dest):
"""Copy the source file to the destination."""
sh("scp %s %s" % (source, dest))
Paver-1.2.1/paver/runtime.py 0000644 0001750 0001750 00000003051 12152711177 016123 0 ustar almad almad 0000000 0000000 """Helper functions and data structures used by pavements."""
import warnings
warnings.warn("Import from paver.easy instead of paver.runtime",
DeprecationWarning, 2)
from paver.easy import *
__all__ = ["Bunch", "task", "Task", "needs", "dry", "error",
"info", "debug", "call_task", "require_keys", "sh", "options",
"BuildFailure", "PavementError", "path", 'cmdopts', "consume_args"]
def call_task(task_name, options=None):
"""DEPRECATED. Just call the task instead.
Calls the desired task, including any tasks upon which that task
depends. options is an optional dictionary that will be added
to the option lookup search order.
You can always call a task directly by calling the function directly.
But, if you do so the dependencies aren't called. call_task ensures
that these are called.
Note that call_task will only call the task `once` during a given
build as long as the options remain the same. If the options are
changed, the task will be called again."""
warnings.warn("Just call the function instead of using call_task",
DeprecationWarning, 2)
task = environment.get_task(task_name)
task()
def require_keys(keys):
"""GONE. There is no equivalent in Paver 1.0. Calling this
will raise an exception.
A set of dotted-notation keys that must be present in the
options for this task to be relevant.
"""
raise PavementError("require_keys is no longer available.")
class PaverImportError(ImportError):
pass
Paver-1.2.1/paver/options.py 0000644 0001750 0001750 00000012661 12152711177 016142 0 ustar almad almad 0000000 0000000 class OptionsError(Exception):
pass
class Bunch(dict):
"""A dictionary that provides attribute-style access."""
def __repr__(self):
keys = list(self.keys())
keys.sort()
args = ', '.join(['%s=%r' % (key, self[key]) for key in keys])
return '%s(%s)' % (self.__class__.__name__, args)
def __getitem__(self, key):
item = dict.__getitem__(self, key)
if callable(item):
return item()
return item
def __getattr__(self, name):
try:
return self[name]
except KeyError:
raise AttributeError(name)
__setattr__ = dict.__setitem__
def __delattr__(self, name):
try:
del self[name]
except KeyError:
raise AttributeError(name)
class Namespace(Bunch):
"""A Bunch that will search dictionaries contained within to find a value.
The search order is set via the order() method. See the order method for
more information about search order.
"""
def __init__(self, d=None, **kw):
self._sections = []
self._ordering = None
self.update(d, **kw)
def order(self, *keys, **kw):
"""Set the search order for this namespace. The arguments
should be the list of keys in the order you wish to search,
or a dictionary/Bunch that you want to search.
Keys that are left out will not be searched. If you pass in
no arguments, then the default ordering will be used. (The default
is to search the global space first, then in the order in
which the sections were created.)
If you pass in a key name that is not a section, that
key will be silently removed from the list.
Keyword arguments are:
add_rest=False
put the sections you list at the front of the search
and add the remaining sections to the end
"""
if not keys:
self._ordering = None
return
order = []
for item in keys:
if isinstance(item, dict) or item in self._sections:
order.append(item)
if kw.get('add_rest'):
# this is not efficient. do we care? probably not.
for item in self._sections:
if item not in order:
order.append(item)
self._ordering = order
def clear(self):
self._ordering = None
self._sections = []
super(Namespace, self).clear()
def setdotted(self, key, value):
"""Sets a namespace key, value pair where the key
can use dotted notation to set sub-values. For example,
the key "foo.bar" will set the "bar" value in the "foo"
Bunch in this Namespace. If foo does not exist, it is created
as a Bunch. If foo is a value, an OptionsError will be
raised."""
segments = key.split(".")
obj = self
segment = segments.pop(0)
while segments:
if segment not in obj:
obj[segment] = Bunch()
obj = obj[segment]
if not isinstance(obj, dict):
raise OptionsError("In setting option '%s', %s was already a value"
% (key, segment))
segment = segments.pop(0)
obj[segment] = value
def __setitem__(self, key, value):
if isinstance(value, dict):
self._sections.insert(0, key)
super(Namespace, self).__setitem__(key, value)
def get(self, key, default=None):
try:
return self[key]
except KeyError:
return default
def __getitem__(self, key):
order = self._ordering
if order is None:
order = self._sections
try:
return super(Namespace, self).__getitem__(key)
except KeyError:
pass
for section in order:
if isinstance(section, dict):
try:
return section[key]
except KeyError:
pass
else:
try:
return self[section][key]
except KeyError:
pass
raise KeyError("Key %s not found in namespace" % key)
def __setattr__(self, key, value):
if key.startswith("_"):
object.__setattr__(self, key, value)
else:
self[key] = value
def __delitem__(self, key):
try:
index = self._sections.index(key)
del self._sections[index]
except ValueError:
pass
super(Namespace, self).__delitem__(key)
def update(self, d=None, **kw):
"""Update the namespace. This is less efficient than the standard
dict.update but is necessary to keep track of the sections that we'll be
searching."""
items = []
if d:
# look up keys even though we call items
# because that's what the dict.update
# doc says
if hasattr(d, 'keys'):
items.extend(list(d.items()))
else:
items.extend(list(d))
items.extend(list(kw.items()))
for key, value in items:
self[key] = value
__call__ = update
def setdefault(self, key, default):
if not key in self:
self[key] = default
return default
return self[key]
Paver-1.2.1/paver/path.py 0000644 0001750 0001750 00000005114 12152711177 015376 0 ustar almad almad 0000000 0000000 """
Wrapper around path.py to add dry run support and other paver integration.
"""
from __future__ import with_statement
import functools
import os
from contextlib import contextmanager
import sys
if sys.version_info[0] == 3:
from paver.deps.path3 import path as _orig_path
else:
from paver.deps.path2 import path as _orig_path
from paver import tasks
__all__ = ['path', 'pushd']
@contextmanager
def pushd(dir):
'''A context manager (Python 2.5+ only) for stepping into a
directory and automatically coming back to the previous one.
The original directory is returned. Usage is like this::
from __future__ import with_statement
# the above line is only needed for Python 2.5
from paver.easy import *
@task
def my_task():
with pushd('new/directory') as old_dir:
...do stuff...
'''
old_dir = os.getcwd()
tasks.environment.info('cd %s' % dir)
os.chdir(dir)
try:
yield old_dir
tasks.environment.info('cd %s' % old_dir)
finally:
os.chdir(old_dir)
class path(_orig_path):
def chdir(self):
# compatability with the ancient path.py that had a .chdir() method
self.__enter__()
# This is used to prevent implementation details of dry'd functions from
# printing redundant information.
# In particular, foo_p methods usually call the foo method internally and
# we don't want to print that information twice.
# We can say that the former implies the latter and call it a day.
_silence_nested_calls = False
def _make_wrapper(name, func):
from paver.easy import dry
@functools.wraps(func)
def wrapper(*args, **kwds):
global _silence_nested_calls
msg = None
if not _silence_nested_calls:
msg = name + ' ' + ' '.join(args)
try:
_silence_nested_calls = True
return dry(msg, func, *args, **kwds)
finally:
_silence_nested_calls = False
return wrapper
_METHOD_BLACKLIST = [
'rename', 'renames', 'mkdir', 'mkdir_p', 'makedirs', 'makedirs_p',
'rmdir', 'rmdir_p', 'removedirs', 'removedirs_p', 'touch',
'remove', 'remove_p', 'unlink', 'unlink_p', 'link', 'symlink',
'copyfile', 'copymode', 'copystat', 'copy', 'copy2', 'copytree',
'move', 'rmtree', 'rmtree_p',
# added atop of original dry run support
'chown', 'chmod', 'utime', 'write_bytes', 'write_lines', 'write_text'
]
for name in _METHOD_BLACKLIST:
if not hasattr(_orig_path, name):
continue
wrapper = _make_wrapper(name, getattr(_orig_path, name))
setattr(path, name, wrapper)
Paver-1.2.1/LICENSE.txt 0000644 0001750 0001750 00000003066 12152711177 014602 0 ustar almad almad 0000000 0000000 Copyright (c) 2008, SitePen, Inc. and Kevin Dangoor
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of SitePen, Inc. nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Portions copyright Ned Batchelder, Ian Bicking and Michael Foord.
\ Sort by:\ best rated\ newest\ oldest\
\\
Add a comment\ (markup):
\