|
|
""" File system operations
|
|
|
|
|
|
Contains: Simple variants of normal unix shell commands (icp, imv, irm,
|
|
|
imkdir, igrep).
|
|
|
|
|
|
Some "otherwise handy" utils ('collect' for gathering files to
|
|
|
~/_ipython/collect, 'inote' for collecting single note lines to
|
|
|
~/_ipython/note.txt)
|
|
|
|
|
|
Mostly of use for bare windows installations where cygwin/equivalent is not
|
|
|
installed and you would otherwise need to deal with dos versions of the
|
|
|
commands (that e.g. don't understand / as path separator). These can
|
|
|
do some useful tricks on their own, though (like use 'mglob' patterns).
|
|
|
|
|
|
Not to be confused with ipipe commands (ils etc.) that also start with i.
|
|
|
|
|
|
QUARANTINE, NEEDS UPDATING TO THE NEW IPYTHON API TO WORK
|
|
|
|
|
|
this depends on mglob that used to be in externals,
|
|
|
if this code is updated to run again with current IPython, you may need to
|
|
|
reintroduce that file back. In doing so, look for the possibility of achieving
|
|
|
the same effect only with the standard library (which may have improved by now,
|
|
|
since we currently depend on Python 2.6).
|
|
|
"""
|
|
|
|
|
|
from IPython.core import ipapi
|
|
|
from IPython.core.error import TryNext
|
|
|
ip = ipapi.get()
|
|
|
|
|
|
import shutil,os,shlex
|
|
|
from IPython.external import mglob
|
|
|
from IPython.external.path import path
|
|
|
from IPython.core.error import UsageError
|
|
|
import IPython.utils.generics
|
|
|
|
|
|
def parse_args(args):
|
|
|
""" Given arg string 'CMD files... target', return ([files], target) """
|
|
|
|
|
|
tup = args.split(None, 1)
|
|
|
if len(tup) == 1:
|
|
|
raise UsageError("Expected arguments for " + tup[0])
|
|
|
|
|
|
tup2 = shlex.split(tup[1])
|
|
|
|
|
|
flist, trg = mglob.expand(tup2[0:-1]), tup2[-1]
|
|
|
if not flist:
|
|
|
raise UsageError("No files found:" + str(tup2[0:-1]))
|
|
|
return flist, trg
|
|
|
|
|
|
def icp(ip,arg):
|
|
|
""" icp files... targetdir
|
|
|
|
|
|
Copy all files to target, creating dirs for target if necessary
|
|
|
|
|
|
icp srcdir dstdir
|
|
|
|
|
|
Copy srcdir to distdir
|
|
|
|
|
|
"""
|
|
|
import distutils.dir_util
|
|
|
|
|
|
fs, targetdir = parse_args(arg)
|
|
|
if not os.path.isdir(targetdir) and len(fs) > 1:
|
|
|
distutils.dir_util.mkpath(targetdir,verbose =1)
|
|
|
for f in fs:
|
|
|
if os.path.isdir(f):
|
|
|
shutil.copytree(f, targetdir)
|
|
|
else:
|
|
|
shutil.copy2(f,targetdir)
|
|
|
return fs
|
|
|
ip.define_alias("icp",icp)
|
|
|
|
|
|
def imv(ip,arg):
|
|
|
""" imv src tgt
|
|
|
|
|
|
Move source to target.
|
|
|
"""
|
|
|
|
|
|
fs, target = parse_args(arg)
|
|
|
if len(fs) > 1:
|
|
|
assert os.path.isdir(target)
|
|
|
for f in fs:
|
|
|
shutil.move(f, target)
|
|
|
return fs
|
|
|
ip.define_alias("imv",imv)
|
|
|
|
|
|
def irm(ip,arg):
|
|
|
""" irm path[s]...
|
|
|
|
|
|
Remove file[s] or dir[s] path. Dirs are deleted recursively.
|
|
|
"""
|
|
|
try:
|
|
|
paths = mglob.expand(arg.split(None,1)[1])
|
|
|
except IndexError:
|
|
|
raise UsageError("%irm paths...")
|
|
|
import distutils.dir_util
|
|
|
for p in paths:
|
|
|
print "rm",p
|
|
|
if os.path.isdir(p):
|
|
|
distutils.dir_util.remove_tree(p, verbose = 1)
|
|
|
else:
|
|
|
os.remove(p)
|
|
|
|
|
|
ip.define_alias("irm",irm)
|
|
|
|
|
|
def imkdir(ip,arg):
|
|
|
""" imkdir path
|
|
|
|
|
|
Creates dir path, and all dirs on the road
|
|
|
"""
|
|
|
import distutils.dir_util
|
|
|
targetdir = arg.split(None,1)[1]
|
|
|
distutils.dir_util.mkpath(targetdir,verbose =1)
|
|
|
|
|
|
ip.define_alias("imkdir",imkdir)
|
|
|
|
|
|
def igrep(ip,arg):
|
|
|
""" igrep PAT files...
|
|
|
|
|
|
Very dumb file scan, case-insensitive.
|
|
|
|
|
|
e.g.
|
|
|
|
|
|
igrep "test this" rec:*.py
|
|
|
|
|
|
"""
|
|
|
elems = shlex.split(arg)
|
|
|
dummy, pat, fs = elems[0], elems[1], mglob.expand(elems[2:])
|
|
|
res = []
|
|
|
for f in fs:
|
|
|
found = False
|
|
|
for l in open(f):
|
|
|
if pat.lower() in l.lower():
|
|
|
if not found:
|
|
|
print "[[",f,"]]"
|
|
|
found = True
|
|
|
res.append(f)
|
|
|
print l.rstrip()
|
|
|
return res
|
|
|
|
|
|
ip.define_alias("igrep",igrep)
|
|
|
|
|
|
def collect(ip,arg):
|
|
|
""" collect foo/a.txt rec:bar=*.py
|
|
|
|
|
|
Copies foo/a.txt to ~/_ipython/collect/foo/a.txt and *.py from bar,
|
|
|
likewise
|
|
|
|
|
|
Without args, try to open ~/_ipython/collect dir (in win32 at least).
|
|
|
"""
|
|
|
from IPython.external.path import path
|
|
|
basedir = path(ip.ipython_dir + '/collect')
|
|
|
try:
|
|
|
fs = mglob.expand(arg.split(None,1)[1])
|
|
|
except IndexError:
|
|
|
os.startfile(basedir)
|
|
|
return
|
|
|
for f in fs:
|
|
|
f = path(f)
|
|
|
trg = basedir / f.splitdrive()[1].lstrip('/\\')
|
|
|
if f.isdir():
|
|
|
print "mkdir",trg
|
|
|
trg.makedirs()
|
|
|
continue
|
|
|
dname = trg.dirname()
|
|
|
if not dname.isdir():
|
|
|
dname.makedirs()
|
|
|
print f,"=>",trg
|
|
|
shutil.copy2(f,trg)
|
|
|
|
|
|
ip.define_alias("collect",collect)
|
|
|
|
|
|
def inote(ip,arg):
|
|
|
""" inote Hello world
|
|
|
|
|
|
Adds timestamp and Hello world to ~/_ipython/notes.txt
|
|
|
|
|
|
Without args, opens notes.txt for editing.
|
|
|
"""
|
|
|
import time
|
|
|
fname = ip.ipython_dir + '/notes.txt'
|
|
|
|
|
|
try:
|
|
|
entry = " === " + time.asctime() + ': ===\n' + arg.split(None,1)[1] + '\n'
|
|
|
f= open(fname, 'a').write(entry)
|
|
|
except IndexError:
|
|
|
ip.hooks.editor(fname)
|
|
|
|
|
|
ip.define_alias("inote",inote)
|
|
|
|
|
|
def pathobj_mangle(p):
|
|
|
return p.replace(' ', '__').replace('.','DOT')
|
|
|
def pathobj_unmangle(s):
|
|
|
return s.replace('__',' ').replace('DOT','.')
|
|
|
|
|
|
|
|
|
|
|
|
class PathObj(path):
|
|
|
def __init__(self,p):
|
|
|
self.path = p
|
|
|
if p != '.':
|
|
|
self.ents = [pathobj_mangle(ent) for ent in os.listdir(p)]
|
|
|
else:
|
|
|
self.ents = None
|
|
|
def __complete__(self):
|
|
|
if self.path != '.':
|
|
|
return self.ents
|
|
|
self.ents = [pathobj_mangle(ent) for ent in os.listdir('.')]
|
|
|
return self.ents
|
|
|
def __getattr__(self,name):
|
|
|
if name in self.ents:
|
|
|
if self.path.endswith('/'):
|
|
|
sep = ''
|
|
|
else:
|
|
|
sep = '/'
|
|
|
|
|
|
tgt = self.path + sep + pathobj_unmangle(name)
|
|
|
#print "tgt",tgt
|
|
|
if os.path.isdir(tgt):
|
|
|
return PathObj(tgt)
|
|
|
if os.path.isfile(tgt):
|
|
|
return path(tgt)
|
|
|
|
|
|
raise AttributeError, name # <<< DON'T FORGET THIS LINE !!
|
|
|
def __str__(self):
|
|
|
return self.path
|
|
|
|
|
|
def __repr__(self):
|
|
|
return "<PathObj to %s>" % self.path
|
|
|
|
|
|
def __call__(self):
|
|
|
print "cd:",self.path
|
|
|
os.chdir(self.path)
|
|
|
|
|
|
def complete_pathobj(obj, prev_completions):
|
|
|
if hasattr(obj,'__complete__'):
|
|
|
res = obj.__complete__()
|
|
|
if res:
|
|
|
return res
|
|
|
# just return normal attributes of 'path' object if the dir is empty
|
|
|
raise TryNext
|
|
|
|
|
|
complete_pathobj = IPython.utils.generics.complete_object.when_type(PathObj)(complete_pathobj)
|
|
|
|
|
|
def test_pathobj():
|
|
|
#p = PathObj('c:/prj')
|
|
|
#p2 = p.cgi
|
|
|
#print p,p2
|
|
|
rootdir = PathObj("/")
|
|
|
startmenu = PathObj("d:/Documents and Settings/All Users/Start Menu/Programs")
|
|
|
cwd = PathObj('.')
|
|
|
ip.push("rootdir startmenu cwd")
|
|
|
|
|
|
#test_pathobj()
|
|
|
|
