def getJsonOrGenerate(name, callback):
filename = getI18nCachePath() + name + '.json'
if os.path.exists(filename):
with open(filename, 'r', encoding='utf8') as f:
json = f.read(10485760)
content = sublime.decode_value(json)
else:
content = callback()
dirname = os.path.dirname(filename)
if not os.path.isdir(dirname):
os.makedirs(dirname)
with open(filename, 'w', encoding="utf8") as f:
f.write(sublime.encode_value(content))
return content
python类decode_value()的实例源码
def load_folder_settings_file(folder_settings_file):
try:
folder_settings_file = open(folder_settings_file, "r")
except IOError as e:
sublime.error_message("Error: spandoc.json exists, but could not be read. Exception: " + str(e))
folder_settings_file.close()
else:
settings_file_commented = folder_settings_file.read()
folder_settings_file.close()
# debug("settings_file_commented: " + str(settings_file_commented))
try:
settings_file = sublime.decode_value(settings_file_commented)
except (KeyError, ValueError) as e:
sublime.error_message("JSON Error: Cannot parse spandoc.json. See console for details. Exception: " + str(e))
return None
# debug("settings_file: " + str(settings_file))
return settings_file
def process_message(self) -> None:
"""Called when a full line has been read from the socket
"""
message = b''.join(self.rbuffer)
self.rbuffer = []
try:
data = sublime.decode_value(message.decode('utf8'))
except (NameError, ValueError):
data = json.loads(message.replace(b'\t', b' ' * 8).decode('utf8'))
callback = self.pop_callback(data.pop('uid'))
if callback is None:
logger.error(
'Received {} from the JSONServer but there is not callback '
'to handle it. Aborting....'.format(message)
)
try:
callback(data)
except Exception as error:
logging.error(error)
for traceback_line in traceback.format_exc().splitlines():
logging.error(traceback_line)
def run(self, args, simulate=False):
view = self.view
window = view.window()
save_and_format(window)
if not check_num_selections(view, 1):
return
byte_offset = view.sel()[0].begin()
cmd = [
'guru', '-json', 'describe',
view.file_name() + ':#' + str(byte_offset)
]
cmd_output = run_tool(cmd)
if not cmd_output:
return
json_obj = sublime.decode_value(cmd_output.decode('utf-8'))
type_str = json_obj['value']['type']
window.settings().set(SettingsKeys.PANEL_QUERIED_TYPE, type_str)
window.run_command('show_go_doc_from_panel')
window.settings().erase(SettingsKeys.PANEL_QUERIED_TYPE)
def main():
try:
with open(file) as fp:
obj = sublime.decode_value(fp.read())
except FileNotFoundError:
return
keys = {}
def add_keys(obj, keys):
if isinstance(obj, list):
for item in obj:
add_keys(item, keys)
elif isinstance(obj, dict):
for key, item in obj.items():
keys[key] = type(item).__name__
add_keys(item, keys) if key != 'args' else None
return keys
add_keys(obj, keys)
def getAllLanguages():
return sublime.decode_value(sublime.load_resource('Packages/' + package_name + '/languages.json'))
def decodeEntity(xml, category='iso'):
global entities
if not isinstance(xml, str):
return xml
if entities[category]:
forward, reverse = entities[category]
else:
resourceMap = {
"iso": "IsoEntities.json",
"html": "HtmlEntities.json",
}
forward = sublime.decode_value(sublime.load_resource('Packages/' + package_name + '/' + resourceMap[category]))
reverse = dict((v, k) for k, v in forward.items())
entities[category] = (forward, reverse)
def parseEntity(match):
entity = match.group(1)
try:
if entity.isdigit():
return reverse[int(entity)]
else:
return chr(forward[entity])
except:
return match.group(0)
xml = re.sub('&([a-zA-Z0-9]+);', parseEntity, xml)
return xml
def get_stylesheets(self):
"""Get the stylesheet dict from the file or return an empty dictionary no file contents."""
if not len(self.style_sheets):
content = self.load_stylesheets_content()
if len(content):
self.style_sheets = sublime.decode_value(str(content))
return self.style_sheets
def on_load_async(self, view):
if view and view.file_name() and not view.settings().get('open_with_edit'):
item = SideBarItem(os.path.join(sublime.packages_path(), 'User', 'SideBarEnhancements', 'Open With', 'Side Bar.sublime-menu'), False)
if item.exists():
settings = sublime.decode_value(item.contentUTF8())
selection = SideBarSelection([view.file_name()])
for item in settings[0]['children']:
try:
if item['open_automatically'] and selection.hasFilesWithExtension(item['args']['extensions']):
SideBarFilesOpenWithCommand(sublime_plugin.WindowCommand).run([view.file_name()], item['args']['application'], item['args']['extensions'])
view.window().run_command('close')
break
except:
pass
def tweak_theme():
view = sublime.active_window().active_view()
theme = view.settings().get('theme')
if theme is None:
print("Can't guess current theme.")
return
theme_path = os.path.join(sublime.packages_path(), 'User', theme)
if os.path.exists(theme_path):
with open(theme_path, mode='r', encoding='utf-8') as f:
theme_text = f.read()
if PYTEST_MARKERS.search(theme_text):
print("Already patched")
return
safety_path = os.path.join(
sublime.packages_path(), 'User', 'Original-' + theme)
with open(safety_path, mode='w', encoding='utf-8') as f:
f.write(theme_text)
theme = sublime.decode_value(theme_text)
else:
theme = []
theme.extend(PYTEST_RULES)
tweaked_theme = sublime.encode_value(theme, True)
with open(theme_path, mode='w', encoding='utf-8') as f:
f.write(tweaked_theme)
print('Done tweaking!')
# sublime.active_window().open_file(theme_path)
def _parse_tpl(self, cmd):
"""Parses the builder template
"""
template_file = os.path.join(
os.path.dirname(__file__),
'../../', 'templates', 'python_build.tpl'
)
with open(template_file, 'r', encoding='utf8') as tplfile:
template = Template(tplfile.read())
cmd = cmd.replace('\\', '\\\\')
return sublime.decode_value(
template.safe_substitute({'python_interpreter': cmd})
)
def get_stylesheets(self):
"""Get the stylesheet dict from the file or return an empty dictionary no file contents."""
if not len(self.style_sheets):
content = self.load_stylesheets_content()
if len(content):
self.style_sheets = sublime.decode_value(str(content))
return self.style_sheets
def _load_index(package, index_file):
"""
Takes a package name and its associated hyperhelp.json index resource name
and loads it. Returns None on failure or a HelpData tuple for the loaded
help information on success.
"""
try:
_log("Loading help index for package %s", package)
json = sublime.load_resource(index_file)
raw_dict = sublime.decode_value(json)
except:
return _log("Unable to load help index from '%s'", index_file)
# Extract all known top level dictionary keys from the help index
description = raw_dict.pop("description", "No description available")
doc_root = raw_dict.pop("doc_root", None)
toc = raw_dict.pop("toc", None)
help_files = raw_dict.pop("help_files", dict())
package_files = raw_dict.pop("package_files", dict())
urls = raw_dict.pop("urls", dict())
# Warn about unknown keys still in the dictionary; they are harmless, but
# probably the author did something dodgy.
for key in raw_dict.keys():
_log("Unknown key '%s' in help index for package '%s'", key, package)
if doc_root is None:
doc_root = path.split(index_file)[0]
else:
doc_root = path.normpath("Packages/%s/%s" % (package, doc_root))
# Pull in all the topics.
topics = dict()
_process_topic_dict(package, topics, help_files)
_process_topic_dict(package, topics, package_files)
_process_topic_dict(package, topics, urls)
if toc is None:
toc = [topics.get(topic) for topic in sorted(topics.keys())]
else:
_validate_toc(package, toc, topics)
return HelpData(package, description, index_file, doc_root, topics,
sorted(help_files.keys()),
sorted(package_files.keys()),
list(urls.keys()),
toc)
