def __init__(self, Mp=params.get("LRS"), Mn=params.get("HRS"), delay=0):
self.Mp = Mp
self.Mn = Mn
self.delay = [0] * (delay)
self.VDD = params.get("VDD")
self.VSS = params.get("VSS")
self.MID = (self.VDD - self.VSS) / 2 + self.VSS
self.cycles = params.get("cycles")
self.G = np.ones(self.cycles) * (1 / self.Mp - 1 / self.Mn)
self.activity = np.zeros(self.cycles)
def lpr_serachDB(lpr_search):
base_url = params.get("Elasticsearch", "lpr")
url = base_url.format(10, lpr_search)
found, list_dict = elastic_serachDB(url)
#app.logger.info("Found = {} \n elastic_serachDB OUT = {}".format(found,list_dict))
lpr_time_all = ""
lpr = ""
lpr_original = ""
lpr_preview = ""
old_time = ""
if (found > 0):
i = 0
for each_dict in list_dict:
if (i == 0):
lpr = each_dict["lpr"]
lpr_original = format_image(each_dict["origin_file"])
lpr_preview = format_image(each_dict["crop_file"])
app.logger.info("LPR = {}".format(lpr))
each_time = format_time(each_dict["time"])
if (old_time != each_time):
lpr_time_all = "{}\n{}, {}".format(lpr_time_all, lpr,
each_time)
old_time = each_time
i = i + 1
#return found,lpr_time_all,lpr,lpr_original,lpr_preview
app.logger.info("LPR Time = {}".format(lpr_time_all))
app.logger.info("Found = {}".format(found))
return found, lpr_time_all, lpr, lpr_original, lpr_preview
def lpr_ai4thai(origin_file, out_file, crop_file):
url = params.get('AI4Thai', 'lpr_url')
payload = {'crop': '1', 'rotate': '1'}
files = {'image': open(crop_file, 'rb')}
apikey = getAPIKey()
headers = {
'Apikey': apikey,
}
response = requests.post(url, files=files, data=payload, headers=headers)
try:
print("AI4Thai LPR = " + response.json()[0]["lpr"])
data_dict = {}
data_dict["time"] = utils.getCurrentTime()
data_dict["lpr"] = response.json()[0]["lpr"]
data_dict["origin_file"] = origin_file
data_dict["out_file"] = out_file
data_dict["crop_file"] = crop_file
#print(json.dumps(data_dict))
es = db.connect()
result = db.insert(es, json.dumps(data_dict), indexName="lpr")
print("Elastic : Successful = {}\n-----------".format(
result["_shards"]["successful"]))
except Exception as e:
print('LPR error: {}'.format(str(response.json()["message"])))
return response
def main():
# Pull parameters from URL and POST data
post_json = json.JSONDecoder().decode(params.get().getvalue("data")) # FIXME : not final
store_id = params.get().getvalue("storeid") # FIXME : not final
if int(store_id) in c.STORES:
store_name = c.STORES[store_id][0]
else:
raise errors.StoreError()
# Bring in the HTML template.
parser = etree.HTMLParser()
HTMLtree = etree.parse("/var/www/html/"+store_name+"_store_base.html", parser)
# Create a list of strings representing content_item_ids that are entitled.
entitled = []
for entitled_id in post_json["entitled"]: # FIXME : not final
entitled.append(str(entitled_id))
# Create a list of strings representing content_item_ids that are installed.
installed = []
for installed_id in post_json["installed"]: # FIXME : not final
installed.append(str(installed_id))
# Change all the buttons on the page to their correct state:
for entitled_item in entitled:
if entitled_item in installed:
continue
else:
ent_links = HTMLtree.findall(".//a[@class='item"+entitled_item+"']")
for ent_link in ent_links:
ent_button = ent_link.find("div")
ent_button.text = "Download"
ent_button.set("class", ent_button.get("class")+" purchased_button")
for installed_item in installed:
inst_links = HTMLtree.findall(".//a[@class='item"+installed_item+"']")
for inst_link in inst_links:
inst_button = inst_link.find("div")
inst_button.text = "Read"
inst_button.set("class", inst_button.get("class")+" downloaded_button")
print "Content-type: text/html\n"
print etree.tostring(HTMLtree)
def initpositionsnosurf(params):
"""Initialize positions of fluid particles with no surface."""
nparfl = params['nparfl']
lboxx = params['lboxx']
lboxy = params['lboxy']
lboxz = params['lboxz']
rcinit = params['rcinit']
sameseed = params['sameseed']
rcinitsq = rcinit**2.0
pos = np.empty([nparfl, 3])
# excluded region: no fluid particles will be placed in this
# region. We default to False so that fluid particles are placed
# throughout the whole box.
exregion = params.get('exregion', False)
exxmin = params.get('exxmin', 0.0)
exxmax = params.get('exxmax', 0.0)
exymin = params.get('exymin', 0.0)
exymax = params.get('exymax', 0.0)
exzmin = params.get('exzmin', 0.0)
exzmax = params.get('exzmax', 0.0)
pos[:,0], pos[:,1], pos[:,2] = mcfuncs.\
initpositionsnosurff(nparfl, lboxx,
lboxy, lboxz,
rcinitsq,
# excluded region
exregion,
exxmin, exxmax,
exymin, exymax,
exzmin, exzmax,
sameseed)
return pos
def test_get(self):
# If the needed file doesn't exist, create it using params.setup()
user_fn = "params/user_params.json"
if not os.path.exists(user_fn):
params.setup()
# Check return types of request for multiple parameters
p1, p2, p3, p4, p5 = params.get("VDD", "VSS", "tper", "cycles", "cap")
self.assertTrue(isinstance(p1, float))
self.assertTrue(isinstance(p2, int))
self.assertTrue(isinstance(p3, float))
self.assertTrue(isinstance(p4, int))
self.assertTrue(isinstance(p5, float))
# Check return type of request for one parameter
p6 = params.get("VDD")
self.assertTrue(isinstance(p6, float))
def agent(i, exp_queue, model_queue, metric_queue):
device = torch.device('cuda:1')
p = params.get()
# --- Create environments ---
env = gym.make('CartPole-v1')
sdim = env.observation_space.shape
adim = env.action_space.n
# --- Create model ---
model = Model(sdim[0], adim)
# --- exp data ---
states, statesn = [np.empty((p.HORIZON,) + sdim) for _ in range(2)]
rewards, dones = [np.empty((p.HORIZON, 1)) for _ in range(2)]
actions = np.empty((p.HORIZON, 1), dtype=np.int)
episode_rewards = [0.]
sn = env.reset()
while True:
# --- update model ---
state_dict = model_queue.get()
model.load_state_dict(state_dict)
model.to(device)
model.eval()
# --- get exp ---
for t in range(p.HORIZON):
states[t] = sn.copy()
actions[t] = model.action_sample(states[t])
sn, rewards[t], dones[t], _ = env.step(actions[t][0])
episode_rewards[-1] += rewards[t]
if dones[t]:
sn = env.reset()
episode_rewards.append(0.)
statesn[t] = sn.copy()
# --- send exp ---
exp_dict = {
'states': states,
'statesn': statesn,
'rewards': rewards,
'actions': actions,
'dones': dones,
}
exp_queue.put(exp_dict)
metric_dict = {
'episode_rewards': episode_rewards[:-1],
}
metric_queue.put(metric_dict)
episode_rewards = [0.]
def build(self, network_file):
with open(network_file, "r") as f:
lines = f.readlines()
HRS, LRS = params.get("HRS", "LRS")
# TODO --> Fix the indexing here
for line in lines[1:18]:
line = line.replace("\n", "")
line = line.split(" ")
# Read in a network
if line[0] == "+":
if line[1] == "I":
print("N: I")
elif line[1] == "O":
print("N: O")
unique_id = line[2]
threshold = line[3]
# TODO --> Fix the threshold calculation here
threshold = 599e-3
x = line[4]
y = line[5]
z = line[6]
self.neuron_dict[unique_id] = IAF(name=unique_id,
Vth=threshold,
rf=1)
if line[1] == "I":
input_neuron = IN("Input",
self.input_arrays[int(unique_id)])
input_synapse = TM(Mp=LRS,
Mn=HRS,
delay=0,
pre=input_neuron,
post=self.neuron_dict[unique_id])
self.synapse_list.append(input_synapse)
self.neuron_dict[unique_id].input_synapses.append(
input_synapse)
else:
pass
elif line[0] == "|":
pre = self.neuron_dict[line[3]]
post = self.neuron_dict[line[4]]
delay = int(line[5])
mbits = int(line[6])
Mp = LRS if mbits & 1 == 1 else HRS
Mn = HRS if (mbits >> 1) & 1 == 1 else LRS
syn = TM(Mp, Mn, delay, pre, post)
self.synapse_list.append(syn)
post.input_synapses.append(syn)
else:
pass
def central(exp_queues, model_queues, metric_queues, test_queue, tb_queue):
device = torch.device('cuda:1')
p = params.get()
# --- Create Model ---
env = gym.make('CartPole-v1')
sdim = env.observation_space.shape
adim = env.action_space.n
model = Model(sdim[0], adim)
while True:
# --- Synchronize model: send the model to each agent ---
model.to(torch.device('cpu'))
state_dict = model.state_dict()
for i in range(p.NUM_AGENTS):
model_queues[i].put(state_dict)
model.to(device)
model.train()
# --- Receive, compute, shuffle exp ---
exp = train_func.merge_exp(exp_queues)
exp['values'] = model.values(exp['states'])
exp['advs'], exp['returns'] = train_func.compute_adv(exp, p=p)
# --- Update model ---
results = train_func.train_model(model, exp, p.NUM_UPDATE, p=p)
r = SimpleNamespace(**results)
p.NUM_UPDATE += 1
# --- Send to tensorboard ---
tbs = []
tbs.append((TB_SCALAR, 'Loss(updates)/Total', r.total, p.NUM_UPDATE))
tbs.append((TB_SCALAR, 'Loss(updates)/Actor', r.actor, p.NUM_UPDATE))
tbs.append((TB_SCALAR, 'Loss(updates)/Critic', r.critic, p.NUM_UPDATE))
tbs.append((TB_SCALAR, 'Loss(updates)/Entropy Coef', r.ent_coefs, p.NUM_UPDATE))
tbs.append((TB_SCALAR, 'Loss(updates)/Entropy', r.entropies, p.NUM_UPDATE))
tbs.append((TB_SCALAR, 'Loss(updates)/Returns', np.mean(exp['returns']), p.NUM_UPDATE))
tbs.append((TB_SCALAR, 'Loss(updates)/Advantage', np.mean(exp['advs']), p.NUM_UPDATE))
for d in tbs:
tb_queue.put(d)
metric_dict = train_func.merge_metric(metric_queues)
metric = SimpleNamespace(**metric_dict)
for i in range(len(metric.episode_rewards)):
tb_queue.put((TB_SCALAR, 'Episode/Rewards', metric.episode_rewards[i], p.NUM_EPISODE))
p.NUM_EPISODE += 1
# --- update model param ---
model.params = p.__dict__
# --- test model ---
if test_queue.empty():
model.to(torch.device('cpu'))
test_queue.put(copy.deepcopy(model))
def __init__(self, name="", refractory=0, cap=params.get("cap")):
"""Creates an Integrate-and-Fire neuron with the given parameters.
Args:
name - A string uniquely identifying the neuron.
Vmem - The initial value of the membrane voltage.
Vth - The threshold of the neuron.
rf - The refractory period of the neuron (in cycles).
cap - The membrane capacitance of the neuron.
"""
self.name = str(name)
self.Vth = params.get("Vth")
self.tper = params.get("tper")
self.VDD = params.get("VDD")
self.VSS = params.get("VSS")
self.MID = (self.VDD - self.VSS)/2 + self.VSS
self.cycles = params.get("cycles")
self.Cmem = cap
self.refractory = refractory
self.refractory_cycles_left = 0
# Neuron state information
#self.Vmem = self.MID
self.Vmem = np.ones(self.cycles) * self.MID
self.fire = np.zeros(self.cycles)
# Neuron firing flop
self.firing_flop_state = 0
def handle_pm(event):
url = params.get("Elasticsearch", "lora_pm")
found, list_dict = elastic_serachDB(url)
#app.logger.info("found : {} , Data: {}".format(found,list_dict[0]["pm25"]))
time = list_dict[0]["time"]
pm = list_dict[0]["pm25"]
temp = list_dict[0]["temperature"]
hum = list_dict[0]["humidity"]
output_text = "Date: {}\n----------------------\nPM 2.5 = {} ug/m3\nHumidity= {} %\nTemperature = {} Celcius".format(
format_time(time), pm, hum, temp)
app.logger.info(output_text)
detail_text = "More: https://totsmartcity.com/pm"
line_bot_api.reply_message(
event.reply_token,
[TextSendMessage(text=output_text),
TextSendMessage(text=detail_text)])
def __init__(self,
Mp=params.get("LRS"),
Mn=params.get("HRS"),
delay=0,
pre=None,
post=None):
self.Mp = Mp
self.Mn = Mn
self.delay = delay
self.pre = pre
self.post = post
self.Gmax = 1 / params.get("LRS") - 1 / params.get("HRS")
self.G = np.ones(params.get("cycles")) * self.Gmax
self.activity = np.zeros(params.get("cycles"))
self.VDD = params.get("VDD")
self.VSS = params.get("VSS")
self.GND = (self.VDD - self.VSS) / 2 + self.VSS
def auto_fill():
"""
============================================================================
Description: AutoFill Excel-Questions Columns (Id, Valid, Priority, Date).
============================================================================
"""
row_first = 2
col_id = 1
col_valid = 2
col_priority = 3
col_question = 4
col_date = 7
date = u_datetime.to_str(datetime.now(), 'yymmdd')
id_last = params.get('id last')
filepaths = u_excel.get_filepaths_questions()
for xlsx in filepaths:
changed = False
excel = Excel(xlsx)
row_last = excel.ws.max_row
for row in range(row_first, row_last + 1):
if excel.is_blank(row, col_question):
continue
# AutoFill Id
if excel.is_blank(row, col_id):
excel.set_value(row, col_id, id_last + 1)
id_last += 1
changed = True
# AutoFill Valid
if excel.is_blank(row, col_valid):
excel.set_value(row, col_valid, 1)
changed = True
# AutoFill Priority
if excel.is_blank(row, col_priority):
excel.set_value(row, col_priority, 'A')
changed = True
# AutoFill Date
if excel.is_blank(row, col_date):
excel.set_value(row, col_date, date)
changed = True
excel.close()
if changed:
print(xlsx)
params.set('id last', id_last)
def build_from_file(self, network_file):
with open(network_file, "r") as f:
lines = f.readlines()
HRS, LRS = params.get("HRS", "LRS")
for line in lines[1:18]:
line = line.replace("\n", "")
line = line.split(" ")
# Read a network
if line[0] == "+":
if line[1] == "I":
print("N: I")
elif line[1] == "O":
print("N: O")
unique_id = line[2]
elif line[0] == "|":
pass
else:
pass
size = comm.Get_size()
topology = params.calculate_topology(size)
cart = MPI.Intracomm(comm).Create_cart([topology[0], topology[1]],
[True, True])
rank = cart.Get_rank()
# calculate neighbors
coord = cart.Get_coords(rank)
neighbor_coords = [[coord[0] - 1, coord[1]], [coord[0], coord[1] - 1],
[coord[0] + 1, coord[1]], [coord[0], coord[1] + 1]]
neighbors = set(map(cart.Get_cart_rank, neighbor_coords))
print('rank: {}, neighbors: {}'.format(rank, neighbors))
# read parameters
term_m, term_v, pop_size, f_out, f_model, migr_int, migr_size,\
mut_prob, mut_eta, xover_prob, xover_eta = params.get()
# start multiple runs
start = time.time()
# -- setup algorithm --
# init evaluator
model = JspModel(f_model)
evaluator = JspEvaluator(model)
solution_length = model.solution_length()
# init GA
fitness_size = evaluator.metrics_count()
weights = tuple([-1 for _ in range(fitness_size)])
creator.create("FitnessMin", base.Fitness, weights=weights)
creator.create("Individual", JspSolution, fitness=creator.FitnessMin)
import requests
from werkzeug.middleware.proxy_fix import ProxyFix
from linebot import (LineBotApi, WebhookHandler)
from linebot.exceptions import (InvalidSignatureError)
from linebot.models import (
MessageEvent,
TextMessage,
TextSendMessage,
ImageSendMessage,
)
app = Flask(__name__)
app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_host=1, x_proto=1)
token = params.get("Line", "token")
secret = params.get("Line", "secret")
line_bot_api = LineBotApi(token)
handler = WebhookHandler(secret)
@app.route('/')
def main():
return "Python Line!"
@app.route('/test')
def test():
return "Python Test!"
fits = map(lambda x: operators.calc_fitness(x, self.evaluator),
offspring)
for fit, i_off in zip(fits, offspring):
i_off.fitness.values = fit
# select individuals for the next generation
offspring.extend(population)
population = toolbox.select(offspring, len(population))
return population
if __name__ == '__main__':
term_m, term_v, pop, f_out, f_model, _, _, mut_pb,\
mut_eta, xover_pb, xover_eta = params.get()
start = time.time()
alg = NSGA2(f_model)
population = alg.optimize(term_m, term_v, pop, mut_pb, mut_eta, xover_pb,
xover_eta)
duration = time.time() - start
output.write_pareto_front(population, f_out)
with open('{}.time'.format(f_out), 'a') as myfile:
myfile.write('{}\n'.format(duration))
import copy
import params
import train_func
from types import SimpleNamespace
from torch.utils.tensorboard import SummaryWriter
from model import Model
TB_SCALAR = 'scalar'
TB_HIST = 'histogram'
torch.set_default_tensor_type(torch.DoubleTensor)
p = params.get()
def tensorboard(tb_queue):
stime = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
dir_path = '../tensorboard/' + 'CartPole-A2C_' + stime
writer = SummaryWriter(dir_path)
writer.add_text('hparams', str(params.data), 0)
while True:
tbtype, tag, value, step = tb_queue.get()
if tbtype == TB_SCALAR:
writer.add_scalar(tag, value, step)
elif tbtype == TB_HIST:
writer.add_histogram(tag, value, step)
def getAPIKey():
apikey = params.get('AI4Thai', 'Apikey')
return apikey
if (args.image):
# Open the image file
if not os.path.isfile(args.image):
print("Input image file ", args.image, " doesn't exist")
sys.exit(1)
video_source = args.image
outputFile = args.image[:-4] + '_yolo_out_py.jpg'
elif (args.video):
# Open the video file
if not os.path.isfile(args.video):
print("Input video file ", args.video, " doesn't exist")
sys.exit(1)
video_source = args.video
outputFile = args.video[:-4] + '_yolo_out_py.avi'
elif (args.rtsp):
rtsp_stream = params.get('RTSP', args.rtsp)
video_source = rtsp_stream
outputFile = args.rtsp + '_yolo_out_py.avi'
else:
# Webcam input
video_source = 0
cap = cv.VideoCapture(video_source)
# Get the video writer initialized to save the output video
#if (not args.image):
# vid_writer = cv.VideoWriter(outputFile, cv.VideoWriter_fourcc('M','J','P','G'), 30, (round(cap.get(cv.CAP_PROP_FRAME_WIDTH)),round(cap.get(cv.CAP_PROP_FRAME_HEIGHT))))
skipFrame = int(params.get(
"RTSP", "skip")) # input number of frame to be skipped processing
frameNo = 0
import params
import os
import pandas as pd
import scipy.io
print "begin"
path = "/media/carlos/CE2CDDEF2CDDD317/concursos/cancer/stage1_100_100_200_test/"
files = [path + file for file in os.listdir(path)]
features_file = "data/resp_18000"
sub_file = "data/stage1_submission_6.csv"
r = []
r.append(["id", "cancer"])
features = scipy.io.loadmat(features_file)
parameters = params.get()
preds = model.eval_conv(files, parameters, features)
a = []
for pred in preds:
name, prob = pred
d = {}
d["id"] = name.split("/")[-1:][0].split("_")[0]
d["cancer"] = prob[0][1]
a.append(d)
df = pd.DataFrame(a)
df = df.groupby("id").mean()
print df
df.to_csv(sub_file)
def reset(self):
self.G = np.ones(params.get("cycles")) * self.Gmax
self.activity = np.zeros(params.get("cycles"))
# Import Elasticsearch package
from elasticsearch import Elasticsearch
import params
database = params.get('Elasticsearch', 'database')
port = params.get('Elasticsearch', 'port')
#Create index lora by
#http://localhost:9200/lora
# Connect to the elastic cluster
def connect():
es = Elasticsearch([{'host': database, 'port': port}])
#print(es)
return es
# Insert
def insert(es, data, indexName="lora"):
#print(data)
#Now let's store this document in Elasticsearch
res = es.index(index=indexName, doc_type="lora", body=data)
return res
def main():
# Pull parameters from URL and POST data
store_id = params.get().getvalue("storeid") # FIXME : not final
if int(store_id) in c.STORES:
store_name = c.STORES[store_id][0]
bundle_id = c.STORES[store_id][1]
else:
raise errors.StoreError()
# Bring in the HTML template.
parser = etree.HTMLParser()
HTMLtree = etree.parse("/var/www/html/"+store_name+"_template.html", parser)
legacyHTMLtree = etree.parse("/var/www/html/legacy_"+store_name+"_template.html", parser)
# Create db connection for fetching promotions.
dB = db_connect.OpenDB()
# Create and make query to retrieve data for the currently stored issues.
items_query = """
SELECT *
FROM content_items
WHERE bundle_id = '%s'
ORDER BY publication_date DESC
""" % (bundle_id)
items_results = dB.SelectQuery(items_query)
# Create and make query to retrieve preview image urls.
previews_query = """SELECT content_item_id, image_url FROM previews"""
previews_results = dB.SelectQuery(previews_query)
# Close db connection.
dB.Close()
# Create a workable dictionary of the preview image query.
previews_dict = datautils.workablepreviews(previews_results)
# Pop off the first item in the result as the featured item.
featured_item = datautils.singleissue(items_results.pop(0), previews_dict)
# Get a list of objects from the result, allowing the issue metadata to be
# accessed by name rather than index in the query results.
previous_issues = datautils.listissues(items_results, previews_dict)
# Find the featured section:
featured_holder = HTMLtree.find(".//div[@id='featured_issue']")
legacy_featured_holder = legacyHTMLtree.find(".//div[@id='featured_issue']")
# Find the preview section:
issue_holder = HTMLtree.find(".//div[@id='issue_float_holder']")
legacy_issue_holder = legacyHTMLtree.find(".//div[@id='issue_float_holder']")
# Find the lightbox section:
details_holder = HTMLtree.find(".//div[@id='hide_details']")
legacy_details_holder = legacyHTMLtree.find(".//div[@id='hide_details']")
# Build the featured issue section.
featured_id = str(featured_item.info["id"])
if featured_item.info["price_tier"] > 0:
featured_action_string = "Buy $"+str(float(featured_item.info["price_tier"]) - 0.01)
else:
featured_action_string = "Download"
featured_holder.append(
A(
IMG(
ID("featured_cover"),
SRC(featured_item.info["cover_url"])
),
HREF("#frame"+featured_id),
CLASS("show_lightbox")
)
)
if featured_item.info["subtitle"] is not None:
featured_subtitle = makecleanelement("<p>",featured_item.info["subtitle"],"</p>")
featured_holder.append(
DIV(
DIV(
H1(makeunicode(featured_item.info["title"])),
featured_subtitle,
ID("featured_desc")
),
DIV(
A(
DIV(
featured_action_string,
CLASS("feature_button","action_button","buy_button")
),
HREF("sm://itemOpen/"+featured_id),
CLASS("item"+featured_id)
),
A(
DIV(
"Details",
CLASS("feature_button","action_button","details_button")
),
HREF("#frame"+featured_id),
CLASS("show_lightbox")
),
ID("featured_buttons")
),
ID("featured_details")
)
)
details_holder.append(builders.buildlightbox(featured_item, featured_action_string))
# Build the list of previous issues and the detail panels for each.
for issue in previous_issues:
previous_id = str(issue.info["id"])
if issue.info["price_tier"] > 0:
issue_action_string = "Buy $"+str(float(issue.info["price_tier"]) - 0.01)
else:
issue_action_string = "Download"
# Append an issue element to the main scrollable list of previous issues.
issue_holder.append(
DIV(
DIV(
A(
IMG(SRC(issue.info["thumbnail_url"])),
HREF("#frame"+previous_id),
CLASS("show_lightbox")
),
CLASS("picture")
),
DIV(makeunicode(trimtext(issue.info["title"], 20)), CLASS("desc_picture")),
DIV(
A(
DIV(
issue_action_string,
CLASS("left_button","action_button","buy_button")
),
HREF("sm://itemOpen/"+previous_id),
CLASS("item"+previous_id)
),
A(
DIV(
"Details",
CLASS("right_button","action_button","details_button")
),
HREF("#frame"+previous_id),
CLASS("show_lightbox")
),
CLASS("button_holder")
),
CLASS("issue")
)
)
details_holder.append(builders.buildlightbox(issue, issue_action_string))
legacy_featured_holder = featured_holder
legacy_issue_holder = issue_holder
legacy_details_holder = details_holder
# Write the generated HTML to a temporary file. Using temporary files prevents race conditions.
data = etree.tostring(HTMLtree)
tmp = tempfile.mkstemp(dir=TEMP_BASE)
legacy_tmp = tempfile.mkstemp(dir=TEMP_BASE)
bytes_written = os.write(tmp[0], data)
os.write(legacy_tmp[0], data)
os.close(tmp[0])
os.close(legacy_tmp[0])
# Move the temporary file to the final URL.
# FIXME : do we need to fix permissions here?
os.rename(tmp[1], STORE_BASE % (store_name))
os.rename(legacy_tmp[1], LEGACY_BASE % (store_name))
return bytes_written
