dk-tasklib 3.0.9__py3-none-any.whl

dktasklib/pset.py

@@ -0,0 +1,122 @@
+# noinspection PyPep8Naming
+class pset(dict):
+    """Property Set class.
+       A property set is an object where values are attached to attributes,
+       but can still be iterated over as key/value pairs.
+       The order of assignment is maintained during iteration.
+       Only one value allowed per key.
+
+         >>> x = pset()
+         >>> x.a = 42
+         >>> x.b = 'foo'
+         >>> x.a = 314
+         >>> x
+         pset(a=314, b='foo')
+
+    """
+    def __init__(self, items=(), **attrs):
+        object.__setattr__(self, '_order', [])
+        super().__init__()
+        if isinstance(items, dict):
+            items = items.items()
+        for k, v in items:
+            self._add(k, v)
+        for k, v in attrs.items():
+            self._add(k, v)
+
+    def __repr__(self):
+        return '{%s}' % ', '.join(["%r: %r" % kv for kv in self])
+
+    def _add(self, key, value):
+        """Add key->value to client vars.
+        """
+        if key not in self._order:
+            self._order.append(key)
+        dict.__setitem__(self, key, value)
+
+    def remove(self, key):
+        """Remove key from client vars.
+        """
+        if key in self._order:
+            self._order.remove(key)
+        dict.__delitem__(self, key)
+
+    def __eq__(self, other):
+        """Equal iff they have the same set of keys, and the values for
+           each key is equal. Key order is not considered for equality.
+        """
+        if other is None:
+            return False
+        if type(other) is dict:
+            return dict.__eq__(self, other)
+        # noinspection PyProtectedMember
+        if set(self._order) == set(other._order):  # pylint: disable=W0212
+            for key in self._order:
+                if self[key] != other[key]:
+                    return False
+            return True
+        return False
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __iadd__(self, other):
+        for k, v in other:
+            self._add(k, v)
+        return self
+
+    def __add__(self, other):
+        """self + other
+        """
+        tmp = self.__class__()
+        tmp += self
+        tmp += other
+        return tmp
+
+    def __radd__(self, other):
+        """other + self
+        """
+        tmp = self.__class__()
+        for k, v in other.items():
+            tmp[k] = v
+        tmp += self
+        return tmp
+
+    def __getattr__(self, key):
+        if not super().__contains__(key):
+            raise AttributeError(key)
+        return dict.get(self, key)
+
+    def __getitem__(self, key):
+        return dict.get(self, key)
+
+    def __delattr__(self, key):
+        if key in self:
+            self.remove(key)
+
+    def __delitem__(self, key):
+        if key in self:
+            self.remove(key)
+
+    def __iter__(self):
+        return ((k, dict.get(self, k)) for k in self._order)
+
+    def items(self):
+        return iter(self)
+
+    def values(self):
+        # type: () -> list
+        return [dict.get(self, k) for k in self._order]
+
+    def keys(self):
+        return self._order
+
+    def __setattr__(self, key, val):
+        # assert key not in self._reserved, key
+        if key.startswith('_'):
+            object.__setattr__(self, key, val)
+        else:
+            self._add(key, val)
+
+    def __setitem__(self, key, val):
+        self._add(key, val)

dktasklib/publish.py

@@ -0,0 +1,50 @@
+from dktasklib.executables import requires
+from dktasklib.wintask import task
+from . import Package
+
+
+@requires('wheel', 'twine')
+@task(
+    default=True,
+    help={
+        'force': 'sets all other options to True',
+        'clean': 'remove the build/ and dist/ directory before starting',
+        'docs': 'build and upload docs to PyPi',
+        'wheel': 'build wheel (in addition to sdist)',
+        'sign': 'sign the wheel using weel sign pkgname',
+        'upload': 'upload to PyPI after building'
+    }
+)
+def publish(ctx, force=False, clean=True, wheel=True, sign=True, docs=False, upload=False):
+    """Publish to PyPi
+    """
+    pkg = Package()
+    if force:  # pragma: nocover
+        clean = True
+        wheel = True
+        docs = True
+        upload = True
+        sign = True     # noqa
+
+    if not wheel:
+        sign = False    # noqa
+
+    with pkg.root.cd():
+        if clean:
+            ctx.run("rm -rf dist")
+            ctx.run("rm -rf build/lib")
+            ctx.run("rm -rf build/bdist.win32")
+
+        targets = 'sdist'
+        if wheel:
+            targets += ' bdist_wheel'
+
+        ctx.run("python setup.py " + targets)
+
+        if docs:
+            ctx.run("python setup.py build_sphinx")
+
+        if upload:
+            ctx.run("twine upload dist/*")
+        else:
+            print("Not uploading (use --upload flag to upload).")

dktasklib/rule.py

