dk-tasklib 3.0.9__py3-none-any.whl

dktasklib/utils.py

@@ -0,0 +1,234 @@
+import os
+import string
+import sys
+from contextlib import contextmanager
+
+from dkfileutils.path import Path
+import operator
+
+join = os.path.join
+null = "NUL" if sys.platform == 'win32' else '/dev/null'
+win32 = sys.platform == 'win32'
+
+
+class Column(dict):
+    pass
+
+
+# from dkbuild/utils/tableprinter.py
+def format_table(data, *columns, **kw):
+    """Format data into a .rst-like formatted table.
+
+       Args:
+           data: list of dict/object (having fields corresponding to `columns`)
+           columns: one-or-more
+
+                 dict(title='',
+                      field='',
+                      align='left',
+                      format=lambda x:x)
+
+               title is optional and defaults to field, other defaults as
+               indicated.
+           kw[get_field]: function to extract fields from data objects, ie.:
+               ``get_field(data[i], columns[i]['field']) => data[i].field``
+               Default value is :func:`operator.itemgetter`
+
+       Usage::
+
+           >>> print format_table(
+           ...     [
+           ...         dict(field1=42, field2='world', field3='n/a'),
+           ...         dict(field1=12, field2='hello')
+           ...     ],
+           ...     Column(field='field1', format=str, align='center'),
+           ...     Column(field='field2', title='f2           ', align='right')
+           ... )
+           ====== =============
+           field1 f2
+           ====== =============
+             42           world
+             12           hello
+           ====== =============
+
+    """
+    fields = [col['field'] for col in columns]
+    titles = [col.get('title', col['field']) for col in columns]
+    identity = lambda x: x      # noqa
+    fmt = [col.get('format', identity) for col in columns]
+    _align = [col.get('align', 'left') for col in columns]
+    _alignselect = {'left': '', 'right': '>', 'center': '^'}
+    align = [_alignselect[a] for a in _align]
+    getter = kw.get('get_field', operator.itemgetter)
+    get_fields = [getter(field) for field in fields]
+
+    field_lengths = [len(t) for t in titles]
+    for item in data:
+        values = [fmtfn(getfn(item)) for fmtfn, getfn in zip(fmt, get_fields)]
+        value_lengths = [max([0] + [len(ln) for ln in v.splitlines()]) for v in
+                         values]
+        field_lengths = [max(fieldval) for fieldval in zip(value_lengths,
+                                                           field_lengths)]
+    rst_line = ['=' * clen for clen in field_lengths]
+    thead = [
+        rst_line,
+        ['%-*s' % (clen, title) for clen, title in zip(field_lengths, titles)],
+        rst_line
+    ]
+
+    def get_lineno(n, val):
+        lines = val.splitlines()
+        if n >= len(lines):
+            return ''
+        return lines[n]
+
+    rows = []
+    for item in data:
+        values = [fmtfn(getfn(item)) for fmtfn, getfn in zip(fmt, get_fields)]
+        multiline = [v.count('\n') for v in values]
+        if any(multiline):
+            for i in range(max(multiline) + 1):
+                line = [get_lineno(i, val) for val in values]
+                rows.append([
+                    '{:{align}{width}}'.format(value, align=a, width=w)
+                    # line, align=align[i], width=field_lengths[i])
+                    for a, w, value in zip(align, field_lengths, line)
+                ])
+        else:
+            rows.append(
+                ['{:{align}{width}}'.format(value, align=a, width=w)
+                 for a, w, value in zip(align, field_lengths, values)]
+            )
+        if kw.get('rowspace'):
+            rows.append(['' * len(columns)])
+    if kw.get('rowspace'):
+        del rows[-1]
+    tfoot = [rst_line]
+    header = '\n'.join([' '.join(row) for row in thead])
+    body = '\n'.join([' '.join(row) for row in rows])
+    footer = '\n'.join([' '.join(row) for row in tfoot])
+    return '\n'.join([header, body, footer])
+
+
+def dest_is_newer_than_source(src, dst):
+    """Check if destination is newer than source.
+
+       Usage::
+
+            if not force and dest_is_newer_than_source(source, dest):
+                print 'babel:', dest, 'is up-to-date.'
+                return dest
+
+    """
+    if not os.path.exists(dst):
+        return False
+    if not os.path.exists(src):
+        raise ValueError("Source does not exist: " + str(src))
+    return os.path.getmtime(src) < os.path.getmtime(dst)
+
+
+class _MissingDottedString(str):
+    def __getattr__(self, attr):
+        return _MissingDottedString(self[:-1] + '.' + attr + '}')
+
+
+class _MissingContext(dict):
+    def __missing__(self, key):
+        return _MissingDottedString('{%s}' % key)
+
+
+def fmt(s, ctx):
+    """Use the mapping `ctx` as a formatter for the {new.style} formatting
+       string `s`.
+    """
+    return string.Formatter().vformat(s, (), _MissingContext(ctx))
+
+
+def switch_extension(fname, ext="", old_ext=None):
+    """Switch file extension on `fname` to `ext`. Returns the resulting
+       file name.
+
+       Usage::
+
+           switch_extension('a/b/c/d.less', '.css')
+
+    """
+    name, _ext = os.path.splitext(fname)
+    if old_ext:
+        assert old_ext == _ext
+    return name + ext
+
+
+def filename(fname):
+    """Return only the file name (removes the path)
+    """
+    return os.path.split(fname)[1]
+
+
+@contextmanager
+def message(s):
+    try:
+        print((' %s ' % s).center(80, '-'))
+        yield
+    except:     # noqa
+        print('error =====>', s, '<====== error')
+        raise
+    else:
+        print((' (ok: %s) ' % s).center(80, '='))
+
+
+@contextmanager
+def env(**kw):
+    """Context amanger to temporarily override environment variables.
+    """
+    currentvals = {k: os.environ.get(k) for k in kw}
+    for k, v in kw.items():
+        os.environ[k] = str(v)
+    try:
+        yield
+    finally:
+        for k in kw:
+            if currentvals[k] is None:
+                os.environ.pop(k, None)
+            else:
+                os.environ[k] = currentvals[k]
+
+
+@contextmanager
+def cd(directory):
+    """Context manager to change directory.
+
+       Usage::
+
+           with cd('foo/bar'):
+               # current directory is now foo/bar
+           # current directory restored.
+
+    """
+    cwd = os.getcwd()
+    try:
+        os.chdir(directory)
+        yield
+    finally:
+        os.chdir(cwd)
+
+
+def find_pymodule(dotted_name):
+    """Find the directory of a python module, without importing it.
+    """
+    name = dotted_name.split('.', 1)[0]
+    for p in sys.path:
+        pth = Path(p)
+        if not pth:
+            continue
+        try:
+            if name in pth and (pth/name).isdir():
+                return pth/name
+            if name + '.py' in pth:
+                return pth
+        except OSError:
+            continue
+        except Exception as e:
+            print('error', pth, e)
+            raise
+    raise ValueError("Path not found for: " + dotted_name)

