ct 0.10.8.114__py3-none-any.whl

cantools/__init__.py

@@ -0,0 +1,24 @@
+__version__ = "0.10.8.114"
+
+from . import util, hooks
+from . import config as cfgmod
+config = cfgmod.config
+include_plugin = cfgmod.include_plugin
+mods_and_repos = cfgmod.mods_and_repos
+
+if config.web.server == "gae":
+	util.init_gae()
+else:
+	util.init_basic()
+from . import geo
+from .scripts import builder, deploy, init, pubsub, start, index, migrate, doc, bench, util
+
+ctstart = start.go
+ctdeploy = deploy.run
+ctpubsub = pubsub.get_addr_and_start
+ctinit = init.parse_and_make
+ctindex = index.go
+ctmigrate = migrate.go
+ctdoc = doc.build
+ctbench = bench.run
+ctutil = util.run

cantools/_db.py

@@ -0,0 +1,142 @@
+import json
+from cantools.web import respond, succeed, fail, send_file, send_text, cgi_get, cgi_dump, read_file, getmem, setmem, clearmem
+from cantools.db import get, get_model, get_schema, get_blobs, get_page, get_bulker, get_multi, put_multi, edit, dprep, admin, BlobWrapper
+from cantools.util.data import props, spreadsheet
+from cantools.util import getxls
+from cantools import config
+import model # load up all models (for schema)
+
+def response():
+	action = cgi_get("action", choices=["schema", "blobs", "get", "blob", "edit", "edits", "delete", "put", "index", "bulk", "spreadsheet", "credcheck"])
+
+	# edit/delete/put/index/bulk always require credentials; getters do configurably
+	if not config.db.public or action in ["blobs", "edit", "edits", "delete", "put", "index", "bulk", "spreadsheet", "credcheck"]:
+		pw = cgi_get("pw")
+		if pw != config.admin.pw:
+			if not pw or pw != config.apikey:
+				fail("wrong")
+
+	# clear cache!
+	if (config.memcache.db or config.memcache.dbclear) and action in ["edit", "delete", "put", "bulk"]:
+		clearmem()
+
+	if action == "schema":
+		succeed(get_schema())
+	elif action == "blobs":
+		succeed(get_blobs(cgi_get("variety")))
+	elif action == "bulk":
+		rawd = read_file(cgi_get("data"))
+		mname = cgi_get("modelName")
+		fixed = json.loads(cgi_get("fixed", default="{}"))
+		mod = get_model(mname)
+		bulker = get_bulker(mname)
+		if bulker:
+			bulker(rawd, fixed)
+		else:
+			data = getxls(rawd) # add: csv, etc
+			schema = get_schema(mname)
+			smap = {}
+			headers = data.pop(0)
+			puts = []
+			for index in range(len(headers)):
+				header = headers[index]
+				if header in schema:
+					smap[header] = index
+			for properties in data:
+				kwargs = {}
+				for p in smap:
+					kwargs[p] = properties[smap[p]]
+				for p in fixed:
+					kwargs[p] = fixed[p]
+				puts.append(mod(**kwargs))
+			put_multi(puts)
+	elif action == "spreadsheet":
+		ssform = cgi_get("format", default="csv")
+		mname = cgi_get("modelName")
+		mod = get_model(mname)
+		fkey = cgi_get("fixed_key", required=False)
+		fval = cgi_get("fixed_value", required=False)
+		q = mod.query()
+		if fkey:
+			q.filter(getattr(mod, fkey) == fval)
+			mname = "%s_%s"%(mname, fval)
+		send_text(spreadsheet(ssform, q.all(), props(mod)), ssform, mname)
+	elif action == "get":
+		sig = cgi_dump()
+		res = config.memcache.db and getmem(sig, False) or None
+		if not res:
+			mname = cgi_get("modelName", required=False)
+			keys = cgi_get("keys", required=False)
+			exporter = cgi_get("exporter", default="export")
+			if mname:
+				order = cgi_get("order", default="index")
+				if config.web.server == "gae":
+					order = getattr(get_model(mname), order)
+				res = get_page(mname, int(cgi_get("limit")), int(cgi_get("offset")), order,
+					cgi_get("filters", default={}), count=cgi_get("count", required=False), exporter=exporter)
+			elif keys:
+				res = [getattr(d, exporter)() for d in get_multi(keys)]
+			else:
+				res = getattr(get(cgi_get("key")), exporter)()
+			if config.memcache.db and config.web.server == "dez":
+				setmem(sig, res, False)
+		succeed(res)
+	elif action == "blob":
+		value = cgi_get("value", required=False) # fastest way
+		data = cgi_get("data", required=False)
+		prop = cgi_get("property", required=False)
+		entkey = cgi_get("key", required=False)
+		setter = cgi_get("setter", required=False)
+		ent = entkey and get(entkey)
+		blob = value and BlobWrapper(value=value) or (ent and prop and getattr(ent, prop))
+		if cgi_get("delBlob", default=False):
+			blob.delete()
+			setattr(ent, prop, None)
+			ent.put()
+		elif data:
+			if config.memcache.db:
+				clearmem()
+#			if False:#value: # screw this -- doesn't update entity
+#				blob.set(read_file(data))
+#			else: # going by key, property -- must update index
+			if ent:
+				if prop:
+					setattr(ent, prop, read_file(data))
+					ent.put()
+					blob = getattr(ent, prop)
+				elif setter:
+					getattr(ent, setter)(read_file(data))
+					succeed(ent.data())
+			else:
+				blob = BlobWrapper(data=read_file(data))
+			succeed(blob.urlsafe())
+		else:
+			if not value and hasattr(ent, "getBlob"): # for custom blob construction (such as split up gae blobs)
+				blob = ent.getBlob()
+			if config.web.server == "gae":
+				send_file(blob) # no magic :'(
+			else:
+				if hasattr(blob, "get"): # if not getBlob(), essentially
+					blob = blob.get()
+				send_file(blob, detect=True)
+	elif action == "edit":
+		eres = edit(cgi_get("data"), blobifier=cgi_get("blobifier", required=False))
+		if type(eres) == str:
+			fail(eres)
+		else:
+			succeed(getattr(eres, cgi_get("exporter", default="data"))())
+	elif action == "edits":
+		items = cgi_get("data")
+		blobifier = cgi_get("blobifier", required=False)
+		exporter = cgi_get("exporter", default="data")
+		for item in items:
+			edit(item, blobifier=blobifier)
+	elif action == "put":
+		put_multi([get_model(d["modelName"])(**dprep(d)) for d in cgi_get("data")])
+	elif action == "delete":
+		get(cgi_get("key")).rm()
+	elif action == "index":
+		setmem("last_index", admin.index(cgi_get("kind", default="*"),
+			getmem("last_index", False) or int(cgi_get("index", default=0))), False)
+
+respond(response)

