def __init__(self, auth_file):
logger.debug("\n================== ISOGEO API WITH QT ==================")
# getting credentials :
logger.debug("Getting credentials")
self.utils = IsogeoUtils()
self.app_creds = self.utils.credentials_loader(auth_file)
self.app_id = self.app_creds.get("client_id")
self.app_secrets = self.app_creds.get("client_secret")
# for connection :
self.naMngr = QNetworkAccessManager()
self.token_url = "https://id.api.isogeo.com/oauth/token"
self.request_url = (
"https://v1.api.isogeo.com/resources/search?_limit=0&_offset=0"
)
# init variables :
self.token = ""
self.search_type = "init"
self.checked_kw = {}
# for ui (launch and display):
logger.debug("Processing and displaying UI")
self.app = QApplication(sys.argv)
self.ui = AuthWidget()
self.ui.resize(400, 100)
self.pysdk_checking()
self.api_authentification()
self.ui.btn_reset.pressed.connect(self.reset)
self.ui.show()
self.app.exec()
# 3rd party library
from isogeo_pysdk import (
Condition,
IsogeoTranslator,
IsogeoUtils,
License,
Specification,
)
# ##############################################################################
# ############ Globals ############
# #################################
logger = logging.getLogger("isogeotoxlsx") # LOG
utils = IsogeoUtils()
# ##############################################################################
# ########## Classes ###############
# ##################################
class Formatter(object):
"""Metadata formatter to avoid repeat operations on metadata during export in different formats.
:param str lang: selected language
:param str output_type: name of output type to format for. Defaults to 'Excel'
:param tuple default_values: values used to replace missing values. Structure:
(
str_for_missing_strings_and_integers,
# -*- coding: UTF-8 -*-
# standard lib
# 3rd party
from isogeo_pysdk import Isogeo, IsogeoUtils, __version__
#########
print("Working with package version: {}".format(__version__))
utils = IsogeoUtils()
#print(dir(utils))
#print(help(utils))
#######
api_auth = utils.credentials_loader(r"./client_secrets.json")
# authenticate your client application
isogeo = Isogeo(client_id=api_auth.get("client_id"),
client_secret=api_auth.get("client_secret"))
# get the token
token = isogeo.connect()
# add properties as attribute
isogeo.get_app_properties(token)
# set augment option on True
search = isogeo.search(token,
from ttkwidgets.frames import Balloon
try:
import Tkinter as tk
import ttk
from Tkinter import BOTH, LEFT
except ImportError:
import tkinter as tk
from tkinter import ttk, BOTH, LEFT
# ############################################################################
# ########### Globals ##############
# ##################################
language = "EN"
utils = IsogeoUtils()
# UI quick and dirty styling
data = """
R0lGODlhKgAaAOfnAFdZVllbWFpcWVtdWlxeW11fXF9hXmBiX2ZnZWhpZ2lraGxua25wbXJ0
cXR2c3V3dHZ4dXh6d3x+e31/fH6AfYSGg4eJhoiKh4qMiYuNio2PjHmUqnqVq3yXrZGTkJKU
kX+asJSWk32cuJWXlIGcs5aYlX6euZeZloOetZial4SftpqbmIWgt4GhvYahuIKivpudmYei
uYOjv5yem4ijuoSkwIWlwYmlu56gnYamwp+hnoenw4unvaCin4ioxJCnuZykrImpxZmlsoaq
zI2pv6KkoZGouoqqxpqms4erzaOloo6qwYurx5Kqu5untIiszqSmo5CrwoysyJeqtpOrvJyo
tZGsw42typSsvaaopZKtxJWtvp6qt4+uy6epppOuxZCvzKiqp5quuZSvxoyx06mrqJWwx42y
1JKxzpmwwaqsqZaxyI6z1ZqxwqutqpOzz4+01qyuq56yvpizypS00Jm0y5W10Zq1zJa20rCy
rpu3zqizwbGzr6C3yZy4z7K0saG4yp250LO1sqK5y5660Z+70qO7zKy4xaC806S8zba4taG9
1KW9zq66x6+7yLi6t6S/1rC8yrm7uLO8xLG9y7q8ubS9xabB2anB07K+zLW+xrO/za7CzrTA
zrjAyLXBz77BvbbC0K/G2LjD0bnE0rLK28TGw8bIxcLL07vP28HN28rMycvOyr/T38DU4cnR
2s/RztHT0NLU0cTY5MrW5MvX5dHX2c3Z59bY1dPb5Nbb3dLe7Nvd2t3f3NXh797g3d3j5dnl
9OPl4eTm4+Ln6tzo9uXn5Obo5eDp8efp5uHq8uXq7ejq5+nr6OPs9Ovu6unu8O3v6+vw8+7w
class KeyWordsSelection:
def __init__(self, auth_file):
logger.debug("\n================== ISOGEO API WITH QT ==================")
# getting credentials :
logger.debug("Getting credentials")
self.utils = IsogeoUtils()
self.app_creds = self.utils.credentials_loader(auth_file)
self.app_id = self.app_creds.get("client_id")
self.app_secrets = self.app_creds.get("client_secret")
# for connection :
self.naMngr = QNetworkAccessManager()
self.token_url = "https://id.api.isogeo.com/oauth/token"
self.request_url = (
"https://v1.api.isogeo.com/resources/search?_limit=0&_offset=0"
)
# init variables :
self.token = ""
self.search_type = "init"
self.checked_kw = {}
# for ui (launch and display):
logger.debug("Processing and displaying UI")
self.app = QApplication(sys.argv)
self.ui = AuthWidget()
self.ui.resize(400, 100)
self.pysdk_checking()
self.api_authentification()
self.ui.btn_reset.pressed.connect(self.reset)
self.ui.show()
self.app.exec()
def pysdk_checking(self):
logger.debug("\n--------------- isogeo-pysdk ---------------")
logger.debug("Checking credentials")
try:
isogeo = Isogeo(self.app_id, self.app_secrets)
isogeo.connect()
except OSError as e:
logger.debug("Credentials issue : {}".format(e))
return
except ValueError as e:
logger.debug("Credentials issue : {}".format(e))
return
if self.search_type == "init":
result = isogeo.search(
whole_share=0, page_size=0, augment=0, tags_as_dicts=1
)
else:
query = " ".join(list(self.checked_kw.keys()))
result = isogeo.search(
whole_share=0, page_size=0, augment=0, tags_as_dicts=1, query=query
)
self.tags_expected = result.get("tags")
self.kw_expected_nb = len(self.tags_expected.get("keywords"))
self.ui.lbl_expected.setText(
"Expected : {} resources and {} keywords".format(
result.get("total"), self.kw_expected_nb
)
)
logger.debug(
"isogeo-pysdk validates the authentication file, {} accessible resources".format(
result.get("total")
)
)
def api_authentification(self):
logger.debug("\n------------------ Authentication ------------------")
# creating credentials header
crd_header_value = QByteArray()
crd_header_value.append("Basic ")
crd_header_value.append(
base64.b64encode("{}:{}".format(self.app_id, self.app_secrets).encode())
)
crd_header_name = QByteArray()
crd_header_name.append("Authorization")
# creating Content-Type header
ct_header_value = QByteArray()
ct_header_value.append("application/json")
# creating request
token_rqst = QNetworkRequest(QUrl(self.token_url))
# setting headers
token_rqst.setRawHeader(crd_header_name, crd_header_value)
token_rqst.setHeader(token_rqst.ContentTypeHeader, ct_header_value)
# creating data
data = QByteArray()
data.append(urlencode({"grant_type": "client_credentials"}))
# requesting and handle reply
logger.debug("Asking for token")
token_reply = self.naMngr.post(token_rqst, data)
token_reply.finished.connect(partial(self.api_handle_token, reply=token_reply))
def api_handle_token(self, reply):
logger.debug("Token asked and API reply received")
# formating API response
bytarray = reply.readAll()
content = bytarray.data().decode("utf8")
# check API response structure
try:
parsed_content = json.loads(content)
except:
logger.debug("Reply format issue")
return
# check API response content
if "access_token" in parsed_content:
self.token = "Bearer " + parsed_content.get("access_token")
self.api_get_request()
else:
logger.debug("ya une couille dans la magouille : {}".format(parsed_content))
def api_get_request(self):
logger.debug("\n----------------- Sending request -----------------")
# creating credentials header
crd_header_value = QByteArray()
crd_header_value.append(self.token)
crd_header_name = QByteArray()
crd_header_name.append("Authorization")
# creating request
rqst = QNetworkRequest(QUrl(self.request_url))
# setting credentials header
rqst.setRawHeader(crd_header_name, crd_header_value) # sending request
rqst_reply = self.naMngr.get(rqst)
rqst_reply.finished.connect(partial(self.api_handle_request, reply=rqst_reply))
def api_handle_request(self, reply):
logger.debug("Request sent and API reply received")
bytarray = reply.readAll()
content = bytarray.data().decode("utf8")
if reply.error() == 0:
# check API response structure
try:
parsed_content = json.loads(content)
except:
logger.debug("Reply format issue")
return
# check API response content
self.tags_found = parsed_content.get("tags")
self.kw_found = {}
for tag in sorted(self.tags_found):
if tag.startswith("keyword:is"):
self.kw_found[tag] = self.tags_found.get(tag)
else:
pass
# displaying result
self.ui.lbl_found.setText(
"Found : {} resources and {} keywords".format(
parsed_content.get("total"), len(self.kw_found)
)
)
if self.search_type == "init":
if len(self.kw_found) == self.kw_expected_nb:
logger.debug("!!! It's working !!!")
else:
logger.debug("It's NOT working")
else:
pass
# filling keywords checkable combo box
self.pop_kw_cbbox()
elif self.search_type != "init":
logger.debug("token expired, renewing it")
self.api_authentification()
else:
pass
def pop_kw_cbbox(self):
logger.debug("\n-------------- Poping Keywords ComboBox --------------")
# to prepare the filling
self.ui.kw_cbbox.clear()
if self.search_type != "init":
self.ui.kw_cbbox.activated.disconnect(self.get_checked_kw)
# filling the combobox with checkable items
self.ui.kw_cbbox.addItem("-- Keywords --")
first_item = self.ui.kw_cbbox.model().item(0, 0)
first_item.setEnabled(False)
i = 1
for kw_code, kw_lbl in self.kw_found.items():
if self.search_type == "kw" and kw_code in self.checked_kw.keys():
self.ui.kw_cbbox.insertItem(1, kw_lbl)
item = self.ui.kw_cbbox.model().item(1, 0)
item.setCheckState(Qt.Checked)
else:
self.ui.kw_cbbox.addItem(kw_lbl)
item = self.ui.kw_cbbox.model().item(i, 0)
item.setCheckState(Qt.Unchecked)
item.setData(kw_code, 32)
i += 1
logger.debug("Keywords Combobox filled")
self.ui.kw_cbbox.setEnabled(True)
# connecting to a signal returning the checked item's index
self.ui.kw_cbbox.activated.connect(self.get_checked_kw)
def get_checked_kw(self, index):
logger.debug("\n------------ Getting Checked Keywords ------------")
self.ui.kw_cbbox.setEnabled(False)
self.ui.kw_cbbox.setCurrentText(self.ui.kw_cbbox.itemText(index))
# Testing if checked keyword is already in the dict is easier than
# testing if the user checked or unchecked it :
# removing the selected keyword from the dict if it is already in
if self.ui.kw_cbbox.itemData(index, 32) in self.checked_kw.keys():
del self.checked_kw[self.ui.kw_cbbox.itemData(index, 32)]
# adding the selected keyword to the dict if it is not already in
else:
self.checked_kw[
self.ui.kw_cbbox.itemData(index, 32)
] = self.ui.kw_cbbox.itemText(index)
logger.debug("ckeched kw : {}".format(self.checked_kw))
self.ui.lbl_selection.setText(
"{} keywords selected".format(len(self.checked_kw))
)
self.ui.kw_cbbox.setToolTip(" / ".join(list(self.checked_kw.values())))
# now selected keywords are stocked, time to request the API
self.kw_search()
def kw_search(self):
logger.debug("\n------------ Searching with keywords -------------")
# preparing the request
self.search_type = "kw"
self.request_url = self.url_builder()
self.pysdk_checking()
# launching the request
self.api_get_request()
def url_builder(self):
logger.debug("\n------------------ Building URL ------------------")
# adding selected keywords to the request URL
search_url = "https://v1.api.isogeo.com/resources/search?q="
for kw in self.checked_kw:
search_url += "{} ".format(str(kw))
logger.debug("URL : {}".format(search_url))
return search_url[:-1]
def reset(self):
logger.debug("----------------- RESET -------------------")
self.search_type = "reset"
self.checked_kw = {}
self.request_url = (
"https://v1.api.isogeo.com/resources/search?_limit=0&_offset=0"
)
self.ui.lbl_selection.setText("")
self.ui.kw_cbbox.setToolTip("")
self.pysdk_checking()
self.api_get_request()
class ApiConnection:
def __init__(self, auth_file):
logger.debug(
"\n================== ISOGEO API WITH QT ==================")
# getting credentials :
logger.debug("Getting credentials")
self.utils = IsogeoUtils()
self.app_creds = self.utils.credentials_loader(auth_file)
self.app_id = self.app_creds.get("client_id")
self.app_secrets = self.app_creds.get("client_secret")
# for connection :
self.naMngr = QNetworkAccessManager()
self.token_url = "https://id.api.isogeo.com/oauth/token"
self.request_url = (
"https://v1.api.isogeo.com/resources/search?_limit=0&_offset=0")
self.token = ""
# for ui :
logger.debug("Processing and displaying UI")
self.app = QApplication([])
self.ui = AuthWidget()
self.ui.resize(350, 100)
self.ui.btn.clicked.connect(self.api_authentification)
self.pysdk_checking()
self.ui.show()
self.app.exec()
def pysdk_checking(self):
logger.debug("\n------------------ isogeo-pysdk ------------------")
logger.debug("Checking credentials")
try:
isogeo = Isogeo(self.app_id, self.app_secrets)
isogeo.connect()
except OSError as e:
logger.debug("Credentials issue : {}".format(e))
return
except ValueError as e:
logger.debug("Credentials issue : {}".format(e))
return
self.md_expected = isogeo.search(whole_share=0, page_size=0,
augment=0).get("total")
self.ui.lbl_expected.setText("{} expected resources".format(
self.md_expected))
logger.debug(
"isogeo-pysdk validates the authentication file, {} accessible resources"
.format(self.md_expected))
def api_authentification(self):
logger.debug("\n------------------ Authentication ------------------")
# creating credentials header
logger.debug("Creating credentials header")
crd_header_value = QByteArray()
crd_header_value.append("Basic ")
crd_header_value.append(
base64.b64encode("{}:{}".format(self.app_id,
self.app_secrets).encode()))
crd_header_name = QByteArray()
crd_header_name.append("Authorization")
# creating Content-Type header
logger.debug("Creating 'Content-Type' header")
ct_header_value = QByteArray()
ct_header_value.append("application/json")
# creating request
token_rqst = QNetworkRequest(QUrl(self.token_url))
logger.debug("Creating token request : {}".format(token_rqst.url()))
# setting headers
token_rqst.setRawHeader(crd_header_name, crd_header_value)
logger.debug("Setting credentials header : {}".format(
token_rqst.rawHeader(crd_header_name)))
token_rqst.setHeader(token_rqst.ContentTypeHeader, ct_header_value)
logger.debug("Setting 'Content-Type' header : {}".format(
token_rqst.header(token_rqst.ContentTypeHeader)))
# creating data
data = QByteArray()
data.append(urlencode({"grant_type": "client_credentials"}))
logger.debug("Creating data : {}".format(data))
# requesting and handle reply
logger.debug("Asking for token")
token_reply = self.naMngr.post(token_rqst, data)
token_reply.finished.connect(
partial(self.api_handle_token, reply=token_reply))
def api_handle_token(self, reply):
logger.debug("\n------------------ Token retrieval ------------------")
logger.debug("Token asked and API reply received : {}".format(reply))
logger.debug("Storage and formatting of the reply")
bytarray = reply.readAll()
content = bytarray.data().decode("utf8")
# check API response structure
try:
parsed_content = json.loads(content)
except:
logger.debug("Reply format issue")
return
logger.debug("Reply format is good")
if "access_token" in parsed_content:
self.token = "Bearer " + parsed_content.get("access_token")
logger.debug("TOKEN STORED")
self.api_get_request()
else:
logger.debug(
"ya une couille dans la magouille : {}".format(parsed_content))
def api_get_request(self):
logger.debug("\n------------------ Sending request ------------------")
# creating credentials header
logger.debug("Creating credentials header")
crd_header_value = QByteArray()
crd_header_value.append(self.token)
crd_header_name = QByteArray()
crd_header_name.append("Authorization")
# creating request
rqst = QNetworkRequest(QUrl(self.request_url))
logger.debug("Creating request : {}".format(rqst.url()))
# setting credentials header
rqst.setRawHeader(crd_header_name, crd_header_value)
logger.debug("Setting credentials header : {}".format(
rqst.rawHeader(crd_header_name)))
# sending request
rqst_reply = self.naMngr.get(rqst)
logger.debug("Sending request")
rqst_reply.finished.connect(
partial(self.api_handle_request, reply=rqst_reply))
def api_handle_request(self, reply):
logger.debug("\n------------------ Reply retrieval ------------------")
logger.debug("Request sent and API reply received : {}".format(reply))
logger.debug("Storage and formatting of the reply")
bytarray = reply.readAll()
content = bytarray.data().decode("utf8")
# check API response structure
try:
parsed_content = json.loads(content)
except:
logger.debug("Reply format issue")
return
logger.debug("Reply format is good")
self.md_found = parsed_content.get("total")
logger.debug("RESULT STORED")
self.ui.lbl_found.setText("{} resources found".format(self.md_found))
if self.md_found == self.md_expected:
logger.debug("!!! It's working !!!")
else:
logger.debug("It's NOT working")
# secret key
app.secret_key = urandom(24)
# upload
Path(environ.get("UPLOAD_FOLDER")).mkdir(exist_ok=True)
app.config["UPLOAD_FOLDER"] = Path(environ.get("UPLOAD_FOLDER"))
app.config["MAX_CONTENT_LENGTH"] = 16 * 1024 * 1024
# logging
logger = logging.getLogger("IsogeoFlask")
# oAuth2 settings from client_secrets.json
utils = utils()
try:
api = utils.credentials_loader(environ.get("CREDENTIALS_FILE"))
ISOGEO_API_URL_BASE = api.get("uri_base")
ISOGEO_OAUTH_CLIENT_ID = api.get("client_id")
ISOGEO_OAUTH_CLIENT_SECRET = api.get("client_secret")
ISOGEO_OAUTH_URL_301 = "https://localhost:3000/login/callback"
ISOGEO_OAUTH_URL_AUTH = api.get("uri_auth")
ISOGEO_OAUTH_URL_TOKEN = api.get("uri_token")
ISOGEO_OAUTH_URL_TOKEN_REFRESH = ISOGEO_OAUTH_URL_TOKEN
ISOGEO_OAUTH_CREDENTIALS = 1
except OSError as e:
logger.error(e)
ISOGEO_OAUTH_CREDENTIALS = 0
# SSL verify
if environ.get("OAUTHLIB_INSECURE_TRANSPORT"):
ssl_opt = 0