@@ -0,0 +1,65 @@
+import invoke
+
+
+class BuildRule:
+    requires = []
+    after = []
+    _temp_mark = _perm_mark = False
+
+    def __init__(self, *args, **kwargs):
+        self.ctx = None
+        self.kwargs = kwargs
+        self.args = ()
+        if len(args) == 0:
+            return
+
+        ctx = None
+        first, rest = args[0], args[1:]
+        if isinstance(first, invoke.Context):
+            ctx = first
+            self.args = rest
+        else:
+            self.args = args
+
+        if ctx is not None:
+            self.run(ctx)
+
+    def run(self, ctx):
+        self.ctx = ctx
+        for task_obj in self.topsort(self.requires):
+            task_obj.run(ctx)
+
+        if self.needs_to_run():
+            self(*self.args, **self.kwargs)
+            for task_obj in self.topsort(self.after):
+                task_obj.run(ctx)
+
+    def __call__(self, *args, **kwargs):
+        raise NotImplementedError
+
+    def needs_to_run(self):
+        return True
+
+    def topsort(self, tasklist):
+        """Topological sort
+        """
+        permanent = set()
+        temporary = set()
+        res = []
+
+        def visit(task):
+            name = id(task)
+            if name in temporary:
+                raise ValueError("Circularity", name, res)
+            if name in permanent:
+                return
+            temporary.add(name)
+            for dependency in task.requires:
+                visit(dependency)
+            permanent.add(name)
+            temporary.remove(name)
+            res.append(task)
+
+        for task in tasklist:
+            visit(task)
+        return res

dktasklib/runners.py