cantools/_memcache.py

@@ -0,0 +1,76 @@
+import datetime
+from cantools.web import respond, succeed, cgi_get, getmem, setmem, delmem, clearmem, read_file, send_file, fetch
+from cantools.util import token, transcode, resizep2
+from cantools.hooks import memhook
+from cantools import config
+
+def prox():
+	url = cgi_get("url")
+	data = getmem(url, False)
+	if not data:
+		data = fetch(url, timeout=config.memcache.prox.timeout, fakeua=True)
+		if cgi_get("p2", default=False):
+			data = resizep2(data)
+		setmem(url, data, False)
+	send_file(data, detect=True)
+
+def response():
+	action = cgi_get("action", choices=["get", "set", "forget", "prox", "clear"])
+	if action == "clear":
+		if cgi_get("pw") != config.admin.pw:
+			fail("wrong")
+		clearmem()
+		succeed()
+	if action == "prox":
+		return prox()
+	key = cgi_get("key")
+	json = cgi_get("json", default=False)
+	mode = cgi_get("mode", default="normal")
+	value = cgi_get("value", required=False) # set only
+	countdown_list = getmem("_countdown_list", False)
+	meta = cgi_get("meta", default={})
+	if action == "forget":
+		delmem(key)
+	elif action == "get":
+		data = getmem(key, json)
+		if mode == "countdown":
+			if key == "_countdown_list":
+				succeed(list(countdown_list or set()))
+			elif data:
+				succeed({
+					"ttl": (data["ttl"] - datetime.datetime.now()).total_seconds(),
+					"token": data["token"],
+					"meta": data["meta"]
+				})
+		elif mode == "blob":
+			send_file(data, detect=True)
+		succeed(data)
+	elif action == "set":
+		if mode == "countdown":
+			cdl = countdown_list or set()
+			cdl.add(key);
+			setmem("_countdown_list", cdl, False)
+			setmem(key, {
+				"ttl": datetime.datetime.now() + datetime.timedelta(0, value),
+				"token": token(),
+				"meta": meta
+			}, json)
+		elif mode == "blob":
+			value = read_file(value)
+			if cgi_get("transcode", default=False):
+				value = transcode(value, True)
+			setmem(key, value, False) # JSON disallowed
+			json = False # for memhook
+		else:
+			setmem(key, value, json)
+	cgi_get("nohook", default=False) or memhook({ # actions: set, forget
+		"action": action,
+		"key": key,
+		"mode": mode,
+		"json": json,
+		"meta": meta,
+		"value": value,
+		"countdown_list": countdown_list
+	})
+
+respond(response)

