aridity 97__tar.gz → 99__tar.gz

{aridity-97 → aridity-99}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.1
 Name: aridity
-Version: 97
+Version: 99
 Summary: DRY config and template system, easily extensible with Python
 Home-page: https://pypi.org/project/aridity/
 Author: foyono
 Author-email: shrovis@foyono.com
 Description-Content-Type: text/markdown
 Requires-Dist: foyndation>=14
-Requires-Dist: pyparsing>=3.0.2
 
 # aridity
 DRY config and template system, easily extensible with Python.

{aridity-97 → aridity-99}/aridity/config.py

@@ -1,9 +1,9 @@
 from .functions import OpaqueKey
-from .model import Entry, Locator, Resource, Stream, Text, wrap
+from .model import Entry, Locator, Resource, Stream, wrap
 from .scope import StaticScope
 from .search import resolvedscopeornone
 from .util import NoSuchPathException, selectentrypoints
-from foyndation import dotpy, Forkable, rmsuffix, solo
+from foyndation import dotpy, Forkable, rmsuffix
 from io import StringIO
 from parabject import Parabject, register
 from pathlib import Path
@@ -74,19 +74,6 @@ class ConfigCtrl(Forkable):
         resource.source(self.basescope.getorcreatesubscope([*self.prefix, appname]), Entry([]))
         return getattr(self.node, appname)
 
-    def reapplysettings(self, mainfunction):
-        if hasattr(mainfunction, 'encode'):
-            appname = mainfunction
-        else:
-            _, appname = _processmainfunction(mainfunction)
-        s = self.scope.duplicate()
-        s.label = Text(appname)
-        p = solo(s.parents)
-        p[appname,] = s
-        parent = self._of(p)
-        parent.loadsettings()
-        return getattr(parent.node, appname)
-
     def load(self, pathorstream):
         'Execute config from the given path or stream.'
         _wrappathorstream(pathorstream).source(self.scope, Entry([]))

{aridity-97 → aridity-99}/aridity/functions.py

@@ -1,4 +1,4 @@
-from .keyring import gpg, keyring
+from .keyring import gpg
 from .model import Boolean, Hole, Indeterminate, Number, Resource, Text, wrap
 from .util import NoSuchPathException
 from foyndation import dotpy
@@ -184,7 +184,7 @@ def processtemplate(scope, resolvable):
 def _lower(scope, resolvable):
     return Text(resolvable.resolve(scope).textvalue.lower())
 
-def pyref(scope, moduleresolvable, qualnameresolvable):
+def pyref(scope, moduleresolvable, qualnameresolvable): # FIXME: Allow load from __init__.py in current dir.
     'Python object in given module with given qualified name. Module may be relative to current resource, in which case assignment with `:=` is normally necessary. Typically used to import functions.'
     def moduleobj():
         moduleref = moduleresolvable.resolve(scope).textvalue
@@ -253,7 +253,6 @@ def getimpl(scope, *resolvables):
 
 def corefunctions():
     yield 'gpg', gpg
-    yield 'keyring', keyring
     yield 'screenstr', screenstr
     yield 'scstr', scstr
     yield 'hclstr', hclstr

aridity-99/aridity/grammar.py

