def __init__(self):
self.serial = serial.Serial(
port =config()['port'],\
baudrate=config()['baudrate'],\
parity =serial.PARITY_NONE,\
stopbits=serial.STOPBITS_ONE,\
bytesize=serial.EIGHTBITS,\
timeout =config()['timeout']
)
def backup(self,backup_location=None):
# If they just called backup(), then use the path specified in the config
if not backup_location:
backup_location = settings.config()["Storage"]["backup directory"]
# If backup_location is still undefined, then we have no idea where to do the backup, so
# we just return after printing a message
if not backup_location:
ice_logger.log("No backup location specified. Not creating backup file.")
return None
# If the shortcuts file is undefined, print an error and return
if not self.shortcuts_file:
print "SteamShortcutManager Backup Error: No file specified"
return None
# Get the user id using the location of the shortcuts file and create a directory
# in the backup location using the same directory structure Steam uses
user_id = os.path.split(os.path.dirname(os.path.dirname(self.shortcuts_file)))[1]
new_dir = os.path.expanduser(os.path.join(os.path.join(backup_location,user_id),"config"))
try: # Handle possible race condition
os.makedirs(new_dir)
except OSError:
if not os.path.isdir(new_dir):
raise
backup_file_name = "shortcuts." + datetime.now().strftime('%Y%m%d%H%M%S') + ".vdf"
open(os.path.join(new_dir,backup_file_name),"w").write(open(self.shortcuts_file,"r").read())
def should_download_images():
try:
should_download = settings.config()["Grid Images"]["source"] != ""
return should_download
except KeyError:
log_both("Could not find '[Grid Images] Source' in config.txt.")
return False
def create_app():
app = Flask(__name__, instance_relative_config=True)
env = os.environ.get("FLASK_ENV")
try:
os.makedirs(app.instance_path)
except OSError:
pass
else:
with open(app.instance_path + "/application.cfg", "w") as conf:
from config import DevelopmentConfig
line = '{}="{}"\n'
for key, value in DevelopmentConfig.fields().items():
if isinstance(value, (bool, int)):
conf.write('{}={}\n'.format(key, value))
else:
conf.write(line.format(key, value))
conf.writelines([
line.format(key, value)
for key, value in DevelopmentConfig.fields().items()
])
if env:
app.config.from_object(config(env))
else:
app.config.from_pyfile("application.cfg")
db.init_app(app)
app.register_blueprint(user)
return app
def save_user_to_postgresql(user_name, sex, age, weight, work):
"""
save user data to postgresql
"""
connection = config()
cursor = connection.cursor()
try:
postgres_insert_users = """
INSERT INTO users
(username, sex, age, weight, work)
VALUES (%s, %s, %s, %s, %s)"""
records_to_users = (user_name, sex, age, weight, work)
cursor.execute(postgres_insert_users, records_to_users)
except psycopg2.errors.UniqueViolation:
connection.rollback()
postgres_insert_users = """
UPDATE users SET
sex=%s, age=%s, weight=%s, work=%s WHERE username=%s
"""
records_to_users = (sex, age, weight, work, user_name)
cursor.execute(postgres_insert_users, records_to_users)
finally:
cursor.close()
connection.commit()
connection.close()
def save_pressure_to_postgresql(username,
systolic,
diastolic,
timestamp,
arm,
pulse=None):
"""
save username(unique), systolic, diastolic, timestamp, date, arm
"""
connection = config()
cursor = connection.cursor()
try:
postgres_insert_users = """INSERT INTO users (username) VALUES (%s)"""
record_to_users = username
cursor.execute(postgres_insert_users, [record_to_users])
except psycopg2.errors.UniqueViolation:
connection.rollback()
finally:
postgres_insert_pressure = """
INSERT INTO pressure (
username, systolic, diastolic, timestamp, arm, pulse
)
VALUES (%s, %s, %s, %s, %s, %s)
"""
records_to_pressure = (username, systolic, diastolic, timestamp, arm,
pulse)
cursor.execute(postgres_insert_pressure, records_to_pressure)
cursor.close()
connection.commit()
connection.close()
def roms_directory():
"""
Returns the path to the ROMs directory, as specified by config.txt.
"""
path = os.path.expanduser(settings.config()['Storage']['roms directory'])
if not os.access(path, os.W_OK):
path = os.path.join(os.path.expanduser('~'),'ROMs')
return path
def roms_directory():
"""
Returns the path to the ROMs directory, as specified by config.txt.
"""
path = os.path.expanduser(settings.config()["Storage"]["roms directory"])
if not os.access(path, os.W_OK):
path = os.path.join(os.path.expanduser("~"), "ROMs")
return path
def roms_directory():
"""
Returns the path to the ROMs directory, as specified by config.txt.
"""
path = os.path.expanduser(settings.config()['Storage']['roms directory'])
if not os.access(path, os.W_OK):
path = os.path.expanduser("~")
return os.path.join(path, "ROMs")
def roms_directory():
"""
Returns the path to the ROMs directory, as specified by config.txt.
"""
path = os.path.expanduser(settings.config()['Storage']['roms directory'])
if path == "":
path = os.path.join(os.path.expanduser("~"), "ROMs")
if not available_to_use(path, create_if_needed=True):
fix_instructions = "Ice does not have permission to write to your ROMs Directory, %s. Please choose a different folder or change your permissions." % path
raise ConfigError("Storage", "ROMs Directory", fix_instructions)
return path
def roms_directory():
"""
Returns the path to the ROMs directory, as specified by config.txt.
"""
path = os.path.expanduser(settings.config()['Storage']['roms directory'])
if path == "":
path = os.path.join(os.path.expanduser("~"), "ROMs")
if os.path.exists(path) and not os.access(path, os.W_OK):
fix_instructions = "Ice does not have permission to write to your ROMs Directory, %s. Please choose a different folder or change your permissions." % path
raise ConfigError("Storage","ROMs Directory", fix_instructions)
return path
def roms_directory():
"""
Returns the path to the ROMs directory, as specified by config.txt.
"""
path = os.path.expanduser(settings.config()['Storage']['roms directory'])
if path == "":
path = os.path.join(os.path.expanduser("~"), "ROMs")
if not available_to_use(path, create_if_needed=True):
fix_instructions = "Ice does not have permission to write to your ROMs Directory, %s. Please choose a different folder or change your permissions." % path
raise ConfigError("Storage","ROMs Directory", fix_instructions)
return path
def create_tables():
"""
create 2 tables:
users: - username, sex, age, weight, work
pressure: pressure_id, username, systolic, diastoic,
timestamp, date, arm, foreign key to users
"""
tables = (
"""
CREATE TABLE IF NOT EXISTS users (
username VARCHAR(50) PRIMARY KEY NOT NULL,
sex VARCHAR(20),
age VARCHAR(15),
weight VARCHAR(15),
work VARCHAR(15)
);
""",
"""
CREATE TABLE IF NOT EXISTS pressure(
pressure_id SERIAL PRIMARY KEY,
username VARCHAR(50),
systolic VARCHAR(3) NOT NULL,
diastolic VARCHAR(3) NOT NULL,
timestamp timestamptz NOT NULL,
arm VARCHAR(50) NOT NULL,
pulse VARCHAR(3),
FOREIGN KEY (username) REFERENCES users
);
"""
)
try:
connection = config()
cursor = connection.cursor()
for table in tables:
cursor.execute(table)
cursor.close()
connection.commit()
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if connection is not None:
connection.close()
def get(endpoint):
"""
GET a json payload from the photostreamer-server
"""
cfg = settings.config()
url = cfg.get('server', 'url') + endpoint
try:
r = requests.get(url)
if r.status_code == 200:
l.debug("photostreamer-server endpoint %s responded with %s", endpoint, r.json())
return r.json()
else:
l.error("Received HTTP status code %d while trying to reach %s.",
r.status_code, url)
return False
except requests.ConnectionError:
l.error("Network error trying to GET %s.", url)
return False
def select_data_from_postgresql(user, first_date, last_date):
"""
select data for the user and time period
"""
connection = config()
cursor = connection.cursor()
postgreSQL_select_query = """
SELECT * FROM pressure WHERE username = %s
AND timestamp >= %s AND timestamp <= %s;
"""
details = [user, first_date, last_date]
cursor.execute(postgreSQL_select_query, details)
pressure_data = cursor.fetchall()
cursor.close()
connection.close()
return pressure_data
def lookup_emulator(platform,console):
emulators_key = platform + ' Emulators' # ex: "Windows Emulators"
console_key = console.shortname.lower()
try:
user_supplied_name = settings.config()[emulators_key][console_key]
if not user_supplied_name:
log_file("No user supplied name for %s" % console.shortname)
return None
name = emulator_platform_prefix(platform) + user_supplied_name
return emulator_from_name(name)(console.shortname)
except KeyError as e:
# TODO(#28) Throw a ConfigError once it will be caught...
log_file("Configuration missing key for %s on %s" % (console.shortname, platform))
return None
except AttributeError as e:
# TODO(#28) Throw a ConfigError once it will be caught...
log_user("Cannot load emulator for %s. Check that your spelling is correct, and that the emulator you request is supported" % console.shortname)
log_file("Error loading [%s] %s" % (emulator_key, console_key))
return None
def lookup_emulator(platform,console):
emulators_key = platform + ' Emulators' # ex: "Windows Emulators"
console_key = console.shortname.lower()
try:
user_supplied_name = settings.config()[emulators_key][console_key]
except KeyError as e:
log_file("Configuration missing key for %s on %s" % (console.shortname, platform))
return None
if not user_supplied_name:
log_file("No user supplied name for %s" % console.shortname)
return None
name = emulator_platform_prefix(platform) + user_supplied_name
try:
return emulator_from_name(name)(console.shortname)
except (KeyError, AttributeError) as e:
message = "Could not load emulator. Check your spelling, and make sure the emulator is supported for your console"
raise ConfigError(emulators_key, console.shortname, message)
def base_environment(environment=""):
""" Base environment for all environments """
_env.environment = environment.lower()
environment = environment.upper()
application_name = config(environment + "_APPLICATION_NAME", '') or \
config("APPLICATION_NAME", '')
_env.host = config(environment + "_SERVER_HOST", '')
_env.user = config(environment + "_OS_USER", 'root')
_env.environment_variables = config(
environment + '_ENVIRONMENT_VARIABLES', '')
_env.dokku_command = "ssh dokku@" + \
config(environment + "_SERVER_HOST", '')
_env.app_name_dokku = application_name
print("Connecting to %s..." % environment.lower())
def connect():
"""
Return a connected S3 bucket based on settings in
config.cfg.
"""
# Reduce the number of retries to 1 if it's not set already so requests
# fail quickly rather than delaying the downloading of photos
if not boto.config.has_option('Boto', 'num_retries'):
if not boto.config.has_section('Boto'):
boto.config.add_section('Boto')
boto.config.set('Boto', 'num_retries', '1')
cfg = settings.config()
try:
aws_access_key = cfg.get('s3', 'access_key')
aws_secret_key = cfg.get('s3', 'secret_key')
aws_s3_bucket = cfg.get('s3', 'bucket')
except NoOptionError as e:
l.error("Error reading a setting from the config.cfg file: %s", e)
raise
conn = S3Connection(aws_access_key, aws_secret_key)
bucket = conn.get_bucket(aws_s3_bucket, validate=False)
return bucket
def lookup_emulator(platform, console):
emulators_key = platform + ' Emulators' # ex: "Windows Emulators"
console_key = console.shortname.lower()
try:
user_supplied_name = settings.config()[emulators_key][console_key]
if not user_supplied_name:
log_file("No user supplied name for %s" % console.shortname)
return None
name = emulator_platform_prefix(platform) + user_supplied_name
return emulator_from_name(name)(console.shortname)
except KeyError as e:
# TODO(#28) Throw a ConfigError once it will be caught...
log_file("Configuration missing key for %s on %s" %
(console.shortname, platform))
return None
except AttributeError as e:
# TODO(#28) Throw a ConfigError once it will be caught...
log_user(
"Cannot load emulator for %s. Check that your spelling is correct, and that the emulator you request is supported"
% console.shortname)
log_file("Error loading [%s] %s" % (emulator_key, console_key))
return None
def connect():
"""
Return a connected S3 bucket based on settings in
config.cfg.
"""
# Reduce the number of retries to 1 if it's not set already so requests
# fail quickly rather than delaying the downloading of photos
if not boto.config.has_option('Boto', 'num_retries'):
if not boto.config.has_section('Boto'):
boto.config.add_section('Boto')
boto.config.set('Boto', 'num_retries', '1')
cfg = settings.config()
try:
aws_access_key = cfg.get('s3', 'access_key')
aws_secret_key = cfg.get('s3', 'secret_key')
aws_s3_bucket = cfg.get('s3', 'bucket')
except NoOptionError as e:
l.error("Error reading a setting from the config.cfg file: %s", e)
raise
conn = S3Connection(aws_access_key, aws_secret_key)
bucket = conn.get_bucket(aws_s3_bucket, validate=False)
return bucket
def post(endpoint, payload, resend=False):
"""
POST a json payload to the photostreamer-server
"""
cfg = settings.config()
url = cfg.get('server', 'url') + endpoint
try:
r = requests.post(url,
data=json.dumps(payload), headers={'content-type':'application/json'})
if r.status_code == 200:
l.debug("POSTed %s to photostreamer-server endpoint %s.", payload, endpoint)
return True
else:
l.error("Received HTTP status code %d while POSTing to %s.",
r.status_code, url)
if resend == False:
post_later(endpoint, payload)
return False
except requests.ConnectionError:
l.exception("Network error trying to POST to %s.", url)
if resend == False:
post_later(endpoint, payload)
return False
@properness_tests.add_method
def is_proper_position(self, circle):
"""
Test if the scale is in the correct position.
@param Circle circle: the inscribed circle of clock face
@return True for locates in correct position
"""
return circle.is_in_sector(self.center, self._sector_no) and \
(type(self)._MIN_FIT_POINTS <= \
reduce(lambda points_no, nxt: points_no + \
circle.is_in_sector(tuple(nxt), self._sector_no),
[ 0 ] + self.box_points.tolist()))
config(ScaleElement)
import unittest
class TestScaleElement(unittest.TestCase):
"""
Test ScaleElement class.
"""
def test_is_proper_position(self):
self.assertIsNotNone(ScaleElement.is_proper_position.__doc__)
if __name__ == '__main__':
# run unittest TestScaleElement
# XXX: This file is not being used!
#
# It was left here because someday we might add the preferences window back.
import gtk
import logging
from settings import config
logger = logging.getLogger("batterymon")
settings = config()
class prefs:
def destroy(self,widget):
self.pref_win.hide()
def Radio_Call_Back(self,widget,data=None):
test = (("OFF","ON")[widget.get_active()])
Toggled = data +" " + test
if Toggled == "Always_show ON":
logger.debug("DEBUG Always show an icon")
settings.write_settings_int("show_icon","1")
return
elif Toggled == "show_charging_discharging ON":
logger.debug("DEBUG only show when battery is charging or discharing")
settings.write_settings_int("show_icon","3")
return
elif Toggled == "Show_discharging_only ON":
logger.debug("DEBUG Show an icon when discharging")
settings.write_settings_int("show_icon","2")
return
def config_userdata_location():
return os.path.expanduser(settings.config()["Steam"]["userdata directory"])
# encoding: utf-8
import requests
import json
import Cookie,os
#import settings as set
from settings import config
cfg = config()
#ws = set.Wsh()
class Product(object):
baseurl = cfg.URL
proxylist = cfg.PROXY
headers = cfg.HEADERS
headers_json = cfg.HEADERS_JSON
######### 商品 ##########
def get_product_list(self,sessionid):
print u"---Test 获取商品列表---"
url = self.baseurl+"/product/list-ajax"
#url = "http://betanewwsh.vikduo.com/reduction/list-ajax"
headers = self.headers
cookies = {'PHPSESSID': sessionid}
r = requests.post(url, headers=headers,cookies=cookies)
print "Headers:", r.headers
print "Response:", r.content
return r
@return list sorted elements
"""
# zip the element list with their angles to the center of the circle
sorted_element_angles = sorted(map(lambda e: (e, np.arctan2(
*np.subtract(e.center, center))), elements),
key=lambda e_ag: e_ag[1], reverse=True)
# sort and return the element list
return list(map(lambda e_ag: e_ag[0],
list(filter(lambda e_ag: e_ag[1] >= type(self)._START_RAD,
sorted_element_angles)) +
sorted(filter(lambda e_ag: e_ag[1] < type(self)._START_RAD,
sorted_element_angles), key=lambda e_ag: e_ag[1],
reverse=True)))
config(ScaleImageMixin)
import unittest
class TestScaleImageMixin(unittest.TestCase):
"""
Test ScaleImageMixin class.
"""
def test_elements(self):
"""
Test lazy property elements.
"""
self.assertIsNotNone(ScaleImageMixin.elements.__doc__)
#!/usr/bin/env python
import os
import time
from PIL import Image
from ConfigParser import NoOptionError
import s3
import server
import settings
import db
import logger
l = logger.setup('hook')
cfg = settings.config()
sender = 0
def generate_key(fileName):
"""
Generate a unique filename based on the current timestamp.
"""
timestamp = str(time.time()).replace(".", "")
file_extension = fileName.split(".")[1]
return timestamp + "." + file_extension
def generate_thumb(src, dest):
"""
Create a thumbnail of the file using Pillow and return
the path to the created thumbnail.
"""
# XXX: This file is not being used!
#
# It was left here because someday we might add the preferences window back.
import gtk
import logging
from settings import config
logger = logging.getLogger("batterymon")
settings = config()
class prefs:
def destroy(self, widget):
self.pref_win.hide()
def Radio_Call_Back(self, widget, data=None):
test = (("OFF", "ON")[widget.get_active()])
Toggled = data + " " + test
if Toggled == "Always_show ON":
logger.debug("DEBUG Always show an icon")
settings.write_settings_int("show_icon", "1")
return
elif Toggled == "show_charging_discharging ON":
logger.debug(
"DEBUG only show when battery is charging or discharing")
settings.write_settings_int("show_icon", "3")
return
elif Toggled == "Show_discharging_only ON":
logger.debug("DEBUG Show an icon when discharging")
settings.write_settings_int("show_icon", "2")
Use pointPolygonTest to see if the given point is inside the specified
sector (one of the sectors).
@param tuple point: a given point
int sector_no: which sector (clockwise order, 0 ~ 11)
find all sectors if not specified
@return True if the point is in the sector (one of the sectors)
"""
if sector_no < 0:
return reduce(lambda result, sector: result or \
cv.pointPolygonTest(sector, point, False) > 0,
[ False ] + self.sectors)
return cv.pointPolygonTest(self.sectors[sector_no], point, False) > 0
config(Circle)
import unittest
class TestCircle(unittest.TestCase):
"""
Test Circle class.
"""
# create a test circle class for unittest
_TestCircle = type('_TestCircle', (Circle, ), {})
def test_sectors(self):
"""
Test evaluation method for sectors.
"""
import pygame as pg
from settings import Settings as config
import assets.values.booleans as bools
pg.init()
conf = config(pg)
conf.loadDefaults()
conf.createSession()
while bools.isPlaying:
conf.setBackground()
conf.buildMapRelay()
for event in pg.event.get():
if event.type is pg.QUIT:
bools.playing = False
conf.setControls()
conf.buldMarioRelay()
conf.physicsRelay()
pg.display.flip()
pg.time.delay(conf.setFPS())
def provider_with_protocol(self):
host = settings.config()["Grid Images"]["source"]
if not host.startswith("http://"):
host = "http://" + host
return host
Formula: (4 * pi * area) / perimeter ^ 2
@param ClockFace clock_face: clock face of the image
ElementMixin element: useless here
@return bool True for being circular
"""
perimeter = cv.arcLength(clock_face.main_contour, True)
area = clock_face.area
# calculate and return circularity
return ((4 * np.pi * area) / (perimeter * perimeter)) > \
type(self)._CIRCULARITY_THRESH_VAL
config(Circularity)
import unittest
class TestCircularity(unittest.TestCase):
"""
Test Circularity class.
"""
def test_inscribed_circle_mtd(self):
"""
Test _inscribed_circle_mtd method with a square and a perfect circle.
"""
from utils.create_imgs import create_square, create_circle
from models.clock_face import ClockFace
from models.model_mixins.image_mixin import ImageMixin
def config_userdata_location():
return os.path.expanduser(settings.config()["Steam"]["userdata directory"])
#!/usr/bin/env python
# -*- coding: utf8 -*-
import boto.ec2
import settings
c = settings.config()
conn = boto.ec2.connect_to_region(c.ec2_region_name,
aws_access_key_id=c.aws_key,
aws_secret_access_key=c.aws_secret,
debug=c.debug)
print conn.get_all_instances()
def provider_with_protocol(self):
host = settings.config()["Grid Images"]["source"]
if not host.startswith("http://"):
host = "http://" + host
return host
return map(list, zip(*clean_contours_info))
@lazy_property
def img(self):
"""
The lazy property img. Preprocessed raw image.
@return ndarray img preprocessed with binarization
"""
return self._preprocess(self._raw_img,
binarization=True,
opening=False,
closing=False)
config(ImageMixin)
import unittest
class TestImageMixin(unittest.TestCase):
"""
Test ImageMixin class.
"""
def test_preprocess(self):
"""
Test _preprocess method.
"""
self.assertIsNotNone(ImageMixin._preprocess.__doc__)
def test_find_clean_contours(self):
# encoding: utf-8
import requests
import json
import Cookie,os
from urllib import urlencode
import re
from settings import config
cfg = config()
#ws = set.Wsh()
defaultapp = 'android'
class Shop(object):
capt = cfg.CAPTCHA
user = cfg.USER
passwd = cfg.PASSWORD
baseurl = cfg.URL
terminalurl = cfg.URL_TERMINAL
proxylist = cfg.PROXY
headers = cfg.HEADERS
headers_json = cfg.HEADERS_JSON
def __init__(self):
pass
def wsh_test(self):
print "mytest"
#### 获取活动详情
from settings import config
from dev_script import emailLoader, extractFile
import datetime
import os
if __name__ == "__main__":
params = config()
date_jour = datetime.datetime.today().strftime('%d-%b-%Y')
files_path = os.path.join('..','data_storage','itop')
emailLoader(dateJ=date_jour,configuration=params, path=files_path)
extractFile(input_path=files_path)