cantools/_pay.py

@@ -0,0 +1,46 @@
+from cantools.web import respond, succeed, fail, cgi_get
+from cantools import config, util
+from model import *
+
+try:
+	import braintree
+except:
+	util.error("please install braintree >= 0.4.5")
+try:
+	gateway = braintree.BraintreeGateway(braintree.Configuration(
+		environment=getattr(braintree.Environment, config.pay.environment),
+		merchant_id=config.pay.merchant,
+		public_key=config.pay.public,
+		private_key=config.pay.private
+	))
+except:
+	util.error("please install braintree >= 0.4.5 and check your PAY config values")
+
+def response():
+	nonce = cgi_get("nonce", required=False)
+	if nonce:
+		amount = cgi_get("amount")
+		user = db.get(cgi_get("user"))
+		onsale = getattr(user, "onsale", None)
+		emsg = None
+		result = gateway.transaction.sale({
+			"amount": amount,
+			"payment_method_nonce": nonce,
+			"options": {
+				"submit_for_settlement": True
+			}
+		})
+		util.log(result)
+		if not result.is_success:
+			msg = result.errors.deep_errors
+			if not msg:
+				msg = "%s: %s"%(result.transaction.processor_settlement_response_code,
+					result.transaction.processor_settlement_response_text)
+			emsg = "%s (%s)"%(result.message, msg)
+			onsale and onsale(amount, emsg)
+			fail(emsg)
+		onsale and succeed(onsale(amount))
+	else:
+		succeed(gateway.client_token.generate())
+
+respond(response)

cantools/admin.py

@@ -0,0 +1,31 @@
+import os
+from cantools.web import respond, succeed, fail, cgi_get, getcache, clearmem
+from cantools import config
+
+def response():
+    action = cgi_get("action", choices=["db", "memcache", "mcclear", "monitor", "pubsub"])
+    if cgi_get("pw") != config.admin.pw:
+        fail("wrong");
+    if action == "memcache":
+        succeed(getcache())
+    elif action == "mcclear":
+        clearmem()
+        succeed()
+    else:
+        obj = { "host": config.pubsub.host, "port": config.pubsub.port }
+        if action == "monitor": # vs pubsub
+            if config.admin.monitor.geo:
+                obj["geo"] = config.admin.monitor.geo
+            p = os.path.join("logs", "monitor")
+            if config.admin.monitor.log and os.path.isdir(p):
+                obj["logs"] = logs = []
+                for year in os.listdir(p):
+                    yp = os.path.join(p, year)
+                    for month in os.listdir(yp):
+                        mp = os.path.join(yp, month)
+                        for day in os.listdir(mp):
+                            dp = os.path.join(mp, day)
+                            logs.append((dp, os.listdir(dp)))
+        succeed(obj)
+
+respond(response)

cantools/cfg.py