@@ -0,0 +1,211 @@
+from .model import Blank, Boolean, Boundary, Call, Concat, Entry, Indeterminate, nullmonitor, Number, Suffix, Text
+from decimal import Decimal
+import re
+
+class ParseException(Exception): pass
+
+booleans = {t: Boolean(b).augment(textvalue = t) for b in map(bool, range(2)) for t in [str(b).lower()]}
+brackets = {x: y for pair in ['()', '[]'] for x, y in [pair, reversed(pair)]}
+dollar = re.compile('[$]')
+dollarorbracket = re.compile(r'[$()[\]]')
+dollarorbracketorws = re.compile(r'[$()[\]\s]')
+dollaroropenorws = re.compile(r'([$([])|\s')
+eolornotws = re.compile(r'(\r\n|[\r\n])|\S')
+notws = re.compile(r'\S')
+numbermatch = re.compile('-?(?:[0-9]+(?:[.][0-9]*)?|[.][0-9]+)').fullmatch
+
+def _scalar(text):
+    try:
+        return booleans[text]
+    except KeyError:
+        m = numbermatch(text)
+    if m is None:
+        return Text(text)
+    if '.' in text:
+        val = Decimal(text)
+    else:
+        val = int(text)
+        if not val and '-' == text[0]:
+            val = Decimal(text) # Preserve sign.
+    return Number(val).augment(textvalue = text)
+
+class Parser:
+
+    def __init__(self, monitor):
+        self.monitor = monitor
+
+    def _join(self, parts):
+        n = len(parts)
+        if 0 == n:
+            return Indeterminate
+        if 1 == n:
+            return parts[0]
+        return Concat(parts, self.monitor)
+
+    def _templateparts(self, text):
+        eye = 0
+        parts = []
+        while eye < len(text):
+            m = dollar.search(text, eye)
+            if m is None:
+                parts.append(Text(text[eye:]))
+                break
+            fence = m.start()
+            if eye < fence:
+                parts.append(Text(text[eye:fence]))
+            call, eye = self._readcall(text, fence)
+            parts.append(call)
+        return parts
+
+    def readtemplate(self, text):
+        return self._join(self._templateparts(text))
+
+    def readparts(self, text):
+        eye = 0
+        parts = []
+        while eye < len(text):
+            m = eolornotws.search(text, eye)
+            if m is None:
+                parts.append(Blank(text[eye:]))
+                break
+            fence = m.start()
+            if eye < fence:
+                parts.append(Blank(text[eye:fence]))
+            if m.group(1) is None:
+                chunk, eye = self._readchunk(text, fence, None)
+                parts.append(chunk)
+            else:
+                parts.append(Boundary)
+                eye = m.end()
+        return parts
+
+    def readsuffix(self, text):
+        return Suffix(Entry(self.readparts(text)))
+
+    def _readcall(self, text, eye):
+        eye += 1
+        names = []
+        while True:
+            m = dollaroropenorws.search(text, eye)
+            openchar = m.group(1)
+            if openchar is None:
+                raise ParseException
+            names.append(text[eye:m.start()])
+            eye = m.end()
+            if '$' != openchar:
+                break
+        k = len(names) - 1
+        if '.' == names[k]:
+            args, eye = self._readspan(text, eye, False, openchar)
+            call = Text('') if not args else Concat(args, self.monitor)
+        elif "'" == names[k]:
+            args, eye = self._readspan(text, eye, True, openchar)
+            call = Text('') if not args else args[0] if 1 == len(args) else Concat(args, self.monitor)
+        else:
+            args, eye = self._readargs(text, eye, openchar)
+            call = Call(names[k], args)
+        while k:
+            k -= 1
+            if '.' != names[k]:
+                call = Call(names[k], [call])
+        return call, eye + 1
+
+    def _readargs(self, text, eye, openchar):
+        closechar = brackets[openchar]
+        args = []
+        while True:
+            m = notws.search(text, eye)
+            c = m.group()
+            eye = m.start()
+            if closechar == c:
+                break
+            chunk, eye = self._readchunk(text, eye, openchar)
+            args.append(chunk)
+        return args, eye
+
+    def _readspan(self, text, eye, literal, openchar):
+        closechar = brackets[openchar]
+        mark = eye
+        parts = []
+        depth = 0
+        while True:
+            m = dollarorbracket.search(text, eye)
+            if m is None:
+                raise ParseException
+            c = m.group()
+            if '$' == c:
+                if literal:
+                    eye = m.end()
+                else:
+                    fence = m.start()
+                    if mark < fence:
+                        parts.append(Text(text[mark:fence]))
+                    call, eye = self._readcall(text, fence)
+                    parts.append(call)
+                    mark = eye
+                continue
+            if closechar == c:
+                if depth:
+                    depth -= 1
+                    eye = m.end()
+                    continue
+                fence = m.start()
+                if mark < fence:
+                    parts.append(Text(text[mark:fence]))
+                mark = eye = fence
+                break
+            if openchar == c:
+                depth += 1
+                eye = m.end()
+                continue
+            eye = m.end()
+        return parts, eye
+
+    def _readchunk(self, text, eye, openchar):
+        closechar = brackets.get(openchar)
+        mark = eye
+        parts = []
+        depth = 0
+        while True:
+            if eye == len(text):
+                if mark < eye:
+                    parts.append(_scalar(text[mark:eye]))
+                break
+            m = dollarorbracketorws.search(text, eye)
+            if m is None:
+                parts.append(_scalar(text[mark:]))
+                mark = eye = len(text)
+                break
+            c = m.group()
+            if '$' == c:
+                fence = m.start()
+                if mark < fence:
+                    parts.append(Text(text[mark:fence]))
+                call, eye = self._readcall(text, fence)
+                parts.append(call)
+                mark = eye
+                continue
+            if closechar == c:
+                if depth:
+                    depth -= 1
+                    eye = m.end()
+                    continue
+                fence = m.start()
+                if mark < fence:
+                    parts.append(_scalar(text[mark:fence]))
+                mark = eye = fence
+                break
+            if openchar == c:
+                depth += 1
+                eye = m.end()
+                continue
+            if c not in brackets:
+                fence = m.start()
+                if mark < fence:
+                    parts.append(_scalar(text[mark:fence]))
+                mark = eye = fence
+                break
+            eye = m.end()
+        return self._join(parts), eye
+
+staticparser = Parser(nullmonitor)