dktasklib/version.py

@@ -0,0 +1,103 @@
+import os
+import hashlib
+
+from dkfileutils.path import Path
+from dktasklib.wintask import task
+from invoke import Collection
+from dktasklib.concat import copy
+from .package import Package
+
+
+@task(
+    default=True,
+    autoprint=True,     # print return value
+)
+def version(ctx):
+    """Print this package's version number.
+    """
+    return Package().version
+
+
+def min_name(fname, min='.min'):
+    """Adds a `.min` extension before the last file extension.
+    """
+    name, ext = os.path.splitext(fname)
+    return name + min + ext
+
+
+def versioned_name(fname):
+    """Returns a template string containing `{version}` in the correct
+       place.
+    """
+    if '.min.' in fname:
+        pre, post = fname.split('.min.')
+        return pre + '-{version}.min.' + post
+    else:
+        return min_name(fname, '-{version}')
+
+
+version_name = versioned_name
+
+
+def get_version(ctx, fname, kind='pkg'):
+    """Return the version number for fname.
+    """
+    fname = Path(fname)
+    if kind == "pkg":
+        if not hasattr(ctx, 'pkg'):
+            ctx.pkg = Package()
+        return ctx.pkg.version
+
+    elif kind == "hash":
+        directory = fname.dirname() or Path('.')
+        md5 = directory / '.md5'
+        if md5.exists():
+            return md5.open().read()
+        return hashlib.md5(open(fname, 'rb').read()).hexdigest()
+    return ""
+
+
+def copy_to_version(ctx, source, outputdir=None, kind="pkg", force=False):
+    """Copy source with version number to `outputdir`.
+
+       The version type is specified by the ``kind`` parameter and can be
+       either "pkg" (package version), "svn" (current subversion revision
+       number), or "hash" (the md5 hash of the file's contents).
+
+       Returns:
+           (str) output file name
+    """
+    # where to place the versioned file..
+    source = Path(source)
+    outputdir = Path(outputdir) if outputdir else source.dirname() or Path('.')
+    outputdir.makedirs()
+    dst_fname = source.basename()
+    if '{version}' not in str(dst_fname):
+        dst_fname = versioned_name(dst_fname)
+    dst = outputdir / dst_fname.format(version=get_version(ctx, source, kind))
+
+    if force or not os.path.exists(dst):
+        copy(ctx, source, dst, force=force)
+
+    elif open(source).read() != open(dst).read():
+        print("""
+        Filename already exists, add --force or call upversion: {}
+        """.format(dst))
+
+    return dst
+
+
+add_version = copy_to_version
+
+
+ns = Collection(
+    'version',
+    version,
+)
+ns.configure({
+    'force': False,
+    'pkg': {
+        'name': '<package-name>',
+        'version': '<version-string>',
+    },
+})