@@ -0,0 +1,347 @@
+import os
+
+cfg = {
+	"log": {
+		"deep": False,
+		"flush": False,
+		"timestamp": True,
+		"openfiles": False,
+		"tracemalloc": False,
+		"allow": ["info", "log", "warn", "error"] # access,info,log,warn,error,detail,db,query,kernel
+	},
+	"mempad": 0, # 0 = unset (uses dez's default)
+	"rel": { # 0 = unset (uses rel's default)
+		"sleep": 0,
+		"turbo": 0,
+		"verbose": False,
+		"loudlisten": False
+	},
+	"plugin": {
+		"modules": [],
+		"path": "%s/.ctplug"%(os.environ.get("HOME") or os.environ.get("USERPROFILE"),),
+		"base": "bubbleboy14", # change to 'cantools' account or something
+	},
+	"geo": {
+		"test": False,
+		"where": {
+			"nom": True,
+			"ua": "cantools geo query"
+		},
+		"zip": "google", # google|geonames
+		"user": {
+			"geonames": ["demo"],
+			"google": [""]
+		}
+	},
+	"memcache": {
+		"request": False,
+		"db": False,
+		"prox": {
+			"timeout": 5
+		}
+	},
+	"cron": {
+		"catchup": False
+	},
+	"admin": {
+		"host": "localhost",
+		"port": 8002,
+		"protocol": "http",
+		"log": None,
+		"contacts": [],
+		"reportees": [],
+		"whitelist": [],
+		"monitor": {
+			"interval": 5,
+			"log": False,
+			"geo": [],
+			"proxy": None,
+			"thresholds": {
+				"cpu": 80
+			}
+		}
+	},
+	"web": {
+		"server": "dez",
+		"domain": "your.web.domain",
+		"host": "0.0.0.0",
+		"port": 8080,
+		"protocol": "http",
+		"xorigin": False,
+		"shield": False,
+		"csp": None,
+		"log": None,
+		"errlog": None,
+		"report": False,
+		"rollz": {},
+		"eflags": [],
+		"blacklist": [],
+		"whitelist": []
+	},
+	"ssl": {
+		"verify": True,
+		"certfile": None,
+		"keyfile": None,
+		"cacerts": None,
+		"pubsubcert": None, # pubsub-only cert!!
+		"pubsubcacerts": None, # pubsub-only cacert!!
+		"pubsubkey": None # pubsub-only key!! (use pubsubs when running web/admin behind ssl drp)
+	},
+	"db": { # switch on web backend (override w/ DB)
+		"cache": True,
+		"refcount": False,
+		"gae": "data.db",
+		"dez": "sqlite:///data.db",
+		"test": "sqlite:///data_test.db",
+		"blob": "blob",
+		"alter": False, # add new columns to tables - sqlite only!
+		"echo": False,
+		"public": True, # read from db without credentials via _db.py web handler
+		"pool": {
+			"null": True,
+			"size": 10,
+			"recycle": 30,
+			"overflow": 20
+		}
+	},
+	"pay": {
+		"merchant": None,
+		"public": None,
+		"private": None,
+		"environment": "Sandbox"
+	},
+	"scrambler": "1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/=_",
+	"encode": False,
+	"gmailer": False,
+	"mailer": None, # (override w/ MAILER)
+	"mailhtml": True,
+	"mailoud": False,
+	"mailscantick": 2,
+	"pubsub": {
+		"host": "localhost",
+		"port": 8888,
+		"history": 10,
+		"botnames": [],
+		"bots": {},
+		"echo": True,
+		"log": None,
+		"meta": False,
+		"b64": False
+	},
+	"parse_error_segment_length": 100,
+	"build": {
+		"dependencies": [],
+		"include": [],
+		"exclude": [],
+		"notjs": [],
+		"prod": {
+			"b64": False,
+			"closure": False
+		},
+		"web": {
+			"dynamic": "html",
+			"compiled": {
+				"static": "html-static",
+				"production": "html-production"
+			}
+		},
+		"admin": {
+			"dynamic": "dynamic",
+			"compiled": {
+				"static": "static",
+				"production": "production"
+			}
+		}
+	},
+	"js": {
+		"path": "js",
+		"flag": '<script src="/',
+		"offset": len('<script src="'),
+		"endoffset": len('"></script>')
+	},
+	"yaml": {
+		"path": "app.yaml",
+		"start": "# START mode: ",
+		"end": "# END mode: "
+	},
+	"py": {
+		"path": "ct.cfg",
+		"enc": "ENCODE = %s",
+		"mode": "MODE = %s"
+	},
+	"noscript": """
+		<noscript>
+		 <div style="position: absolute; left:0px; top:0px;">
+		  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.
+		 </div>
+		</noscript>
+	""",
+	"init": {
+		"core": ['CT.require("core.config");', 'CT.require("core.util");'],
+		"config": {
+			"log": {
+				"include": [],
+				"exclude": []
+			},
+			"header": {
+				"logo": "Your Logo",
+				"right": []
+			},
+			"spinner": True,
+			"borderbox": True,
+			"css": [],
+			"keys": {},
+			"mobile": {
+				"scale": False
+			},
+			"modals": {
+				"escape": True,
+				"transition": "slide"
+			},
+			"softclosure": False,
+			"CC": {
+				"gateway": "https://care-coin.net/comp/api.js",
+				"membership": None,
+				"agent": None,
+				"pod": None
+			}
+		},
+		"util": {
+			"main": {},
+			"post": "",
+			"template": "core.util = %s;\r\n\r\nCT.log.grep(core.config.log.include, core.config.log.exclude);%s"
+		},
+		"dirs": ["js", "css", "img", "logs", "blob", "html", "html-static", "html-production"],
+		"vcignore": {
+			".": ["*pyc", "*~", ".ctp", "_", "admin.py", "_db.py", "_memcache.py", "_pay.py", "logs", "blob"],
+			"css": ["ct.css"],
+			"js": ["CT"]
+		},
+		"yaml": {
+			"gae": """application: %s
+version: 1
+runtime: python27
+api_version: 1
+threadsafe: false
+
+handlers:
+- url: /remote_api
+  script: $PYTHON_LIB/google/appengine/ext/remote_api/handler.py
+  login: admin""",
+  			"core": """
+- url: /css
+  static_dir: css
+
+- url: /img
+  static_dir: img
+
+- url: /blob
+  static_dir: blob
+
+- url: /_db
+  script: _db.py
+
+- url: /_memcache
+  script: _memcache.py
+
+- url: /_pay
+  script: _pay.py
+
+## MODE SWITCHING -- DON'T MESS WITH (unless you know what you're doing)!
+# START mode: dynamic
+- url: /js
+  static_dir: js
+- url: /.*\.html
+  static_dir: html
+# END mode: dynamic
+# START mode: static
+#- url: /js
+#  static_dir: js
+#- url: /.*\.html
+#  static_dir: html-static
+# END mode: static
+# START mode: production
+#- url: /.*\.html
+#  static_dir: html-production
+# END mode: production"""
+		},
+		"cron": "cron:",
+		"html": """<!doctype html>
+<html>
+  <head>
+    <title>%s</title>
+    <link rel="stylesheet" href="/css/ct.css">
+    <script src="/js/CT/ct.js"></script>
+  </head>
+  <body>
+   Hello World
+  </body>
+</html>""",
+		"ctcfg": os.linesep.join(['ENCODE = False', 'MODE = dynamic', 'WEB_SERVER = %s']),
+		"model": "from cantools import db"
+	},
+	"about": """# cantools %s
+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.
+
+ - Docs: http://ct.mkult.co
+ - License: MIT (see LICENSE)
+
+## Repository Installation (full)
+  - upside: includes full codebase (not just Python)
+  - site: https://github.com/bubbleboy14/cantools
+  - steps
+    - git clone https://github.com/bubbleboy14/cantools.git
+    - cd cantools
+    - pip3 install -e .
+
+If you're running Debian or Fedora or BSD or OSX, you may consider running (probably as root or sudoer):
+
+    ./bootstrap.sh
+
+Instead of the pip3 install line. This will also install various dependencies that
+may not already be present on your system (some systems don't even come with Python).
+
+## Production Installation (transparent)
+  - upside
+    - cantools and all dependencies installed in one line
+    - hidden away like any standard system library
+    - cleanest way to deploy your applications
+  - downside
+    - no easy access to ct source -- aren't you curious?
+    - OSX or Debian (especially Ubuntu) -only (until you add support for your system!)
+  - command: curl https://raw.githubusercontent.com/bubbleboy14/cantools/master/bootstrap.sh | cat | sh
+
+## Package Installation (limited -- not recommended)
+  - downside
+    - does _not_ include full package (such as client-side web files)
+    - enough to mess around with cantools -- not enough to develop end-to-end applications
+  - package: https://pypi.python.org/pypi/ct
+  - command: easy_install ct
+
+## Hello World
+This takes less than a moment. Pop open a terminal in your home directory:
+
+	~$ git clone https://github.com/bubbleboy14/cantools.git
+	~$ cd cantools/
+	~/cantools$ pip3 install -e .
+	~/cantools$ cd ..
+	~$ ctinit hello_world
+	~$ cd hello_world/
+	~/hello_world$ ctstart
+
+And that's it. Open http://localhost:8080/ in your browser and call it a day.
+
+## Deployment Steps
+You just found out that you need to deploy a cantools project to a fresh, naked
+Ubuntu system that doesn't even have Python or git. Oh no, what do you do? This
+(as root or sudoer for first and last commands):
+
+	~$ curl https://raw.githubusercontent.com/bubbleboy14/cantools/master/bootstrap.sh | cat | sh
+	~$ git clone https://github.com/your_organization/your_project.git
+	~$ cd your_project
+	~/your_project$ ctinit -r
+	~/your_project$ ctstart -p80
+
+Now just make sure port 80 is open, and you're good to go. Also, you should probably
+run ctstart in a screen or something (so that you can eventually log out) - that's it!"""
+}