PyPI - ct - Versions diffs - 0.10.8.114__py3-none-any.whl - Mend

ct 0.10.8.114__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (55) hide show

cantools/__init__.py +24 -0
cantools/_db.py +142 -0
cantools/_memcache.py +76 -0
cantools/_pay.py +46 -0
cantools/admin.py +31 -0
cantools/cfg.py +347 -0
cantools/config.py +131 -0
cantools/db/__init__.py +18 -0
cantools/db/admin.py +27 -0
cantools/db/gae/__init__.py +0 -0
cantools/db/gae/model.py +127 -0
cantools/db/gae/properties.py +35 -0
cantools/db/wp.py +99 -0
cantools/geo.py +188 -0
cantools/hooks.py +13 -0
cantools/scripts/__init__.py +0 -0
cantools/scripts/bench.py +167 -0
cantools/scripts/builder.py +272 -0
cantools/scripts/deploy.py +154 -0
cantools/scripts/doc.py +239 -0
cantools/scripts/index.py +226 -0
cantools/scripts/init.py +345 -0
cantools/scripts/migrate.py +593 -0
cantools/scripts/pubsub/__init__.py +28 -0
cantools/scripts/pubsub/actor.py +13 -0
cantools/scripts/pubsub/bots.py +143 -0
cantools/scripts/pubsub/channel.py +85 -0
cantools/scripts/pubsub/ps.py +145 -0
cantools/scripts/pubsub/user.py +51 -0
cantools/scripts/start.py +53 -0
cantools/scripts/util.py +24 -0
cantools/util/__init__.py +78 -0
cantools/util/admin.py +620 -0
cantools/util/data.py +109 -0
cantools/util/media.py +303 -0
cantools/util/package.py +125 -0
cantools/util/system.py +73 -0
cantools/web/__init__.py +9 -0
cantools/web/dez_server/__init__.py +1 -0
cantools/web/dez_server/controller.py +129 -0
cantools/web/dez_server/cron.py +115 -0
cantools/web/dez_server/daemons.py +64 -0
cantools/web/dez_server/mail.py +24 -0
cantools/web/dez_server/response.py +63 -0
cantools/web/dez_server/routes.py +21 -0
cantools/web/dez_server/server.py +229 -0
cantools/web/dez_server/sms.py +12 -0
cantools/web/gae_server.py +68 -0
cantools/web/util.py +552 -0
ct-0.10.8.114.dist-info/LICENSE +9 -0
ct-0.10.8.114.dist-info/METADATA +25 -0
ct-0.10.8.114.dist-info/RECORD +55 -0
ct-0.10.8.114.dist-info/WHEEL +5 -0
ct-0.10.8.114.dist-info/entry_points.txt +10 -0
ct-0.10.8.114.dist-info/top_level.txt +1 -0

cantools/web/gae_server.py ADDED Viewed

@@ -0,0 +1,68 @@
+from google.appengine.runtime.apiproxy_errors import RequestTooLargeError
+from google.appengine.api import mail
+from .util import *
+envelope = {
+    'plain': "\n%s",
+    'html': "\n\n<html><head></head><body>%s</body></html>"
+}
+respond = do_respond
+set_env(lambda html : envelope[html and 'html' or 'plain'])
+# requests
+def fetch(host, path="/", port=80, asjson=False):
+    from google.appengine.api.urlfetch import fetch
+    raw = fetch("http://%s:%s%s"%(host, port, path)).content
+    if asjson:
+        return json.loads(raw)
+    return raw
+def post(host, path="/", port=80, data=None, protocol="http", asjson=False):
+    from google.appengine.api.urlfetch import fetch
+    raw = fetch("%s://%s:%s%s"%(protocol, host, port, path),
+        payload=json.dumps(data), method="POST").content
+    if asjson:
+        return json.loads(raw)
+    return raw
+# file uploads
+def read_file(data_field):
+    try:
+        return data_field.file.read()
+    except RequestTooLargeError:
+        fail("The file you are trying to upload is too large. Please submit something under 1MB. Thank you!", html=True, noenc=True)
+# emails
+def send_mail(to=None, subject=None, body=None, html=None):
+    m = config.mailer
+    if not m:
+        fail("failed to send email -- no MAILER specified in ct.cfg!")
+    if config.mailername:
+        m = "%s <%s>"%(config.mailername, m)
+    mail.send_mail(to=to, sender=m, subject=subject, body=body, html=html)
+# memcache stuff
+def getmem(key, tojson=True):
+    from google.appengine.api import memcache
+    result = memcache.get(key)
+    if result is None: return None
+    return tojson and json.loads(result) or result
+def setmem(key, val, fromjson=True):
+    from google.appengine.api import memcache
+    memcache.set(key, fromjson and json.dumps(val) or val)
+def delmem(key):
+    from google.appengine.api import memcache
+    if memcache.get(key) is not None:
+        memcache.delete(key)
+def clearmem():
+    from google.appengine.api import memcache
+    memcache.flush_all()
+set_getmem(getmem)
+set_setmem(setmem)
+set_delmem(delmem)
+set_clearmem(clearmem)

