325 lines
16 KiB
Python
325 lines
16 KiB
Python
import urllib
|
|
import urllib.request
|
|
import zipfile
|
|
import json
|
|
import http.client
|
|
import socket
|
|
import ssl
|
|
import time
|
|
import re
|
|
import io
|
|
import os
|
|
from PyQt5.QtCore import *
|
|
from PyQt5.QtGui import *
|
|
|
|
class GetKritaAPI(QObject):
|
|
|
|
MAP_TYPES = {
|
|
'QStringList': ['List[str]'],
|
|
'QString': ['str'],
|
|
'qreal': ['float'],
|
|
'double': ['float'],
|
|
'QByteArray': ['Union[QByteArray, bytes, bytearray]','QByteArray'],
|
|
'QList':['List'],
|
|
'QVector':['List'],
|
|
'QMap':['Dict'],
|
|
'true':['True'],
|
|
'false':['False'],
|
|
'void': ['None']
|
|
}
|
|
|
|
DECLARE_CLASS = {
|
|
'Document': 'Krita.instance().activeDocument()',
|
|
'Node': 'Krita.instance().activeDocument().activeNode()'
|
|
}
|
|
|
|
|
|
def updateData(self, kritaVersion, defaultTimeout = 5):
|
|
headers = {
|
|
'Accept': '*/*',
|
|
"User-Agent": "Krita-DevTools Plugin"
|
|
}
|
|
|
|
|
|
# Get List of tags and confirm if IPv6 is working properly
|
|
tagList = "https://invent.kde.org/api/v4/projects/graphics%2Fkrita/repository/tags"
|
|
|
|
s1 = time.time()
|
|
req = urllib.request.Request(tagList, headers=headers)
|
|
with urllib.request.urlopen(req, timeout=defaultTimeout) as source:
|
|
if time.time() - s1 > defaultTimeout:
|
|
ForceIPv4Connection()
|
|
defaultTimeout += 25
|
|
|
|
try:
|
|
jres = json.loads(source.read())
|
|
|
|
tag = 'master'
|
|
|
|
for tagDict in jres:
|
|
if (tagDict['name'].split('-'))[0] == 'v'+ kritaVersion:
|
|
tag = tagDict['name']
|
|
|
|
# Figure out when API was last updated
|
|
lastCommit = "https://invent.kde.org/api/graphql"
|
|
|
|
urldata={"query":"query pathLastCommit($projectPath: ID!, $path: String, $ref: String!) {\n project(fullPath: $projectPath) {\n id\n __typename\n repository {\n __typename\n tree(path: $path, ref: $ref) {\n __typename\n lastCommit {\n __typename\n sha\n title\n titleHtml\n descriptionHtml\n message\n webPath\n authoredDate\n authorName\n authorGravatar\n author {\n __typename\n name\n avatarUrl\n webPath\n }\n signatureHtml\n pipelines(ref: $ref, first: 1) {\n __typename\n edges {\n __typename\n node {\n __typename\n detailedStatus {\n __typename\n detailsPath\n icon\n tooltip\n text\n group\n }\n }\n }\n }\n }\n }\n }\n }\n}\n","variables":{"projectPath":"graphics/krita","ref":tag,"path":"libs/libkis"}}
|
|
|
|
|
|
req = urllib.request.Request(lastCommit, headers=headers)
|
|
req.add_header('Content-Type', 'application/json; charset=utf-8')
|
|
jsondata = json.dumps(urldata)
|
|
jsondataasbytes = jsondata.encode('utf-8') # needs to be bytes
|
|
req.add_header('Content-Length', len(jsondataasbytes))
|
|
|
|
with urllib.request.urlopen(req, jsondataasbytes, timeout=defaultTimeout) as source:
|
|
jres = json.loads(source.read())
|
|
date = jres['data']['project']['repository']['tree']['lastCommit']['authoredDate']
|
|
|
|
# Download the API details
|
|
zipUrl = 'https://invent.kde.org/graphics/krita/-/archive/'+tag+'/krita-'+tag+'.zip?path=libs/libkis'
|
|
req = urllib.request.Request(zipUrl, headers=headers)
|
|
with urllib.request.urlopen(req, timeout=defaultTimeout) as source:
|
|
data = source.read()
|
|
with zipfile.ZipFile(io.BytesIO(data)) as myzip:
|
|
if 'krita-'+tag+'-libs-libkis/libs/libkis/Window.h' in myzip.namelist():
|
|
with open( os.path.dirname(os.path.realpath(__file__)) + '.KritaAPI.'+kritaVersion+'.zip', 'wb') as f:
|
|
f.write(data)
|
|
f.close()
|
|
return { 'status': 1, 'data': { 'updated': date } }
|
|
|
|
else:
|
|
raise Exception("Archive is invalid.")
|
|
|
|
|
|
|
|
except Exception as e:
|
|
|
|
return { 'status':0, 'error': str(e) }
|
|
|
|
|
|
def parseData(self, kritaVersion):
|
|
mapDict = {}
|
|
|
|
with zipfile.ZipFile( os.path.dirname(os.path.realpath(__file__)) + '.KritaAPI.'+kritaVersion+'.zip' ) as myzip:
|
|
for fn in myzip.namelist():
|
|
if fn.endswith('.h') and '/Test/' not in fn:
|
|
content = str(myzip.read(fn),'utf-8')
|
|
className = re.search(r'^.*[/\\](.+?)\.h$', fn).group(1)
|
|
|
|
#print ("CLASSNAME", className)
|
|
|
|
#print ( content )
|
|
regexFile = re.compile(r"^(?:.+?\/\*\*\s*(.+?)\s*\*\/.*?|.+?)\n\s*?class KRITALIBKIS_EXPORT (\w+)\s*?[\:\n]\s*(?:public\s+|)(\w+|)", re.DOTALL)
|
|
|
|
match = regexFile.search(content)
|
|
content = regexFile.sub('', content)
|
|
#print ( content )
|
|
|
|
regexClass = re.compile(r"\n\s*?(public|private)\s*(Q_SLOTS|)\s*:\s*?\n(.+?)(\n\s*?(?:public|private)\s*(?:Q_SLOTS|)\s*:\s*?\n|\#endif \/\/ LIBKIS_)", re.DOTALL)
|
|
|
|
regexMethod = re.compile(r"^(?:.+?(?P<doc>\/\*\*\s*.+?\s*\*\/|\/\/\/[^\r\n]+?)\s*?|\s+?)\n\s*?(?:(?P<type>(?:virtual|static|)\s*?[\w\*]+(?:\<[\w \*,]+\>|))\s+(?P<name>[\w\*]+)|(?P<cname>"+className+r"))\((?P<params>[^\r\n]*)\)(?P<extra>[^\r\n])*?;", re.DOTALL)
|
|
|
|
regexParam = re.compile(r'(?:^|\s)(\S+?(?:\<.+?\>|))\s*[\&\*]*(\w+?)(?:\s*=\s*(.+?)|)\s*$', re.DOTALL)
|
|
|
|
if match:
|
|
#print( "match=",match.group(2), match.group(1) )
|
|
modName = match.group(2)
|
|
doc = match.group(1) if match.group(1) else ''
|
|
doc = re.sub(r'^\s*(?:/\*\*|///)\s*\**', r'', doc)
|
|
doc = re.sub(r'/\s*$', r'', doc)
|
|
doc = re.sub(r'\n\s*?\* \@', r'\n@', doc )
|
|
start = doc.find('@code')
|
|
|
|
if start > -1:
|
|
end = doc.find('@endcode',start)
|
|
doc = doc.replace( doc[start:end],re.sub(r'\n\s*?\* ',r'\n', doc[start:end]))
|
|
|
|
doc = re.sub(r'\n\s*?\*', r'', doc )
|
|
mapDict[modName] = { 'doc':doc, 'methods':{}, 'declare':[], 'parent':match.group(3) }
|
|
if modName in self.DECLARE_CLASS:
|
|
mapDict[modName]['declare'].append({
|
|
'doc': self.DECLARE_CLASS[modName],
|
|
'return': className,
|
|
'params': [],
|
|
'access': ''
|
|
})
|
|
|
|
while True:
|
|
match = regexClass.search(content)
|
|
if match is not None:
|
|
|
|
#print ( "matchMethod", match.group(1), match.group(2), match.group(3) )
|
|
content = regexClass.sub(match.group(4), content, 1)
|
|
|
|
methodAccess = match.group(1) + " " + match.group(2)
|
|
subcontent = match.group(3)
|
|
|
|
while True:
|
|
matchMethod = regexMethod.search(subcontent)
|
|
subcontent = regexMethod.sub('', subcontent, 1)
|
|
if matchMethod:
|
|
#if matchMethod.group('cname'): print ("CNAME!", matchMethod.group('cname') )
|
|
docMethod = matchMethod.group('doc') if matchMethod.group('doc') else ''
|
|
docMethod = re.sub(r'^\s*(?:/\*\*|///)\s*\**', r'', docMethod)
|
|
docMethod = re.sub(r'/\s*$', r'', docMethod)
|
|
docMethod = re.sub(r'\n\s*?\* \@', r'\n@', docMethod)
|
|
start2 = docMethod.find('@code')
|
|
if start2 > -1:
|
|
#print ("SELECTION FOUND!")
|
|
end2 = docMethod.find('@endcode',start2)
|
|
docMethod = docMethod.replace( docMethod[start2:end2],re.sub(r'\n\s*?\* ',r'\n', docMethod[start2:end2]))
|
|
|
|
docMethod = re.sub(r'\n\s*?\*', r'', docMethod )
|
|
methName = (matchMethod.group('name') if matchMethod.group('name') else matchMethod.group('cname')).replace('*','')
|
|
|
|
params = []
|
|
#print ('mp', matchMethod.group('params'))
|
|
paramText = matchMethod.group('params')
|
|
if paramText:
|
|
paramText = re.sub(r'\<(.*?),(.*?)\>',r'<\1&&\2>', paramText)
|
|
for param in paramText.split(','):
|
|
pmatch = regexParam.search(param)
|
|
#print ( "p["+param+']', pmatch )
|
|
params.append({
|
|
'type': re.sub(r'\<(.*?)&&(.*?)\>',r'<\1,\2>', pmatch.group(1)),
|
|
'name': pmatch.group(2),
|
|
'optional': re.sub(r'\<(.*?)&&(.*?)\>',r'<\1,\2>', pmatch.group(3)) if pmatch.group(3) else None
|
|
})
|
|
#print ("met", className, methName, params)
|
|
#if 'internal use only' in docMethod: continue
|
|
if methName == modName:
|
|
|
|
mapDict[modName]['declare'].append({
|
|
'doc': docMethod,
|
|
'return': className if matchMethod.group('cname') else matchMethod.group('type'),
|
|
'params': params,
|
|
'access': methodAccess
|
|
})
|
|
else:
|
|
mapDict[modName]['methods'][methName]={
|
|
'name': methName,
|
|
'doc':docMethod,
|
|
'return': matchMethod.group('type').strip(),
|
|
'params': params,
|
|
'access': methodAccess
|
|
}
|
|
else:
|
|
break
|
|
#print ("cont=",content)
|
|
else:
|
|
#print ("NO MATCH!")
|
|
break
|
|
|
|
|
|
#print ("cont=",content)
|
|
|
|
#methods = decl.group(3)
|
|
|
|
|
|
return mapDict
|
|
|
|
def convertType(self, vtype, classKeys, param = True):
|
|
for k in reversed(sorted(self.MAP_TYPES.keys())):
|
|
v = self.MAP_TYPES[k]
|
|
rv = v[0] if param or len(v) == 1 else v[1]
|
|
if k == vtype:
|
|
return rv
|
|
elif k in vtype:
|
|
vtype = vtype.replace(k, rv)
|
|
|
|
vtype = vtype.replace('<','[').replace('>',']').replace(' *','').replace('*','').replace('&','').replace('virtual ','')
|
|
|
|
#if param:
|
|
for k in reversed(sorted(classKeys)):
|
|
vtype = re.sub( r"(^|[\[\( ,])"+k, r"\1'"+k+"'", vtype)
|
|
|
|
vtype = re.sub( r"((?:Kis|Ko)\w+)", r"'\1'", vtype)
|
|
|
|
return vtype
|
|
|
|
def genAutoComplete(self, kritaVersion):
|
|
output = "from PyQt5.QtCore import *\nfrom PyQt5.QtGui import *\nfrom PyQt5.QtWidgets import *\nfrom typing import List, Dict, Union\n"
|
|
parseData = self.parseData(kritaVersion)
|
|
|
|
sortedLists = { 'QObject':[], 'Other':[] }
|
|
for k in reversed(sorted(parseData.keys())):
|
|
v = parseData[k]
|
|
|
|
if v['parent'] == 'QObject':
|
|
sortedLists['QObject'].append( k )
|
|
else:
|
|
sortedLists['Other'].append( k )
|
|
|
|
if v['parent'].startswith('Ko') or v['parent'].startswith('Kis'):
|
|
output += v['parent']+" = QObject\n"
|
|
|
|
|
|
|
|
for k in sortedLists['QObject'] + sortedLists['Other']:
|
|
v = parseData[k]
|
|
output += "class " + k + "(" + v['parent'] +"):\n"
|
|
output += '\t"""' + v['doc'] + ' """\n\n'
|
|
|
|
if v['declare']:
|
|
paramList = ['self']
|
|
|
|
for param in m['params']:
|
|
paramList.append( param['name'] + ": " + self.convertType(param['type'], parseData.keys() ) + (" = " + self.convertType(param['optional'], parseData.keys() ) if param['optional'] else "") )
|
|
|
|
output += "\tdef __init__(" + ', '.join(paramList) + ") -> " + self.convertType(m['return'], parseData.keys() , False) +":\n"
|
|
output += '\t\t"""' + m['doc'] + ' """\n\n'
|
|
|
|
for km, m in v['methods'].items():
|
|
paramList = []
|
|
paramNames = []
|
|
|
|
#print ( "METHOD=", m )
|
|
if "static" not in m['return']:
|
|
paramList.append('self')
|
|
else:
|
|
m['return'] = m['return'].replace('static','')
|
|
output += "\t@staticmethod\n"
|
|
|
|
for param in m['params']:
|
|
paramNames.append( param['name'] )
|
|
paramList.append( param['name'] + ": " + self.convertType(param['type'], parseData.keys() ) + (" = " + self.convertType(param['optional'], parseData.keys() ) if param['optional'] else "") )
|
|
|
|
output += "\tdef " + m['name'] + "(" + ', '.join(paramList) + ") -> " + self.convertType(m['return'], parseData.keys() , False) +":\n"
|
|
output += "\t\t# type: (" + ', '.join(paramNames) + ") -> " + self.convertType(m['return'], {}.keys() , False) +":\n"
|
|
output += '\t\t"""@access ' + m['access'] + "\n" + m['doc'] + ' """\n\n'
|
|
|
|
return output
|
|
|
|
|
|
class ForceIPv4Connection():
|
|
def __init__(self, caller = None):
|
|
super().__init__()
|
|
urllib.request.HTTPSHandler = self.OverloadHTTPSHandler
|
|
print ("overloaded!")
|
|
|
|
class OverloadHTTPSConnection(http.client.HTTPSConnection):
|
|
def connect(self):
|
|
self.sock = socket.socket(socket.AF_INET)
|
|
self.sock.connect((self.host, self.port))
|
|
if self._tunnel_host:
|
|
self._tunnel()
|
|
self.sock = ssl.wrap_socket(self.sock, self.key_file, self.cert_file)
|
|
|
|
|
|
|
|
class OverloadHTTPSHandler(urllib.request.AbstractHTTPHandler):
|
|
|
|
def __init__(self, debuglevel=0, context=None, check_hostname=None):
|
|
urllib.request.AbstractHTTPHandler.__init__(self, debuglevel)
|
|
self._context = context
|
|
self._check_hostname = check_hostname
|
|
|
|
def https_open(self, req):
|
|
return self.do_open(ForceIPv4Connection.OverloadHTTPSConnection, req,
|
|
context=self._context, check_hostname=self._check_hostname)
|
|
|
|
https_request = urllib.request.AbstractHTTPHandler.do_request_
|
|
|
|
|