def on_query_completions(self, view, prefix, locations):
if utils.get_language() != "java":return
ultimo=utils.get_last_character()
if ultimo=="." and utils.get_language()=="java":
window=sublime.active_window()
view=window.active_view()
word=utils.get_word(-1)
variables=Java().get_variables()
tipo=word
static=True
if variables.get(word):
tipo=variables[word]
static=False
package=re.findall("import ([\w.]+\.%s);"%tipo, utils.get_text())
if not package:
posibleRuta=os.path.join(PATH_JSON, "java", "lang", tipo+".json")
if os.path.exists(posibleRuta):
package=["java.lang."+tipo]
if package:
package=package[0]
clase=self.get_project_class(package)
if clase:
return utils.get_completion_list(clase["members"])
ruta=package.replace(".", os.sep)+".json"
ruta=os.path.join(PATH_JSON, ruta)
print("ya se determino")
objeto=utils.load_json(ruta)
miembros="clase" if static else "object"
return utils.get_completion_list(objeto[miembros])
def get_settings_text(user_id, lang_code):
user = get_person(user_id)
text = strings.get(get_language(lang_code)).get("settings").format(num_of_words=user["word_count"],
prefixes=strings.get(get_language(lang_code)).get("yes")
if user["prefixes"] else strings.get(get_language(lang_code)).get("no"),
separators=strings.get(get_language(lang_code)).get("yes")
if user["separators"] else strings.get(get_language(lang_code)).get("no"))
return text
def get_settings_text(user_id, lang_code):
user = get_person(user_id)
text = strings.get(get_language(lang_code)).get("settings").format(
num_of_words=user["word_count"],
prefixes=strings.get(get_language(lang_code)).get("yes") if
user["prefixes"] else strings.get(get_language(lang_code)).get("no"),
separators=strings.get(get_language(lang_code)).get("yes") if
user["separators"] else strings.get(get_language(lang_code)).get("no"))
return text
async def language(self, ctx: Context, *args):
settings = get_language_config_by_id(ctx.guild.id)
supported_languages = [
i.replace(".yml", "") for i in os.listdir("./translations")
]
if args:
if args[0] not in supported_languages:
await ctx.send(
embed=Embed(description=settings.not_supported_language,
color=0xff0000))
return
langs = config.language
translation = config.translation
langs[str(ctx.guild.id)] = args[0]
config.save("language", langs)
translation[str(ctx.guild.id)] = get_default_bible_translation(
str(ctx.guild.id))
config.save("translation", translation)
settings = get_language_config_by_id(ctx.guild.id)
await ctx.send(embed=Embed(
description=settings.f_language_successfully_changed(
get_language(ctx.guild.id)),
color=0x34bdeb))
return
embed = Embed(
title=settings.f_language_settings_embed_title(ctx.guild.name),
description=settings.f_language_settings_embed_description(
get_language(ctx.guild.id), await get_prefix(ctx.message)),
color=0x34bdeb)
langs = dict()
for filename in os.listdir("./translations"):
if filename.endswith(".yml"):
yaml_file = yaml.safe_load(open(f"translations/{filename}"))
langs[filename[:-4]] = yaml_file["language-name"]
description = ""
for l in langs.keys():
description += f"`{l}` | " + langs[l] + "\n"
embed.add_field(name=settings.supported_languages,
value=description,
inline=False)
await ctx.send(embed=embed)
def common_annotations(entry):
annotations = []
lang = get_language(entry.language)
if lang:
annotations.append({
"type": "net.app.core.language",
"value": {
"language": lang,
}
})
if entry.author:
annotations.append({
"type": "net.app.pourover.item.author",
"value": {
"author": entry.author,
}
})
if entry.tags:
annotations.append({
"type": "net.app.pourover.item.tags",
"value": {
"tags": entry.tags,
}
})
return annotations
def ruta():
window=sublime.active_window()
view=window.active_view()
tipo=utils.get_language()
#print("el tipo para los snippets es : "+tipo)
# return sublime.packages_path()+os.sep+"snippets"+os.sep+tipo+".json"
return get_path_snippets()+"/"+tipo+".json"
def on_query_completions(self, view, prefix, locations):
window=sublime.active_window()
view=window.active_view()
self.clases=set()
lang=utils.get_language()
if lang=="html" or lang=="php":
punto=view.sel()[0].a
linea=view.substr(sublime.Region(view.line(punto).a, punto)).replace('"', "'")
linea=linea[:linea.rfind("'")].strip()
print("la linea es :"+linea)
if linea.endswith("class="):
print("en compass")
cssFiles=utils.get_files({"ext":"css"})
self.clases=[]
for cssFile in cssFiles:
texto=open(cssFile).read()
cssClases=re.findall("\.(?P<clase>[a-z][-\w]*)\s+", texto)
self.clases=self.clases + cssClases
self.clases=list(set(self.clases))
self.clases=[[clase + "\t(CSS)", clase] for clase in self.clases]
return list(self.clases)
linea=view.substr(sublime.Region(view.line(punto).a, punto)).replace('"', "'").strip()
if linea.endswith("src='") and linea.startswith("<script"):
path=view.file_name()
path=path[:path.rfind("/")] if path.find("/")!=-1 else path[:path.rfind("\\")]
RecursosHtml(path, "js").insertar()
elif linea.endswith("href='") and linea.startswith("<link "):
path=view.file_name()
path=path[:path.rfind("/")] if path.find("/")!=-1 else path[:path.rfind("\\")]
RecursosHtml(path, "css").insertar()
def run(self):
while True:
comando=None
if os.path.exists(ARCHIVO_COMANDO) and existe_archivo_bloqueo(ORDEN):
archivito=open(ARCHIVO_COMANDO)
comando=archivito.read()
archivito.close()
os.remove(ARCHIVO_COMANDO)
if comando:
comando=comando.strip()
print(comando)
window=sublime.active_window()
view=window.active_view()
if comando.find("side_bar")!=-1:
window.run_command(comando)
elif comando.startswith("code_"):
rutaJson=sublime.packages_path()+os.sep+"snippets"+os.sep+utils.get_language()+".json"
if os.path.exists(rutaJson):
comando=comando.replace("code_", "")
d=utils.load_json(rutaJson)
if d.get(comando) :view.run_command('insert_snippet', {"contents":utils.agregarCursores(d[comando])})
elif comando.startswith("make_"):
window=sublime.active_window()
view=window.active_view()
comando=comando.replace("make_", "")
view.run_command("load_template", {"nombre":comando})
else:
view.run_command(comando)
time.sleep(1)
def make_regenerate_keyboard(lang_code):
keyboard = types.InlineKeyboardMarkup()
btn = types.InlineKeyboardButton(text=strings.get(
get_language(lang_code)).get("regenerate"),
callback_data="regenerate")
keyboard.add(btn)
return keyboard
def run(self, edit):
lang=utils.get_language()
self.rutaSamples= os.path.normpath(os.path.join(sublime.packages_path(), "..", "samples", lang+".json"))
print("la ruta es : "+self.rutaSamples)
if not os.path.exists(self.rutaSamples):
utils.file_write(self.rutaSamples, "{}")
window=sublime.active_window()
window.show_input_panel("sample name", "", self.save, None, None)
def run(self, edit):
self.view = sublime.active_window().active_view()
view=self.view
lang = utils.get_language()
archivo = self.extraerArchivo(view.file_name(), lang)
proceso=None
salida=1
puntos=[]
errores=[]
os.chdir(archivo["ruta"])
patron=None
patronNumerico=re.compile("\d+")
if lang=="java" or lang=="c":
patron=re.compile(":\d+: error:")
if lang=="java":
comando="javac %(nombreCompleto)s"%archivo
elif lang=="c":
comando="gcc %(nombreCompleto)s -o %(nombre)s"%archivo
elif lang=="scala":
comando="scalac %(nombreCompleto)s"%archivo
patron=re.compile("\(\d+\): Error:")
elif lang=="cs":
salida=0
comando="csc %(nombreCompleto)s"%archivo
patron=re.compile("\(\d+,\d+\): error")
elif lang=="d":
comando="dmd %(nombreCompleto)s"%archivo
patron=re.compile("\(\d+\): Error:")
else:
sublime.status_message("no tiene compilacion")
return
print(comando)
proceso=Popen(comando, stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True)
error=proceso.communicate()[salida]
if error:
listaErrores=error.decode("utf-8").splitlines()
for e in listaErrores:
e=e.strip()
errorl=patron.search(e)
if errorl:
errorl=errorl.group()
punto=patronNumerico.search(errorl).group().replace(":", "").replace(",","")
puntos.append(punto)
errores.append(punto+":"+e[e.rfind(":")+1:])
if errores:
self.marcarErrores(puntos)
f=open(sublime.packages_path()+os.sep+"errores.txt", "w")
for p in errores:f.write(p+"\n")
f.close()
view.run_command("buscar_errores")
if proceso.returncode==0:
self.view.erase_regions("errores")
sublime.status_message("-----BIEN-----")
else:
sublime.status_message("-----MAL-----")
def on_query_completions(self, view, prefix, locations):
lang=utils.get_language()
if lang != "go":return
ultimo=utils.get_last_character()
if ultimo != ".":return
d=utils.load_json(GO_MAIN_MODULE)
word=utils.get_word(-1)
if d.get(word):
return utils.get_completion_list(d[word])
def run(self, **kwargs):
text = str(kwargs.get("text"))
to_lang = str(kwargs.get("to_lang"))
if not to_lang:
to_lang = get_language()
from deep_translator import GoogleTranslator
return GoogleTranslator(source='auto', target=to_lang).translate(text)
def on_query_completions(self, view, prefix, locations):
print(utils.get_language())
lang=utils.get_language()
if lang!="javascript" and lang!="nodejs":return
if not utils.is_point():return
jsonPath=sublime.packages_path()+os.sep+"javascript"+os.sep+"functions.json"
if lang=="nodejs":jsonPath=sublime.packages_path()+os.sep+"javascript"+os.sep+"functions_node.json"
d=utils.load_json(jsonPath)
obj=utils.get_word(-1)
if not d.get(obj):
d[obj]=[];
utils.save_json(jsonPath, d)
return
functions=d[obj]
return utils.get_completion_list(functions)
def on_post_save(self, view):
if utils.get_language()!="jsf":return
window=sublime.active_window()
folders=window.folders()
if not folders:return
folderProyecto=folders[0]
if not os.path.exists(os.path.join(folderProyecto, "pom.xml")):return
server=utils.get_preference("server")
folderDeploy=server_folder_deploy[server]
self.folderDeploy=folderDeploy
filepath=utils.get_filepath()
self.filepath=filepath
if server=="weblogic":
threading.Thread(target=self.reemplazarTodos).start()
return
if server!="jboss":
folderDeploy=folderDeploy+os.sep+os.listdir(folderDeploy)[0]
self.folderDeploy=folderDeploy
folderDeploy=os.path.normpath(folderDeploy)
print("the folder deploy is : "+folderDeploy)
nombreProyecto=filepath.replace(folderProyecto+os.sep, "")
#print("el nombre del proyceto es : "+nombreProyecto)
nombreProyecto=nombreProyecto[:nombreProyecto.find(os.sep)]
#print("el nuevo nombre del proyecto es: "+nombreProyecto)
#print("el filepath es : "+filepath)
#print("el folderDeploy es : "+folderDeploy)
fileLocation=filepath[filepath.find("webapp"+os.sep)+7:]
#print("el fileLocation is: "+fileLocation)
print(server)
print("el nombre del proyecto es : "+nombreProyecto)
folders=os.listdir(folderDeploy)
folders=[os.path.join(folderDeploy, x) for x in folders]
def comparador(x):return os.path.getmtime(x)
folders=sorted(folders, key=comparador, reverse=True)
print(folders)
for folderS in folders:
for folder in os.listdir(folderS):
print(folder)
if folder.find(nombreProyecto)!=-1:
fileLocation=folderS+os.sep+folder+os.sep+fileLocation
print("la nueva localizacion del archivo es : "+fileLocation)
utils.file_write(fileLocation, utils.file_read(filepath))
#print("escrito con exito")
return
else:print("no")
def on_query_completions(self, view, prefix, locations):
if utils.get_language()!="nodejs":return
if utils.is_point():
modulo=utils.get_back_word()
core=utils.load_json_packages_path("nodejs", "core.json")
if core.get(modulo):
return utils.get_completion_list(core[modulo])
else:
core=utils.load_json_packages_path("nodejs", "core.json")
return utils.get_completion_list(core.keys())
def run(self, edit):
lang=utils.get_language()
self.rutaSamples=os.path.normpath(os.path.join(sublime.packages_path(), "..", "samples", lang+".json"))
print("la ruta es : "+self.rutaSamples)
if not os.path.exists(self.rutaSamples):
return
self.samples=utils.load_json(self.rutaSamples)
self.keys=list(self.samples.keys())
window=sublime.active_window()
window.show_quick_panel(self.keys,self.load)
def make_settings_keyboard_for_user(user_id, lang_code):
"""
Prepare keyboard for user based on his settings
:param user_id: User ID in Telegram
:return: Inline Keyboard object
"""
user = dbworker.get_person(user_id)
kb = types.InlineKeyboardMarkup()
wrds_lst = []
if user["word_count"] >= (config.length_min + 1):
wrds_lst.append(types.InlineKeyboardButton(text=strings.get(get_language(lang_code)).get("minusword"), callback_data="minus_word"))
if user["word_count"] <= (config.length_max - 1):
wrds_lst.append(types.InlineKeyboardButton(text=strings.get(get_language(lang_code)).get("plusword"), callback_data="plus_word"))
kb.add(*wrds_lst)
if user["prefixes"]:
kb.add(types.InlineKeyboardButton(text=strings.get(get_language(lang_code)).get("minuspref"), callback_data="disable_prefixes"))
else:
kb.add(types.InlineKeyboardButton(text=strings.get(get_language(lang_code)).get("pluspref"), callback_data="enable_prefixes"))
if user["separators"]:
kb.add(types.InlineKeyboardButton(text=strings.get(get_language(lang_code)).get("minussep"), callback_data="disable_separators"))
else:
kb.add(types.InlineKeyboardButton(text=strings.get(get_language(lang_code)).get("plussep"), callback_data="enable_separators"))
return kb
def info(epub):
data = {}
try:
z = zipfile.ZipFile(epub)
except zipfile.BadZipFile:
logger.debug('invalid epub file %s', epub)
return data
opf = [f.filename for f in z.filelist if f.filename.endswith('opf')]
if opf:
info = ET.fromstring(z.read(opf[0]))
metadata = info.findall('{http://www.idpf.org/2007/opf}metadata')
if metadata:
metadata = metadata[0]
for e in metadata.getchildren():
if e.text and e.text.strip() and e.text not in ('unknown', 'none'):
key = e.tag.split('}')[-1]
key = {
'creator': 'author',
}.get(key, key)
value = e.text.strip()
if key == 'identifier':
value = normalize_isbn(value)
if stdnum.isbn.is_valid(value):
data['isbn'] = [value]
elif key == 'author':
data[key] = value.split(', ')
else:
data[key] = value
if 'description' in data:
data['description'] = strip_tags(decode_html(data['description']))
text = extract_text(epub)
data['textsize'] = len(text)
if not 'isbn' in data:
isbn = extract_isbn(text)
if isbn:
data['isbn'] = [isbn]
if 'date' in data and 'T' in data['date']:
data['date'] = data['date'].split('T')[0]
if 'language' in data and isinstance(data['language'], str):
data['language'] = get_language(data['language'])
return data
def update_for_feed(cls, feed, publish=False, skip_queue=False, overflow=False, overflow_reason=OVERFLOW_REASON.BACKLOG):
parsed_feed, resp = yield fetch_parsed_feed_for_feed(feed)
num_new_items = 0
drain_queue = False
# There should be no data in here anyway
if resp.status_code != 304:
etag = resp.headers.get('ETag')
modified_feed = False
# Update feed location
if resp.was_permanente_redirect:
feed.feed_url = resp.final_url
modified_feed = True
publish = False
elif etag and feed.etag != etag:
feed.etag = etag
modified_feed = True
if 'language' in parsed_feed.feed:
lang = get_language(parsed_feed.feed.language)
if lang != feed.language:
feed.language = lang
modified_feed = True
if modified_feed:
yield feed.put_async()
new_guids, old_guids = yield cls.process_parsed_feed(parsed_feed, feed, overflow, overflow_reason)
num_new_items = len(new_guids)
if len(new_guids + old_guids) >= 5 and len(new_guids) == len(new_guids + old_guids):
drain_queue = True
if publish:
yield cls.publish_for_feed(feed, skip_queue)
if drain_queue:
yield cls.drain_queue(feed)
raise ndb.Return((parsed_feed, num_new_items))
def on_pre_save(self, view):
lang=utils.get_language()
if lang!="javascript" and lang!="nodejs":return
text=utils.get_text()
text=re.sub("\$\([\"'.\w#-]*\)", "jQuery", text)
functions=re.findall("([$A-Za-z]+)\.([\w]+)\(", text)
jsonPath=sublime.packages_path()+os.sep+"javascript"+os.sep+"functions.json"
if lang=="nodejs":jsonPath=sublime.packages_path()+os.sep+"javascript"+os.sep+"functions_node.json"
d=utils.load_json(jsonPath)
for function in functions:
key=function[0]
if key=="$scope":continue
value=function[1]+"()"
if not d.get(key):d[key]=[]
if not value in d[key]:
d[key].append(value)
utils.save_json(jsonPath, d)
def make_settings_keyboard_for_user(user_id, lang_code):
"""
Prepare keyboard for user based on his settings
:param user_id: User ID in Telegram
:return: Inline Keyboard object
"""
user = dbworker.get_person(user_id)
kb = types.InlineKeyboardMarkup()
wrds_lst = []
if user["word_count"] >= (config.length_min + 1):
wrds_lst.append(
types.InlineKeyboardButton(text=strings.get(
get_language(lang_code)).get("minusword"),
callback_data="minus_word"))
if user["word_count"] <= (config.length_max - 1):
wrds_lst.append(
types.InlineKeyboardButton(text=strings.get(
get_language(lang_code)).get("plusword"),
callback_data="plus_word"))
kb.add(*wrds_lst)
if user["prefixes"]:
kb.add(
types.InlineKeyboardButton(text=strings.get(
get_language(lang_code)).get("minuspref"),
callback_data="disable_prefixes"))
else:
kb.add(
types.InlineKeyboardButton(text=strings.get(
get_language(lang_code)).get("pluspref"),
callback_data="enable_prefixes"))
if user["separators"]:
kb.add(
types.InlineKeyboardButton(text=strings.get(
get_language(lang_code)).get("minussep"),
callback_data="disable_separators"))
else:
kb.add(
types.InlineKeyboardButton(text=strings.get(
get_language(lang_code)).get("plussep"),
callback_data="enable_separators"))
return kb
def info(opf):
data = {}
try:
with open(opf, 'rb') as fd:
opf = ET.fromstring(fd.read().decode())
except:
logger.debug('failed to load opf %s', opf, exc_info=1)
return data
ns = '{http://www.idpf.org/2007/opf}'
metadata = opf.findall(ns + 'metadata')[0]
for e in metadata.getchildren():
if e.text:
key = e.tag.split('}')[-1]
key = {
'creator': 'author',
}.get(key, key)
value = e.text
if key == 'identifier':
isbn = normalize_isbn(value)
if stdnum.isbn.is_valid(isbn):
if not 'isbn' in data:
data['isbn'] = [isbn]
else:
data['isbn'].append(isbn)
if e.attrib.get(ns + 'scheme') == 'AMAZON':
if not 'asin' in data:
data['asin'] = [value]
else:
data['asin'].append(value)
else:
data[key] = strip_tags(e.text)
#YYY-MM-DD
if 'date' in data and len(data['date']) > 10:
data['date'] =data['date'][:10]
if 'language' in data:
data['language'] = get_language(data['language'])
return data
def info(opf):
data = {}
try:
with open(opf, 'rb') as fd:
opf = ET.fromstring(fd.read().decode())
except:
logger.debug('failed to load opf %s', opf, exc_info=1)
return data
ns = '{http://www.idpf.org/2007/opf}'
metadata = opf.findall(ns + 'metadata')[0]
for e in metadata.getchildren():
if e.text:
key = e.tag.split('}')[-1]
key = {
'creator': 'author',
}.get(key, key)
value = e.text
if key == 'identifier':
isbn = normalize_isbn(value)
if stdnum.isbn.is_valid(isbn):
if not 'isbn' in data:
data['isbn'] = [isbn]
else:
data['isbn'].append(isbn)
if e.attrib.get(ns + 'scheme') == 'AMAZON':
if not 'asin' in data:
data['asin'] = [value]
else:
data['asin'].append(value)
else:
data[key] = strip_tags(e.text)
#YYY-MM-DD
if 'date' in data and len(data['date']) > 10:
data['date'] = data['date'][:10]
if 'language' in data:
data['language'] = get_language(data['language'])
return data
async def settings(self, ctx: Context):
"""
Manage the Settings of BibleBot
"""
if ctx.invoked_subcommand is None:
message = await ctx.send(embed=Embed(
description="Gathering Information ..."))
settings = get_language_config_by_id(ctx.guild.id)
embed = Embed(
title=settings.f_general_settings_embed_title(ctx.guild.name),
description=settings.f_general_settings_embed_description(
await get_prefix(ctx.message)),
color=0x34bdeb)
embed.add_field(
name=settings.general_settings_embed_field_prefix_title,
value=settings.
f_general_settings_embed_field_prefix_description(
await get_prefix(ctx.message), await
get_prefix(ctx.message)))
embed.add_field(
name=settings.general_settings_embed_field_language_title,
value=settings.
f_general_settings_embed_field_language_description(
get_language(ctx.guild.id), await get_prefix(ctx.message)))
embed.add_field(
name=settings.general_settings_embed_field_translation_title,
value=settings.
f_general_settings_embed_field_translation_description(
get_translation(ctx.guild.id), await
get_prefix(ctx.message)))
await message.edit(embed=embed)
def format_for_adn(feed, entry):
post_text = entry.title
links = []
summary_text = ''
if feed.include_summary:
summary_text = strip_html_tags(entry.summary)
sentances = list(splitter.split(summary_text))
sentances.reverse()
summary_text = sentances.pop()
while len(summary_text) <= 200:
try:
next_sentance = sentances.pop()
except IndexError:
break
if len(summary_text + ' ' + next_sentance) <= 200:
summary_text += ' ' + next_sentance
summary_text = ellipse_text(summary_text, 200)
if entry.feed_item:
link = get_link_for_item(feed, entry.feed_item)
else:
link = entry.link
link = iri_to_uri(link)
link = append_query_string(link, params={'utm_source': 'PourOver', 'utm_medium': 'App.net'})
# If viewing feed from preview don't shorten urls
preview = getattr(feed, 'preview', False)
has_own_bitly_creds = feed.bitly_login and feed.bitly_api_key
if has_own_bitly_creds or feed.format_mode == FORMAT_MODE.TITLE_THEN_LINK:
if not has_own_bitly_creds:
feed.bitly_login = '******'
feed.bitly_api_key = 'R_a1311cd1785b7da2aedac9703656b0f1'
short_url = yield get_short_url(entry, link, feed)
if short_url:
link = short_url
# Starting out it should be as long as it can be
max_chars = MAX_CHARS
max_link_chars = 40
ellipse_link_text = ellipse_text(link, max_link_chars)
# If the link is to be included in the text we need to make sure we reserve enough space at the end
if feed.format_mode == FORMAT_MODE.TITLE_THEN_LINK:
max_chars -= len(' ' + ellipse_link_text)
# Should be some room for a description
if len(post_text) < (max_chars - 40) and summary_text:
post_text = u'%s\n%s' % (post_text, summary_text)
post_text = ellipse_text(post_text, max_chars)
if feed.format_mode == FORMAT_MODE.TITLE_THEN_LINK:
post_text += ' ' + ellipse_link_text
if feed.format_mode == FORMAT_MODE.TITLE_THEN_LINK:
links.insert(0, (link, ellipse_link_text))
else:
links.insert(0, (link, entry.title))
link_entities = []
index = 0
for href, link_text in links:
# logger.info('Link info: %s %s %s', post_text, link_text, index)
text_index = post_text.find(link_text, index)
if text_index > -1:
link_entities.append({
'url': href,
'text': link_text,
'pos': text_index,
'len': len(link_text),
})
index = text_index
post = {
'text': post_text,
'annotations': [cross_post_annotation(link)]
}
if link_entities:
post['entities'] = {
'links': link_entities,
}
# logger.info('Info %s, %s', include_thumb, self.thumbnail_image_url)
if feed.include_thumb and entry.thumbnail_image_url:
post['annotations'].append(image_annotation_for_entry(entry))
if feed.include_video and entry.video_oembed:
oembed = entry.video_oembed
oembed['embeddable_url'] = entry.link
post['annotations'].append({
"type": "net.app.core.oembed",
"value": oembed
})
lang = get_language(entry.language)
if lang:
post['annotations'].append({
"type": "net.app.core.language",
"value": {
"language": lang,
}
})
if entry.author:
post['annotations'].append({
"type": "net.app.pourover.item.author",
"value": {
"author": entry.author,
}
})
if entry.tags:
post['annotations'].append({
"type": "net.app.pourover.item.tags",
"value": {
"tags": entry.tags,
}
})
raise ndb.Return(post)
def run(self, edit):
window=sublime.active_window()
view=window.active_view()
self.lang=utils.get_language()
self.regMetodos={
"python":"def\\s+%(nombre)s\\(",
"python3":"def\\s+%(nombre)s\\(",
"ruby":"def\\s+%(nombre)s",
"java":"[\w].+\s+%(nombre)s\(",
"javascript":"function\\s*%(nombre)s\\(|%(nombre)s\\s*=\\s*function\\(",
"nodejs":"function\\s*%(nombre)s\\(|%(nombre)s\\s*=\\s*function\\(",
"c":"\\b%(nombre)s\\([^)]*\\)\\s*\\n?\\s*\\{",
"c#":"\\b%(nombre)s\\([^)]*\\)\\s*\\n?\\s*\\{",
"c++":"\\b%(nombre)s\\([^)]*\\)\\s*\\n?\\s*\\{"
}
self.regVariables={
"python":"\\b%(nombre)s\\s*=[^=]?|\\b%(nombre)s\\s+in\\s+|def [\\w_]+\\(.*\\b%(nombre)s",
"python3":"\\b%(nombre)s\\s*=[^=]?|\\b%(nombre)s\\s+in\\s+|def [\\w_]+\\(.*\\b%(nombre)s",
"ruby":"\\b%(nombre)s\\s*=[^=]?|\\b%(nombre)s\\s+in\\s+|def [\\w_]+\\(.*\\b%(nombre)s",
"java":"\\b%(nombre)s\\s*=[^=]?|[\\w]+\\s+%(nombre)s;|[\\w]+\\s+%(nombre)s,",
"javascript":"\\b%(nombre)s\\s*=[^=]?|var+\\s+%(nombre)s;|var+\\s+%(nombre)s,",
"nodejs":"\\b%(nombre)s\\s*=[^=]?|var+\\s+%(nombre)s;|var+\\s+%(nombre)s,",
"c":"\\b%(nombre)s\\s*=[^=]?|[\\w]+\\s+%(nombre)s;|[\\w]+\\s+%(nombre)s,",
"c#":"\\b%(nombre)s\\s*=[^=]?|[\\w]+\\s+%(nombre)s;|[\\w]+\\s+%(nombre)s,",
"c++":"\\b%(nombre)s\\s*=[^=]?|[\\w]+\\s+%(nombre)s;|[\\w]+\\s+%(nombre)s,",
"jsf":'id\\s*=\\s*"%(nombre)s"'
}
self.comentarios={
"python":'#[^\\n]\\n|"""[^"]"""',
"python3":'#[^\\n]\\n|"""[^"]"""',
"ruby":'#[^\\n]\\n|"""[^"]"""',
"java":"//[^\\n]\\n|/[*][^/]*[*]/",
"javascript":"//[^\\n]\\n|/[*][^/]*[*]/",
"nodejs":"//[^\\n]\\n|/[*][^/]*[*]/",
"c":"//[^\\n]\\n|/[*][^/]*[*]/",
"c#":"//[^\\n]\\n|/[*][^/]*[*]/",
"c++":"//[^\\n]\\n|/[*][^/]*[*]/",
"jsf":"<!--[^-]->"
}
var=utils.get_word_signature()
print(var)
isMethod=utils.is_method()
isUnique=var.find(".")==-1
if self.lang=="python" and var.startswith("self."):
isUnique=True
var=var[var.find(".")+1:]
elif self.lang=="java" and var.startswith("this."):
isUnique=True
var=var[var.find(".")+1:]
if isMethod:
if isUnique:self.goto_method(var)
else:self.goto_class_method(var[:var.find(".")], var[var.find(".")+1:])
else:
if isUnique:
self.goto_definition(var)
paquete=re.findall("import\s+([\w._]+\."+var+");", utils.get_text(), flags=re.IGNORECASE)
if var[0].isupper() and paquete:
print("va hacia la clase")
self.goto_class(paquete[0])
else:
self.goto_class_definition(var[:var.find(".")], var[var.find(".")+1:])
print("no unico")
async def cmd_help(message: types.Message):
await message.answer(
strings.get(get_language(message.from_user.language_code)).get("help"))
def info(pdf):
data = {}
with open(pdf, 'rb') as fd:
try:
pdfreader = PdfFileReader(fd)
data['pages'] = pdfreader.numPages
if pdfreader.getIsEncrypted():
pdfreader.decrypt('')
info = pdfreader.getDocumentInfo()
if info:
for key in info:
if info[key]:
try:
value = info[key]
if len(value) == 1:
value = value[0]
if isinstance(value, bytes):
value = value.decode('utf-16')
data[key[1:].lower()] = value
except:
pass
xmp = pdfreader.getXmpMetadata()
if xmp:
for key in dir(xmp):
if key.startswith('dc_'):
value = getattr(xmp, key)
if isinstance(value, dict) and 'x-default' in value:
value = value['x-default']
elif isinstance(value, list):
value = [v.strip() if isinstance(v, str) else v for v in value if v]
value = [v.strftime('%Y-%m-%d') if isinstance(v, datetime) else v for v in value]
if len(value) == 1:
value = value[0]
_key = key[3:]
if value and _key not in data:
data[_key] = value
except:
logger.debug('FAILED TO PARSE %s', pdf, exc_info=1)
'''
cmd = ['pdfinfo', pdf]
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=True)
stdout, stderr = p.communicate()
for line in stdout.strip().split('\n'):
parts = line.split(':')
key = parts[0].lower().strip()
if key:
data[key] = ':'.join(parts[1:]).strip()
for key in data.keys():
if not data[key]:
del data[key]
'''
if 'identifier' in data:
value = normalize_isbn(data['identifier'])
if stdnum.isbn.is_valid(value):
data['isbn'] = [value]
del data['identifier']
for key, value in data.items():
if isinstance(value, dict):
value = ' '.join(list(value.values()))
data[key] = value.strip()
for key in list(data):
if data[key] in ('Unknown',):
del data[key]
if key == 'language':
data[key] = get_language(data[key])
text = extract_text(pdf)
data['textsize'] = len(text)
if settings.server['extract_text']:
if not 'isbn' in data:
isbn = extract_isbn(text)
if isbn:
data['isbn'] = [isbn]
if 'isbn' in data and isinstance(data['isbn'], str):
data['isbn'] = [data['isbn']]
if 'date' in data and len(data['date']) == 8 and data['date'].isdigit():
d = data['date']
data['date'] = '%s-%s-%s' % (d[:4], d[4:6], d[6:])
if 'author' in data and isinstance(data['author'], str):
data['author'] = data['author'].split(', ')
return data
def info(pdf):
data = {}
with open(pdf, 'rb') as fd:
try:
pdfreader = PdfFileReader(fd)
data['pages'] = pdfreader.numPages
if pdfreader.getIsEncrypted():
pdfreader.decrypt('')
info = pdfreader.getDocumentInfo()
if info:
for key in info:
if info[key]:
try:
value = info[key]
if len(value) == 1:
value = value[0]
if isinstance(value, bytes):
value = value.decode('utf-16')
data[key[1:].lower()] = value
except:
pass
xmp = pdfreader.getXmpMetadata()
if xmp:
for key in dir(xmp):
if key.startswith('dc_'):
value = getattr(xmp, key)
if isinstance(value, dict) and 'x-default' in value:
value = value['x-default']
elif isinstance(value, list):
value = [
v.strip() if isinstance(v, str) else v
for v in value if v
]
value = [
v.strftime('%Y-%m-%d') if isinstance(
v, datetime) else v for v in value
]
if len(value) == 1:
value = value[0]
_key = key[3:]
if value and _key not in data:
data[_key] = value
except:
logger.debug('FAILED TO PARSE %s', pdf, exc_info=1)
'''
cmd = ['pdfinfo', pdf]
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=True)
stdout, stderr = p.communicate()
for line in stdout.strip().split('\n'):
parts = line.split(':')
key = parts[0].lower().strip()
if key:
data[key] = ':'.join(parts[1:]).strip()
for key in data.keys():
if not data[key]:
del data[key]
'''
if 'identifier' in data:
value = normalize_isbn(data['identifier'])
if stdnum.isbn.is_valid(value):
data['isbn'] = [value]
del data['identifier']
for key, value in data.items():
if isinstance(value, dict):
value = ' '.join(list(value.values()))
data[key] = value.strip()
for key in list(data):
if data[key] in ('Unknown', ):
del data[key]
if key == 'language':
data[key] = get_language(data[key])
text = extract_text(pdf)
data['textsize'] = len(text)
if settings.server['extract_text']:
if not 'isbn' in data:
isbn = extract_isbn(text)
if isbn:
data['isbn'] = [isbn]
if 'isbn' in data and isinstance(data['isbn'], str):
data['isbn'] = [data['isbn']]
if 'date' in data and len(data['date']) == 8 and data['date'].isdigit():
d = data['date']
data['date'] = '%s-%s-%s' % (d[:4], d[4:6], d[6:])
if 'author' in data and isinstance(data['author'], str):
data['author'] = data['author'].split(', ')
return data
def run(self, edit):
esLinux=False
esMac=False
view=sublime.active_window().active_view()
tipo=utils.get_language()
comando=""
archivo=self.extraerArchivo(view.file_name(), tipo)
print("el archivo es :"+archivo["ruta"])
print("la ruta es : "+archivo["ruta"])
os.chdir(archivo["ruta"])
pausa=" & pause>nul"
plataforma=platform.system().lower().strip()
if plataforma == "linux":
esLinux=True
pausa=' && read - p ""'
elif plataforma == "darwin":
esMac=True
print(archivo)
commands={
"java":"java %(nombre)s"%archivo,
"c":"%(nombre)s"%archivo,
"batch file":"%(nombre)s"%archivo,
"ruby":'ruby %(path)s'%archivo,
"r":'rscript %(path)s'%archivo,
"python":'python %(path)s'%archivo,
"python3":'python3 %(path)s'%archivo,
"dart":'dart %(nombreCompleto)s'%archivo,
"plsql":'sqlplus %(username)s/%(password)s~%(host)s:%(port)s/%(service)s @ %(path)s'%archivo,
"sqlite":'sqlite -cmd ".read %(nombreCompleto)s"'%archivo,
"mysql":'mysql --bind-address=%(host)s --port=%(port)s --user=%(username)s --password=%(password)s --database=%(db)s -e "source %(path)s"'%archivo,
"nodejs":'node %(path)s'%archivo,
"perl":'perl %(nombreCompleto)s'%archivo,
"mongodb":"mongo %(nombreCompleto)s"%archivo,
"source.postgre ":"psql -f %(nombreCompleto)s"%archivo,
"sqlserver":'sqlcmd -S "ANTIN\SQLEXPRESS" -i "%(nombreCompleto)s"'%archivo,
"scala":"scala %(nombreCompleto)s"%archivo,
"groovy":"groovy %(path)s"%archivo,
"go":"go run %(path)s"%archivo
}
print("el tipo es : "+tipo)
if commands.get(tipo):
print("el tipo es: "+commands.get(tipo))
comando=commands.get(tipo)
elif tipo.startswith("source.js ") or tipo.startswith("source.basic.html"):
webbrowser.open_new_tab(archivo["path"])
return
else:
print("no es ninguno")
if comando.strip():
print("el comando es : "+comando)
if esMac:
print("es mac")
rutaArchivo = os.path.join(sublime.packages_path(), "run.command")
utils.file_write(rutaArchivo, comando)
comando='open "'+rutaArchivo+'"'
print("el comando final es : "+comando)
os.system(comando)
else:
view.run_command("ejecutar_comando", {"comando":comando})
def on_query_completions(self, view, prefix, locations):
if utils.get_language()!="java":return
line=utils.get_line()
line=line.lstrip()
if line.startswith("@"):line=line[1:]
if len(line)==1 and line.isupper() or line.endswith("new "):return utils.get_completion_list(utils.load_json(PATH_INDEX_CLASSES), "(Class)")
def on_query_completions(self, view, prefix, locations):
lang=utils.get_language()
def guardarTemplate(self):
lang=utils.get_language()
ruta=TEMPLATES_PATH+lang
filename=utils.get_filename()
rutaArchivo=os.path.join(ruta,"x."+lang)
def run(self, edit):
lang=utils.get_language()
if not lang in ["java"]:return
self.vistas=utils.get_files({"ext":"xhtml", "ignores":["target", "build", ".svn", ".git", "bin"]})
window=sublime.active_window()
window.show_quick_panel(self.vistas,self.seleccionarVista)
def on_query_completions(self, view, prefix, locations):
lang=utils.get_language()
if lang in ["css"] or utils.get_last_character()!=".":
return [(x+"\t(R)", x) for x in list(set(utils.get_views_words()))]
def make_regenerate_keyboard(lang_code):
keyboard = types.InlineKeyboardMarkup()
btn = types.InlineKeyboardButton(text=strings.get(get_language(lang_code)).get("regenerate"), callback_data="regenerate")
keyboard.add(btn)
return keyboard
def cmd_help(message):
bot.send_message(message.chat.id, strings.get(get_language(message.from_user.language_code)).get("help"), parse_mode="HTML")
if config.botan_id:
botan.track(config.botan_api_key, message.chat.id, message, 'Help')
return
def cmd_help(message):
bot.send_message(message.chat.id,
strings.get(get_language(
message.from_user.language_code)).get("help"),
parse_mode="HTML")