cantools/web/util.py ADDED Viewed

@@ -0,0 +1,552 @@
+import re, os, sys, ast, json, time, threading
+try:
+    from urllib.parse import quote, unquote, urlencode # py3
+    from urllib.request import urlopen, Request
+except:
+    from urllib import quote, unquote, urlencode # py2.7
+    from urllib2 import urlopen, Request
+from base64 import b64encode, b64decode
+from dez.http.static import StaticStore
+from cantools import config
+from six import string_types
+DEBUG = True
+# memcache stuff -- overwrite with setters
+def getmem(key, tojson=True):
+    log("memcache getting: %s"%(key,))
+def setmem(key, val, fromjson=True):
+    log("memcache setting: %s -> %s"%(key, val))
+def delmem(key):
+    log("memcache deleting: %s"%(key,))
+def clearmem():
+    log("memcache clearing")
+def set_getmem(f):
+    global getmem
+    getmem = f
+def set_setmem(f):
+    global setmem
+    setmem = f
+def set_delmem(f):
+    global delmem
+    delmem = f
+def set_clearmem(f):
+    global clearmem
+    clearmem = f
+# logging -- overwrite with setlog if ya want
+def log(*args, **kwargs):
+    print(args, kwargs)
+# encoding, decoding -- may overwrite with setenc/setdec, but not _that_ necessary
+_c = config.scrambler
+_cl = len(_c)
+_chl = int(_cl / 2)
+def flip(c):
+    i = _c.find(c)
+    if i == -1:
+        return c
+    return _c[(i + _chl) % _cl]
+def scramble(s):
+    return "".join([flip(c) for c in s])
+def enc(data):
+    return scramble(b64encode(hasattr(data, "encode") and data.encode() or data).decode())
+def dec(data):
+    return data.startswith("{") and data or b64decode(scramble(data)).decode()
+# setters (see above)
+def setlog(f):
+    global log
+    log = f
+def setenc(f):
+    global enc
+    enc = f
+def setdec(f):
+    global dec
+    dec = f
+# threading
+localvars = threading.local()
+def local(key, fallback=None):
+    return getattr(localvars, key, fallback)
+# request functions
+def deUnicodeDict(d):
+    if not isinstance(d, dict):
+        return d
+    n = {}
+    for v in d:
+        n[str(v)] = deUnicodeDict(d[v])
+    return n
+def cgi_dump():
+    return local("request_string")
+def cgi_read():
+    return local("read", sys.stdin.read)()
+def set_read(f):
+    localvars.read = f
+def set_redir(f):
+    localvars.redir = f
+def rdec(data):
+    bdata = b64decode(data.encode())
+    try: # py2
+        return unquote(bdata).decode()
+    except: #py3
+        return unquote(bdata.decode())
+def renc(data):
+    try: # py2
+        return b64encode(quote(data).encode()).decode()
+    except: #py3
+        return b64encode(quote(data.encode())).decode()
+def rb64(data, de=False): # depped
+    log("[DEPRECATION WARNING] Something just called rb64(), which is depped -- use rec_conv()")
+    return rec_conv(data, de)
+def rec_conv(data, de=False):
+    if isinstance(data, bytes):
+        try:
+            data = data.decode()
+        except:
+            pass
+    if isinstance(data, string_types):
+        return (de and rdec or renc)(data)
+    elif isinstance(data, dict):
+        for k, v in list(data.items()):
+            data[k] = rec_conv(v, de)
+    elif isinstance(data, list):
+        return [rec_conv(d, de) for d in data]
+    return data
+def qs_get(x, y):
+    val = localvars.request.getvalue(x, y)
+    if val:
+        val = unquote(val)
+    return val
+def cgi_load(force=False):
+    localvars.request_string = cgi_read()
+    data = config.encode and dec(localvars.request_string) or localvars.request_string
+    try:
+        try:
+            jdata = json.loads(data)
+        except:
+            jdata = ast.literal_eval(data)
+        try:
+            localvars.request = rec_conv(jdata, True)
+        except:
+            localvars.request = jdata
+    except:
+        import cgi
+        localvars.request = cgi.FieldStorage()
+        setattr(localvars.request, "get", qs_get)
+    if not localvars.request:
+        if force or config.web.server == "dez":
+            localvars.request = {}
+        else:
+            fail('no request data!')
+def cgi_get(key, choices=None, required=True, default=None, shield=False, decode=False, base64=False):
+    request = local("request")
+    val = request.get(key, default)
+    if val is None:
+        required and fail('no value submitted for required field: "%s" [%s]'%(key, request))
+    elif shield:
+        ip = local("ip")
+        shield = config.web.shield
+        if shield(val, ip, fspath=True, count=False):
+            log('cgi_get() shield bounced "%s" for "%s"'%(ip, shield.ip(ip)["message"]))
+            fail()
+    if choices and val not in choices:
+        fail('invalid value for "%s": "%s"'%(key, val))
+    if base64 and val:
+        val = b64decode(unquote(val))
+    if decode and val:
+        val = unquote(val)
+    return val
+# response functions
+def _send(data):
+    send = local("send")
+    if send:
+        send(data)
+    else:
+        print(data)
+def set_send(f):
+    localvars.send = f
+def _close():
+    local("close", sys.exit)()
+def set_close(f):
+    localvars.close = f
+def _pre_close():
+    pass
+def set_pre_close(f):
+    global _pre_close
+    _pre_close = f
+def _header(hkey, hval):
+    header = local("header")
+    if header:
+        header(hkey, hval)
+    else:
+        _send("%s: %s"%(hkey, hval))
+def set_header(f):
+    localvars.header = f
+def _write(data, exit=True, savename=None):
+    if savename:
+        setmem(savename, data, False)
+#    try:
+#        data = data.decode('ascii', 'replace').encode('utf-8')
+#    except Exception as e:
+#        data = data.encode('utf-8')
+    _send(data)
+    if exit:
+        _pre_close()
+        _close()
+def trysavedresponse(key=None):
+    key = key or local("request_string")
+    response = getmem(key, False)
+    response and _write(response, exit=True)
+def dez_wrap(resp, failure):
+    from cantools.db import seshman
+    from rel.errors import AbortBranch
+    def f():
+        try:
+            resp()
+        except AbortBranch as e:
+            seshman.close()
+            raise AbortBranch() # handled in rel
+        except SystemExit:
+            pass
+        except Exception as e:
+            failure(e)
+    return f
+def gae_wrap(resp, failure):
+    def f():
+        try:
+            resp()
+        except SystemExit:
+            pass
+        except Exception as e:
+            failure(e)
+    return f
+resp_wrap = { "dez": dez_wrap, "gae": gae_wrap }
+def do_respond(responseFunc, failMsg="failed", failHtml=False, failNoEnc=False, noLoad=False, threaded=False, response=None, autowin=True):
+    def resp():
+        response and response.set_cbs()
+        noLoad or cgi_load()
+        responseFunc()
+        autowin and succeed()
+    def failure(e):
+        fail(data=failMsg, html=failHtml, err=e, noenc=failNoEnc)
+    wrapped_response = resp_wrap[config.web.server](resp, failure)
+    if threaded: # dez only!!!
+        from rel import thread
+        thread(wrapped_response)
+    else:
+        wrapped_response()
+def redirect(addr, msg="", noscript=False, exit=True, metas=None):
+    a = "<script>"
+    if msg:
+        a += 'alert("%s"); '%(msg,)
+    a += "document.location = '%s';</script>"%(addr,)
+    if noscript:
+        a += '<noscript>This site requires Javascript to function properly. To enable Javascript in your browser, please follow <a href="http://www.google.com/support/bin/answer.py?answer=23852">these instructions</a>. Thank you, and have a nice day.</noscript>'
+    if metas:
+        a = "<html><head>%s%s</head><body></body></html>"%(metas, a)
+    _header("Content-Type", "text/html")
+    _write(_env(True)%(a,), exit)
+def setcachedefault(shouldCache=True):
+    # deprecated -- should set via config.memcache.update("requst", [bool])
+    config.memcache.update("request", shouldCache)
+def _env(html):
+    return "%s"
+def set_env(f):
+    global _env
+    _env = f
+def processResponse(data, code):
+    if code == "1":
+        try:
+            data = json.dumps(data)
+        except:
+            data = json.dumps(rec_conv(data))
+            code = "3"
+    elif code == "0":
+        try:
+            json.dumps(data)
+        except:
+            data = rec_conv(data)
+            code = "2"
+    return "%s%s"%(code, data)
+def succeed_sync(func, cb):
+    d = {}
+    def handle(*a, **k):
+        d["a"] = a
+        d["k"] = k
+    func(handle)
+    while True:
+        time.sleep(0.01)
+        if d["a"] or d["k"]:
+            succeed(cb(*d["a"], **d["k"]))
+def succeed(data="", html=False, noenc=False, savename=None, cache=False):
+    if cache or config.memcache.request:
+        savename = local("request_string")
+    _header("Content-Type", "text/%s"%(html and "html" or "plain"))
+    draw = processResponse(data, "1")
+    dstring = (config.encode and not noenc) and enc(draw) or draw
+    _write(_env(html)%(dstring,), savename=savename)
+def fail(data="failed", html=False, err=None, noenc=False, exit=True):
+    if err:
+        # log it
+        import traceback
+        logdata = "%s --- %s --> %s"%(data, repr(err), traceback.format_exc())
+        log(logdata, "error")
+        if DEBUG:
+            # write it
+            data = logdata
+        resp = local("response")
+        reqstring = local("request_string")
+        path = resp and resp.request.url or "can't find path!"
+        ip = local("ip") or (resp and resp.ip or "can't find ip!")
+        edump = "%s\n\n%s\n\n%s\n\n%s"%(path, ip, reqstring, logdata)
+        shield = config.web.shield
+        if reqstring and shield(reqstring, ip):
+            data = "nabra"
+            reason = shield.ip(ip)["message"]
+            logline = "%s - IP (%s) banned!"%(reason, ip)
+            edump = "%s\n\n%s"%(logline, edump)
+            log(logline)
+        elif config.web.eflags:
+            samples = {
+                "traceback": logdata
+            }
+            if reqstring:
+                samples["request"] = reqstring
+            for sample in samples:
+                for ef in config.web.eflags:
+                    if ef in samples[sample]:
+                        reason = '"%s" in %s'%(ef, sample)
+                        logline = "%s - IP (%s) banned!"%(reason, ip)
+                        edump = "%s\n\n%s"%(logline, edump)
+                        shield.suss(ip, reason)
+                        log(logline)
+        if config.web.report:
+            from cantools.web import email_admins
+            email_admins("error encountered", edump)
+    _header("Content-Type", "text/%s"%(html and "html" or "plain"))
+    draw = processResponse(data, "0")
+    dstring = (config.encode and not noenc) and enc(draw) or draw
+    _write(_env(html)%(dstring,), exit)
+def _headers(headers):
+    for k, v in list(headers.items()):
+        _header(k, v)
+    if config.web.server == "gae":
+        _send("")
+def send_pdf(data, title=None):
+    if title:
+        _headers({
+            "Content-Type": 'application/pdf; name="%s.pdf"'%(title,),
+            "Content-Disposition": 'attachment; filename="%s.pdf"'%(title,)
+        })
+    else:
+        _headers({"Content-Type": "application/pdf"})
+    _send(data)
+    _close()
+def send_image(data):
+    _headers({"Content-Type": "image/png"})
+    _send(data)
+    _close()
+FILETYPES = {"pdf": "application/pdf", "img": "image/png", "ico": "image/ico", "html": "text/html"}
+def send_file(data, file_type=None, detect=False, headers={}):
+    if detect:
+        import magic
+        file_type = data and magic.from_buffer(data, True)
+    if file_type:
+        headers["Content-Type"] = FILETYPES.get(file_type, file_type)
+    _headers(headers)
+    _send(data)
+    _close()
+def send_text(data, dtype="html", fname=None, exit=True, headers={}):
+    headers["Content-Type"] = "text/%s"%(dtype,)
+    if fname:
+        headers['Content-Disposition'] = 'attachment; filename="%s.%s"'%(fname, dtype)
+    _headers(headers)
+    _write(data, exit)
+def send_xml(data):
+    send_text(data, "xml")
+# misc
+def verify_recaptcha(cresponse, pkey):
+    verification_result = urlopen(Request(
+        url = "https://www.google.com/recaptcha/api/siteverify",
+        data = urlencode({
+            'secret': pkey,
+            'remoteip': os.environ.get('REMOTE_ADDR', os.environ.get('REMOTE_HOST')),
+            'response': cresponse
+        }).encode(),
+        headers = {
+            "Content-type": "application/x-www-form-urlencoded"
+        }))
+    vdata = verification_result.read().decode()
+    verification_result.close()
+    if "true" not in vdata:
+        fail(vdata)
+def strip_punctuation(s):
+    return "".join([c for c in s if c.isalnum() or c.isspace()])
+def strip_html(s):
+    p = re.compile(r'<.*?>')
+    return p.sub("", s)
+def strip_html_carefully(s, besides=[]):
+    i = s.find('<');
+    while i != -1:
+        j = s.find('>', i)
+        if s[i+1:j] in besides or s[i+2:j] in besides:
+            i = s.find('<', i+1)
+        else:
+            s = s[:i] + s[j+1:]
+            i = s.find('<')
+    s = s.replace("&nbsp;", " ")
+    while "  " in s:
+        s = s.replace("  ", " ")
+    return s
+# media extraction
+ITYPES = [ # from CT.parse.imgTypes[]
+    ".png", ".PNG",
+    ".jpg", ".JPG",
+    ".gif", ".GIF",
+    ".img", ".IMG",
+    ".bmp", ".BMP",
+    "jpeg", "JPEG",
+    "webp", "WEBP",
+    "avif", "AVIF"
+]
+def vid2thumb(url):
+    if "youtube.com" in url and "img.youtube.com" not in url:
+        if "shorts" in url:
+            token = url.split("/").pop()
+        else:
+            token = url.split("?v=")[1]
+        url = "https://img.youtube.com/vi/%s/0.jpg"%(token,)
+    elif "tl.fzn.party" in url:
+        url = url.replace("/v/", "/img/v/").replace(".mp4", ".jpg")
+    if url[-4:] in ITYPES: # fast
+        return url
+    for itype in ITYPES: # thorough
+        if itype in url:
+            return url
+def text2image(parts, full=False):
+    name = []
+    while parts:
+        part = parts.pop(0)
+        if part.startswith("https://"):
+            part = vid2thumb(part)
+            if not part:
+                continue
+            if part[-4:] in ITYPES: # fast
+                break
+            for itype in ITYPES: # thorough
+                if itype in part:
+                    break
+        name.append(part)
+    if full:
+        return " ".join(name), part, " ".join(parts)
+    return part
+def text2parts(text):
+    if " http" in text:
+        name, rest = text.split(" http", 1)
+        if " " in rest:
+            image, blurb = rest.split(" ", 1)
+            image = vid2thumb("http%s"%(image,))
+            if name and image and blurb:
+                return name, image, blurb
+    return text2image(text.split(" "), True)
+# metaization
+metastore = StaticStore()
+qcache = {}
+METS = """
+  <meta property="og:title" content="%s">
+  <meta property="twitter:title" content="%s">
+  <meta property="og:image" content="%s">
+  <meta property="twitter:image" content="%s">
+  <meta property="og:description" content="%s">
+  <meta property="twitter:description" content="%s">
+  <meta property="description" content="%s">
+"""
+def metized(m, markup=None):
+    n = m["name"]
+    i = m["image"]
+    b = m["blurb"]
+    mets = METS%(n, n, i, i, b, b, b)
+    return markup and markup.replace("<head>",
+        "<head>%s"%(mets,)) or mets
+def metize(mextractor):
+    qs = local("request_string") # better key?
+    p = local("response").request.url
+    mdir = config.mode == "dynamic" and "html" or "html-%s"%(config.mode,)
+    fp = "%s%s"%(mdir, p)
+    if os.path.isdir(fp):
+        fp += "/index.html"
+    if p not in qcache:
+        qcache[p] = {}
+    if qs not in qcache[p]:
+        markup = metastore.read(fp)[0].decode()
+        metas = mextractor(p, markup)
+        qcache[p][qs] = metas and metized(metas, markup) or markup
+    send_file(qcache[p][qs])

