dk-tasklib 0.2.0__zip → 0.2.3__zip

{dk-tasklib-0.2.0 → srv/venv/dev/Lib/site-packages/dk_tasklib-0.2.3-py2.7.egg-info}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 1.1
 Name: dk-tasklib
-Version: 0.2.0
+Version: 0.2.3
 Summary: dk-tasklib - short description
-Home-page: UNKNOWN
+Home-page: https://github.com/datakortet/dk-tasklib
 Author: Bjorn Pettersen
 Author-email: bp@datakortet.no
 License: UNKNOWN
 Description: 
-        .. image:: https://travis-ci.org/thebjorn/dk-tasklib.svg?branch=master
-            :target: https://travis-ci.org/thebjorn/dk-tasklib
+        .. image:: https://travis-ci.org/datakortet/dk-tasklib.svg?branch=master
+            :target: https://travis-ci.org/datakortet/dk-tasklib
         
         
         dk-tasklib -- pyinvoke  task library

{dk-tasklib-0.2.0/dk_tasklib.egg-info → srv/venv/dev/Lib/site-packages/dk_tasklib-0.2.3-py2.7.egg-info}/SOURCES.txt

@@ -7,9 +7,15 @@ dk_tasklib.egg-info/dependency_links.txt
 dk_tasklib.egg-info/not-zip-safe
 dk_tasklib.egg-info/top_level.txt
 dktasklib/__init__.py
+dktasklib/_version.py
+dktasklib/clean.py
+dktasklib/docs.py
+dktasklib/executables.py
 dktasklib/jstools.py
 dktasklib/lessc.py
+dktasklib/manage.py
 dktasklib/npm.py
 dktasklib/package.py
+dktasklib/runners.py
 dktasklib/utils.py
 dktasklib/version.py

{dk-tasklib-0.2.0 → srv/venv/dev/Lib/site-packages}/dktasklib/__init__.py

@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 
+from ._version import __version__
 from .package import Package
 from . import lessc
-from .npm import isinstalled
-from .utils import changed_dir

srv/venv/dev/Lib/site-packages/dktasklib/_version.py

@@ -0,0 +1 @@
+__version__ = '0.2.3'

srv/venv/dev/Lib/site-packages/dktasklib/clean.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+
+from invoke import ctask as task
+
+
+@task
+def clean(ctx, directory):
+    """Remove all contents from build subdirectory `directory`.
+    """
+    ctx.run("rm -rf build/{directory}/*".format(directory=directory))

srv/venv/dev/Lib/site-packages/dktasklib/docs.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+
+import os
+import webbrowser
+from os.path import join
+
+from invoke import ctask as task, Collection
+
+
+# Underscored func name to avoid shadowing kwargs in build()
+@task(name='clean')
+def _clean(ctx):
+    """Nuke docs build target directory so next build is clean.
+    """
+    builddir = ctx.docs.builddir
+    if os.path.exists(builddir) and len(os.listdir(builddir)) > 0:
+        ctx.run("rm -rf {0}/*".format(builddir))
+
+
+# Ditto
+@task(name='browse')
+def _browse(ctx):  # pragma: nocover
+    """Open build target's index.html in a browser (using the :py:mod:`webbrowser` module).
+    """
+    index = join(ctx.docs.builddir, ctx.docs.target_file)
+    webbrowser.open_new(index)
+
+
+@task(default=True, help={
+    'opts': "Extra sphinx-build options/args",
+    'clean': "Remove build tree before building",
+    'browse': "Open docs index in browser after building",
+    'warn': "Build with stricter warnings/errors enabled",
+    'builder': "Builder to use; defaults tto html",
+    'force': "Force re-reading of all files (ignore cache)",
+})
+def build(ctx, clean=False, browse=False, warn=False,
+          builder='html',
+          force=True,
+          opts=""):
+    """
+    Build the project's Sphinx docs.
+    """
+    if clean:
+        _clean(ctx)
+    if opts is None:  # pragma: nocover
+        opts = ""
+    opts += " -b %s" % builder
+    if warn:
+        opts += " -n -W"
+    if force:
+        opts += " -a -E"
+    cmd = "sphinx-build {opts} {ctx.docs.source} {ctx.docs.builddir}".format(
+        opts=opts, ctx=ctx)
+    ctx.run(cmd)
+    if browse:  # pragma: nocover
+        _browse(ctx)
+
+
+@task
+def tree(ctx):
+    """Display the docs tree.
+    """
+    ignore = ".git|*.pyc|*.swp|dist|*.egg-info|_static|_build|_templates"
+    ctx.run('tree -Ca -I "{0}" {1}'.format(ignore, ctx.docs.source))
+
+
+# Vanilla/default/parameterized collection for normal use
+docs = Collection('docs', _clean, _browse, build, tree)
+docs.configure({
+    'docs': {
+        'source': 'docs',
+        'builddir': join('build', 'docs'),
+        'target_file': 'index.html',
+    }
+})