aridity-99/aridity/keyring.py

@@ -0,0 +1,24 @@
+from .model import Scalar
+from base64 import b64decode
+from subprocess import CalledProcessError, check_output
+from tempfile import NamedTemporaryFile
+
+class Password(str):
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc_info):
+        pass
+
+class DecryptionFailedException(Exception): pass
+
+def gpg(scope, resolvable):
+    'Use gpg to decrypt the given base64-encoded blob.'
+    with NamedTemporaryFile() as f:
+        f.write(b64decode(resolvable.resolve(scope).textvalue))
+        f.flush()
+        try:
+            return Scalar(Password(check_output(['gpg', '-d', f.name]).decode('ascii')))
+        except CalledProcessError:
+            raise DecryptionFailedException

{aridity-97 → aridity-99}/aridity/model.py

@@ -1,10 +1,10 @@
 from .util import Burial
 from contextlib import contextmanager
-from foyndation import dotpy, Forkable, rmsuffix
+from foyndation import dotpy, Forkable, rmsuffix, singleton, solo
 from importlib import import_module
 from importlib.resources import files
 from io import TextIOWrapper
-from itertools import chain, islice
+from itertools import chain
 from parabject import dereference, UnknownParabjectException
 from pathlib import PurePath
 import numbers, os, re
@@ -124,14 +124,12 @@ class Blank(BaseSimpleValue):
     def plus(self, that):
         return Text(self.textvalue + that.textvalue)
 
-class Boundary(BaseSimpleValue):
+@singleton
+class Boundary:
 
     ignorable = True
     boundary = True
 
-    def __init__(self, scalar):
-        self.scalar = scalar
-
 class BaseScalar(BaseSimpleValue):
 
     ignorable = False
@@ -197,6 +195,7 @@ class Text(BaseScalar, Forkable):
     def plus(self, that):
         return self._of(self.textvalue + that.textvalue)
 
+@singleton
 class Indeterminate(BaseSimpleValue): # XXX: Base class needed?
 
     binaryvalue = b''
@@ -208,8 +207,6 @@ class Indeterminate(BaseSimpleValue): # XXX: Base class needed?
     def totext(self):
         return Text('')
 
-Indeterminate = Indeterminate()
-
 class ResidualHoleException(Exception): pass
 
 class Hole(BaseScalar):
@@ -345,29 +342,22 @@ class Call(Resolvable):
 
     ignorable = False
 
-    def __init__(self, name, args, brackets):
+    def __init__(self, name, args):
         self.name = name
         self.args = args
-        self.brackets = brackets
 
     def _functionvalue(self, scope):
         return scope.resolved(self.name).functionvalue
 
-    def _resolvables(self):
-        for a in self.args:
-            if not a.ignorable:
-                yield a
-
     def resolve(self, scope):
-        return self._functionvalue(scope)(scope.getresolvecontext(), *self._resolvables())
+        return self._functionvalue(scope)(scope.getresolvecontext(), *self.args)
 
     def resolvemulti(self, j, scope):
         f = self._functionvalue(scope.getresolvecontext())
         if star != f:
-            yield j, f(scope, *self._resolvables())
+            yield j, f(scope, *self.args)
         else:
-            resolvable, = self._resolvables() # XXX: Support many?
-            for k, o in resolvable.resolve(scope).resolveditems():
+            for k, o in solo(self.args).resolve(scope).resolveditems(): # XXX: Support multiple args?
                 yield (j, k), o
 
 class Directive(Resolved):
@@ -409,26 +399,18 @@ class Stream(Resolved):
         CommandReader(self.streamvalue, prefix).pipeto(scope)
 
     def processtemplate(self, scope):
-        from .grammar import templateparser
+        from .grammar import Parser
         with scope.staticscope().indent.push() as monitor:
-            return templateparser(monitor)(self.streamvalue.read()).resolve(scope)
+            return Parser(monitor).readtemplate(self.streamvalue.read()).resolve(scope)
 
 class Entry(Struct, Forkable):
 
-    @classmethod
-    def pa(cls, s, l, t):
-        return cls(t.asList())
-
     def __init__(self, resolvables):
         self.resolvables = resolvables
 
     def size(self):
         return sum(1 for r in self.resolvables if not r.ignorable)
 
-    def word(self, i):
-        word, = islice((r for r in self.resolvables if not r.ignorable), i, i + 1)
-        return word
-
     def words(self):
         return [r for r in self.resolvables if not r.ignorable]
 
@@ -467,6 +449,19 @@ class Entry(Struct, Forkable):
     def plus(self, that):
         return self._of([*self.resolvables, *that.resolvables])
 
+class MalformedEntryException(Exception): pass
+
+class Suffix:
+
+    def __init__(self, entry):
+        self.indent = entry.indent()
+        self.entry = entry
+
+    def closing(self, contextindent):
+        if any(x != y for x, y in zip(self.indent, contextindent)):
+            raise MalformedEntryException(self.entry)
+        return len(self.indent) <= len(contextindent)
+
 def wrap(value):
     'Attempt to wrap the given value in a model object of the most specific type.'
     try:

{aridity-97 → aridity-99}/aridity/repl.py

@@ -1,24 +1,10 @@
-from .grammar import commandparser
-from .model import Entry
-from pyparsing import ParseException
+from .grammar import ParseException, staticparser
+from .model import Entry, Suffix
 
 class DanglingStackException(Exception): pass
 
 class NoSuchIndentException(Exception): pass
 
-class MalformedEntryException(Exception): pass
-
-class Suffix:
-
-    def __init__(self, entry):
-        self.indent = entry.indent()
-        self.entry = entry
-
-    def closing(self, contextindent):
-        if any(x != y for x, y in zip(self.indent, contextindent)):
-            raise MalformedEntryException(self.entry)
-        return len(self.indent) <= len(contextindent)
-
 class Command:
 
     def __init__(self, entry):
@@ -40,7 +26,7 @@ class CommandReader:
 
     def _readcommands(self, line):
         try:
-            suffix = Suffix(commandparser(''.join([*self.stack, line])))
+            suffix = staticparser.readsuffix(''.join([*self.stack, line]))
             del self.stack[:]
         except ParseException:
             self.stack.append(line)

{aridity-97 → aridity-99}/aridity/scope.py

@@ -5,7 +5,7 @@ from .resolve import AnchorResolveContext
 from .search import Query
 from .stacks import IndentStack, SimpleStack, ThreadLocalResolvable
 from .util import NoSuchPathException, UnsupportedEntryException
-from foyndation import solo
+from foyndation import singleton, solo
 from itertools import chain
 import os, sys, threading
 
@@ -234,6 +234,7 @@ class Star(Function, Directive):
     def _star(self, prefix, suffix, scope):
         scope.getorcreatesubscope(prefix.topath(scope) + (self.protokey,)).execute(suffix)
 
+@singleton
 class StaticScope(Scope):
 
     rootscopekey = OpaqueKey()
@@ -245,8 +246,6 @@ class StaticScope(Scope):
             self[word,] = Directive(d)
         for name, f in corefunctions():
             self[name,] = Function(f)
-        self['keyring_cron',] = Scalar(False)
-        self['keyring_force',] = Scalar(False)
         self['~',] = Text(os.path.expanduser('~'))
         self['LF',] = Text('\n')
         self['EOL',] = Text(os.linesep)
@@ -268,8 +267,6 @@ class StaticScope(Scope):
             setattr(threadlocals, name, stack)
             return stack
 
-StaticScope = StaticScope()
-
 class ScalarScope(Scope):
 
     def __init__(self, parents, scalarobj):

{aridity-97 → aridity-99}/aridity.egg-info/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.1
 Name: aridity
-Version: 97
+Version: 99
 Summary: DRY config and template system, easily extensible with Python
 Home-page: https://pypi.org/project/aridity/
 Author: foyono
 Author-email: shrovis@foyono.com
 Description-Content-Type: text/markdown
 Requires-Dist: foyndation>=14
-Requires-Dist: pyparsing>=3.0.2
 
 # aridity
 DRY config and template system, easily extensible with Python.

