def test():
try:
n = int(
input(
"Provide an integer 'n' to run 'n' times the pasword generator app: "
))
except ValueError:
print('An integer must be provided')
finally:
for _ in range(n):
app.app()
def get_first_page(self, html_cont):
soup = BeautifulSoup(html_cont, 'html.parser', from_encoding='utf-8')
apps = list()
box_node = soup.find('div', id="appbox")
title = box_node.find_all('b')
app_type = box_node.find_all('ul')
for i in range(0, len(app_type)):
li = app_type[i].find_all('li')
soft = li[0].find_all('a')
img = li[0].find_all('img')
for y in range(0, len(soft)):
item = app()
item.src = soft[y]['href']
self.get_details(HtmlParser.URL + item.src, item)
item.name = soft[y].get_text()
item.imgsrc = img[y]['src']
item.apptype = title[i].get_text()
apps.append(item)
appshow = soup.find('div', id='appshow')
lis = appshow.find_all('li')
for li in lis:
item = AppSpecial()
item.src = li.find('a')['href']
item.iconSrc = li.find('img')['src']
item.name = li.get_text()
self.get_special_details(HtmlParser.URL + item.src, item)
return apps
async def init(loop):
srv = await loop.create_server(
app(loop=loop).make_handler(),
'0.0.0.0',
8080
)
return srv
def main():
import app
import db
import handlers
application = app.app(handlers.URLS)
settings.APP_SETTINGS['debug'] = True
settings.APP_SETTINGS['static_path'] = os.path.join('/home/philip/Development/repo1/server', "static"),
db.connect(
'repo1',
host='localhost',
port=27017
)
#insert default data
if 1==2:
# code = db.QR(url='testing')
# code.save()
bar = db.Bar(name="Freds bar")
bar.save()
server = tornado.httpserver.HTTPServer(application)
server.listen(80)
tornado.ioloop.IOLoop.instance().start()
async def init(loop):
srv = await loop.create_server(
app(loop=loop).make_handler(),
CHAT_SERVER_HOST,
CHAT_SERVER_PORT
)
return srv
def test_create_project(self):
AppInstance=app()
projectname="test123"
projectCode=253424
AppInstance.CreateNewProject(projectname,projectCode)
AppInstance.printInfo()
info = AppInstance.getInfo()
self.assertEqual(info, NAME:test123253424[]', []")
def application(environ, start_response):
"""
make Passenger interpret PATH_INFO the same way that the WSGI standard
does
"""
environ["PATH_INFO"] = urllib.parse.unquote(environ["PATH_INFO"])
return app.app(environ, start_response)
def get_app(self, loop):
server = app(loop=loop)
server['db'] = self.database(
loop=loop
)
return server
def send_request(self, path='/', data='', method='PUT', **kwargs):
response = app(
testing.create_environ(
path=path, \
method=method, \
body=data, \
**kwargs
), \
self.mock, \
)
return response
def setUp(self):
self.app = app("testing")
self.client = self.app.test_client()
self.signup_user1 = {
"firstname": "Tevin",
"lastname": "Gachagua",
"username": "******",
"email": "*****@*****.**",
"password": "******",
"confirm_password": "******"
}
self.signup_user2 = {
"firstname": "Tony",
"lastname": "Andela",
"username": "******",
"email": "*****@*****.**",
"password": "******",
"confirm_password": "******"
}
self.signup_user3 = {
"firstname": "Third",
"lastname": "Avenger",
"username": "******",
"email": "*****@*****.**",
"password": "******",
"confirm_password": "******"
}
self.login_user_1 = {"username": "******", "password": "******"}
self.login_user_2 = {"username": "******", "password": "******"}
self.login_user_3 = {"username": "******", "password": "******"}
self.post_question1 = {
"title": "What is Dev?",
"creator_id": 1,
"body": "I really like how people talk about Tony's Dev"
}
self.post_question2 = {
"title": "Question 2",
"creator_id": 1,
"body": "This is question 2"
}
self.post_question3 = {
"title": "Question 3",
"creator_id": 1,
"body": "This is question 3"
}
self.answer_to_question1 = {"answer": "I believe its...."}
self.answer_to_question2 = {"answer": "I think the answer is ..."}
self.broken_answer = {"ans": "No its not"}
self.token = ""
self.token2 = ""
self.token3 = ""
def test_open(self):
AppInstance=app()
projectname="Imagepipeline"
projectCode=29143
AppInstance.CreateNewProject(projectname,projectCode)
previnfo = AppInstance.getInfo()
AppInstance.saveCurrentProject("ISP.project")
AppInstance.deleteProject()
AppInstance.OpenProject("ISP.project")
info = AppInstance.getInfo()
self.assertEqual(info, previnfo)
def setUp(self):
self.app = app("testing")
self.client = self.app.test_client()
init_db()
admin = self.client.post("api/v2/auth/signin",
data=json.dumps({
"email": "*****@*****.**",
"password": "******"
}),
content_type="application/json")
self.ADMIN_TOKEN = json.loads(
admin.data.decode("utf-8"))["data"]["token"]
def post(self, cls, meth, args):
import app
body = {
'__class': cls,
'__method': meth,
'__args': args,
}
def sres(statuscode0, resheads0):
global statuscode
global resheads
statuscode, resheads = statuscode0, resheads0
env = {
'content_length': len(body),
'content_type': 'application/x-www-form-urlencoded',
'http_accept': '*/*',
'http_host': '127.0.0.0:8000',
'http_user_agent': 'tester/1.0',
'path_info': '/',
'query_string': '',
'raw_uri': '/',
'remote_addr': '52.52.249.177',
'remote_port': '43130',
'request_method': 'post',
'script_name': '',
'server_name': '172.31.9.64',
'server_port': '8000',
'server_protocol': 'http/1.1',
'server_software': 'gunicorn/19.4.5',
'gunicorn.socket': None,
'wsgi.errors': None,
'wsgi.file_wrapper': None,
'wsgi.input': body,
'wsgi.multiprocess': False,
'wsgi.multithread': False,
'wsgi.run_once': False,
'wsgi.url_scheme': 'http',
'wsgi.version': (1, 0)
}
app.app.breakonexception = self.testers.breakonexception
iter = app.app(env, sres)
for body in iter:
body = body.decode('utf-8')
body = json.loads(body)
statusmessage = statuscode
statuscode0 = int(statuscode[:3])
return httpresponse(statuscode0, statusmessage, resheads, body)
def boot():
print('1: High School \n2: College\n3: Primaire\n0: Exit')
x = int(input(''))
if x == 1:
scraping = app()
elif x == 2:
scraping = app1(1)
elif x == 3:
scraping = app1(0)
elif x == 0:
print('Bye !')
sys.exit()
else:
boot()
def runtest(self):
c = contact.contact()
c.checkForContacts()
w = wifi.wifi()
w.wifiTest()
n = note.Note()
n.testNotes()
a = app.app()
a.apptest()
p = photo.photo()
p.phototest()
v = video.video()
v.videotest()
m = media.Media()
m.MediaCheck()
def get_special_details(self, url, app):
html_content = html_downloader.HtmlDownloader().download(url)
soup = BeautifulSoup(html_content,
'html.parser',
from_encoding='utf-8')
appdata = soup.find('div', class_='tagdata')
app.desc = appdata.find('ul').find('p').get_text()
applist = soup.find('div', class_='list').find_all('li')
for apl in applist:
item = app()
item.src = apl.find('a')['href']
self.get_details(HtmlParser.URL + item.src, item)
item.name = apl.find('a').get_text()
item.imgsrc = apl.find('img')['src']
app.appList.append(item)
def setUp(self):
"""Set up test variables."""
self.app = app()
# initialize the test client
self.client = self.app.test_client
# This is the user test json data with a predefined email and password
self.user_data = {
'email': '*****@*****.**',
'password': '******'
}
with self.app.app_context():
# create all tables
db.session.close()
db.drop_all()
db.create_all()
def __init__(self, parent):
self.parent = parent
self.device = parent.device
self.data_layer = parent.data_layer
self.apps = parent.apps
self.marionette = parent.marionette
self.actions = Actions(self.marionette)
# Globals used for reporting ...
self.errNum = 0
self.start_time = time.time()
# Get run details from the OS.
self.general = general(self)
self.test_num = parent.__module__[5:]
self.app = app(self)
self.date_and_time = date_and_time(self)
self.debug = debug(self)
self.element = element(self)
self.home = home(self)
self.iframe = iframe(self)
self.messages = Messages(self)
self.network = network(self)
self.reporting = reporting(self)
self.statusbar = statusbar(self)
self.test = test(self)
self.visual_tests = visualtests(self)
self.marionette.set_search_timeout(10000)
self.marionette.set_script_timeout(10000)
elapsed = time.time() - self.start_time
elapsed = round(elapsed, 0)
elapsed = str(datetime.timedelta(seconds=elapsed))
self.reporting.debug(
"Initializing 'UTILS' took {} seconds.".format(elapsed))
current_lang = parent.data_layer.get_setting("language.current").split(
'-')[0]
self.reporting.info(
"Current Toolkit language: [{}]".format(current_lang))
try:
btn = self.marionette.find_element('id', 'charge-warning-ok')
btn.tap()
except:
pass
parent.data_layer.set_setting('screen.automatic-brightness', True)
def application(environ, start_response):
start_time = time.time()
output = {}
try:
output = app(
command_name=environ['PATH_INFO'].strip('/'),
data=urlparse.parse_qs(environ['QUERY_STRING'])
)
except Exception as e:
output['error'] = str(e)
traceback.print_exc()
start_response("200 OK", [('Content-Type', 'application/json')])
output['time'] = '%.3f ms' % ((time.time() - start_time) * 1000)
return [json.dumps(output, indent=2)]
def handle_installapp(self, args):
rand_num = random.randint(1, 100)
if rand_num <= macro.cmd_fail_percent[macro.INSTALLAPP]:
return None
if args[0] != 1:
return None
if len(args) < 2:
return None
if not (args[1] in self.applist):
self.applist[args[1]] = app.app(args[1])
res = []
res.append(0)
res.append(0)
return res
def __init__(self, parent):
self.parent = parent
self.device = parent.device
self.data_layer = parent.data_layer
self.apps = parent.apps
self.marionette = parent.marionette
self.actions = Actions(self.marionette)
# Globals used for reporting ...
self.errNum = 0
self.start_time = time.time()
# Get run details from the OS.
self.general = general(self)
self.test_num = parent.__module__[5:]
self.app = app(self)
self.date_and_time = date_and_time(self)
self.debug = debug(self)
self.element = element(self)
self.home = home(self)
self.iframe = iframe(self)
self.messages = Messages(self)
self.network = network(self)
self.reporting = reporting(self)
self.statusbar = statusbar(self)
self.test = test(self)
self.visual_tests = visualtests(self)
self.marionette.set_search_timeout(10000)
self.marionette.set_script_timeout(10000)
elapsed = time.time() - self.start_time
elapsed = round(elapsed, 0)
elapsed = str(datetime.timedelta(seconds=elapsed))
self.reporting.debug("Initializing 'UTILS' took {} seconds.".format(elapsed))
current_lang = parent.data_layer.get_setting("language.current").split('-')[0]
self.reporting.info("Current Toolkit language: [{}]".format(current_lang))
try:
btn = self.marionette.find_element('id', 'charge-warning-ok')
btn.tap()
except:
pass
parent.data_layer.set_setting('screen.automatic-brightness', True)
def application(environ, start_response):
# explicitly set environment variables from the WSGI-supplied ones
ENVIRONMENT_VARIABLES = [
'STACKTODOS_MYSQL_DB_USERNAME',
'STACKTODOS_MYSQL_DB_PASSWORD',
'STACKTODOS_MYSQL_DB_HOST',
'STACKTODOS_MYSQL_DB_PORT',
'STACKTODOS_SOCIAL_FACEBOOK_KEY',
'STACKTODOS_SOCIAL_FACEBOOK_SECRET'
]
for key in ENVIRONMENT_VARIABLES:
if environ.get(key) is None:
print key
else:
os.environ[key] = environ.get(key)
# return app(environ, start_response)
from app import app
return app(environ, start_response)
def setUp(self):
self.app = app("testing")
self.client = self.app.test_client()
self.signup_user1 = {
"firstname": "Tevin",
"lastname": "Gachagua",
"username": "******",
"email": "*****@*****.**",
"password": "******",
"confirm_password": "******"
}
self.signup_user2 = {
"firstname": "Yuppy",
"lastname": "Maann",
"username": "******",
"email": "*****@*****.**",
"password": "******",
"confirm_password": "******"
}
self.login_user_1 = {"username": "******", "password": "******"}
self.login_user_2 = {
"username": "******",
"password": "******"
}
self.post_question1 = {
"title":
"What is a polymorph?",
"creator_id":
1,
"body":
"Im struggling to get by linear algebra, can anyone help out with this"
}
self.titleless_question = {"body": "How do you create a set"}
self.answer_to_question2 = {"answer": "I think the answer is ..."}
self.wrong_answer = {"ans": ""}
self.token = ""
self.token2 = ""
def setUp(self):
"""Define test variables and initialize app."""
os.system('sh setup.sh')
self.app = app()
self.client = self.app.test_client
self.database_path = os.environ.get('DATABASE_TEST_PATH')
# setup_db(self.app, self.database_path)
self.app.config["SQLALCHEMY_DATABASE_URI"] = self.database_path
self.app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
db.app = self.app
db.init_app(self.app)
db.create_all()
# binds the app to the current context
with self.app.app_context():
self.db = SQLAlchemy()
self.db.init_app(self.app)
# create all tables
self.db.create_all()
self.actor = {'name': 'Leonardo Dicaprio', 'age': '46', 'gender': 'M'}
self.updated_actor = {
'name': 'Leonardo Dicaprio',
'age': '47',
'gender': 'M'
}
self.movie = {'title': 'Inception', 'release_date': datetime.now()}
self.updated_movie = {
'title': 'Inception 2',
'release_date': datetime.now()
}
self.director_headers = {
'Content-Type': 'application/json',
'Authorization': os.environ.get('DIRECTOR_TOKEN')
}
self.producer_headers = {
'Content-Type': 'application/json',
'Authorization': os.environ.get('PRODUCER_TOKEN')
}
def testapp():
from webtest import TestApp
app_ = app.app()
return TestApp(app_)
from flask.ext.assets import ManageAssets
from flask.ext.script import Manager
from flask.ext.security.script import CreateUserCommand
from app import app
manager = Manager(app())
manager.add_command("assets", ManageAssets())
manager.add_command('create_user', CreateUserCommand())
if __name__ == "__main__":
manager.run()
from app import app app()
def add_app(self, appname, status):
self.applist[appname] = app.app(appname)
self.applist[appname].setStatus(status)
def setUp(self):
self.app = app('testing')
import app gameApp = app.app() gameApp.Run()
def run_wsgi_app(event, context):
query_string = None
if event.get('queryStringParameters') is not None:
query_string = '&'.join(
[quote(k) + '=' + quote(v)
for k, v in event['queryStringParameters'].items()])
headers = event.get('headers') or {}
body = event.get('body')
if body is None:
body = b''
else:
body = body.encode('utf-8')
# create a WSGI environment for this request
environ = {
'REQUEST_METHOD': event.get('httpMethod', 'GET'),
'SCRIPT_NAME': '',
'PATH_INFO': event.get('path', '/'),
'QUERY_STRING': query_string,
'SERVER_NAME': '',
'SERVER_PORT': 80,
'HTTP_HOST': '',
'SERVER_PROTOCOL': 'https',
'CONTENT_TYPE': headers.get('Content-Type', ''),
'CONTENT_LENGTH': headers.get('Content-Length', str(len(body))),
'wsgi.version': '',
'wsgi.url_scheme': '',
'wsgi.input': BytesIO(body),
'wsgi.errors': sys.stderr,
'wsgi.multithread': False,
'wsgi.multiprocess': False,
'wsgi.run_once': True,
'lambda.event': event,
'lambda.context': context,
}
# add any headers that came with the request
for h, v in headers.items():
environ['HTTP_' + h.upper().replace('-', '_')] = v
status_headers = [None, None]
body = []
def write(item):
body.append(item)
def start_response(status, headers):
status_headers[:] = [status, headers]
return write
# invoke the WSGI app
app_iter = app(environ, start_response)
try:
for item in app_iter:
body.append(item)
finally:
if hasattr(app_iter, 'close'):
app_iter.close()
# format the response as required by the api gateway proxy integration
status = status_headers[0].split()
headers = status_headers[1]
body = b''.join(body)
try:
body = body.decode('utf-8')
b64 = False
except UnicodeDecodeError:
body = base64.b64encode(body).decode('utf-8')
b64 = True
return {
'statusCode': int(status[0]),
'headers': {h[0]: h[1] for h in headers},
'body': body,
'isBase64Encoded': b64
}
def setUp(self): self.app = app.app() self.server = webtest.TestApplication(self.app)
def test_should_issue_hello_world_message(self):
out = mock()
app(out)
verify(out).write("Hello World")
def import_on_first_request(environ,start_response):
from app import app
app.debug=True
return app(environ,start_response)
def setUp(self):
self.app = app("testing")
self.client = self.app.test_client()
self.party1 = {"name": "Party 1", "logoUrl": ""}
self.partytodelete = {"name": "Party 10", "logoUrl": ""}
self.invalidparty = {"_id": 1}
def get_app(self, loop):
return app(loop=loop)
def app(self):
a = app.app()
a.apptest()
def setUp(self):
"""Start up the app so that tests can send requests to it."""
self.testapp = TestApp(app.app())
def setUp(self):
self.app = app("testing")
self.client = self.app.test_client()
self.office1 = {"type": "Governor", "name": "Governor Webuye"}
self.erroroffice = {}
def main():
start = app()
start.load_config()
start.run_model()
def __init__(self): if self.app is None: self.app = app()
class Asenzor:
"""docstring for AsenZor"""
def __init__(self):
#====================================================================
self.HEADERS = Headers()
self.data = {"ajax": False}
self.vista = "error404"
self.data.update(getRest(config))
import imp
import cgi, cgitb
cgitb.enable()
data = cgi.FieldStorage()
if (self.data["control"] == None
and self.data['global_control'] == None
and self.data['metodo'] == None and self.data['app'] == None
and self.data['args'] == [] and self.data['request'] == {}
and self.data['manager'] == False
and self.data['ajax'] == False and self.data['kwargs'] == {}
and self.data['action'] == None):
self.data["app"] = config.default_app
import os
try:
if type(data.value) == list:
d = {}
d2 = {}
for elem in data.value:
if elem.name == "app":
if elem.value != "None" and elem.value != None:
self.data[elem.name] = normalizar(elem.value)
self.data["request"][elem.name] = elem
else:
if elem.name in d:
d[elem.name].append(elem.value)
d2[elem.name].append(elem)
self.data[elem.name] = d[elem.name]
self.data["request"][elem.name] = d2[elem.name]
else:
d[elem.name] = [elem.value]
d2[elem.name] = [elem]
self.data[elem.name] = normalizar(elem.value)
self.data["request"][elem.name] = elem
else:
"""
params=data.value.split("/")[-1].split("&")
for elem in params:
k,v=elem.split("=")
self.data[k]=normalizar(v)
self.data["request"][k]={"value":normalizar(v)}
"""
except Exception, e:
if "action" not in data:
self.data["action"] = None
else:
self.data["action"] = data["action"].value
self.data["request"]["action"] = data["action"]
self.data["model"] = {}
self.data["errores"] = []
self.data["vars"] = {}
self.data["plugins"] = {}
self.data["login"] = False
self.data["user"] = None
self.data["isGlobalUser"] = False
self.data["token"] = None
self.data["model"]["global"] = model("../modelos/global",
"../modelos/request/",
"user",
ext=".py")
self.data["opciones"] = {
"global": self.data["model"]["global"].obtenerFilas("Opciones")
}
self.data["plugins-hooks"] = []
self.data["plugins"] = {}
if self.data["app"] != None and self.data["global_control"] == None:
sys.path.append(config.base_root + config.apps_folder +
self.data["app"] + "/")
from app import app
self.app = app()
sys.path.append(self.app.admin.__path__) if (
self.app.admin.__path__ not in sys.path) else None
self.data["base_url"] = self.app.user.__url__
contenido = self.data["model"]["global"].obtenerContenido(
self.data["app"], "apps")[self.data["app"]]
settings = self.app.admin.settings
routes = self.app.admin.routes
base_root = self.app.admin.__path__
#=======================================================================
if len(contenido) > 1 and self.data["app"] != None:
for k, elem in enumerate(contenido[1]):
if contenido[1][elem]["value"] in settings.dbs:
if os.path.exists(self.app.admin.modelos.__path__ +
str(contenido[1][elem]["value"]) +
"_model.py"):
exec("model" + str(k) + "=imp.load_source('model" +
str(k) + "' ,'" +
self.app.admin.modelos.__path__ +
str(contenido[1][elem]["value"]) +
"_model.py').model")
exec("self.data['model']['" +
contenido[1][elem]["value"] + "']=model" +
str(k) + "('" +
self.app.admin.modelos.__path__ +
contenido[1][elem]["value"] + "','" +
self.app.admin.modelos.__path__ +
"request/','" + self.data["app"] +
"',ext='.py')")
self.data["model"][
contenido[1][elem]["value"]].models[
"global"] = self.data["model"]["global"]
self.data["model"]["global"].models[contenido[1][
elem]["value"]] = self.data["model"][
contenido[1][elem]["value"]]
if "Opciones" in self.data["model"][
contenido[1][elem]["value"]].db.tablas:
self.data["opciones"][contenido[1][elem][
"value"]] = self.data["model"][
contenido[1][elem]
["value"]].obtenerFilas("Opciones")
if self.data["model"][contenido[1][elem]
["value"]].errores != []:
self.data["errores"].append(self.data["model"][
contenido[1][elem]["value"]].errores)
elif self.data["model"][contenido[1][elem]
["value"]].db.errores:
self.data["errores"].append(self.data["model"][
contenido[1][elem]["value"]].db.errores)
else:
self.data["errores"].append(
"No se encontro el modelo: " +
contenido[1][elem]["value"] + " en el directorio")
for k, elem in enumerate(contenido[2]):
if contenido[2][elem]["value"] in settings.dbs:
if os.path.exists("../" + config.modelos_folder +
str(contenido[2][elem]["value"]) +
"_model.py"):
exec("model" + str(k) + "=imp.load_source('model" +
str(k) + "' ,'../" + config.modelos_folder +
str(contenido[2][elem]["value"]) +
"_model.py').model")
exec("self.data['model']['" +
contenido[2][elem]["value"] + "']=model" +
str(k) + "('" + base_root +
routes.models_folder +
contenido[2][elem]["value"] + "','" +
base_root + routes.models_folder +
"request/','" + self.data["app"] +
"',ext='.py')")
self.data["model"][
contenido[2][elem]["value"]].models[
"global"] = self.data["model"]["global"]
self.data["model"]["global"].models[contenido[2][
elem]["value"]] = self.data["model"][
contenido[2][elem]["value"]]
if "Opciones" in self.data["model"][
contenido[2][elem]["value"]].db.tablas:
self.data["opciones"][contenido[2][elem][
"value"]] = self.data["model"][
contenido[2][elem]
["value"]].obtenerFilas("Opciones")
if self.data["model"][contenido[2][elem]
["value"]].errores != []:
self.data["errores"].append(self.data["model"][
contenido[2][elem]["value"]].errores)
elif self.data["model"][contenido[2][elem]
["value"]].db.errores:
self.data["errores"].append(self.data["model"][
contenido[2][elem]["value"]].db.errores)
else:
self.data["errores"].append(
"No se encontro el modelo: " +
contenido[2][elem]["value"] +
" en el directorio")
plugins = {}
self.data["base_url"] = self.app.user.__url__
for elem in self.data["model"]["main"].obtenerFilas("Plugins"):
plugins[elem[0]] = elem[1]
for plugin in self.data["model"]["global"].obtenerFilas("Plugins"):
if plugin[0] in plugins:
if plugins[plugin[0]] == True:
for elem in plugin[1][1]:
self.data["plugins-hooks"].append(
[elem["name"], elem["value"]])
if os.path.exists(config.base_root +
config.plugins_folder + plugin[0] +
"/default.py"):
self.data["plugins"][plugin[0]] = imp.load_source(
"", config.base_root + config.plugins_folder +
plugin[0] + "/default.py").Plugin(self.data)
else:
print "El plugin: " + plugin[
0] + "No puede ser inicializado"
else:
if self.data["model"]["main"].request():
self.data["model"]["main"].db("Plugins").insertar(
plugin[0], False)
self.data["model"]["main"].grabar()
self.app.user.cnt(self.data)
else:
if self.data["app"] != None:
sys.path.append(config.base_root + config.apps_folder +
self.data["app"] + "/")
from app import app
self.app = app()
sys.path.append(self.app.admin.__path__) if (
self.app.admin.__path__ not in sys.path) else None
self.data["base_url"] = self.app.user.__url__
from settings import config as settings
from settings import routes
base_root = self.app.admin.__path__
contenido = self.data["model"]["global"].obtenerContenido(
self.data["app"], "apps")[self.data["app"]]
if len(contenido) > 1:
for k, elem in enumerate(contenido[1]):
if contenido[1][elem]["value"] in settings.dbs:
exec("model" + str(k) + "=imp.load_source('model" +
str(k) + "' ,'" +
self.app.admin.modelos.__path__ +
str(contenido[1][elem]["value"]) +
"_model.py').model")
exec("self.data['model']['" +
contenido[1][elem]["value"] + "']=model" +
str(k) + "('" +
self.app.admin.modelos.__path__ +
contenido[1][elem]["value"] + "','" +
self.app.admin.modelos.__path__ +
"request/','" + self.data["app"] +
"',ext='.py')")
self.data["model"][
contenido[1][elem]["value"]].models[
"global"] = self.data["model"]["global"]
self.data["model"]["global"].models[contenido[1][
elem]["value"]] = self.data["model"][
contenido[1][elem]["value"]]
if "Opciones" in self.data["model"][
contenido[1][elem]["value"]].db.tablas:
self.data["opciones"][contenido[1][elem][
"value"]] = self.data["model"][
contenido[1][elem]
["value"]].obtenerFilas("Opciones")
if self.data["model"][contenido[1][elem]
["value"]].errores != []:
self.data["errores"].append(self.data["model"][
contenido[1][elem]["value"]].errores)
elif self.data["model"][contenido[1][elem]
["value"]].db.errores:
self.data["errores"].append(self.data["model"][
contenido[1][elem]["value"]].db.errores)
for k, elem in enumerate(contenido[2]):
if contenido[2][elem]["value"] in settings.dbs:
exec("model" + str(k) + "=imp.load_source('model" +
str(k) + "' ,'../" + config.modelos_folder +
str(contenido[2][elem]["value"]) +
"_model.py').model")
exec("self.data['model']['" +
contenido[2][elem]["value"] + "']=model" +
str(k) + "('" + base_root +
routes.models_folder +
contenido[2][elem]["value"] + "','" +
base_root + routes.models_folder +
"request/','" + self.data["app"] +
"',ext='.py')")
self.data["model"][
contenido[2][elem]["value"]].models[
"global"] = self.data["model"]["global"]
self.data["model"]["global"].models[contenido[2][
elem]["value"]] = self.data["model"][
contenido[2][elem]["value"]]
if "Opciones" in self.data["model"][
contenido[2][elem]["value"]].db.tablas:
self.data["opciones"][contenido[2][elem][
"value"]] = self.data["model"][
contenido[2][elem]
["value"]].obtenerFilas("Opciones")
if self.data["model"][contenido[2][elem]
["value"]].errores != []:
self.data["errores"].append(self.data["model"][
contenido[2][elem]["value"]].errores)
elif self.data["model"][contenido[2][elem]
["value"]].db.errores:
self.data["errores"].append(self.data["model"][
contenido[2][elem]["value"]].db.errores)
if self.data["manager"] == True and gringolizar(
self.data["global_control"]) in config.controladores:
if self.data["global_control"] == "Plugin":
for plugin in self.data["model"]["global"].obtenerFilas(
"Plugins"):
for elem in plugin[1][1]:
self.data["plugins-hooks"].append(
[elem["name"], elem["value"]])
self.data["plugins"][plugin[0]] = imp.load_source(
"", config.base_root + config.plugins_folder +
plugin[0] + "/default.py").Plugin(self.data)
control = imp.load_source(
"", config.base_root + config.controller_folder +
"Controladores/" +
gringolizar(self.data["global_control"]) + ".py")
exec("control=control." +
gringolizar(self.data["global_control"]) + "(self.data)")
if self.data["metodo"] != None and self.data["metodo"] in dir(
control):
exec("control." + gringolizar(self.data["metodo"]) + "()")
"""
Pendiente ya que plugin no lo utilizaria ya que el metodo desconocido des del plugin que carga no del global_control
elif self.data["metodo"]!=None:
exec("control.metodo_desconocido()")
"""
else:
self.HEADERS.show()
from modulos.ztec.intervalor.control import generar2
generar2(
config.base_root + config.vistas_folder + self.vista +
".html", config.base_root + config.vistas_folder +
config.templates_folder + self.vista + ".py",
"#!/usr/bin/python\n# -*- coding: utf-8 -*-\n")
doc = ""
f = open(
config.base_root + config.vistas_folder +
config.templates_folder + self.vista + ".py", "r")
script = f.read()
exec(script)
print doc
#!/usr/bin/env python
from app import app
import os
from flask.ext.script import Manager, Server
environment = os.environ.get("HOSTENV")
if not environment:
environment = 'default'
app = app(environment)
print "Mode: " + environment
manager = Manager(app)
manager.add_command("runserver", Server(host="0.0.0.0"))
@manager.command
def test(coverage=False):
"""Run the unit tests."""
import unittest
tests = unittest.TestLoader().discover('test')
unittest.TextTestRunner(verbosity=2).run(tests)
if __name__ == '__main__':
manager.run()
"""
This should be how to use the chipFish from the command line.
And output svgs etc.
"""
import os
from app import app
from glbase_wrapper import location
a = app()
a.startup(os.path.expanduser("~/Projects/AP2aGCM/trks/track_list.txt"))
oh = open(os.path.expanduser("~/Projects/AP2aGCM/trks/For raw signal.txt"),
"rU")
for lin in oh:
tt = lin.strip().split("\t")
print(tt)
if tt[0] != "gname":
a.draw.setLocation(loc=location(loc=tt[1]).expand(10000))
a.draw.exportImage(
os.path.expanduser("~/Projects/AP2aGCM/trks/%s_%s.png" %
(tt[0], str(tt[1].replace(":", "-")))),
type="png")
def get_app(self, loop):
server = app(loop=loop)
return server
import app
# Start things up if we're being run from here
if __name__ == "__main__":
theapp = app.app()
theapp.main()
def main():
# Here is the default config for statix content
conf = { '/static': { 'tools.staticdir.on' : True
, 'tools.staticdir.dir': os.path.join(current_folder, 'static')
}
, '/static/formish.css': { 'tools.staticfile.on' : True
, 'tools.staticfile.filename': resource_filename('formish', 'css/formish.css')
}
, '/static/formish.js' : { 'tools.staticfile.on' : True
, 'tools.staticfile.filename': resource_filename('formish', 'js/formish.js')
}
, '/favicon.png' : { 'tools.staticfile.on' : True
, 'tools.staticfile.filename': os.path.join(current_folder, 'static/favicon.png')
}
}
# Desactivate encoding to bypass CherryPy 3.2 new defaults (see: http://www.cherrypy.org/wiki/UpgradeTo32#Responseencoding)
cherrypy.config.update({'tools.encode.on': False})
# Load and apply the global config file
conf_file = os.path.join(current_folder, CONF_NAME)
cherrypy.config.update(conf_file)
# Only show default error page and traceback in debug mode
if DEBUG:
cherrypy.config.update({'autoreload.on': True})
else:
cherrypy.config.update({ 'autoreload.on' : False
, 'request.show_tracebacks': False
, 'error_page.default' : os.path.join(current_folder, 'static/error.html')
# Alternatively, we can call a method to handle generic HTTP errors
#, 'error_page.default' : redirect_home_on_error
# Treat 503 connectivity errors as maintenance
, 'error_page.503' : os.path.join(current_folder, 'static/maintenance.html')
})
# Monkey patch convertish to let it unfold multiple checkbox widgets encoded with dottedish
from convertish.convert import NumberToStringConverter
from dottedish.dottedlist import DottedList, unwrap_list
legacy_to_type = NumberToStringConverter.to_type
def to_type_wrapper(self_class, value, converter_options={}):
# Force decoding of dotted notation
if type(value) == DottedList:
value = unwrap_list(value)
if type(value) == type([]) and len(value) == 1:
value = value[0]
return legacy_to_type(self_class, value, converter_options)
NumberToStringConverter.to_type = to_type_wrapper
from convertish.convert import DateToStringConverter
# Monkey patch convertish again, but this time to parse our french-localized dates
legacy_parseDate = DateToStringConverter.parseDate
def parseDate_wrapper(self_class, value):
return legacy_parseDate(self_class, '-'.join(value.strip().split('/')[::-1]))
DateToStringConverter.parseDate = parseDate_wrapper
# This patch mirror the one above, to let convertish render our datetime object with our localized format
def from_type_replacement(self_class, value, converter_options={}):
return value is None and None or value.strftime('%d/%m/%Y')
DateToStringConverter.from_type = from_type_replacement
# Open a connection to our local OpenERP instance
try:
openerp = OOOP( user = '******'
, pwd = 'admin'
, dbname = 'kev_test'
, uri = 'http://localhost'
, port = 8069 # We are targetting the HTTP web service here
)
except (socket.timeout, socket.error):
raise cherrypy.HTTPError(503)
# Setup our Mako decorator
loader = MakoLoader()
cherrypy.tools.mako = cherrypy.Tool('on_start_resource', loader)
# Let the default formish Mako renderer look at our local directory fisrt
# This let us ovveride default formish Mako templates
_default_renderer.lookup.directories.insert(0, template_folder)
# Import our application logic
from app import app
# Start the CherryPy server
cherrypy.quickstart(app(openerp), config=conf)
. favicon.ico not found
. root dir is not htdocs, chipfish .
. This must surely be a really bad way to do this.
. Isn't there a better (more secure) lightweight way to do this?
. GUI? Even possible? - not with this crappy server!
"""
import time, os, sys
from app import app
from glbase_wrapper import location
if len(sys.argv) < 1:
print("serve.py <track_list_file.txt>")
quit()
cf = app() # Startup chipFish
cf.startup(sys.argv[1])
__version__ = "0.1"
__all__ = ["HTTPRequestHandler"]
import os, sys, time
import posixpath
import http.server
import urllib.request, urllib.parse, urllib.error
import cgi
import shutil
import mimetypes
try:
def create_app(self):
# pass in test configuration
app.config.from_object('config.TestConfiguration')
return app(self)