srv/venv/dev/Lib/site-packages/dktasklib/executables.py

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+import sys
+from dkfileutils.which import get_executable
+
+
+class MissingCommand(Exception):
+    """Exception thrown when a command (executable) is not found.
+    """
+    pass
+
+
+# noinspection PyShadowingNames
+class Executables(object):
+    """Class for finding executables on the host system.
+    """
+    def __init__(self):
+        self._cache = {}
+
+    def require(self, *dependencies):
+        """Ensure that all dependencies are available.
+           You should not need to call this yourself, use the :func:`requires`
+           decorator instead.
+        """
+        for dep in dependencies:
+            self.find(dep)
+
+    def find(self, name, requires=(), install_txt='"'):
+        """Find the executable named ``name`` on the :envvar:`PATH`.
+
+           Args:
+               name (str): name of executable to find.
+               requires (List[str]): list of executables to find first.
+               install_txt (str): instructions for how to install the
+                    executable if it is not found.
+        """
+        if name not in self._cache:
+            self.require(*requires)
+
+            if hasattr(self, 'find_' + name):
+                self._cache[name] = getattr(self, 'find_' + name)()
+            else:
+                self._cache[name] = self._find_exe(name, requires, install_txt)
+        return self._cache[name]
+
+    def _find_exe(self, name, requires=(), install_txt=None):
+        fexe = get_executable(name)
+        if not fexe:  # pragma: nocover
+            if install_txt is None:  # pragma: nocover
+                install_txt = "Missing command: %s %r" % (name, requires)
+            raise MissingCommand(install_txt)
+        return fexe
+
+    def find_nodejs(self):  # pragma: nocover
+        """Find :program:`node`.
+        """
+        if sys.platform == 'win32':
+            node_exe = get_executable('node')
+        else:
+            node_exe = get_executable('nodejs') or get_executable('node')
+
+        if not node_exe:  # pragma: nocover
+            raise MissingCommand("""
+            Install Node.js using your OS package manager
+            https://github.com/joyent/node/wiki/Installing-Node.js-via-package-manager
+            """)
+        return node_exe
+
+    def find_npm(self):
+        """Find the node package manager (:program:`npm`).
+        """
+        npm_exe = get_executable('npm')
+        if not npm_exe:  # pragma: nocover
+            raise MissingCommand("""
+            Install Node.js using your OS package manager
+            https://github.com/joyent/node/wiki/Installing-Node.js-via-package-manager
+            """)
+        return npm_exe
+
+
+#: public interface to the :py:class:`Executables` class
+exe = Executables()
+
+
+def requires(*deps):
+    """Decorator to declare global dependencies/requirements.
+
+       Usage (``@task`` must be last)::
+
+           @requires('nodejs', 'npm', 'lessc')
+           @task
+           def mytask(..)
+
+    """
+    def _wrapper(fn):
+        exe.require(*deps)
+        return fn
+    return _wrapper
+
+
+
+

{dk-tasklib-0.2.0 → srv/venv/dev/Lib/site-packages}/dktasklib/jstools.py

@@ -10,14 +10,15 @@ def browserify(ctx, source, dest, require=(), external=(), entry=None):
     Run ``browserify``
 
     Args:
-        ctx:        context
-        source:     root source file
-        dest:       path/name of assembled file
-        require:
+        ctx (pyinvoke.Context):  context
+        source (str):            root source file
+        dest (str):              path/name of assembled file
+        require (iterable):
         external:
         entry:
 
     Returns:
+        None
 
     """
     options = ""

srv/venv/dev/Lib/site-packages/dktasklib/lessc.py

@@ -0,0 +1,152 @@
+# -*- coding: utf-8 -*-
+import os
+import sys
+
+from dkfileutils.changed import Directory
+from invoke import ctask as task, Collection
+
+from dktasklib.executables import requires
+from .package import Package
+from .utils import switch_extension, filename, min_name, version_name, join
+from .version import add_version, update_template_version
+
+bootstrap = os.path.join(os.environ.get('SRV', ''), 'lib', 'bootstrap', 'less')
+
+
+@requires('nodejs', 'npm', 'lessc')
+def lessc(ctx,
+          source, destination="",
+          include_path=None,
+          strict_imports=False,
+          inline_urls=True,
+          autoprefix=True,
+          cleancss=True):
+    """Run `lessc` with options.
+
+       Args:
+           source (str): the input file name
+           destination (Optional[str]): the output filename (if not specified
+                it will be the same as the input file name and a ``.css``
+                extension).
+           include_path (Optional[List[str]]): Optional list of directories
+                to search to satisfy ``@import`` directives.
+           strict_imports (bool): Re-fetch all imports.
+           inline_urls (bool): Should ``@url(.../foo.png)`` be inlined?
+           autoprefix (bool): Should the autoprefixer be run (last 4 versions)
+           cleancss (bool): Should the css be minified?
+
+       Returns:
+           str: The output file name.
+
+    """
+    if include_path is None:
+        include_path = []
+    if not destination:
+        destination = switch_extension(source, '.css', '.less')
+    options = ""
+    if getattr(ctx, 'verbose', False):  # pragma: nocover
+        options += ' --verbose'
+    if include_path:
+        options += ' --include-path="%s"' % ';'.join(include_path)
+    if strict_imports:
+        options += " --strict-imports"
+    if inline_urls:
+        options += " --inline-urls"
+    if autoprefix:
+        options += ' --autoprefix="last 4 versions"'
+    if cleancss:
+        options += ' --clean-css="-b --s0 --advanced"'
+
+    ctx.run("lessc {options} {source} {destination}".format(**locals()))
+    return destination
+
+
+def build_css(ctx,
+              lessfile, dest,
+              version='pkg',
+              use_bootstrap=True,
+              **kw):
+    """Build a ``.less`` file into a versioned and minified ``.css`` file.
+
+       Args:
+           lessfile (str): input file name
+           dest (str): output file name (should be the plain version of the
+                output file name, ie. foo.css, not foo.min.css).
+           version (str): the type of version number (pkg or hash)
+           use_bootstrap (bool): Should Bootstrap be compiled in?
+
+       Returns:
+           str: output file name
+
+    """
+    path = kw.pop('path', [])
+    if use_bootstrap:
+        path.append(ctx.lessc.bootstrap_less_src)
+
+    # foo.css -> foo.min.css
+    minfname = min_name(dest)
+
+    output_fname = lessc(
+        ctx,
+        lessfile,
+        os.path.join('build', 'css', minfname),
+        # minfname,
+        include_path=path,
+        strict_imports=True,
+        inline_urls=True,
+        autoprefix=True,
+        cleancss=True,
+    )
+    
+    return add_version(
+        ctx,
+        output_fname,
+        version_name(output_fname),
+        kind=version)
+
+
+@task(
+    default=True,
+    post=[update_template_version],
+    help={
+
+    }
+)
+def build(ctx, force=False, verbose=False, src=None, dst=None, **kw):
+    """Compile .less to .css  (pakage.json[build_less_input/output]
+    """
+    if not hasattr(ctx, 'pkg'):
+        ctx.pkg = Package()
+    if not hasattr(ctx.pkg, 'build_less_input'):
+        ctx.pkg.build_less_input = src or 'less/{pkg.name}.less'.format(pkg=ctx.pkg)
+    if not hasattr(ctx.pkg, 'build_less_output'):
+        ctx.pkg.build_less_output = dst or 'static/{pkg.name}/{pkg.name}.css'.format(pkg=ctx.pkg)
+    if not hasattr(ctx, 'force'):
+        ctx.force = force
+    if not hasattr(ctx, 'verbose'):
+        ctx.verbose = verbose
+
+    if ctx.verbose:  # pragma: nocover
+        print 'build_less input: ', ctx.pkg.build_less_input
+        print 'build_less output:', ctx.pkg.build_less_output
+
+    dirname = os.path.dirname(ctx.pkg.build_less_input)
+
+    if ctx.force or Directory(dirname).changed(glob='**/*.less'):
+        build_css(
+            ctx,
+            ctx.pkg.build_less_input,
+            ctx.pkg.build_less_output,
+            version='pkg',
+            **kw
+        )   
+
+
+less = Collection('lessc', build)
+less.configure({
+    'lessc': {
+        'source': 'less/index.less',
+        'target': '',
+        'bootstrap_less_src': os.path.join(os.environ.get('BOOTSTRAPSRC', ''), 'less'),
+    }
+})

srv/venv/dev/Lib/site-packages/dktasklib/manage.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+import os
+from invoke import ctask as task, run
+from .utils import cd
+from .package import Package
+
+
+DEFAULT_SETTINGS_MODULE = 'datakortet.settings'
+DEFAULT_MANAGE_PY_PATH = os.path.join(os.environ.get('SRV', ''), 'src', 'datakortet')
+
+
+@task
+def manage(ctx, cmd, settings=None, manage_path=None):
+    """Run manage.py with `settings` in a separate process.
+    """
+    # os.environ['DJANGO_SETTINGS_MODULE'] = settings or DEFAULT_SETTINGS_MODULE
+    with cd(manage_path or DEFAULT_MANAGE_PY_PATH):
+        run("python manage.py " + cmd)
+
+
+@task
+def collectstatic(ctx, verbose=False):
+    "Run collectstatic with settings from package.json ('django_settings_module')"
+    if not hasattr(ctx, 'pkg'):
+        ctx.pkg = Package()
+    if not hasattr(ctx, 'verbose'):
+        ctx.verbose = verbose
+
+    try:
+        settings = ctx.pkg.django_settings_module
+    except AttributeError:
+        settings = DEFAULT_SETTINGS_MODULE
+    if ctx.verbose:
+        print "using settings:", settings
+    manage(ctx, "collectstatic --noinput", settings)

srv/venv/dev/Lib/site-packages/dktasklib/npm.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+import shlex
+import subprocess
+
+# from invoke import run
+from dktasklib.executables import exe
+from .utils import null, win32
+
+
+def npm(cmdline):
+    npm_exe = exe.find('npm', requires=['nodejs'])
+    return subprocess.check_output("npm " + cmdline, shell=True).decode('u8')
+
+#
+#
+# def cmd2args(cmd):
+#     if isinstance(cmd, basestring):
+#         return cmd if win32 else shlex.split(cmd)
+#         # return cmd.split() if win32 else shlex.split(cmd)
+#     return cmd
+#
+#
+# class RunError(Exception):
+#     def __init__(self, cmd, errno):
+#         self.errno = errno
+#         super(RunError, self).__init__(cmd, errno)
+#
+#
+# def _run(cmd):
+#     popen = subprocess.Popen(
+#         cmd2args(cmd),
+#         stdout=subprocess.PIPE,
+#         stderr=subprocess.STDOUT,
+#         cwd=None,
+#         shell=win32
+#     )
+#
+#     for line in iter(popen.stdout.readline, ""):
+#         # print ">>", line
+#         yield line
+#
+#     exitcode = popen.wait()
+#     if exitcode != 0:
+#         raise RunError(cmd, exitcode)
+#
+#
+# class run(object):
+#     def __init__(self, cmd):
+#         self.return_code = 0
+#         try:
+#             self.output = '\n'.join(line for line in _run(cmd))
+#         except RunError as e:
+#             self.return_code = e.errno
+
+
+def global_package(pkgname):
+    """Check if an npm package is installed globally.
+    """
+    try:
+        # this is the 'correct' way, but it's increadably slow (4+ secs)
+        npm('ls -g --depth 0 ' + pkgname)
+        return True
+    except subprocess.CalledProcessError:
+        return False

{dk-tasklib-0.2.0 → srv/venv/dev/Lib/site-packages}/dktasklib/package.py

@@ -3,20 +3,19 @@
 import json
 import os
 
-from ConfigParser import RawConfigParser
+from ConfigParser import RawConfigParser, NoOptionError
 from dkfileutils.pfind import pfind
 
 
 class PackageInterface(object):
-    def version(self):
-        return self['version']
 
     def upversion(self, major=False, minor=False, patch=False):
         """Update package version (default patch-level increase).
         """
         if not (major or minor or patch):
-            patch = True
-        version = [int(n, 10) for n in self.version().split('.')]
+            # this is normally set by version.upversion
+            patch = True  # pragma: nocover
+        version = [int(n, 10) for n in self.version.split('.')]
         if major:
             version[0] += 1
         if minor:
@@ -27,6 +26,21 @@ class PackageInterface(object):
         self['version'] = newversion
         return newversion
 
+    # for convenience (continue using [](__setitem__) for setting).
+    def __getattr__(self, item):
+        return self[item]
+
+    def __setitem__(self, key, value):  # pragma: nocover
+        # should override
+        pass
+
+    def __getitem__(self, item, default=None):  # pragma: nocover
+        # should override
+        return ''
+
+    def get(self, key, default=None):
+        return self.__getitem__(key, default)
+
 
 class PackageIni(PackageInterface):
     """Read package.ini or dkbuild.ini file::
@@ -39,10 +53,14 @@ class PackageIni(PackageInterface):
     def exists(cls):
         return pfind('.', 'package.ini') or pfind('.', 'dkbuild.ini')
 
-    def __init__(self):
+    def __init__(self, *args, **kw):
         self.fname = pfind('.', 'package.ini') or pfind('.', 'dkbuild.ini')
-        if self.fname is None:
-            raise RuntimeError("I couldn't find a %s file" % packagejson)
+        if self.fname is None:  # pragma: nocover
+            raise RuntimeError("""
+                I couldn't find a package.json, package.ini,
+                or dkbuild.ini file starting from %s.
+                """ % os.getcwd())
+        self.root = os.path.dirname(self.fname)
         self._package = None
 
     def _open(self, fname):
@@ -62,7 +80,8 @@ class PackageIni(PackageInterface):
     def __getitem__(self, attr, default=None):
         try:
             return self.package.get('package', attr)
-        except KeyError:
+        except (KeyError, NoOptionError):
+            # return default
             if default is not None:
                 return default
             raise AttributeError(
@@ -83,26 +102,31 @@ class PackageJson(PackageInterface):
     def __init__(self, basedir=None, packagejson='package.json'):
         if basedir is None:
             self.fname = pfind('.', packagejson)
-            if self.fname is None:
+            if self.fname is None:  # pragma: nocover
                 raise RuntimeError("I couldn't find a %s file" % packagejson)
         else:
             self.fname = os.path.join(basedir, packagejson)
+        self.root = os.path.dirname(self.fname)
         self._package = None
 
     @property
     def package(self):
         if not self._package:
-            self._package = json.loads(open(self.fname).read())
+            with open(self.fname) as fp:
+                self._package = json.loads(fp.read())
         return self._package
 
     def __setitem__(self, key, value):
         self.package[key] = value
-        json.dump(open(self.fname, 'w'), self.package, indent=4)
+        # print "PACKAGE:", self.package
+        # print json.dumps(self.package, indent=4)
+        json.dump(self.package, open(self.fname, 'w'), indent=4)
 
     def __getitem__(self, attr, default=None):
         try:
             return self.package[attr]
         except KeyError:
+            # return default
             if default is not None:
                 return default
             raise AttributeError(

srv/venv/dev/Lib/site-packages/dktasklib/runners.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+import subprocess
+
+
+class Result(str):
+    cmd = None
+    returncode = None
+
+
+def run(cmdline, throw=False):
+    try:
+        res = Result(
+            subprocess.check_output(
+                cmdline,
+                shell=True
+            ).decode('u8')
+        )
+        res.cmd = cmdline
+        return res
+    except subprocess.CalledProcessError as e:
+        if throw:
+            raise
+        res = Result(e.output)
+        res.cmd = cmdline
+        res.returncode = e.returncode
+        return res
+
+
+def command(executable, dryrun=False):
+    def _call(*args, **kwargs):
+        cmdline = " ".join(args)
+        for k, v in kwargs.items():
+            if v is True:
+                cmdline += " --" + k
+            else:
+                if ' ' in v:
+                    v = '"%s"' % v
+                cmdline += ' --%s=%s' % (k, v)
+
+        if dryrun:
+            print cmdline
+        else:
+            return run(cmdline)
+    return _call

srv/venv/dev/Lib/site-packages/dktasklib/utils.py

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+import inspect
+import os
+from contextlib import contextmanager
+
+import sys
+
+from dkfileutils.changed import changed
+
+join = os.path.join
+null = "NUL" if sys.platform == 'win32' else '/dev/null'
+win32 = sys.platform == 'win32'
+
+
+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]
+
+
+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 version_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}')
+    
+
+@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()
+    os.chdir(directory)
+    yield
+    os.chdir(cwd)

{dk-tasklib-0.2.0 → srv/venv/dev/Lib/site-packages}/dktasklib/version.py

@@ -3,6 +3,8 @@ import re
 import os
 import hashlib
 import textwrap
+
+from dkfileutils.path import Path
 from invoke import run, ctask as task
 # from .subversion import get_svn_version
 from .package import Package
@@ -10,12 +12,15 @@ from .package import Package
 
 @task(help=dict(
     dest_template="this filename template must contain '{version}'",
-    kind="type of version number [pkg,svn,hash]",
+    kind="type of version number [pkg,hash]",
 ))
 def add_version(ctx, source, dest_template, kind="pkg", force=None):
     """Add version number to a file (either pkg version, svn revision, or hash).
+
+       Returns:
+           (str) output file name
     """
-    if not hasattr(ctx, 'pkg'):
+    if kind == 'pkg' and not hasattr(ctx, 'pkg'):
         ctx.pkg = Package()
     if not hasattr(ctx, 'force'):
         ctx.force = bool(force)
@@ -23,13 +28,13 @@ def add_version(ctx, source, dest_template, kind="pkg", force=None):
         ctx.force = force
         
     if kind == "pkg":
-        version = ctx.pkg.version
+        ver = ctx.pkg.version
     elif kind == "hash":
-        version = hashlib.md5(open(source).read()).hexdigest()
+        ver = hashlib.md5(open(source).read()).hexdigest()
     # elif kind == "svn":
-    #     version = get_svn_version(source)
+    #     ver = get_svn_version(source)
         
-    ver_fname = dest_template.format(version=version)
+    ver_fname = dest_template.format(version=ver)
 
     if not ctx.force and os.path.exists(ver_fname):
         if open(source).read() != open(ver_fname).read():
@@ -39,13 +44,16 @@ def add_version(ctx, source, dest_template, kind="pkg", force=None):
             or pass --force to the build command.
             """
     else:
+        # copy file contents to versioned file name
         with open(ver_fname, 'wb') as fp:
             fp.write(open(source, 'rb').read())
 
+    return ver_fname
+
 
 @task
 def version(ctx):
-    vnum = Package().version()
+    vnum = Package().version
     print vnum
     return vnum
 
@@ -74,6 +82,7 @@ def update_template_version(ctx, fname=None):
     fname = fname or ctx.pkg.update_template_version_fname
 
     if not os.path.exists(fname):
+        Path(ctx.pkg.root).makedirs(Path(fname).dirname())
         with open(fname, 'w') as fp:
             fp.write(textwrap.dedent("""
             {% load staticfiles %}

dk-tasklib-0.2.0/README.rst

@@ -1,28 +0,0 @@
-
-.. image:: https://travis-ci.org/thebjorn/dk-tasklib.svg?branch=master
-    :target: https://travis-ci.org/thebjorn/dk-tasklib
-
-
-dk-tasklib -- pyinvoke  task library
-==================================================
-
-
-Installing from PyPI
---------------------
-
-This is what you want if you just want to use dk-tasklib:
-
-   pip install dk-tasklib
-
-
-As a source package
--------------------
-This is what you want if you are developing dk-tasklib or want 
-to make local changes to the source code.
-
-   pip install -e <path>
-
-
-
-
-See docs/ folder for documentation.

dk-tasklib-0.2.0/dk_tasklib.egg-info/PKG-INFO

@@ -1,44 +0,0 @@
-Metadata-Version: 1.1
-Name: dk-tasklib
-Version: 0.2.0
-Summary: dk-tasklib - short description
-Home-page: UNKNOWN
-Author: Bjorn Pettersen
-Author-email: bp@datakortet.no
-License: UNKNOWN
-Description: 
-        .. image:: https://travis-ci.org/thebjorn/dk-tasklib.svg?branch=master
-            :target: https://travis-ci.org/thebjorn/dk-tasklib
-        
-        
-        dk-tasklib -- pyinvoke  task library
-        ==================================================
-        
-        
-        Installing from PyPI
-        --------------------
-        
-        This is what you want if you just want to use dk-tasklib:
-        
-           pip install dk-tasklib
-        
-        
-        As a source package
-        -------------------
-        This is what you want if you are developing dk-tasklib or want 
-        to make local changes to the source code.
-        
-           pip install -e <path>
-        
-        
-        
-        
-        See docs/ folder for documentation.
-        
-Platform: UNKNOWN
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Topic :: Software Development :: Libraries

dk-tasklib-0.2.0/dktasklib/lessc.py

@@ -1,109 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-import sys
-
-from invoke import run, ctask as task
-
-from .package import Package
-from .utils import switch_extension, filename, min_name, version_name, join, changed_dir
-from .version import add_version, update_template_version
-
-bootstrap = os.path.join(os.environ['SRV'], 'lib', 'bootstrap', 'less')
-
-
-@task
-def version(ctx):
-    "Display the lessc version"
-    return run("lessc --version")
-
-
-@task
-def lessc(ctx, source, destination="",
-          include_path=None,
-          strict_imports=False,
-          inline_urls=True,
-          autoprefix=True,
-          cleancss=True
-          ):
-    if include_path is None:
-        include_path = []
-    if not destination:
-        destination = source[:-len('.less')] + '.css'
-    options = ""
-    if ctx.verbose:
-        options += ' --verbose'
-    if include_path:
-        options += ' --include-path="%s"' % ';'.join(include_path)
-    if strict_imports:
-        options += " --strict-imports"
-    if inline_urls:
-        options += " --inline-urls"
-    if autoprefix:
-        options += ' --autoprefix="last 4 versions"'
-    if cleancss:
-        options += ' --clean-css="-b --s0 --advanced"'
-
-    run("lessc {options} {source} {destination}".format(**locals()))
-
-
-@task
-def build_css(ctx, lessfile, dest, version='svn',
-              build='build/css', use_bootstrap=True, **kw):
-    """Build all .less files into .css.
-       `dest` should be the target filename.
-    """
-    path = kw.pop('path', [])
-    if use_bootstrap:
-        path.append(bootstrap)
-
-    cssfname = join(build, switch_extension(filename(lessfile), '.css'))
-    minfname = min_name(dest)
-
-    # rawcss = join(build, filename(dest))
-
-    if ctx.verbose:
-        print >>sys.stderr, 'lessc..'
-        
-    lessc(
-        ctx,
-        lessfile,
-        minfname,
-        include_path=path,
-        strict_imports=True,
-        inline_urls=True,
-        autoprefix=True,
-        cleancss=True,
-    )
-    
-    if ctx.verbose:
-        print >>sys.stderr, 'verisioning..'
-    add_version(ctx, minfname, version_name(minfname), kind=version)
-
-
-@task(post=[update_template_version])
-def build_less(ctx, force=False, verbose=False, src=None, dst=None, **kw):
-    """Compile .less to .css  (pakage.json[build_less_input/output]
-    """
-    if not hasattr(ctx, 'pkg'):
-        ctx.pkg = Package()
-    if not hasattr(ctx.pkg, 'build_less_input'):
-        ctx.pkg.build_less_input = src or 'less/{pkg.name}.less'.format(pkg=ctx.pkg)
-    if not hasattr(ctx.pkg, 'build_less_output'):
-        ctx.pkg.build_less_output = dst or 'static/{pkg.name}/{pkg.name}.css'.format(pkg=ctx.pkg)
-    if not hasattr(ctx, 'force'):
-        ctx.force = force
-    if not hasattr(ctx, 'verbose'):
-        ctx.verbose = verbose
-    if ctx.verbose:
-        print 'build_less input: ', ctx.pkg.build_less_input
-        print 'build_less output:', ctx.pkg.build_less_output
-
-    dirname = os.path.dirname(ctx.pkg.build_less_input)
-    with changed_dir(dirname, '**/*.less', force=ctx.force):
-        build_css(
-            ctx,
-            ctx.pkg.build_less_input,
-            ctx.pkg.build_less_output,
-            version='pkg',
-            **kw
-        )   

dk-tasklib-0.2.0/dktasklib/npm.py

@@ -1,19 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from invoke import ctask as task
-
-
-@task
-def is_installed(ctx, pkgname, version=None):
-    "Check if an npm package is installed."
-    rc = ctx.run('npm ls -g --depth=0 {pkgname} >NUL'.format(**locals())).return_code
-    ctx[pkgname] = rc == 0
-
-
-@task
-def isinstalled(ctx, pkgname):
-    "Check if an npm package is installed."
-    rc = ctx.run('which {pkgname}'.format(**locals()), hide=True).return_code
-    ctx[pkgname] = rc == 0
-
-

dk-tasklib-0.2.0/dktasklib/utils.py

@@ -1,88 +0,0 @@
-# -*- coding: utf-8 -*-
-import inspect
-import os
-from contextlib import contextmanager
-
-import sys
-
-from dkfileutils.changed import changed
-
-join = os.path.join
-
-
-def switch_extension(fname, ext="", old_ext=None):
-    """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 os.path.split(fname)[1]
-
-
-def min_name(fname, min='.min'):
-    name, ext = os.path.splitext(fname)
-    return name + min + ext
-
-
-def version_name(fname):
-    if '.min.' in fname:
-        pre, post = fname.split('.min.')
-        return pre + '-{version}.min.' + post
-    else:
-        return min_name(fname, '-{version}')
-    
-
-@contextmanager
-def cd(directory):
-    cwd = os.getcwd()
-    os.chdir(directory)
-    yield
-    os.chdir(cwd)
-
-
-class changed_dir(object):
-    """Has `glob` changed in `dirname` or `force`
-    """
-    class NoChange(ValueError):
-        pass
-
-    def __init__(self,
-                 dirname,
-                 glob='**/*',
-                 filename='.md5',
-                 force=False,
-                 msg="nothing to do"):
-        self.dirname = dirname
-        self.glob = glob
-        self.filename = filename
-        self.force = force
-        self.msg = msg
-        self._trace = None
-
-    def __enter__(self):
-        if self.force or changed(self.dirname, self.glob, self.filename):
-            return
-        else:
-            print self.msg
-            # this horrid hack is just barely ok in task.py code...
-            # (expect debuggers/pylint/coverage/etc. to be unhappy)
-            self._trace = sys.gettrace()
-            sys.settrace(lambda *args, **kw: None)
-            frame = inspect.currentframe(1)
-            # set the trace function below on parent frame
-            frame.f_trace = self.trace
-
-    def trace(self, frame, event, arg):
-        # we just entered the with block.. cleanup and exit immediately
-        sys.settrace(self._trace)
-        raise changed_dir.NoChange()
-
-    def __exit__(self, type, value, traceback):
-        return isinstance(value, changed_dir.NoChange)

dk-tasklib-0.2.0/setup.cfg

@@ -1,8 +0,0 @@
-[wheel]
-universal = 1
-
-[egg_info]
-tag_build = 
-tag_date = 0
-tag_svn_revision = 0
-

dk-tasklib-0.2.0/setup.py

@@ -1,59 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""dk-tasklib - short description
-"""
-import os
-import sys
-
-classifiers = """\
-Development Status :: 3 - Alpha
-Intended Audience :: Developers
-Programming Language :: Python
-Programming Language :: Python :: 2
-Programming Language :: Python :: 2.7
-Topic :: Software Development :: Libraries
-"""
-
-import setuptools
-from distutils.core import setup, Command
-from setuptools.command.test import test as TestCommand
-from ConfigParser import RawConfigParser
-
-
-version = '0.2.0'
-
-
-class PyTest(TestCommand):
-    user_options = [('pytest-args=', 'a', "Arguments to pass to py.test")]
-
-    def initialize_options(self):
-        TestCommand.initialize_options(self)
-        self.pytest_args = []
-
-    def finalize_options(self):
-        TestCommand.finalize_options(self)
-        self.test_args = []
-        self.test_suite = True
-
-    def run_tests(self):
-        # import here, cause outside the eggs aren't loaded
-        import pytest
-        errno = pytest.main(self.pytest_args)
-        sys.exit(errno)
-
-
-setup(
-    name='dk-tasklib',
-    version=version,
-    requires=[],
-    install_requires=[],
-    author='Bjorn Pettersen',
-    author_email='bp@datakortet.no',
-    description=__doc__.strip(),
-    classifiers=[line for line in classifiers.split('\n') if line],
-    long_description=open('README.rst').read(),
-    cmdclass={'test': PyTest},
-    packages=['dktasklib'],
-    zip_safe=False,
-)