dktasklib/watch.py

@@ -0,0 +1,90 @@
+"""
+Usage::
+
+    @task
+    def watch(ctx):
+        watcher = Watcher(ctx)
+        watcher.watch_file(
+            name='{pkg.source}/less/{pkg.name}.less',
+            action=lambda e: build(ctx, less=True)
+        )
+        watcher.watch_directory(
+            path='{pkg.source}/js', ext='.jsx',
+            action=lambda e: build(ctx, js=True)
+        )
+        watcher.watch_directory(
+            path='{pkg.docs}', ext='.rst',
+            action=lambda e: build(ctx, docs=True)
+        )
+        watcher.start()
+
+    ns = Collection(..., watch, ...)
+    ns.configure({
+        'pkg': Package()
+    })
+
+"""
+import time
+from dkfileutils.path import Path
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+
+
+class FileModified(FileSystemEventHandler):
+    def __init__(self, ctx, fname, action):
+        super().__init__()
+        self.ctx = ctx
+        self.fname = Path(fname.format(pkg=ctx.pkg)).abspath()
+        self.action = action
+
+    def on_modified(self, event):
+        if Path(event.src_path).abspath() != self.fname:
+            return
+        self.action(event)
+
+
+class DirectoryModified(FileSystemEventHandler):
+    def __init__(self, ctx, path, ext, action):
+        super().__init__()
+        self.ctx = ctx
+        self.path = Path(path.format(pkg=ctx.pkg)).abspath()
+        self.ext = ext
+        self.action = action
+
+    def on_modified(self, event):
+        event_path = Path(event.src_path).abspath()
+        if not event_path.startswith(self.path):
+            return
+        if self.ext and not event_path.endswith(self.ext):
+            return
+        self.action(event)
+
+
+class Watcher:
+    def __init__(self, ctx):
+        self.ctx = ctx
+        self.observer = Observer()
+
+    def watch_file(self, name, action):
+        self.observer.schedule(
+            FileModified(self.ctx, name, action),
+            self.ctx.pkg.root,
+            recursive=True
+        )
+
+    def watch_directory(self, path, ext, action):
+        self.observer.schedule(
+            DirectoryModified(self.ctx, path, ext, action),
+            self.ctx.pkg.root,
+            recursive=True
+        )
+
+    def start(self):
+        print('watching for changes.. (Ctrl-C to exit)')
+        self.observer.start()
+        try:
+            while 1:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            self.observer.stop()
+        self.observer.join()

dktasklib/wintask.py

@@ -0,0 +1,4 @@
+from invoke import task
+
+
+__all__ = ['task']