aridity-99/aridity.egg-info/requires.txt

@@ -0,0 +1 @@
+foyndation>=14

{aridity-97 → aridity-99}/setup.py

@@ -49,13 +49,13 @@ class SourceInfo:
 sourceinfo = SourceInfo('.')
 setup(
     name = 'aridity',
-    version = '97',
+    version = '99',
     description = 'DRY config and template system, easily extensible with Python',
     url = 'https://pypi.org/project/aridity/',
     author = 'foyono',
     author_email = 'shrovis@foyono.com',
     py_modules = [],
-    install_requires = ['foyndation>=14', 'pyparsing>=3.0.2'],
+    install_requires = ['foyndation>=14'],
     package_data = {'': ['*.pxd', '*.pyx', '*.pyxbld', '*.arid', '*.aridt']},
     entry_points = {'console_scripts': ['aridity=aridity.__init__:main', 'arid-config=aridity.arid_config:main', 'processtemplate=aridity.processtemplate:main']},
     **sourceinfo.setup_kwargs(),

aridity-97/aridity/grammar.py

@@ -1,114 +0,0 @@
-from .model import Blank, Boolean, Boundary, Call, Concat, Entry, nullmonitor, Number, Text
-from decimal import Decimal
-from functools import partial, reduce
-from pyparsing import Forward, Literal, MatchFirst, NoMatch, OneOrMore, Optional, Regex, Suppress, ZeroOrMore
-import operator, re
-
-class AnyScalar:
-
-    numbermatch = re.compile('-?(?:[0-9]+(?:[.][0-9]*)?|[.][0-9]+)').fullmatch
-    booleans = {t: Boolean(b).augment(textvalue = t) for b in map(bool, range(2)) for t in [str(b).lower()]}
-
-    @classmethod
-    def pa(cls, s, l, t):
-        text, = t
-        try:
-            return cls.booleans[text]
-        except KeyError:
-            m = cls.numbermatch(text)
-        if m is None:
-            return Text(text)
-        if '.' in text:
-            val = Decimal(text)
-        else:
-            val = int(text)
-            if not val and '-' == text[0]:
-                val = Decimal(text) # Preserve sign.
-        return Number(val).augment(textvalue = text)
-
-def _gettext(notchars, pa):
-    return Regex(fr"[^$\s{re.escape(notchars)}]+").leaveWhitespace().setParseAction(pa)
-
-def _getarg(callchain, scalarpa, boundarychars):
-    gettext = partial(_gettext, boundarychars)
-    opttext = Optional(gettext(Text.pa))
-    return (OneOrMore(opttext + callchain) + opttext | gettext(scalarpa)).setParseAction(Concat.smartpa)
-
-def _bracketed(callchain, blankpa, scalarpa, o, c):
-    gettext = partial(_gettext, o + c)
-    bracketed = Forward()
-    chainorbrackets = callchain | (Literal(o).setParseAction(Text.pa) + bracketed + Literal(c).setParseAction(Text.pa)).leaveWhitespace()
-    opttext = Optional(gettext(Text.pa))
-    concat = OneOrMore(opttext + chainorbrackets) + opttext
-    optblank = _getoptblank(blankpa, '')
-    bracketed << ZeroOrMore(optblank + (concat | gettext(scalarpa)).setParseAction(Concat.smartpa)) + optblank
-    return bracketed
-
-def _literalbracketed(o, c):
-    bracketed = Forward()
-    brackets = (Literal(o) + bracketed + Literal(c)).leaveWhitespace()
-    opttext = Regex(f"[^{re.escape(o + c)}]*").leaveWhitespace()
-    bracketed << ZeroOrMore(opttext + brackets) + opttext
-    return bracketed
-
-def _getoptblank(pa, boundarychars):
-    return Optional(Regex(fr"[^\S{re.escape(boundarychars)}]+").leaveWhitespace().setParseAction(pa))
-
-class Parser:
-
-    def __init__(self, g, singleton = True):
-        self.g = g.parseWithTabs()
-        self.singleton = singleton
-
-    def __call__(self, text):
-        result = self.g.parseString(text, parseAll = True).asList()
-        if self.singleton:
-            result, = result
-        return result
-
-def _principalcallpa(s, l, t):
-    return Call(t[0], t[2:-1], t[1] + t[-1])
-
-def _additionalcallpa(s, l, t):
-    return Call(t[0], t[1:], ['', ''])
-
-class GFactory:
-
-    bracketpairs = '()', '[]'
-    identifier = Regex(fr"[^\s${''.join(re.escape(o) for o, _ in bracketpairs)}]*")
-
-    def __init__(self, scalarpa = AnyScalar.pa, boundarychars = '\r\n', ormorecls = OneOrMore, monitor = nullmonitor):
-        self.scalarpa = scalarpa
-        self.boundarychars = boundarychars
-        self.ormorecls = ormorecls
-        self.monitor = monitor
-
-    def templatepa(self, s, l, t):
-        return Concat(t, self.monitor)
-
-    def _bracketspa(self, s, l, t):
-        return Concat(t[1:-1] or [Text('')], self.monitor)
-
-    def create(self, pa):
-        def itercalls():
-            def getbrackets(blankpa, scalarpa):
-                return Literal(o) + _bracketed(callchain, blankpa, scalarpa, o, c) + Literal(c)
-            for o, c in self.bracketpairs:
-                yield (Suppress(Regex("[$](?:lit|')")) + Suppress(o) + _literalbracketed(o, c) + Suppress(c)).setParseAction(Text.joinpa)
-                yield (Suppress(Regex('[$](?:pass|[.])')) + getbrackets(Text.pa, Text.pa)).setParseAction(self._bracketspa)
-                yield (Suppress('$') + self.identifier + getbrackets(Blank.pa, AnyScalar.pa)).setParseAction(_principalcallpa)
-                yield (Suppress('$') + self.identifier + callchain).setParseAction(_additionalcallpa)
-        optblank = _getoptblank(Blank.pa, self.boundarychars)
-        callchain = Forward()
-        callchain << MatchFirst(itercalls()).leaveWhitespace()
-        return reduce(operator.add, [
-            self.ormorecls(optblank + _getarg(callchain, self.scalarpa, self.boundarychars)),
-            optblank,
-            Optional(Regex(f"[{re.escape(self.boundarychars)}]+").leaveWhitespace().setParseAction(Boundary.pa) if self.boundarychars else NoMatch()),
-        ]).setParseAction(pa)
-
-commandparser = Parser(GFactory(ormorecls = ZeroOrMore).create(Entry.pa))
-
-def templateparser(monitor):
-    gfactory = GFactory(scalarpa = Text.pa, boundarychars = '', monitor = monitor)
-    return Parser(gfactory.create(gfactory.templatepa) | Regex('^$').setParseAction(Text.pa))

aridity-97/aridity/keyring.py

@@ -1,51 +0,0 @@
-from .model import Scalar
-from .util import null_exc_info
-from base64 import b64decode
-from functools import partial
-from getpass import getpass
-from subprocess import CalledProcessError, check_output
-from tempfile import NamedTemporaryFile
-from threading import Semaphore
-import logging, os
-
-log = logging.getLogger(__name__)
-passwordbase = str
-setenvonce = Semaphore()
-
-class Password(passwordbase):
-
-    def __new__(cls, password, setter):
-        p = passwordbase.__new__(cls, password)
-        p.setter = setter
-        return p
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *exc_info):
-        if self.setter is not None and null_exc_info == exc_info:
-            self.setter(self)
-
-def keyring(scope, serviceres, usernameres):
-    if scope.resolved('keyring_cron').scalar and setenvonce.acquire(False):
-        key = 'DBUS_SESSION_BUS_ADDRESS'
-        value = f"unix:path=/run/user/{os.geteuid()}/bus"
-        log.debug("Set %s to: %s", key, value)
-        os.environ[key] = value
-    from keyring import get_password, set_password
-    service = serviceres.resolve(scope).textvalue
-    username = usernameres.resolve(scope).textvalue
-    password = None if scope.resolved('keyring_force').scalar else get_password(service, username)
-    return Scalar(Password(*[getpass(), partial(set_password, service, username)] if password is None else [password, None]))
-
-class DecryptionFailedException(Exception): pass
-
-def gpg(scope, resolvable):
-    'Use gpg to decrypt the given base64-encoded blob.'
-    with NamedTemporaryFile() as f:
-        f.write(b64decode(resolvable.resolve(scope).textvalue))
-        f.flush()
-        try:
-            return Scalar(Password(check_output(['gpg', '-d', f.name]).decode('ascii'), None))
-        except CalledProcessError:
-            raise DecryptionFailedException

aridity-97/aridity.egg-info/requires.txt

@@ -1,2 +0,0 @@
-foyndation>=14
-pyparsing>=3.0.2