def __init__(self, parent, iface, chunks, playlistUrl, mimeType, encoding):
super(Streaming, self).__init__()
self.DEBUG = True
# Variables from other classes
self.parent = parent # For GUI access
self.iface = iface
self.chunks = chunks
self.playlistUrl = playlistUrl
self.mimeType = mimeType
self.encoding = encoding
# Internal variables
self.__endTag = "#PLAYLIST-END"
self.__exceptionTag = "#EXCEPTION"
self.__exceptionUrl = ""
self.__exceptionFound = False
self.__playlistFinished = False # Did the end tag appeared?
self.__bytesInlastReply = 0 # To compare last and current reply sizes
self.__loadedChunks = 0 # For keeping track of # of loaded (to local vars) chunks
self.__deliveredChunks = 0 # For keeping track of # of loaded (to the map) chunks
self.__bFirstChunk = True
self.__features = {} # {0:[f0,f1,f2], 1:[f0,f1]}
self.__bGeomMulti = False # Is the geometry multi{point|line|polygon}
self.__geometryType = "" # Values: "Point","LineString","Polygon","Unknown", "NoGeometry"
self.__tmpGeometry = {} # For visualization purposes {chunkId1: rb1, chunkId2: rb2 }
self.__memoryLayer = None # The whole merged data
# For rasters only
self.__legend = self.iface.legendInterface()
self.__groupIndex = 0
self.__chunksDir = None
self.__virtualFile = "" # Virtual raster file path
if isMimeTypeRaster(self.mimeType, True) != None:
self.__chunksDir = tempfile.mkdtemp(prefix="tmpChunks")
# Other objects
self.timer = QTimer()
self.timer.setInterval(1 * 1000) # 1 second
self.QNAM4Playlist = QNetworkAccessManager()
self.QNAM4Chunks = QNetworkAccessManager()
self.QNAM4Exception = QNetworkAccessManager()
# SIGNAL/SLOT connections
self.playlistHandled.connect(self.fetchChunks)
self.urlReady.connect(self.fetchResult)
self.dataReady.connect(self.loadData)
self.timer.timeout.connect(partial(self.fetchPlaylist, self.playlistUrl))
self.QNAM4Playlist.finished.connect(self.handlePlaylist)
self.QNAM4Chunks.finished.connect(self.handleChunk)
self.QNAM4Exception.finished.connect(self.handleException)
#self.QNAM4Playlist = QgsNetworkAccessManager.instance()
#theReply2.error.connect(self.handleErrors)
# GUI
self.parent.progressBar.setRange(0,0)
self.parent.lblProcess.setText("Reading output playlist...")
def __init__(self, *args, **kwargs):
self.app = QApplication(sys.argv)
self.option_defaults.update(kwargs)
for k, v in self.option_defaults.items():
if isinstance(v, basestring):
if k in ['margin_left', 'margin_right', 'margin_top', 'margin_bottom']:
v = self.parseUnitReal(v)
if k == 'pageSize':
v = self.setPageSize(v)
if k == 'orientation':
v = self.setOrientation(v)
if k == 'colorMode':
v = self.setColorMode(v)
setattr(self, k, v)
if len(args) < 2:
self.app.quit(1)
raise Exception(
'You need to specify atleast one input file, and exactly one output file\nUse - for stdin or stdout\n\n')
args = list(args)
self.out = args.pop(-1)
self.in_ = args
self.pageNum = 0
self.pages = []
self.am = QNetworkAccessManager()
self.am.connect(self.am, SIGNAL("sslErrors(QNetworkReply*, const QList<QSslError>&)"), self.sslErrors)
self.loading = 0
self.quiet = True
def __init__(self, parent=None, iface=None):
"""Constructor for import dialog.
:param parent: Optional widget to use as parent
:type parent: QWidget
:param iface: An instance of QGisInterface
:type iface: QGisInterface
"""
QDialog.__init__(self, parent)
self.parent = parent
self.setupUi(self)
self.setWindowTitle(self.tr('InaSAFE OpenStreetMap Downloader'))
self.iface = iface
self.url = "http://osm.linfiniti.com/buildings-shp"
# creating progress dialog for download
self.progressDialog = QProgressDialog(self)
self.progressDialog.setAutoClose(False)
myTitle = self.tr("InaSAFE OpenStreetMap Downloader")
self.progressDialog.setWindowTitle(myTitle)
self.show_info()
self.network_manager = QNetworkAccessManager(self)
self.restore_state()
self.update_extent()
def __init__(self, client, *args, **kwargs):
BaseClass.__init__(self, *args, **kwargs)
self.setupUi(self)
self.client = client
self.client.coopTab.layout().addWidget(self)
#Dictionary containing our actual games.
self.games = {}
#Ranked search UI
self.ispassworded = False
self.loaded = False
self.coop = {}
self.cooptypes = {}
self.canChooseMap = False
self.options = []
self.client.showCoop.connect(self.coopChanged)
self.client.coopInfo.connect(self.processCoopInfo)
self.client.gameInfo.connect(self.processGameInfo)
self.coopList.header().setResizeMode(
0, QtGui.QHeaderView.ResizeToContents)
self.coopList.setItemDelegate(CoopMapItemDelegate(self))
self.gameList.setItemDelegate(GameItemDelegate(self))
self.gameList.itemDoubleClicked.connect(self.gameDoubleClicked)
self.coopList.itemDoubleClicked.connect(self.coopListDoubleClicked)
self.coopList.itemClicked.connect(self.coopListClicked)
self.client.coopLeaderBoard.connect(self.processLeaderBoardInfos)
self.tabLeaderWidget.currentChanged.connect(self.askLeaderBoard)
self.linkButton.clicked.connect(self.linkVanilla)
#Load game name from settings (yay, it's persistent!)
self.load_last_hosted_settings()
self.leaderBoard.setVisible(0)
self.stylesheet = util.readstylesheet("coop/formatters/style.css")
self.FORMATTER_LADDER = unicode(
util.readfile("coop/formatters/ladder.qthtml"))
self.FORMATTER_LADDER_HEADER = unicode(
util.readfile("coop/formatters/ladder_header.qthtml"))
self.leaderBoard.setStyleSheet(self.stylesheet)
self.leaderBoardTextGeneral.anchorClicked.connect(self.openUrl)
self.leaderBoardTextOne.anchorClicked.connect(self.openUrl)
self.leaderBoardTextTwo.anchorClicked.connect(self.openUrl)
self.leaderBoardTextThree.anchorClicked.connect(self.openUrl)
self.leaderBoardTextFour.anchorClicked.connect(self.openUrl)
self.replayDownload = QNetworkAccessManager()
self.replayDownload.finished.connect(self.finishRequest)
self.selectedItem = None
def __init__(self, iface, data, fallback = False):
QObject.__init__(self)
self.iface = iface
self.canvas = self.iface.mapCanvas()
self.fallback = fallback
self.settings = QSettings("CatAIS","GeoAdminSearch")
self.wmtsCapabilitities = self.settings.value("services/wmtscapabilities", "http://api3.geo.admin.ch/rest/services/api/1.0.0/WMTSCapabilities.xml")
self.settings = QSettings("CatAIS","GeoAdminSearch")
searchLanguage = self.settings.value("options/language", "de")
self.userName = self.settings.value("options/username", "")
self.password = self.settings.value("options/password", "")
self.layerName = data['layer']
url = self.wmtsCapabilitities
# It does not work:
# a) when networkAccess is not 'self'
# b) without lambda
self.networkAccess = QNetworkAccessManager()
self.connect(self.networkAccess, SIGNAL("finished(QNetworkReply*)"), lambda event, data=data: self.receiveWmtsCapabilities(event, data))
self.networkAccess.get(QNetworkRequest(QUrl(url)))
def cbUserData(self, data):
if 'error' in data:
# TODO Create image for error
self.nameLB.setText(
"<html><head/><body><p><span style=\" text-decoration: underline; color:red;\">error</span></p></body></html>"
)
self.error.emit(data['error'])
return
self.currentUserData = data
self.settings.setValue('/CartoDBPlugin/selected', self.currentUser)
manager = QNetworkAccessManager()
manager.finished.connect(self.returnAvatar)
if 's3.amazonaws.com' in data['avatar_url']:
imageUrl = QUrl(data['avatar_url'])
else:
imageUrl = QUrl('http:' + data['avatar_url'])
request = QNetworkRequest(imageUrl)
request.setRawHeader('User-Agent', 'QGIS 2.x')
reply = manager.get(request)
loop = QEventLoop()
reply.finished.connect(loop.exit)
loop.exec_()
def getUpdateInfo(self):
verurl = 'http://tortoisehg.bitbucket.org/curversion.txt'
# If we use QNetworkAcessManager elsewhere, it should be shared
# through the application.
self._netmanager = QNetworkAccessManager(self)
self._newverreply = self._netmanager.get(QNetworkRequest(QUrl(verurl)))
self._newverreply.finished.connect(self.uFinished)
def __init__(self, *args, **kwargs):
"""Initialize this instance."""
super(WebClient, self).__init__(*args, **kwargs)
self.nam = QNetworkAccessManager(QCoreApplication.instance())
self.nam.finished.connect(self._handle_finished)
self.nam.authenticationRequired.connect(self._handle_authentication)
self.nam.proxyAuthenticationRequired.connect(self.handle_proxy_auth)
self.nam.sslErrors.connect(self._handle_ssl_errors)
self.replies = {}
self.proxy_retry = False
self.setup_proxy()
# Force Qt to load the system certificates
QSslSocket.setDefaultCaCertificates(QSslSocket.systemCaCertificates())
# Apply our local certificates as the SSL configuration to be used
# for all QNetworkRequest calls.
self.ssl_config = QSslConfiguration.defaultConfiguration()
ca_certs = self.ssl_config.caCertificates()
try:
for path in glob.glob(
os.path.join(get_cert_dir(), "UbuntuOne*.pem")):
with open(path) as f:
cert = QSslCertificate(f.read())
if cert.isValid():
ca_certs.append(cert)
else:
logger.error("invalid certificate: {}".format(path))
except (IndexError, IOError) as err:
raise WebClientError(
"Unable to configure SSL certificates: {}".format(err))
self.ssl_config.setCaCertificates(ca_certs)
def test_download(self):
"""Test download."""
manager = QNetworkAccessManager(PARENT)
# NOTE(gigih):
# this is the hash of google front page.
# I think we can safely assume that the content
# of google.com never changes (probably).
# ...or not...changed on 5 Dec 2013 ...
# ...and changed on 28 Apr 2014 by Tim to hash and url below
# ...and change on 9 Des 2014 by Akbar to hash and url below
unique_hash = '57e396baedfe1a034590339082b9abce'
url = 'https://www.google.com/images/srpr/logo11w.png'
path = tempfile.mktemp()
file_downloader = FileDownloader(manager, url, path)
try:
result = file_downloader.download()
except IOError as ex:
raise IOError(ex)
if result[0] is not True:
_, error_message = result
raise DownloadError(error_message)
assert_hash_for_file(unique_hash, path)
def __init__(self, iface, data, fallback=False):
QObject.__init__(self)
self.iface = iface
self.canvas = self.iface.mapCanvas()
self.fallback = fallback
self.settings = QSettings("CatAIS", "GeoAdminSearch")
mapServer = self.settings.value(
"services/mapserver",
"https://api3.geo.admin.ch/rest/services/api/MapServer")
self.settings = QSettings("CatAIS", "GeoAdminSearch")
searchLanguage = self.settings.value("options/language", "de")
self.userName = self.settings.value("options/username", "")
self.password = self.settings.value("options/password", "")
self.layerName = data['layer']
url = mapServer + "?searchText="
url += self.layerName.strip()
url += "&lang=" + searchLanguage
# It does not work:
# a) when networkAccess is not 'self'
# b) without lambda
self.networkAccess = QNetworkAccessManager()
self.connect(
self.networkAccess,
SIGNAL("finished(QNetworkReply*)"),
lambda event, data=data: self.receiveLayerMetadata(event, data))
self.networkAccess.get(QNetworkRequest(QUrl(url)))
def __init__(self, parent=None):
"""Constructor."""
QDockWidget.__init__(self, parent)
self.setupUi(self)
self.SEARCH_URL = "http://www.catais.org/wsgi/search_metadb_sogis.wsgi?query="
self.toolButtonReset.setIcon(QIcon(':/plugins/sogisbrowser/icons/reset.svg'))
today = QDateTime.currentDateTime()
self.dateEdit.setDateTime(today)
self.dateEdit.setCalendarPopup(True)
self.treeWidget = SogisBrowserTreeWidget()
self.gridLayout.addWidget(self.treeWidget)
# self.dateEdit.setLocale(QLocale(QLocale.German)); # Qt Designer
font = QFont()
font.setPointSize(10)
self.treeWidget.setFont(font)
self.networkManager = QNetworkAccessManager(self)
self.connect(self.networkManager, SIGNAL("finished(QNetworkReply*)"), self.handleNetworkData)
QObject.connect(self.toolButtonReset, SIGNAL("clicked()"), self.resetSuggest)
def download(self, sql):
apiUrl = 'http://{}.{}/api/v2/sql?api_key={}&format=spatialite&q={}'.format(
self.cartodbUser, self.hostname, self.apiKey, sql)
url = QUrl(apiUrl)
request = self._getRequest(url)
def finished(reply):
tempdir = tempfile.tempdir
if tempdir is None:
tempdir = tempfile.mkdtemp()
tf = tempfile.NamedTemporaryFile(delete=False)
sqlite = QFile(tf.name)
tf.close()
if (sqlite.open(QIODevice.WriteOnly)):
sqlite.write(reply.readAll())
sqlite.close()
self.fetchContent.emit(tf.name)
else:
self.error.emit('Error saving downloaded file')
manager = QNetworkAccessManager()
manager.finished.connect(finished)
reply = manager.get(request)
loop = QEventLoop()
reply.downloadProgress.connect(self.progressCB)
reply.error.connect(self._error)
reply.finished.connect(loop.exit)
loop.exec_()
def test_download(self):
"""Test download."""
manager = QNetworkAccessManager(PARENT)
# NOTE(gigih):
# this is the hash of google front page.
# I think we can safely assume that the content
# of google.com never changes (probably).
# ...or not...changed on 5 Dec 2013 ...
# ...and changed on 28 Apr 2014 by Tim to hash and url below
unique_hash = '32230a09ffe7b0011095e8cd627097a5'
url = 'http://inasafe.org/en/_static/img/logo.png'
path = tempfile.mktemp()
file_downloader = FileDownloader(
manager, url, path)
try:
result = file_downloader.download()
except IOError as ex:
raise IOError(ex)
if result[0] is not True:
_, error_message = result
raise DownloadError(error_message)
assert_hash_for_file(unique_hash, path)
def __init__(self, parent=None):
super(MikiEdit, self).__init__(parent)
self.parent = parent
self.settings = parent.settings
self.setFontPointSize(12)
self.setVisible(False)
self.ix = open_dir(self.settings.indexdir)
# Spell checker support
try:
import enchant
enchant.Dict()
self.speller = enchant.Dict()
except ImportError:
print("Spell checking unavailable. Need to install pyenchant.")
self.speller = None
except enchant.errors.DictNotFoundError:
print(
"Spell checking unavailable. Need to install dictionary (e.g. aspell-en)."
)
self.speller = None
self.imageFilter = ""
self.documentFilter = ""
for ext in self.settings.attachmentImage:
self.imageFilter += " *" + ext
for ext in self.settings.attachmentDocument:
self.documentFilter += " *" + ext
self.imageFilter = "Image (" + self.imageFilter.strip() + ")"
self.documentFilter = "Document (" + self.documentFilter.strip() + ")"
self.downloadAs = ""
self.networkManager = QNetworkAccessManager()
self.networkManager.finished.connect(self.downloadFinished)
def activate(self, engine):
"""
This method activates the Component.
:param engine: Engine to attach the Component to. ( QObject )
:return: Method success. ( Boolean )
"""
LOGGER.debug("> Activating '{0}' Component.".format(self.__class__.__name__))
self.__engine = engine
self.__settings = self.__engine.settings
self.__settingsSection = self.name
self.__preferencesManager = self.__engine.componentsManager["factory.preferencesManager"]
self.__templatesOutliner = self.__engine.componentsManager["core.templatesOutliner"]
self.__locationsBrowser = self.__engine.componentsManager["addons.locationsBrowser"]
self.__ioDirectory = os.path.join(self.__engine.userApplicationDataDirectory,
Constants.ioDirectory, self.__ioDirectory)
not foundations.common.pathExists(self.__ioDirectory) and os.makedirs(self.__ioDirectory)
self.__networkAccessManager = QNetworkAccessManager()
self.__reportUpdateStatus = True
self.activated = True
return True
def asyncGetLatestVersion(self, uuid, use_stats):
url = self.getRequestUrl(uuid, use_stats)
self.nam = QNetworkAccessManager()
self.nam.finished.connect(self.asyncGetLatestVersionComplete)
self.nam.get(QNetworkRequest(QUrl(str(url))))
def fetch_zip(url, output_path, feature_type, progress_dialog=None):
"""Download zip containing shp file and write to output_path.
.. versionadded:: 3.2
:param url: URL of the zip bundle.
:type url: str
:param output_path: Path of output file,
:type output_path: str
:param feature_type: What kind of features should be downloaded.
Currently 'buildings', 'building-points' or 'roads' are supported.
:type feature_type: str
:param progress_dialog: A progress dialog.
:type progress_dialog: QProgressDialog
:raises: ImportDialogError - when network error occurred
"""
LOGGER.debug('Downloading file from URL: %s' % url)
LOGGER.debug('Downloading to: %s' % output_path)
if progress_dialog:
progress_dialog.show()
# Infinite progress bar when the server is fetching data.
# The progress bar will be updated with the file size later.
progress_dialog.setMaximum(0)
progress_dialog.setMinimum(0)
progress_dialog.setValue(0)
# Get a pretty label from feature_type, but not translatable
label_feature_type = feature_type.replace('-', ' ')
label_text = tr('Fetching %s' % label_feature_type)
progress_dialog.setLabelText(label_text)
# Set Proxy in web page
proxy = get_proxy()
network_manager = QNetworkAccessManager()
if proxy is not None:
network_manager.setProxy(proxy)
# Download Process
downloader = FileDownloader(network_manager, url, output_path,
progress_dialog)
try:
result = downloader.download()
except IOError as ex:
raise IOError(ex)
if result[0] is not True:
_, error_message = result
if result[0] == QNetworkReply.OperationCanceledError:
raise CanceledImportDialogError(error_message)
else:
raise DownloadError(error_message)
def setRemotePixmap(self, url):
# Lazy creation of QNetworkManager, image download is asynchronous.
# When the image download is complete (ie the "finished" signal),
# the image data is read and drawn.
if self.connection is None:
self.connection = QNetworkAccessManager(self)
self.connection.finished.connect(self.pixmapReceived)
self.connection.get(QNetworkRequest(QUrl(url)))
def __init__(self, client, *args, **kwargs):
logger.debug("Lobby instantiating.")
BaseClass.__init__(self, *args, **kwargs)
self.setupUi(self)
self.client = client
#self.client.galacticwarTab.setStyleSheet(util.readstylesheet("galacticwar/galacticwar.css"))
self.COLOR_FACTIONS = {}
self.mapTransparency = 10
self.AA = True
self.rotation = True
self.stars = 25
self.GWOptions = GWOptions(self)
self.GWOptions.loadSettings()
self.client.galacticwarTab.layout().addWidget(self)
self.downloader = QNetworkAccessManager(self)
self.downloader.finished.connect(self.finishRequest)
self.shaderlist = []
self.texturelist = {}
self.shaders = {}
self.infoPanel = None
self.OGLdisplay = None
self.galaxy = Galaxy(self)
self.channel = None
self.initDone = False
self.uid = None
self.faction = None
self.name = None
self.rank = None
self.credits = 0
self.victories = 0
self.enslavedBy = None
self.attacks = {}
self.state = ClientState.NONE
## Network initialization
self.socket = QtNetwork.QTcpSocket()
self.socket.readyRead.connect(self.readFromServer)
self.socket.disconnected.connect(self.disconnectedFromServer)
self.socket.error.connect(self.socketError)
self.blockSize = 0
self.progress = QtGui.QProgressDialog()
self.progress.setMinimum(0)
self.progress.setMaximum(0)
def __init__(self, client, *args, **kwargs):
logger.debug("Lobby instantiating.")
BaseClass.__init__(self, *args, **kwargs)
SimpleIRCClient.__init__(self)
self.setupUi(self)
# CAVEAT: These will fail if loaded before theming is loaded
import json
self.OPERATOR_COLORS = json.loads(
util.readfile("chat/formatters/operator_colors.json"))
self.client = client
self.channels = {}
#avatar downloader
self.nam = QNetworkAccessManager()
self.nam.finished.connect(self.finishDownloadAvatar)
#nickserv stuff
self.identified = False
#IRC parameters
self.ircServer = IRC_SERVER
self.ircPort = IRC_PORT
self.crucialChannels = ["#aeolus"]
self.optionalChannels = []
#We can't send command until the welcom message is received
self.welcomed = False
# Load colors and styles from theme
self.specialUserColors = json.loads(
util.readfile("chat/formatters/special_colors.json"))
self.a_style = util.readfile("chat/formatters/a_style.qss")
#load UI perform some tweaks
self.tabBar().setTabButton(0, 1, None)
#add self to client's window
self.client.chatTab.layout().addWidget(self)
self.tabCloseRequested.connect(self.closeChannel)
#add signal handler for game exit
self.client.gameExit.connect(self.processGameExit)
self.replayInfo = fa.exe.instance.info
#Hook with client's connection and autojoin mechanisms
self.client.connected.connect(self.connect)
self.client.publicBroadcast.connect(self.announce)
self.client.autoJoin.connect(self.autoJoin)
self.client.channelsUpdated.connect(self.addChannels)
self.channelsAvailable = []
self.timer = QtCore.QTimer(self)
self.timer.timeout.connect(self.poll)
# disconnection checks
self.canDisconnect = False
def __init__(self, parent=None, iface=None):
"""Constructor for import dialog.
:param parent: Optional widget to use as parent
:type parent: QWidget
:param iface: An instance of QGisInterface
:type iface: QGisInterface
"""
QDialog.__init__(self, parent)
self.parent = parent
self.setupUi(self)
self.setWindowTitle(self.tr('InaSAFE OpenStreetMap Downloader'))
self.iface = iface
self.buildings_url = 'http://osm.linfiniti.com/buildings-shp'
self.building_points_url = \
'http://osm.linfiniti.com/building-points-shp'
self.roads_url = 'http://osm.linfiniti.com/roads-shp'
self.help_context = 'openstreetmap_downloader'
# creating progress dialog for download
self.progress_dialog = QProgressDialog(self)
self.progress_dialog.setAutoClose(False)
title = self.tr('InaSAFE OpenStreetMap Downloader')
self.progress_dialog.setWindowTitle(title)
# Set up context help
help_button = self.button_box.button(QtGui.QDialogButtonBox.Help)
help_button.clicked.connect(self.show_help)
self.show_info()
# set up the validator for the file name prefix
expression = QRegExp('^[A-Za-z0-9-_]*$')
validator = QRegExpValidator(expression, self.filename_prefix)
self.filename_prefix.setValidator(validator)
# Set Proxy in webpage
proxy = get_proxy()
self.network_manager = QNetworkAccessManager(self)
if proxy is not None:
self.network_manager.setProxy(proxy)
self.restore_state()
# Setup the rectangle map tool
self.canvas = iface.mapCanvas()
self.rectangle_map_tool = \
RectangleMapTool(self.canvas)
self.rectangle_map_tool.rectangle_created.connect(
self.update_extent_from_rectangle)
self.button_extent_rectangle.clicked.connect(
self.drag_rectangle_on_map_canvas)
# Setup pan tool
self.pan_tool = QgsMapToolPan(self.canvas)
self.canvas.setMapTool(self.pan_tool)
self.update_extent_from_map_canvas()
def __init__(self, parent=None):
self.client = parent
self.nam = QNetworkAccessManager()
self.nam.finished.connect(self.finishedDownload)
self.modRequests = {}
self.mapRequests = {}
self.mapRequestsItem = []
def __init__(self, supportUrl, parent=None):
super(GeniusBarReserser, self).__init__(parent)
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.supportUrl = supportUrl
# self.ui.webView.load(QUrl('http://www.apple.com/cn/retail/shanghaiiapm/'))
self.netWorkmgr = QNetworkAccessManager(self)
cookieJar = QNetworkCookieJar()
self.netWrokMgr.setCookieJar(cookieJar)
def run(self):
loop = QtCore.QEventLoop()
nm = QNetworkAccessManager()
reply = nm.get(QNetworkRequest(self.url))
reply.finished.connect(loop.quit)
loop.exec_()
data = reply.readAll()
self.resourceLoaded.emit(self.res_type, self.url, data)
reply.deleteLater()
nm.deleteLater()
def __init__(self):
QWebPage.__init__(self)
self.networkAccessManager = QNetworkAccessManager()
self.networkNoProxy = QNetworkProxy(QNetworkProxy.NoProxy)
self.networkProxy = QNetworkProxy(QNetworkProxy.HttpProxy, "127.0.0.1",
8087)
self.setNetworkAccessManager(self.networkAccessManager)
self.loadFinished.connect(self._loadFinished)
def __init__(self, client):
super(BaseClass, self).__init__()
self.setupUi(self)
#self.replayVault.setVisible(False)
self.client = client
client.replaysTab.layout().addWidget(self)
client.gameInfo.connect(self.processGameInfo)
client.replayVault.connect(self.replayVault)
self.onlineReplays = {}
self.onlineTree.setItemDelegate(ReplayItemDelegate(self))
self.replayDownload = QNetworkAccessManager()
self.replayDownload.finished.connect(self.finishRequest)
# sending request to replay vault
self.searchButton.pressed.connect(self.searchVault)
self.playerName.returnPressed.connect(self.searchVault)
self.mapName.returnPressed.connect(self.searchVault)
self.myTree.itemDoubleClicked.connect(self.myTreeDoubleClicked)
self.myTree.itemPressed.connect(self.myTreePressed)
self.myTree.header().setResizeMode(0,
QtGui.QHeaderView.ResizeToContents)
self.myTree.header().setResizeMode(1,
QtGui.QHeaderView.ResizeToContents)
self.myTree.header().setResizeMode(2, QtGui.QHeaderView.Stretch)
self.myTree.header().setResizeMode(3,
QtGui.QHeaderView.ResizeToContents)
self.liveTree.itemDoubleClicked.connect(self.liveTreeDoubleClicked)
self.liveTree.itemPressed.connect(self.liveTreePressed)
self.liveTree.header().setResizeMode(
0, QtGui.QHeaderView.ResizeToContents)
self.liveTree.header().setResizeMode(1, QtGui.QHeaderView.Stretch)
self.liveTree.header().setResizeMode(
2, QtGui.QHeaderView.ResizeToContents)
self.games = {}
self.onlineTree.itemDoubleClicked.connect(self.onlineTreeDoubleClicked)
self.onlineTree.itemPressed.connect(self.onlineTreeClicked)
# replay vault connection to server
self.searching = False
self.blockSize = 0
self.replayVaultSocket = QtNetwork.QTcpSocket()
self.replayVaultSocket.error.connect(self.handleServerError)
self.replayVaultSocket.readyRead.connect(self.readDataFromServer)
self.replayVaultSocket.disconnected.connect(self.disconnected)
self.replayVaultSocket.error.connect(self.errored)
logger.info("Replays Widget instantiated.")
def __init__(self, parent=None, signalManager=None,
title="Databases Pack"):
super(OWDatabasesPack, self).__init__(
parent, signalManager, title, wantMainArea=False)
self.fileslist = [("Taxonomy", "ncbi_taxonomy.tar.gz")]
self.downloadurl = "https://dl.dropboxusercontent.com/u/100248799/sf_pack.tar.gz"
self.downloadmessage = (
"Downloading a subset of available databases for a smoother " +
"ride through the workshop"
)
self.loadSettings()
self._tmpfile = None
self.reply = None
# Locks held on server files
self.locks = []
self.net_manager = QNetworkAccessManager()
# Lock all files in files list so any other (in process) atempt to
# download the files waits)
box = OWGUI.widgetBox(self.controlArea, "Info")
self.info = OWGUI.widgetLabel(box, self.downloadmessage)
self.info.setWordWrap(True)
box = OWGUI.widgetBox(self.controlArea, "Status")
self.statusinfo = OWGUI.widgetLabel(box, "Please wait")
self.statusinfo.setWordWrap(True)
self.progressbar = QProgressBar()
box.layout().addWidget(self.progressbar)
self.setMinimumWidth(250)
already_available = [(domain, filename)
for domain in serverfiles.listdomains()
for filename in serverfiles.listfiles(domain)]
if set(self.fileslist) <= set(already_available):
# All files are already downloaded
self.statusinfo.setText("All files already available")
self.setStatusMessage("Done")
else:
for domain, filename in self.fileslist + [("_tmp_cache_", "pack")]:
manager = serverfiles._lock_file(domain, filename)
try:
manager.__enter__()
except Exception:
warnings.warn("Could not acquire lock for {0} {0}"
.format(domain, filename))
self.warning(0, "...")
else:
self.locks.append(manager)
QTimer.singleShot(0, self.show)
QTimer.singleShot(0, self.run)
def __init__(self, parent):
QWidget.__init__(self, parent)
http = QNetworkAccessManager()
self.weatherText = self.trUtf8("正在查询天气情况...")
self.pixmap = QPixmap()
self.setContextMenuPolicy(Qt.ActionsContextMenu)
# self.actionConfigure=QAction(QIcon(":/images/configure.png"), self.trUtf8("配置(&C)..."), None)
# self.actionConfigure.triggered.connect(self.configure)
# self.addAction(self.actionConfigure)
self.provider = LiqweiProvider(http)
self.provider.gotResult.connect(self.setResult)
def asyncFetchAlternateCoverURLs(self, issue_id, issue_page_url):
# This async version requires the issue page url to be provided!
self.issue_id = issue_id
url_list = self.fetchCachedAlternateCoverURLs(issue_id)
if url_list is not None:
self.altUrlListFetchComplete.emit(url_list, int(self.issue_id))
return
self.nam = QNetworkAccessManager()
self.nam.finished.connect(self.asyncFetchAlternateCoverURLsComplete)
self.nam.get(QNetworkRequest(QUrl(str(issue_page_url))))
def asyncFetchIssueCoverURLs( self, issue_id ): self.issue_id = issue_id details = self.fetchCachedIssueSelectDetails( issue_id ) if details['image_url'] is not None: self.urlFetchComplete.emit( details['image_url'],details['thumb_image_url'], self.issue_id ) return issue_url = self.api_base_url + "/issue/" + CVTypeID.Issue + "-" + str(issue_id) + "/?api_key=" + self.api_key + "&format=json&field_list=image,cover_date,site_detail_url" self.nam = QNetworkAccessManager() self.nam.finished.connect( self.asyncFetchIssueCoverURLComplete ) self.nam.get(QNetworkRequest(QUrl(issue_url)))
