def encrypt_public(key): #open the file conatining the id of DC name_of_dc = open('data/temporary_store.txt').read().replace('\n', '') encrypted_data = asymcrypt.encrypt_data( key, "data/" + name_of_dc + ".pem") # encrypt with the public key hex_str = encrypted_data.hex() publish(name_of_dc, hex_str) #publish the encrypted key to EDC
def bk(orderstr: str, sizes: Iterable[int], func_indices: List[int], samples: int) -> None: order = to_int(orderstr) stats_per_func_by_size = {} for size in sizes: begin = time.process_time() g, clique_count = read_random_graph(orderstr=orderstr, size=size) secs = time.process_time() - begin name = f"random of order {orderstr}, size {size}, {clique_count} cliques:" if order < 10: print(f"{name} {g.adjacencies}") else: print(f"{name} (creating took {secs:.3f}s)") stats = bron_kerbosch_timed(g, clique_count=clique_count, func_indices=func_indices, samples=samples) for func_index, func_name in enumerate(FUNC_NAMES): mean = stats[func_index].mean() if not isnan(mean): reldev = stats[func_index].deviation() / mean print(f" {func_name:<8}: {mean:6.3f}s ± {reldev:.0%}") stats_per_func_by_size[size] = stats if len(stats_per_func_by_size) > 1: publish(language="python3", orderstr=orderstr, case_names=FUNC_NAMES, stats_per_func_by_size=stats_per_func_by_size)
def sym_key(): symmetricKey_KIS = b'aQOQxINtlrXU_HkbJywoMxfiFMXC-OToihHK2ApIeCs=' KIS = Fernet(symmetricKey_KIS) KIE = Fernet.generate_key() # generate symmetric key KIE_IoTD = KIS.encrypt((KIE)) #print(KIE_IoTD) encrypt_public(KIE) publish("sensor_sym_key", KIE_IoTD) # publish symmetric key to IoTD
def test_publish_update(self): """ Publish an article update """ f = open(os.path.join(here, 'sample.rst')) publish(f, draft=True, login_required=True) updated_article = Article.objects.get(pk=1) self.assertFalse(self.article.login_required) self.assertTrue(updated_article.login_required)
def abort_process(original_combination, temp_data, start): publish("sensor_sym_key", "abort") encrypt_public("nodata") benchmark() abort_reason("error", " \n") spoof_detect(original_combination, temp_data).to_csv( "/logs/error.log", mode="a", index=False) # save the error details with time end = time.time() print("Time taken for the analysis after receving the data ", end - start) clearFiles()
def build(do_publish=0): print("Build") print("-----") outfile = 'hardware.json' oldfile = 'backup.json' print("Backup current json...") oldjso = None if os.path.isfile(outfile) and not os.path.isfile(oldfile): os.rename(outfile, oldfile) errorlevel = 0 errorlevel += parse_machines() if errorlevel == 0: errorlevel += vitamins() if errorlevel == 0: errorlevel += cut() if errorlevel == 0: errorlevel += printed() if errorlevel == 0: errorlevel += assemblies() if errorlevel == 0: errorlevel += machines() if errorlevel == 0: errorlevel += guides() catalogue() if errorlevel == 0 and do_publish > 0: publish() # if everything is ok then delete backup - no longer required if errorlevel == 0: os.remove(oldfile) try: if sys.platform == "darwin": check_output([ 'osascript', '-e', 'display notification "Build Complete" with title "Build Process"' ]) except: print("Exception running osascript") print("") print("==============") print("Build Complete") return errorlevel
def build(do_publish=0): print("Build") print("-----") outfile = 'hardware.json' oldfile = 'backup.json' print("Backup current json...") oldjso = None if os.path.isfile(outfile) and not os.path.isfile(oldfile): os.rename(outfile, oldfile) errorlevel = 0 errorlevel += parse_machines() if errorlevel == 0: errorlevel += vitamins() if errorlevel == 0: errorlevel += cut() if errorlevel == 0: errorlevel += printed() if errorlevel == 0: errorlevel += assemblies() if errorlevel == 0: errorlevel += machines() if errorlevel == 0: errorlevel += guides() catalogue(); if errorlevel == 0 and do_publish > 0: publish() # if everything is ok then delete backup - no longer required if errorlevel == 0: os.remove(oldfile) try: if sys.platform == "darwin": check_output(['osascript','-e','display notification "Build Complete" with title "Build Process"']) except: print("Exception running osascript") print("") print("==============") print("Build Complete") return errorlevel
def publish_reports(request): if request.method == 'POST': form = ReportPublishForm(request.POST) if form.is_valid(): translation.activate(form.cleaned_data['language']) request.LANGUAGE_CODE = translation.get_language() publish(form.cleaned_data['start_date'], form.cleaned_data['end_date'], form.cleaned_data['report'], form.cleaned_data['edition']) translation.deactivate() return HttpResponseRedirect('/admin/report/publish') # Redirect after POST return render_to_response('report_publish.html', {'form': ReportPublishForm(), }, context_instance=RequestContext(request))
def waitInput(key): # Open the configuration file and put content in config variable with open('config.json', 'r') as content_file: config = content_file.read() config = json.loads(config) infile_path = config[key] #long int, long int, unsigned short, unsigned short, unsigned int FORMAT = 'llHHI' EVENT_SIZE = struct.calcsize(FORMAT) #open file in binary mode in_file = open(infile_path, "rb") event = in_file.read(EVENT_SIZE) event2 = in_file.read(EVENT_SIZE) codigo = "" while event: (tv_sec, tv_usec, type, code, value) = struct.unpack(FORMAT, event) (tv_sec, tv_usec, type, code, value) = struct.unpack(FORMAT, event2) if type != 0 or code != 0 or value != 0: if type==4 and code==4 and str(value) in config[infile_path]: tvalue = config[infile_path][str(value)] if tvalue == "/": if len(codigo) != 0: if (codigo.find(tvalue) == -1) and (codigo.find(".") == -1): codigo = codigo + tvalue elif tvalue == ".": if len(codigo) != 0: if (codigo.find(tvalue) == -1) and (codigo.find("/") == -1): codigo = codigo + tvalue elif tvalue=="ENTER": if len(codigo) >= 1: publish(codigo, key) codigo = "" else: codigo = codigo + tvalue event = in_file.read(EVENT_SIZE) event2 = in_file.read(EVENT_SIZE) in_file.close()
def check_annotations(): while True: known_lampposts = annotation.get_lampposts() print '--------------------------------------- monitoring {} lampposts ---------------------------------------'.format( len(known_lampposts)) for fid in known_lampposts: # print "> '{}':".format(fid) f_uri = r.get('f:uri:{}'.format(fid)) agreements = stats.check_agreement(fid) agreed_color = None agreed_wattage = None agreed_cover = None position = annotation.get_lamppost_position(fid) position_dict = {} if position is not None: position_dict['latitude'] = position[0] position_dict['longitude'] = position[1] for agreement in agreements: agreement['id'] = fid attribute = agreement['attribute'] if attribute == 'color': agreed_color = agreement['value'] if attribute == 'wattage': agreed_wattage = agreement['value'] if attribute == 'covered': agreed_cover = agreement['value'] value = get_current_aggreement(fid, attribute) if value != agreement['value']: if f_uri is not None: agreement['uri'] = f_uri publish(dict(agreement, **position_dict)) set_current_aggreement(fid, attribute, agreement['value']) annotation.delete_temporal(fid) try: if agreed_color and agreed_cover and agreed_wattage: pollution = calculate_pollution(agreed_color, agreed_wattage, agreed_cover) current_pollution = get_current_aggreement(fid, 'pollution') if current_pollution is None or current_pollution != pollution: set_current_aggreement(fid, 'pollution', pollution) data = {'id': fid, 'attribute': 'pollution', 'value': str(pollution)} if f_uri is not None: data['uri'] = f_uri publish(dict(data, **position_dict)) except Exception as e: print e.message sleep(3)
def quickpost(count): rows = wantudal.get_available_rows(count) for row in rows: postid = publish(row.savedpath, row.description, row.description) if postid: wantudal.set_published(row.url) print '[row_id:%d] is published as [post_id:%s]' % (row.id, postid) else: print '[row_id:%d] is failed to be published' % (row.id)
def verify_request(): print("Received a new request") df1 = pd.read_csv("data/register_dc.csv", delimiter=",", names=["topic", "time"]) # file having details of registered DC df1["time"] = pd.to_datetime( df1["time"], infer_datetime_format=True) # converting to datatime format df2 = pd.read_csv("data/data_request.csv", delimiter=",", names=["topic", "time"]) # file with new request df2["time"] = pd.to_datetime( df2["time"], infer_datetime_format=True) # converting to datatime format l = len(df1) # when there are more than one registered DC for i in range(0, l): if (df1.topic[i] == df2.topic[0]): if (df1.time[i] < df2.time[0]): df1.time[i] = datetime.datetime.now( ) # updating the time to the request time print(df1.time[i]) # print the request time publish("sensor_data_req", "usbdata") # requesting data from IoTD df1.to_csv("data/register_dc.csv", index=False, header=False) #print("DC name im request ",df2.topic[0]) with open('data/temporary_store.txt', 'a+') as f: f.write( str(df2.topic[0]) ) # storing the EDC name to be used in other decider_proper.py #print("file written") f.close() df2 = df2.drop(df2.index[[0]]) #removing the request details df2.to_csv("data/data_request.csv", mode="w", index=False, header=False) #update the file else: print("old request") # Discard the old request else: pass
def build(do_publish=0): print("Build") print("-----") outfile = 'hardware.json' oldfile = 'backup.json' print("Backup current json...") oldjso = None if os.path.isfile(outfile) and not os.path.isfile(oldfile): os.rename(outfile, oldfile) errorlevel = 0 errorlevel += parse_machines() if errorlevel == 0: errorlevel += vitamins() if errorlevel == 0: errorlevel += cut() if errorlevel == 0: errorlevel += printed() if errorlevel == 0: errorlevel += assemblies() if errorlevel == 0: errorlevel += machines() if errorlevel == 0: errorlevel += guides() catalogue(); if errorlevel == 0 and do_publish > 0: publish() # if everything is ok then delete backup - no longer required if errorlevel == 0: os.remove(oldfile) return errorlevel
def benchmark(): name_of_dc = open('data/temporary_store.txt').read().replace('\n', '') #print("name of DC is",name_of_dc) df1 = pd.read_csv("data/register_dc.csv", delimiter=",", names=["topic", "time"]) df1["time"] = pd.to_datetime( df1["time"], infer_datetime_format=True) # convert the object to datetime format #print(df1) #print("name of DC in bench",name_of_dc) #print(type(name_of_dc)) a = (df1.loc[df1.topic == name_of_dc, "time"].iloc[0]) #print("a ",a) c = (datetime.datetime.now() - a) print("Time taken benchmark ", c.total_seconds()) publish("sc_time", str(c.total_seconds())) print("*************************************************") f = open("data/temporary_store.txt", "w") f.truncate() f.close()
def build(do_publish=0): print("Build") print("-----") outfile = 'hardware.json' oldfile = 'backup.json' print("Backup current json...") oldjso = None if os.path.isfile(outfile) and not os.path.isfile(oldfile): os.rename(outfile, oldfile) errorlevel = 0 errorlevel += parse_machines() if errorlevel == 0: errorlevel += vitamins() if errorlevel == 0: errorlevel += cut() if errorlevel == 0: errorlevel += printed() if errorlevel == 0: errorlevel += assemblies() if errorlevel == 0: errorlevel += machines() if errorlevel == 0: errorlevel += guides() catalogue() if errorlevel == 0 and do_publish > 0: publish() # if everything is ok then delete backup - no longer required if errorlevel == 0: os.remove(oldfile) return errorlevel
def publish_apk(): content = request.json print(content) folder = str("/tmp/pwa_apk" + str(int(time.time() * 1000))) os.system("mkdir " + folder) file = open(folder + '/pwa.apk', 'wb') file.write( base64.b64decode(content['apk'].replace( 'data:application/vnd.android.package-archive;base64,', ''))) file.close() outcome = publish.publish(content['client_id'], content['client_key'], content['app_id'], folder + "/pwa.apk") return outcome
def gcs_to_bq(data, context): """Background Cloud Function to be triggered by Cloud Storage. This function loads a CSV file imported to Cloud Storage to Google BigQuery. Load job can be configured to import different CSVs to different BQ tables. Parameters are taken from config.json file and schema directory Args: data (dict): The Cloud Functions event payload. context (google.cloud.functions.Context): Metadata of triggering event. Returns: None; the output is written to Stackdriver Logging """ project_id = 'PROJECT_ID' # Add project ID success_topic_name = 'bq-upload-success' # Add pub sub topic name error_topic_name = 'bq-upload-error' # Add pub sub topic name # Success message variables file_name = data['name'] upload_bucket_name = data['bucket'] config_file_path = 'config.json' with open(config_file_path) as config_file: config_data = json.load(config_file) for config in config_data: if config['file_name'] == file_name: table_name = config['table_name'] dataset_name = config['dataset_name'] #Load and post result try: ltbq().load_to_bq(data, context) data_package = u'File gs://{}/{} successfully loaded to {}.{}'.format( upload_bucket_name, file_name, dataset_name, table_name) data_package.encode('utf-8') publish().publisher(project_id, success_topic_name, data_package) except Exception as err: error_package = str(err).encode('utf-8') publish().publisher(project_id, error_topic_name, error_package)
def gcs_to_bq(data, context): """Background Cloud Function to be triggered by Cloud Storage. This function loads a CSV file imported to Cloud Storage to Google BigQuery. Load job can be configured to import different CSVs to different BQ tables. Parameters are taken from config.json file and schema directory Args: data (dict): The Cloud Functions event payload. context (google.cloud.functions.Context): Metadata of triggering event. Returns: None; the output is written to Stackdriver Logging """ project_id = 'PROJECT_ID' # Add project ID success_topic_name = 'bq-upload-success' # Add pub sub topic name error_topic_name = 'bq-upload-error' # Add pub sub topic name # Success message variables file_name = data['name'] upload_bucket_name = data['bucket'] config_file_path = 'config.json' with open(config_file_path) as config_file: config_data = json.load(config_file) for config in config_data: if config['file_name'] == file_name: table_name = config['table_name'] dataset_name = config['dataset_name'] #Load and post result try: ltbq().load_to_bq(data, context) data_package = u'File gs://{}/{} successfully loaded to {}.{}'.format(upload_bucket_name, file_name, dataset_name, table_name) data_package.encode('utf-8') publish().publisher(project_id, success_topic_name, data_package) except Exception as err: error_package = str(err).encode('utf-8') publish().publisher(project_id, error_topic_name, error_package)
def do_GET(self): try: parseRes = urllib.parse.urlparse(self.path) if parseRes.path == '/publish': if publish() != 0: raise Exception('publish error!') except: self.send_response(500) self.send_header("Content-Type", "text/html; charset=UTF-8") self.end_headers() self.wfile.write(bytes("internal error!", "utf-8")) else: self.send_response(200) self.send_header("Content-Type", "text/html; charset=UTF-8") self.end_headers() self.wfile.write(bytes('done', "utf-8"))
def test_publish_new(self): """ Publish a new article """ # Make a different title title = 'Here is another article' pubstr = '2020-09-01 12:00' pubdate = filter_field('publish', { 'publish': pubstr }) contents = open(os.path.join(here, 'sample.rst')).read().replace( 'This is my title', title) f = StringIO(contents) a = publish(f, draft=True, publish=pubstr, debug=True) self.assertNotEqual(a.pk, self.article.pk) self.assertEqual(a.title, title) self.assertEqual(a.publish_date, pubdate) self.assertTrue('Some content' in a.content) followups = a.followup_for.all() self.assertTrue(self.article.pk in [a.pk for a in followups], followups) related = a.related_articles.all() # We have to use titles due to ambiguous slug self.assertTrue(self.article.title in [b.title for b in related], related)
def write_output(entries): # Write HTML output logger.debug("Publishing HTML 5 file...") publish.publish( config.HTML5_TEMPLATE, config.HTML5_OUTPUT_FILE, entries[:config.NUM_ENTRIES] ) # Write Atom output logger.debug("Publishing Atom file...") publish.publish( config.ATOM_TEMPLATE, config.ATOM_OUTPUT_FILE, entries[:config.NUM_ENTRIES], opt_template_values = { 'feed_title': config.ATOM_FEED_TITLE, 'feed_subtitle': config.ATOM_FEED_SUBTITLE, 'feed_url': config.ATOM_FEED_URL } ) # Write a link-only feed links = [] for entry in entries: if entry.type == 'link': links.append(entry) logger.debug("Publishing Atom links file...") publish.publish( config.ATOM_TEMPLATE, config.ATOM_LINKS_OUTPUT_FILE, links[:config.NUM_ENTRIES], opt_template_values = { 'feed_title': config.ATOM_LINKS_FEED_TITLE, 'feed_subtitle': config.ATOM_LINKS_FEED_SUBTITLE, 'feed_url': config.ATOM_LINKS_FEED_URL } )
'Sr20R21_a0_p0_U20_z10_tr.hdf5', 'Sr20R21_a0_p0_U20_z05_tr.hdf5', 'Sr20R21_a0_p0_U20_z00_tr.hdf5', ] do_the_streamwise_coherence_analysis( hdf_list_to_process, overwrite = True ) #do_the_vertical_coherence_analysis( # hdf_list_to_process, # plot_individual = False, # overwrite = True # ) from os.path import join import publish root = join('/home/carlos/Documents/PhD/Articles/Article_2', 'Article2_Scripts/time_resolved_scripts/LineReservedData/') #get_relevant_wall_normal_data_from_pandas_hdf(exceptions = ['STE']) #get_relevant_wall_normal_data_from_pandas_hdf() #get_relevant_wall_normal_data_from_pandas_hdf(exceptions = ['z05','STE','z00']) #do_the_time_resolved_analysis() correlation_coherence_and_length_scale_analysis() publish.publish()
streamwise_correction = case[1].x_corr, ) df = tar.get_dimensionless_inner_variables( df, correction = 0, Cf = case[1].Cf, ) df['x_loc'] = case[1].x_loc if time_resolved: bl_file.replace('.csv','_TR.csv') tar.write_boundary_layers(df, boundary_layers_file = bl_file) bl_file = "Boundary_layer_information.csv" if isfile(bl_file): remove(bl_file) #get_tr_streamlined_surface(z_loc = 0) get_trailing_edge_for_all_cases_at_TE_m1() #get_trailing_edge_for_all_cases_at_x_m1() #get_trailing_edge_for_all_TR_cases_at_TE_m1() #get_trailing_edge_for_all_TR_cases_at_x_m1() #write_wall_normal_lines_to_csv() publish.publish()
#!/usr/bin/env python3 import os, re, publish publish.publish("Debug", ['win-x64', 'linux-x64'])
#!/usr/bin/env python3 import os, re, publish publish.publish("Release", ['win-x64', 'linux-x64'])
## Licensees holding valid Syntext Serna commercial licenses may use this file ## in accordance with the Syntext Serna Commercial License Agreement provided ## with the software, or, alternatively, in accorance with the terms contained ## in a written agreement between you and Syntext, Inc. ## ## GNU GENERAL PUBLIC LICENSE USAGE ## Alternatively, this file may be used under the terms of the GNU General ## Public License versions 2.0 or 3.0 as published by the Free Software ## Foundation and appearing in the file LICENSE.GPL included in the packaging ## of this file. In addition, as a special exception, Syntext, Inc. gives you ## certain additional rights, which are described in the Syntext, Inc. GPL ## Exception for Syntext Serna Free Edition, included in the file ## GPL_EXCEPTION.txt in this package. ## ## You should have received a copy of appropriate licenses along with this ## package. If not, see <http://www.syntext.com/legal/>. If you are unsure ## which license is appropriate for your use, please contact the sales ## department at [email protected]. ## ## This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE ## WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ## from PublishingPlugin import PublishingPlugin import sys if __name__ == "__main__": from publish import publish publish(sys.argv)
def send_message(): msg = request.form.get('msg') return publish.publish(msg) or redirect(url_for("index"))
def build(argv): doCatalogue = True doQuick = False doPublish = False try: opts, args = getopt.getopt(argv, "hcqp", []) except getopt.GetoptError: print 'build.py -h -c -q -p' print '' sys.exit(2) for opt, arg in opts: if opt == '-h': print 'Usage: -h -c -q -p' print '' print ' -c Skip catalogue' print ' -p Publish: auto commit and push to git' print ' -q Quick build - skip assemblies, guide and catalogue' sys.exit() if opt in ("-c"): doCatalogue = False if opt in ("-q"): doQuick = True doCatalogue = False if opt in ("-p"): doPublish = True print("Build") print("-----") outfile = 'hardware.json' oldfile = 'backup.json' print("Backup current json...") oldjso = None if os.path.isfile(outfile) and not os.path.isfile(oldfile): os.rename(outfile, oldfile) errorlevel = 0 errorlevel += parse_machines() if errorlevel == 0: errorlevel += vitamins() if errorlevel == 0: errorlevel += cut() if errorlevel == 0: errorlevel += printed() if errorlevel == 0 and not doQuick: errorlevel += assemblies() if errorlevel == 0: errorlevel += machines() if errorlevel == 0 and not doQuick: errorlevel += guides() if doCatalogue and not doQuick: catalogue() if errorlevel == 0 and doPublish > 0: publish() # if everything is ok then delete backup - no longer required if errorlevel == 0: os.remove(oldfile) try: if sys.platform == "darwin": check_output([ 'osascript', '-e', 'display notification "Build Complete" with title "Build Process"' ]) except: print("Exception running osascript") print("") print("==============") print("Build Complete") return errorlevel
# -*- coding: utf-8 -*- from publish import publish __author__ = '*****@*****.**' if __name__ == '__main__': publish(u'狼人们别熬夜了,晚安')
print("The sensors are all authentic") if (len( spoof_detect(a[["Sensor", "Type"]], b[["Sensor", "Type"]])) == 0): print(" The types are all authentic") if (len( spoof_detect(a[["Sensor", "Type", "Units"]], b[["Sensor", "Type", "Units"]])) == 0): print(" The units are all authentic") sym_key() # generate the symmetric key benchmark() # benchmark process clearFiles() else: print("there are fake units") publish("sensor_sym_key", "abort") # publish abort data message to IoTD abort_process(a, b, start) clearFiles() else: print("there are fake categories") publish("sensor_sym_key", "abort") # publish abort data message to IoTD abort_process(a, b, start) clearFiles() else: print("there are fake sensors") publish("sensor_sym_key", "abort") # publish abort data message to IoTD abort_process(a, b, start) clearFiles()
from extract import extract from publish import publish import util if __name__ == "__main__": config = configparser.ConfigParser() config.read('config') logfile = util.get_conf_logfile(config, default='log') loglevel = util.get_conf_loglevel(config, default=logging.DEBUG) logger = logging.getLogger(__file__) formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(filename)s:' '%(lineno)d(%(funcName)s) %(msg)s') stream_handler = logging.StreamHandler() stream_handler.setFormatter(formatter) logger.addHandler(stream_handler) file_handler = logging.FileHandler(logfile) file_handler.setFormatter(formatter) logger.addHandler(file_handler) logger.setLevel(loglevel) logger.info('Starting win10_lockscreen_extract...') extract(config) arrange(config) publish(config)
def build(argv): doCatalogue = True doQuick = False doPublish = False try: opts, args = getopt.getopt(argv,"hcqp",[]) except getopt.GetoptError: print 'build.py -h -c -q -p' print '' sys.exit(2) for opt, arg in opts: if opt == '-h': print 'Usage: -h -c -q -p' print '' print ' -c Skip catalogue' print ' -p Publish: auto commit and push to git' print ' -q Quick build - skip assemblies, guide and catalogue' sys.exit() if opt in ("-c"): doCatalogue = False if opt in ("-q"): doQuick = True doCatalogue = False if opt in ("-p"): doPublish = True print("Build") print("-----") outfile = 'hardware.json' oldfile = 'backup.json' print("Backup current json...") oldjso = None if os.path.isfile(outfile) and not os.path.isfile(oldfile): os.rename(outfile, oldfile) errorlevel = 0 errorlevel += parse_machines() if errorlevel == 0: errorlevel += vitamins() if errorlevel == 0: errorlevel += cut() if errorlevel == 0: errorlevel += printed() if errorlevel == 0 and not doQuick: errorlevel += assemblies() if errorlevel == 0: errorlevel += machines() if errorlevel == 0 and not doQuick: errorlevel += guides() if doCatalogue and not doQuick: catalogue() if errorlevel == 0 and doPublish > 0: publish() # if everything is ok then delete backup - no longer required if errorlevel == 0: os.remove(oldfile) try: if sys.platform == "darwin": check_output(['osascript','-e','display notification "Build Complete" with title "Build Process"']) except: print("Exception running osascript") print("") print("==============") print("Build Complete") return errorlevel
def update(_): #print('update') (t, p, h) = sensors.measure(sens) publish.publish(pub, t, p, h)
def main(): if setting.daemon: daemonize(setting.pid_file) formatter = logging.Formatter("[%(levelname)s@%(created)s] %(message)s") file_handler = logging.FileHandler(setting.log_file) file_handler.setFormatter(formatter) log = logging.getLogger(setting.log_hdr) log.setLevel(setting.log_level) log.addHandler(file_handler) if setting.log_level == logging.DEBUG: stdout_handler = logging.StreamHandler() stdout_handler.setFormatter(formatter) log.setLevel(setting.log_level) log.addHandler(stdout_handler) log.info("logger setting up") while True: c = cache.Cache() t_begin = time.time() post = xinpinla.crawler_page(c) publish_flag = False for k, l in post.items(): post_time = k for d in l: title = d["title"] link = d["link"] desc = d["desc"] s = kr36.search(title) if s == None: n = datetime.datetime.now() n = "%04d-%02d-%02d %02d:%02d:%02d" % (n.year, n.month, n.day, n.hour, n.minute, n.second) s = {"time":n, "title":title, "link":None, "detail":desc} post_dat = {"pg_time":post_time, "pg_title":title, "pg_link":link, "pg_desc":desc, \ "rst_time":s["time"], "rst_title":s["title"], "rst_link":s["link"], "rst_desc":s["detail"]} log.debug("title: = > " + post_dat["pg_title"]) parse = html2markdown.Html2MarkdownParser() parse.feed(post_dat["rst_desc"].strip()) detail = parse.get_markdown() log.info("hexo => " + post_dat["pg_title"]) publish_flag = hexo.hexo(post_dat) if publish_flag == True: log.info("hexo => " + post_dat["pg_title"] + " success") log.debug("append sync: %s=%s" % (k, link)) c.append_sync_one(k, link) del c if publish_flag == True: hexo.post_hexo() publish.publish() t_end = time.time() log.info("it cost %s seconds for one single loop. start = %d, end = %d" % (t_end - t_begin, t_begin, t_end)) log.info("going to sleep %d seconds for next loop" % (setting.sleep_time, )) time.sleep(setting.sleep_time) log.info("done")
import publish import sys min = 0 max = 0 if len(sys.argv) == 3: min = int(sys.argv[1]) max = int(sys.argv[2]) def service_func(): print 'Publishing...' if __name__ == '__main__': service_func() for i in range(min,max+1): publish.publish(i,i+1)
global args parser = argparse.ArgumentParser() parser.add_argument( "book", help= "Book to publish, where id is the directory where the book is located. Works only with very small books. For other purposes try to use GitHub pages or other available hosting services." ) parser.add_argument("--shorten", help="Shorten generated URL with bit.ly", action='store_true') parser.add_argument( "--bypass", help= "Bypass size restriction (not recommended. only for debugging purposes)", action='store_true') args = parser.parse_args() if __name__ == "__main__": set_args() book = Book(args.book) html_file = f"{args.book}/{args.book}.html" if not os.path.isfile(html_file): print( f"Build your book first with:\nmake html BOOK={args.book} OFFLINE=no" ) else: publish(html_file, book.title, args.shorten, args.bypass)