ct-0.10.8.114.dist-info/LICENSE ADDED Viewed

@@ -0,0 +1,9 @@
+MIT License:
+Copyright (c) 2011 Civil Action Network
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

ct-0.10.8.114.dist-info/METADATA ADDED Viewed

@@ -0,0 +1,25 @@
+Metadata-Version: 2.1
+Name: ct
+Version: 0.10.8.114
+Summary: Modern minimal web framework
+Author: Mario Balibrera
+Author-email: mario.balibrera@gmail.com
+License: MIT License
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+License-File: LICENSE
+Requires-Dist: catmail >=0.1.9.1
+Requires-Dist: databae >=0.1.4.6
+Requires-Dist: dez >=0.10.10.37
+Requires-Dist: fyg >=0.1.7.2
+Requires-Dist: rel >=0.4.9.20
+Requires-Dist: requests >=2.3.0
+Requires-Dist: six >=1.12.0
+Requires-Dist: venvr >=0.1.5.3
+This portable modern web framework is the application-neutral backbone of Civil Action Network. It includes: a pubsub WebSocket server and bot platform; swappable web backends capable of targeting high-concurrency standalone or cloud platforms; a variable-mode application compiler; a broad-spectrum ORM and database migration tools; a built in administrative interface; and a rich modular JavaScript library.