@@ -0,0 +1,40 @@
+import subprocess
+
+
+class Result(str):
+    cmd = None
+    returncode = None
+
+
+def run(cmdline, throw=False):
+    try:
+        output = subprocess.check_output(cmdline, shell=True)
+        res = Result(output.decode('u8'))
+        res.cmd = cmdline
+        return res
+    except subprocess.CalledProcessError as e:
+        if throw:
+            raise
+        output = e.output.decode('u8') if isinstance(e.output, bytes) else e.output
+        res = Result(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

dktasklib/upversion.py

@@ -0,0 +1,165 @@
+"""
+Update a package's version number.
+"""
+import re
+import os
+import textwrap
+import warnings
+
+from dkfileutils.path import Path
+from dktasklib.wintask import task
+from invoke import Collection
+from .rule import BuildRule
+from .package import Package
+
+
+def files_with_version_numbers(pkg=None):
+    pkg = pkg or Package()
+    root = pkg.root
+    default = {
+        root / 'setup.py',
+        root / 'package.json',
+        root / 'package.ini',
+        root / 'package.yaml',
+        root / 'dkbuild.yml',
+        root / 'docs' / 'conf.py',
+        root / 'src' / 'version.js',
+        root / 'js' / 'version.js',
+        root / 'styles' / 'index.less',
+        root / 'styles' / 'index.scss',
+        root / 'less' / 'index.less',
+        pkg.source / '__init__.py',
+        pkg.source / '_version.py',
+        pkg.source / 'package.json',
+    }
+    return default
+
+
+def _replace_version(fname, cur_version, new_version):
+    """Replace the version string ``cur_version`` with the version string
+       ``new_version`` in ``fname``.
+    """
+    if not fname.exists():
+        return False
+
+    with open(fname, 'rb') as fp:
+        txt = fp.read()
+
+    cur_version = cur_version.encode('u8')
+    new_version = new_version.encode('u8')
+    if cur_version not in txt:  # pragma: nocover
+        return False
+    occurences = txt.count(cur_version)
+    if occurences > 2:  # pragma: nocover
+        warnings.warn(
+            "Found version string (%r) multiple times in %r, skipping" % (
+                cur_version, fname
+            )
+        )
+    txt = txt.replace(cur_version, new_version)
+
+    with open(fname, 'wb') as fp:
+        fp.write(txt)
+    return 1
+
+
+@task(
+    autoprint=True,
+    default=True,
+    help=dict(
+        major="update major version number (set minor and patch to 0)",
+        minor="update minor version number (set patch to 0)",
+        patch="(default) update patch version",
+        tag="create a tag (git only)"
+    )
+)
+def upversion(ctx, major=False, minor=False, patch=False, tag=False):
+    """Update package version (default patch-level increase).
+    """
+    # while it may be tempting to make this task auto-tag the new version,
+    # this is generally a bad idea (bumpversion did this, and it was a mess)
+    pkg = Package()
+    if not (major or minor or patch):
+        patch = True  # pragma: nocover
+    txt_version = pkg.version
+    cur_version = [int(n, 10) for n in txt_version.split('.')]
+    if major:
+        cur_version[0] += 1
+        cur_version[1] = 0
+        cur_version[2] = 0
+    elif minor:
+        cur_version[1] += 1
+        cur_version[2] = 0
+    elif patch:
+        cur_version[2] += 1
+    new_version = '.'.join([str(n) for n in cur_version])
+
+    changed = 0
+    changed_files = []
+    addlfiles = set()
+    if hasattr(ctx, 'versionfiles'):
+        addlfiles = {pkg.root / fname for fname in ctx.versionfiles}
+    for fname in addlfiles | files_with_version_numbers():
+        was_changed = _replace_version(fname, txt_version, new_version)
+        changed += was_changed
+        if was_changed:
+            changed_files.append(fname)
+    if changed == 0:
+        warnings.warn("I didn't change any files...!")  # pragma: nocover
+    elif tag and pkg.vcs() == 'git':
+        with pkg.root.abspath().cd():
+            ctx.run('git tag -a v{version} -m "Version {version}"'.format(
+                version=new_version
+            ))
+            ctx.run('git push origin --tags')
+    print("changed version to %s in %d files" % (new_version, changed))
+    for fname in changed_files:
+        print('  ', fname)
+    return new_version
+
+
+class UpdateTemplateVersion(BuildRule):
+    def __call__(self, fname):
+        fname = fname.format(**self.ctx)
+
+        if not os.path.exists(fname):
+            Path(self.ctx.pkg.root).makedirs(Path(fname).dirname())
+            with open(fname, 'w') as fp:
+                fp.write(textwrap.dedent("""
+                {% load staticfiles %}
+                {% with "0.0.0" as version %}
+                    {# keep the above exactly as-is (it will be overwritten when compiling the css). #}
+                    {% with app_path="PKGNAME/PKGNAME-"|add:version|add:".min.css" %}
+                        {% if debug %}
+                            <link rel="stylesheet" type="text/css" href='{% static "PKGNAME/PKGNAME.css" %}'>
+                        {% else %}
+                            <link rel="stylesheet" type="text/css" href="{% static app_path %}">
+                        {% endif %}
+                    {% endwith %}
+                {% endwith %}
+                """).replace("PKGNAME", self.ctx.pkg.name))
+
+        with open(fname, 'r') as fp:
+            txt = fp.read()
+
+        newtxt = re.sub(
+            r'{% with "(\d+\.\d+\.\d+)" as version',
+            '{{% with "{}" as version'.format(self.ctx.pkg.version),
+            txt
+        )
+        with open(fname, 'w') as fp:
+            fp.write(newtxt)
+        print('Updated {% import %} template:', fname)
+
+
+ns = Collection(
+    'upversion',
+    upversion,
+)
+ns.configure({
+    'force': False,
+    'pkg': {
+        'name': '<package-name>',
+        'version': '<version-string>',
+    },
+})

dktasklib/urlinliner.py

@@ -0,0 +1,90 @@
+from dktasklib.wintask import task
+import base64
+import os
+import re
+from urllib.request import urlopen
+
+
+def inline_data(data, type='image/png', name=""):
+    """Inline (encode) the ``data``.
+    """
+    if len(data) > 10 * 1024:
+        print("%s is too big (%d bytes), max is 10KB" % (name, len(data)))
+        return name
+
+    encoded = base64.b64encode(data).decode('ascii')
+    return 'data:{type};base64,{encoded}'.format(
+        type=type,
+        encoded=encoded.replace('\n', '')
+    )
+
+
+def inline_file(fname):
+    """Inline from a file source named ``fname``.
+    """
+    ext = os.path.splitext(fname)[1]  # ".png"
+    return inline_data(
+        open(fname, 'rb').read(),
+        type='image/' + ext[1:],      # remove the dot
+        name=fname
+    )
+
+
+def inline_url(uri):
+    """Fetch ``uri`` and inline.
+    """
+    with urlopen(uri) as fp:
+        return inline_data(
+            fp.read(),
+            type=fp.headers['Content-Type'],
+            name=uri
+        )
+
+
+@task(
+    default=True
+)
+def inline(ctx, fname):
+    """Compile a file of inlines to data uris.
+
+       The file should be named foo.less.inline, and contain a list
+       of variables, i.e.::
+
+           @foo: "http://.." ;
+           @bar: "path/to/local/file.png";
+
+       into::
+
+           @foo: "data:image/png;base64,..."
+           @bar: "data:image/png;base64,..."
+
+       for all resources that are less than 10KB and writes the result
+       to `foo.less` (i.e. the filname without the `.inline` extension).
+
+       If the resource is too big, the original value is passed through,
+       so if you specify a url it should always be safe (but slower to build).
+    """
+    lines = open(fname).readlines()
+    output_fname = os.path.splitext(fname)[0]
+    with open(output_fname, 'w') as fp:
+        for line in lines:
+            if line.startswith('@'):
+                varname, content = line.split(':', 1)
+                content = content.strip().rstrip(';').strip("\"'")
+                if re.match(r'^https?://', content):
+                    data = inline_url(content)
+                else:
+                    data = inline_file(content)
+                line = '{varname}: "{content}";\n'.format(
+                    varname=varname,
+                    content=data
+                )
+            fp.write(line)
+
+
+@task
+def list_urls(ctx, filename):
+    """List all url(..) targets in the filename.
+    """
+    for match in re.findall(r'url\((.*?)\)', open(filename).read()):
+        print(match)