def get_legacy_image(new_version, remote_doc):
print "generating legacy image"
new_version = new_version.split(".")
new_version_patch = int(new_version[2])
new_version_minor = int(new_version[1])
new_version_major = int(new_version[0])
current_version = remote_doc["version"].split(".")
current_version_patch = int(current_version[2])
current_version_minor = int(current_version[1])
current_version_major = int(current_version[0])
# major version bump
if new_version_major > current_version_major and (
new_version_minor == 0 and new_version_patch == 0):
return generate_legacy_label(remote_doc)
# minor version bump
elif new_version_minor > current_version_minor and (
new_version_patch == 0
and current_version_major == new_version_major):
return generate_legacy_label(remote_doc)
else: # TODO: remove this code after gatk and bioconductor images have a major or minor version bump
#if no major or minor version bump, hardcode legacy images
if "terra-jupyter-bioconductor" in remote_doc["image"]:
return utils.read_json_file(static_config_location)[0]
else:
return utils.read_json_file(static_config_location)[1]
def main():
# CAT: carreguem el dataframe amb les url i tota la informació necessària per trobar els noms dels bolets
# EN: we load the dataframe with the urls and all the information needed to find the names of the mushrooms
df = pd.read_pickle('Noms/url_comestibles')
bolets_comestibles = []
for idx in df.index:
soup = BeautifulSoup(requests.get(df['url'][idx]).text, 'lxml')
text = find_items(soup,
df['tag id'][idx],
df['tag especific'][idx],
case=df['grafia'][idx])
names = get_names(text, replacements=df['replace'][idx])
bolets_comestibles = list(set(bolets_comestibles) | set(names))
bolets_comestibles += ['Bolet de tinta', 'Mollerons', 'Cogomella']
excepcions_catala = read_json_file(
'Noms/excepcions_comestibles_catala.txt', 'r')
excepcions_llati = read_json_file('Noms/excepcions_comestibles_llati.txt',
'r')
bolets_comestibles = list(
set(bolets_comestibles).difference(set(excepcions_catala)))
# CAT: afegim la paraula 'bolet' al final de cada nom per facilitar la cerca a google. Per exemple, els bolets
# 'Camperol' o 'Coliflor' són més fàcils de trobar si cerquem 'Camperol bolet' o 'Colifor bolet'. També es
# podria afegir directament dins la funció get_latin_names
# EN: we add the word 'bolet' (mushroom) at the end of each name to facilitate the google search. For example,
# it is easier to find 'Camperol bolet' or 'Coliflor bolet' than 'Camperol' (Peasant) or 'Coliflor' (Cauliflower).
# This could also be done inside the get_latin_names function
cerca_bolets = [bolet + ' bolet' for bolet in bolets_comestibles]
# aquests noms els traiem definitivament
# we remove these names
diferencies = [
'Tòfona', 'Cigró', 'Gastronomia dels bolets', 'Llenega', 'Terfeziàcies'
]
excepcions_catala = list(
set(excepcions_catala).difference(set(diferencies)))
# busquem els noms en llatí
# we search for the names in latin
noms_llati = get_latin_names(cerca_bolets)
bolets_comestibles += excepcions_catala
noms_llati += excepcions_llati
bolets = dict(zip(noms_llati, bolets_comestibles))
# guardem el diccionari final com una string en un arxiu .txt
# we save the final dictionary as a string in a .txt file
save_content_to_file(str(bolets), "Noms/bolets_comestibles.txt", "w")
def migrate(number):
if number == '1':
company_index = db['company_index']
company_index_data = read_json_file('company_index.json')
results = company_index.insert_many(company_index_data)
print(results.inserted_ids)
elif number == '2':
company_profile = db['company_profile']
company_profile_data = read_json_file('company_profile.json')
results = company_profile.insert_many(company_profile_data)
print(results.inserted_ids)
else:
print('no_migration_found')
def parse_product_json(config):
product = config.product
product_json = os.path.join(config.get_build_path(), 'product',
'{}.json'.format(product))
json_content = read_json_file(product_json)
Compile.get_tool_path(config, json_content)
return load_subsystem_feature(json_content, config)
def open(cls, wallet_name):
'''Initialize this class from an existing wallet file'''
file_name = f'wallets/{wallet_name}.json'
wallet_dict = read_json_file(file_name)
wallet = cls.from_dict(wallet_dict)
logger.info(f"Opened wallet from {file_name}")
return wallet
def update_data(path, new_data: dict):
if not (os.path.exists(path) and os.path.isfile(path)):
write_json_file(path, data=[])
data_list = read_json_file(path)
data_list.append(new_data)
write_json_file(path, data_list)
def get_notice_file_name(readme_file_path, copyright_file,
module_relative_src_path):
if not os.path.exists(readme_file_path) or os.path.isdir(readme_file_path):
return '', '', '', ''
opensource_config = read_json_file(readme_file_path)
if opensource_config is None:
return '', '', '', ''
license_file = ''
license_name = None
software_name = None
for info in opensource_config:
license_file = info.get('License File')
license_name = info.get('License')
software_name = '{} {}'.format(info.get('Name'), info.get('Version Number'))
license_file_path = os.path.join(os.path.dirname(readme_file_path),
license_file.strip())
if not os.path.exists(license_file_path):
return '', '', '', ''
copyright_file_path = os.path.join(os.path.dirname(copyright_file),
copyright_file.strip())
if not os.path.exists(copyright_file_path):
return '', '', '', ''
return license_file_path, license_name, software_name, copyright_file_path
def __init__(self, cluster, url, component, service):
'''
@param cluster: 集群名称, 在配置文件配置或者通过命令行设置.
@param url: 每个组件暴露指标的URL。例如：通过http://ip:9870/jmx可以获取hdfs集群的指标。
而通过http://ip:8088/jmx可以获取ResourceManager的指标。
@param component: 组件名称. 例如："hdfs", "resourcemanager", "mapreduce", "hive", "hbase".
@param service: 服务名称. 例如："namenode", "resourcemanager", "mapreduce".
'''
self._cluster = cluster
# 删除末尾的/
self._url = url.rstrip('/')
self._component = component
# 指标前缀, 以 hadoop_组件名_服务名 命名
self._prefix = 'hadoop_{0}_{1}'.format(component, service)
# 获取以服务名命名的所有JSON文件列表，例如：namenode，会将namenode中的所有文件夹中的json文件加载
# 获取到的是文件名
self._file_list = utils.get_file_list(service)
# 获取common目录中的所有json文件
self._common_file = utils.get_file_list("common")
# 整合所有json文件
self._merge_list = self._file_list + self._common_file
# 用于保存指标对象
self._metrics = {}
for i in range(len(self._file_list)):
# 设置文件名，并读取对应的指标配置文件（JSON文件）
self._metrics.setdefault(self._file_list[i], utils.read_json_file(service, self._file_list[i]))
def sort_module_name_list():
global auto_bump
global ballerina_version_regex
try:
name_list = utils.read_json_file(constants.MODULE_LIST_FILE)
except Exception as e:
print('Failed to read module_list.json', e)
sys.exit()
name_list['modules'].sort(key=lambda x: x['name'].split('-')[-1])
try:
utils.write_json_file(constants.MODULE_LIST_FILE, name_list)
except Exception as e:
print('Failed to write to file module_list.json', e)
sys.exit()
name_list['modules'].append({
'name': 'ballerina-distribution'
})
auto_bump = name_list['auto_bump']
ballerina_version_regex = name_list['lang_version_substring']
return name_list['modules']
def __init__(self, source_file="papers.json", prune_dictionary=False, num_topics=5):
data = utils.read_json_file(source_file)
data_words = [x.split() for x in data]
self.dictionary = gensim.corpora.Dictionary(data_words)
if prune_dictionary:
self.dictionary.filter_extremes(no_below=0, no_above=0.90, keep_n=None)
corpus = [self.dictionary.doc2bow(text) for text in data_words]
self.lda_model = gensim.models.ldamodel.LdaModel(corpus=corpus,
id2word=self.dictionary,
num_topics=num_topics,
random_state=100,
update_every=1,
chunksize=100,
passes=10,
alpha='symmetric',
per_word_topics=False)
# Print the Keyword in the 10 topics
logging.info("Topics discovered (%s topics): ", num_topics)
logging.info(self.lda_model.print_topics())
def set_geo_metadata_to_dataframe(dataframe):
""" Iterate over all cities in the dataframe, then add geo metadata to all of them """
geolocator = get_goog_geolocator(GEOCODE_API_KEY)
cached_json = read_json_file(GEOCODE_CACHED_JSON_FILENAME)
add_empty_columns(dataframe, ['latitude', 'longitude', 'reverse_address'])
api_count = 0
# pylint: disable=W0612
for index, row in dataframe.iterrows():
search_query = '{}, {}, USA'.format(row['city'], row['state'])
# make sure all 3 values are in the cache...
if search_query in cached_json:
# add to dataframe from cache
city_geo_dict = cached_json[search_query]
row[list(city_geo_dict.keys())] = list(city_geo_dict.values())
continue
location = geolocator.geocode(search_query)
reverse_address = get_reverse_address(geolocator, location)
set_geo_metadata_to_dataframe_row(row, location, reverse_address)
set_geo_metadata_to_dict(cached_json, location, reverse_address,
search_query)
api_count += 2 # two api hits per loop, 1 for geocode, 1 for reverse address
time.sleep(1)
if api_count % 50 == 0:
print('API count: ', str(api_count))
write_json_file(GEOCODE_CACHED_JSON_FILENAME, cached_json)
write_json_file(GEOCODE_CACHED_JSON_FILENAME, cached_json)
async def api_yaya_book_detail(*, id):
book = DataObject.get_yaya_books(id=id)
book_list = None
if book:
book = book[0]
book_json_name = f"/{YAYA_BASE_PATH}/{book['id']}.{book['name'].replace('|', '')}/{book['id']}.chapterList.json"
book_list = read_json_file(book_json_name)
if book_list:
for item in book_list:
item['cover'] = item['cover'].replace('http://', '//')
item['audio_url'] = get_cdn_url(f"/{YAYA_BASE_PATH}/{book['id']}.{book['name'].replace('|', '')}/audio/{item['name']}.mp3")
item['cover_url'] = get_cdn_url(f"/{YAYA_BASE_PATH}/{book['id']}.{book['name'].replace('|', '')}/img/{item['name']}.png")
text_json_name = f"/{YAYA_BASE_PATH}/{book['id']}.{book['name'].replace('|', '')}/json/{item['id']}.{item['name']}.json"
item['content'] = read_json_file(text_json_name)['data']['chapter']['content']
return dict(book_list=book_list)
def yaya_book(*, id=None):
book = DataObject.get_yaya_books(id=id)
book_data = None
if book:
book = book[0]
book_json_name = f"/{YAYA_BASE_PATH}/{book['id']}.{book['name']}/{book['id']}.resourceDetail.json"
book_data = read_json_file(book_json_name)['data']
res_data = {
'announcer': '白宇航',
'id': 2269,
'name': '咪子的家',
'ageDesc': '4-6岁',
'cover': 'http://cover.yayagushi.com/e29ae422522840f58294f06b5b9572d7_%s.png',
'desc': '小女孩有一只小猫“咪子”，一天它突然消失了。小女孩体验了失去并寻找咪子的失望和希望，也收获了新生命的惊奇和感动。\n\n猫咪带给了女孩生命的启示，关于信任、母性之爱。故事质朴温暖、情感真挚。',
'estimatedChapter': 16,
'totalChapter': 16,
'labelList': ['爱与情感', '生命', '温暖', '亲情', '友情', '动物']
}
if book_data:
res_data['announcer'] = book_data['announcer']['nickName'] if 'announcer' in book_data and 'nickName' in book_data['announcer'] else '未知'
res_data['id'] = book_data['resource']['id']
res_data['name'] = book_data['resource']['name']
res_data['ageDesc'] = book_data['resource']['ageDesc']
res_data['cover'] = book_data['resource']['cover'].replace('http://', '//').replace('.png', '_%s.png')
res_data['desc'] = book_data['resource']['desc'].replace('\n', '<br />')
res_data['estimatedChapter'] = book_data['resource']['estimatedChapter']
res_data['totalChapter'] = book_data['resource']['totalChapter']
res_data['labelList'] = book_data['resource']['labelList']
res_data['priceType'] = book_data['resource']['priceType']
return {
'book': toDict(res_data),
'__template__': 'yaya_book.html'
}
def add_walkscore_to_cities(dataframe):
""" Parse every city row from the geocode csv, add the walkscores cells to each. """
cached_dict = read_json_file(WALKSCORE_CACHED_JSON_FILENAME)
add_empty_columns(dataframe, ['walkscore', 'bikescore', 'transitscore'])
api_count = 0
for index, row in dataframe.iterrows():
state_city_name = get_state_city_name(row)
# make sure all 3 values are in the cache...
if state_city_name in cached_dict:
# add to dataframe from cache
walkscore_dict = cached_dict[state_city_name]
cached_dict[state_city_name] = remove_attributes_from_dict(walkscore_dict)
dataframe.loc[index] = get_dataframe_row_with_walkscores(
row, walkscore_dict)
continue
walkscore_dict = get_walkscores(row)
remove_attributes_from_dict(walkscore_dict)
cached_dict[state_city_name] = walkscore_dict
dataframe.loc[index] = get_dataframe_row_with_walkscores(
row, walkscore_dict)
api_count += 2 # two api hits per loop, 1 for geocode, 1 for reverse address
if api_count % 10 == 0:
print('cached_dict count: ', str(len(cached_dict.keys())))
write_json_file(WALKSCORE_CACHED_JSON_FILENAME, cached_dict)
write_json_file(WALKSCORE_CACHED_JSON_FILENAME, cached_dict)
def get_doc_label(image_config):
additional_package_names = image_config["packages"]
tools = image_config["tools"]
base_label = image_config["base_label"]
doc_suffix = config["doc_suffix"]
package_file = "{}-{}-{}".format(image_config['name'],
image_config['version'], doc_suffix)
utils.gsutil_cp(package_file, config["doc_bucket"], copy_to_remote=False)
packages = utils.read_json_file(package_file)
additional_package_labels = []
for tool in additional_package_names.keys():
labels = map(
lambda package: "{} {}".format(package, packages[tool][package]),
additional_package_names[tool])
additional_package_labels = additional_package_labels + list(labels)
tool_labels = map(
lambda tool: "{} {}".format(tool.capitalize(), packages[tool][tool]),
tools)
labels = list(tool_labels) + list(additional_package_labels)
label = "{}: ({})".format(base_label, ', '.join(labels))
return label
def run():
torch.multiprocessing.freeze_support()
logging.basicConfig(level=logging.INFO)
### Load data
logging.info("Load embedding")
token_embedding = fasttext.load_model(path=embedding_path)
logging.info("Read dict")
try:
data_dict = torch.load(serialize_file)
except FileNotFoundError:
logging.warning("No dict found, create new")
data_dict = defaultdict(list)
logging.info("Read files")
list_of_json_file_paths = list(Path(data_path).glob('**/*.json'))
list_of_json_file_paths = [str(p) for p in list_of_json_file_paths]
len_initial = len(data_dict)
for index, json_file in enumerate(list_of_json_file_paths[:]):
if not json_file in data_dict.keys():
logging.info(
str(index) + "/" + str(len(list_of_json_file_paths)) + " - " +
json_file)
d_lst = utils.read_json_file(json_file)
for d in d_lst: # dict keys: if_ast, condition, code_adjacent, label
if strategy == 'lstm':
data_dict[json_file].append(
utils.generate_data_dict_sequence(d, token_embedding))
elif strategy == 'gcn':
data_dict[json_file].append(
utils.generate_data_dict_graph(d, token_embedding))
elif strategy == 'cnn':
data_dict[json_file].append(
utils.generate_data_dict_flattened(d, token_embedding))
if len_initial < len(data_dict):
logging.info("Save new dict")
torch.save(data_dict, serialize_file)
logging.info("Generate data list")
data_lst = []
for data_key, data_file_lst in data_dict.items():
data_lst += data_file_lst
del data_dict # Free resources to improve debugging performance
data_lst = data_lst[:]
print("Training data length: ", str(len(data_lst)))
### Train
distribution_lst = [[0.9, 0.02, 0.02, 0.02, 0.02, 0.02],
[0.8, 0.04, 0.04, 0.04, 0.04, 0.04],
[0.7, 0.06, 0.06, 0.06, 0.06, 0.06],
[0.6, 0.08, 0.08, 0.08, 0.08, 0.08]]
for distribution in distribution_lst:
logging.info("Load model")
net = utils.load_model(model_path, strategy)
logging.info(net)
net.train(data_lst, 1e-3, 4, distribution)
def update_lang_version():
global ballerina_lang_version
global ballerina_timestamp
data = utils.read_json_file(constants.LANG_VERSION_FILE)
ballerina_lang_version = data["version"]
lang_version = ballerina_lang_version.split("-")
ballerina_timestamp = create_timestamp(lang_version[2], lang_version[3])
def _read_examples_js(self, fn, language, fformat):
"""Infer and load the example file based on the root filename and root format."""
examples_type = "usersays" if fformat == DIALOGFLOW_INTENT else "entries"
examples_fn_ending = "_{}_{}.json".format(examples_type, language)
examples_fn = fn.replace(".json", examples_fn_ending)
if os.path.isfile(examples_fn):
return utils.read_json_file(examples_fn)
else:
return None
def load_subsystem_feature(config):
product = config.product
product_json = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'product', '{}.json'.format(product))
json_content = read_json_file(product_json)
for subsystem in json_content['subsystem']:
for component in subsystem['component']:
for feature in component['features']:
CallbackDict.args_list.append(feature)
def get_unexec_ops(timeline_fname, out_fname):
timeline = read_json_file(timeline_fname)
gpu_pids_regex = re.compile('/device:GPU:0/.*Compute')
cpu_pids_regex = re.compile(
'/job:localhost/replica:0/task:0/device:CPU:0 Compute')
gpukernel_pids_regex = re.compile(
'/job:localhost/replica:0/task:0/device:GPU:.* Compute')
gpu_pids = set([])
cpu_pids = set([])
gpu_kernel_pids = set([])
for event in timeline['traceEvents']:
if event['ph'] == 'M':
event_id = event['pid']
if gpu_pids_regex.match(event['args']['name']):
gpu_pids.add(event_id)
elif gpukernel_pids_regex.match(event['args']['name']):
gpu_kernel_pids.add(event_id)
elif cpu_pids_regex.match(event['args']['name']):
cpu_pids.add(event_id)
gpu_ops = set([])
gpu_ops_exec = set([])
cpu_ops = set([])
for event in timeline['traceEvents']:
if event['ph'] == 'X' and 'args' in event.keys() and not (
event['args']['op'].startswith('MEMCPY')):
op_name = event['args']['name']
pid = event['pid']
ts = event['ts']
dur = event['dur']
if pid in gpu_kernel_pids:
gpu_ops.add(op_name)
elif pid in gpu_pids:
gpu_ops_exec.add(op_name)
elif pid in cpu_pids:
cpu_ops.add(op_name)
unexecuted_ops = set([])
for op_name in gpu_ops:
if op_name not in gpu_ops_exec:
unexecuted_ops.add(op_name)
print('number of gpu ops : ', len(gpu_ops))
print('number of cpu ops : ', len(cpu_ops))
print('number of unexecuted ops : ', len(unexecuted_ops))
with open(out_fname, 'w') as f:
for op_name in unexecuted_ops:
f.write('%s\n' % (op_name))
def inference_topic(self, file_location="data.json"):
data = utils.read_json_file(file_location)
data_words = [x["bow_content"].split() for x in data]
termdoc_vector = [self.dictionary.doc2bow(text) for text in data_words]
doc_lda = self.lda_model[termdoc_vector]
print doc_lda
for topic in doc_lda:
print(topic)
def update_lang_version():
global ballerina_lang_version
global ballerina_timestamp
global latest_ballerina_stable_version
data = utils.read_json_file(constants.LANG_VERSION_FILE)
ballerina_lang_version = data["version"]
lang_version = ballerina_lang_version.split("-")
ballerina_timestamp = create_timestamp(lang_version[2], lang_version[3])
latest_ballerina_stable_version = '-'.join(
ballerina_lang_version.split('-')[0:2])
def is_opensource(bundle):
"""Get opensource infomation from bundle.json."""
bundle_data = read_json_file(bundle)
bundle_publish = bundle_data.get('publishAs')
if not bundle_publish:
raise Exception('Could not find "publishAs" in {}'.format(bundle))
if bundle_publish == 'source':
return True
return False
def get_current_versions():
try:
utils.gsutil_cp(config["version_master_file"], config["doc_bucket"], copy_to_remote=False)
current_versions = utils.read_json_file(config["version_master_file"])
except subprocess.CalledProcessError:
print("detected remote file doesn't exist, will regenerate versions")
current_versions = {}
except IOError:
print("detected remote file doesn't exist, will regenerate versions")
current_versions = {}
return current_versions
def __init__(self, cluster, component, service):
self.cluster = cluster
self.componet = component
self.service = service
self.prefix = 'hadoop_{0}_{1}'.format(component, service)
self.common_metrics = {}
self.tmp_metrics = {}
file_list = utils.get_file_list("common")
for i in range(len(file_list)):
self.common_metrics.setdefault(file_list[i], {})
self.tmp_metrics.setdefault(
file_list[i], utils.read_json_file("common", file_list[i]))
def search_article_content(self, url):
"""
Return the title and content of the article that has been extracted and saved in articles.log.json
in a tuple. Return None if there is no entry cached.
"""
data = read_json_file(self.article_log)
try:
for stock_name in data.keys():
if data[stock_name].get(url) is not None:
return data[stock_name].get(url).get("content")
except KeyError:
return None
def generate_docs():
docs = []
#filter for images in the conf that have the generate_docs flag set to true
image_configs = filter(
lambda image: image["automated_flags"]["generate_docs"] == True and
image["automated_flags"]["include_in_ui"] == True and image[
"automated_flags"]["build"] == True, config["image_data"])
remote_docs = get_current_versions()
#maps the current documentation to a map of {image_name: version} key values
remote_versions_list = list(
map(lambda image_doc: {image_doc["id"]: image_doc["version"]},
remote_docs))
remote_versions = utils.flatten_list_of_dicts(remote_versions_list)
print "current versions detected: " + str(remote_versions)
legacy_gatk_doc = filter(
lambda remote_doc: remote_doc["id"] == "terra-jupyter-gatk_legacy",
remote_docs)[0]
legacy_bioconductor_doc = utils.read_json_file(static_config_location)[
0] # hard coding this until next bioconductor release (~06/2022)
for image_config in image_configs:
# Here we check first if the remote documentation exists, then if the local version is the same as the remote.
# If the remote documentation exists and the version matches the local, we re-use the old documentation
remote_doc = list(
filter(lambda image_doc: image_doc["id"] == image_config["name"],
remote_docs))[0]
if image_config["name"] in remote_versions and image_config[
"version"] == remote_versions[image_config["name"]]:
print "using remote doc: {}".format(remote_doc)
doc = remote_doc
else:
doc = generate_doc_for_image(image_config)
#Computing legacy images for gatk and bioconductor
if image_config["name"] == "terra-jupyter-gatk":
legacy_gatk_doc = get_legacy_image(image_config["version"],
remote_doc, legacy_gatk_doc)
# TODO: add back in after next bioconductor release (~06/2022)
#if image_config["name"] == "terra-jupyter-bioconductor":
#legacy_bioconductor_doc = get_legacy_image(image_config["version"], doc)
docs.append(doc)
docs.extend(get_other_docs())
docs.extend([legacy_gatk_doc, legacy_bioconductor_doc])
return docs
async def api_xmly_book_detail(*, id):
book = DataObject.get_xmly_books(id=id)
book_screen = None
if book:
book = book[0]
book_json_name = f"/{XMLY_BASE_PATH}/{book['recordId']}.{book['recordTitle'].replace('|', '')}/{book['recordId']}.{book['recordTitle'].replace('|', '')}.json"
book_screen = read_json_file(book_json_name)['screens']
if book_screen:
for item in book_screen:
item['cover_url'] = get_cdn_url(f"/{XMLY_BASE_PATH}/{book['recordId']}.{book['recordTitle'].replace('|', '')}/imgs/{item['index']}.jpg")
return dict(book_screen=book_screen)
def __init__(self, params):
if not len(params) == 2:
raise ValueError("Usage: python generate_package_docs.py [STRING: image_dir], given: " + params)
self.image_dir = argv[1]
self.config = utils.read_json_file(config_location)
image_config = list(filter(lambda image_config: image_config["name"] == self.image_dir, self.config["image_data"]))
if not len(image_config) == 1:
raise ValueError("The image_dir argument must be one of the images in the image_data section of conf.json")
self.image_config = image_config[0]
def get_all_articles(self):
"""
Return all the articles in articles.log.json in the following format:
[(index, stock_name, title, url)]
"""
data = read_json_file(self.article_log)
index = 1
articles = []
for stock_name in data.keys():
for url, article in data[stock_name].items():
articles.append((index, stock_name, article["title"], url))
index += 1
return articles
def reload(self):
"""
重加载配置文件
"""
content = _utils.read_json_file(_config_file)
self.update(content)
APP_BASE_PATH = _os.path.dirname(_os.path.realpath(__file__))
_config_file = APP_BASE_PATH + '/config.json'
class ConfigWithJsonFile(_ReadOnlyObjectDict):
def reload(self):
"""
重加载配置文件
"""
content = _utils.read_json_file(_config_file)
self.update(content)
# json配置文件里面的数据
CONFIG = ConfigWithJsonFile(_utils.read_json_file(_config_file))
VERSION_MAIN = 1 # 主版本号
VERSION_SUB = 1 # 子版本号
# ----------------------- 服务类型集合 ------------------------------------------#
SERVICE_CONTROL = 0 # 服务器的控制命令
SERVICE_LOGIN = 1 # 登陆服务
SERVICE_SYSTEM = 2 # 系统服务
SERVICE_MALL = 3 # 商城服务
SERVICE_BANK = 4 # 银行服务
SERVICE_GAME = 5 # 普通场游戏服务
# ----------------------- 服务类型集合 ------------------------------------------#
