def __init__(self, parent=None):
super(HttpWindow, self).__init__(parent)
self.url = QUrl()
self.qnam = QNetworkAccessManager()
self.reply = None
self.outFile = None
self.httpGetId = 0
self.httpRequestAborted = False
self.urlLineEdit = QLineEdit('https://qt-project.org')
urlLabel = QLabel("&URL:")
urlLabel.setBuddy(self.urlLineEdit)
self.statusLabel = QLabel(
"Please enter the URL of a file you want to download.")
self.statusLabel.setWordWrap(True)
self.downloadButton = QPushButton("Download")
self.downloadButton.setDefault(True)
self.quitButton = QPushButton("Quit")
self.quitButton.setAutoDefault(False)
buttonBox = QDialogButtonBox()
buttonBox.addButton(self.downloadButton, QDialogButtonBox.ActionRole)
buttonBox.addButton(self.quitButton, QDialogButtonBox.RejectRole)
self.progressDialog = QProgressDialog(self)
self.urlLineEdit.textChanged.connect(self.enableDownloadButton)
self.qnam.authenticationRequired.connect(
self.slotAuthenticationRequired)
self.qnam.sslErrors.connect(self.sslErrors)
self.progressDialog.canceled.connect(self.cancelDownload)
self.downloadButton.clicked.connect(self.downloadFile)
self.quitButton.clicked.connect(self.close)
topLayout = QHBoxLayout()
topLayout.addWidget(urlLabel)
topLayout.addWidget(self.urlLineEdit)
mainLayout = QVBoxLayout()
mainLayout.addLayout(topLayout)
mainLayout.addWidget(self.statusLabel)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle("HTTP")
self.urlLineEdit.setFocus()
def __init__(self, client, playerset, me, *args, **kwargs):
if not self.use_chat:
logger.info("Disabling chat")
return
logger.debug("Lobby instantiating.")
BaseClass.__init__(self, *args, **kwargs)
SimpleIRCClient.__init__(self)
self.setupUi(self)
self.client = client
self._me = me
self._chatters = IrcUserset(playerset)
self.channels = {}
# avatar downloader
self.nam = QNetworkAccessManager()
self.nam.finished.connect(self.finish_download_avatar)
# nickserv stuff
self.identified = False
# IRC parameters
self.crucialChannels = ["#aeolus"]
self.optionalChannels = []
# We can't send command until the welcome message is received
self.welcomed = False
# Load colors and styles from theme
self.a_style = util.THEME.readfile("chat/formatters/a_style.qss")
# load UI perform some tweaks
self.tabBar().setTabButton(0, 1, None)
self.tabCloseRequested.connect(self.close_channel)
# Hook with client's connection and autojoin mechanisms
self.client.authorized.connect(self.connect)
self.client.autoJoin.connect(self.auto_join)
self.channelsAvailable = []
self._notifier = None
self._timer = QTimer()
self._timer.timeout.connect(self.once)
# disconnection checks
self.canDisconnect = False
def __init__(self):
super().__init__()
self._zero_conf = None
self._zero_conf_browser = None
# Create a cloud output device manager that abstracts all cloud connection logic away.
self._cloud_output_device_manager = CloudOutputDeviceManager()
# Because the model needs to be created in the same thread as the QMLEngine, we use a signal.
self.addDeviceSignal.connect(self._onAddDevice)
self.removeDeviceSignal.connect(self._onRemoveDevice)
Application.getInstance().globalContainerStackChanged.connect(
self.reCheckConnections)
self._discovered_devices = {}
self._network_manager = QNetworkAccessManager()
self._network_manager.finished.connect(self._onNetworkRequestFinished)
self._min_cluster_version = Version("4.0.0")
self._api_version = "1"
self._api_prefix = "/api/v" + self._api_version + "/"
self._cluster_api_version = "1"
self._cluster_api_prefix = "/cluster-api/v" + self._cluster_api_version + "/"
# Get list of manual instances from preferences
self._preferences = Application.getInstance().getPreferences()
self._preferences.addPreference(
"um3networkprinting/manual_instances",
"") # A comma-separated list of ip adresses or hostnames
self._manual_instances = self._preferences.getValue(
"um3networkprinting/manual_instances").split(",")
# Store the last manual entry key
self._last_manual_entry_key = "" # type: str
# The zero-conf service changed requests are handled in a separate thread, so we can re-schedule the requests
# which fail to get detailed service info.
# Any new or re-scheduled requests will be appended to the request queue, and the handling thread will pick
# them up and process them.
self._service_changed_request_queue = Queue()
self._service_changed_request_event = Event()
self._service_changed_request_thread = Thread(
target=self._handleOnServiceChangedRequests, daemon=True)
self._service_changed_request_thread.start()
def download_chlists(self, subscriptions):
self.load_user_chlist()
self.load_cached_chlists(subscriptions)
urls = []
for subscription in subscriptions:
if subscription[0] == True:
urls.append(QUrl(subscription[1]))
self.access_manager = QNetworkAccessManager()
self.access_manager.finished.connect(self.handle_response)
for url in urls:
request = QNetworkRequest()
request.setUrl(url)
self.access_manager.get(request)
def _createNetworkManager(self) -> None:
Logger.log("d", "Creating network manager")
if self._manager:
self._manager.finished.disconnect(self.__handleOnFinished)
self._manager.authenticationRequired.disconnect(
self._onAuthenticationRequired)
self._manager = QNetworkAccessManager()
self._manager.finished.connect(self.__handleOnFinished)
self._last_manager_create_time = time()
self._manager.authenticationRequired.connect(
self._onAuthenticationRequired)
machine_manager = CuraApplication.getInstance().getMachineManager()
machine_manager.checkCorrectGroupName(self.getId(), self.name)
def __init__(self):
super().__init__()
self.commandslist = {
"eval": self.evaluate,
"print": self.printexpression,
"split": self.splitup,
"ans": self.instantanswer
}
evalcolor = QColor("#FF5742")
googlecolor = QColor("#4285F4")
self.colors = {"eval": evalcolor, "ans": googlecolor}
self.aeval = Interpreter()
self.network = QNetworkAccessManager()
def start(self):
# Ensure that previous requests (if any) are stopped.
self.stop()
if self._target is None:
Logger.log("w", "Unable to start camera stream without target!")
return
self._started = True
url = QUrl(self._target)
self._image_request = QNetworkRequest(url)
if self._manager is None:
self._manager = QNetworkAccessManager()
self._image_reply = self._manager.get(self._image_request)
self._image_reply.downloadProgress.connect(
self._onStreamDownloadProgress)
def start(self) -> None:
self.stop() # Ensure that previous requests (if any) are stopped.
if not self._source_url:
Logger.log("w", "Unable to start camera stream without target!")
return
self._started = True
Logger.log("w", "MJPEG starting stream...")
self._image_request = QNetworkRequest(self._source_url)
if self._network_manager is None:
self._network_manager = QNetworkAccessManager()
self._image_reply = self._network_manager.get(self._image_request)
self._image_reply.downloadProgress.connect(
self._onStreamDownloadProgress)
def __init__(self):
super().__init__()
self.title = "OraDocs by littleT"
self.left = 10
self.top = 10
self.width = 600
self.height = 400
self.initUI()
self.url = QUrl()
self.qnam = QNetworkAccessManager()
self.reply = None
self.outFile = None
self.httpGetId = 0
self.httpRequestAborted = False
def _createNetworkManager(self) -> None:
Logger.log("d", "Creating network manager")
if self._manager:
self._manager.finished.disconnect(self._handleOnFinished)
self._manager.authenticationRequired.disconnect(
self._onAuthenticationRequired)
self._manager = QNetworkAccessManager()
self._manager.finished.connect(self._handleOnFinished)
self._last_manager_create_time = time()
self._manager.authenticationRequired.connect(
self._onAuthenticationRequired)
if self._properties.get(b"temporary", b"false") != b"true":
self._checkCorrectGroupName(self.getId(), self.name)
def __init__(self, args):
QApplication.__init__(self, args)
self.__class__.INSTANCE = self
if (opengl_vendor() == 'nouveau'
and not (os.environ.get('LIBGL_ALWAYS_SOFTWARE') == '1'
or 'QT_XCB_FORCE_SOFTWARE_OPENGL' in os.environ)):
sys.exit("You are using the nouveau graphics driver but it"
" has issues with multithreaded opengl. You must"
" use another driver or set the variable environment"
" QT_XCB_FORCE_SOFTWARE_OPENGL to force software"
" opengl. Note that it might be slow, depending"
" on your hardware.")
self._setup_conf_paths()
self._interceptor = UrlInterceptor(self)
self._download_manager = DownloadManager(self)
self.profile = default_profile()
self.profile.enable(self)
settings = QWebEngineSettings.globalSettings()
settings.setAttribute(
QWebEngineSettings.LinksIncludedInFocusChain,
False,
)
settings.setAttribute(
QWebEngineSettings.PluginsEnabled,
True,
)
settings.setAttribute(
QWebEngineSettings.FullScreenSupportEnabled,
True,
)
settings.setAttribute(
QWebEngineSettings.JavascriptCanOpenWindows,
True,
)
self.installEventFilter(LOCAL_KEYMAP_SETTER)
self.setQuitOnLastWindowClosed(False)
self.network_manager = QNetworkAccessManager(self)
_app_requires()
def __init__(self):
super().__init__()
self.docRoot = "https://oradocs-corp.documents.us2.oraclecloud.com/documents/"
self.url = QUrl()
self.qnam = QNetworkAccessManager()
self.reply = None
self.outFile = None
self.httpGetId = 0
self.httpRequestAborted = False
self.gotToken = False
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# self.ui.setupUi.MainWindow.setTitle("OraDocs")
self._connections()
def processPycomDeviceVersion(self):
product = PycomDeviceServer.uname[0].lower()
platform = PycomDeviceServer.uname[1].lower()
url = "https://software.pycom.io/findupgrade?product=%s&type=stable&platform=%s" % (
product, platform)
try:
request = QNetworkRequest(QUrl(url))
networkManager = QNetworkAccessManager()
request.setAttribute(QNetworkRequest.CacheLoadControlAttribute,
QNetworkRequest.AlwaysNetwork)
self.__request = request
self.__networkManager = networkManager
self.__reply = networkManager.get(self.__request)
self.__reply.finished.connect(self.__PycomDeviceDownloadDone)
except:
pass
def __init__(self):
super().__init__()
self.lbl = QLabel("loading...")
self.lbl.setAutoFillBackground(True)
self.nam = QNetworkAccessManager()
self.nam.finished.connect(self.finish_request)
url = "http://pp.vk.me/c627626/v627626428/be07/wbpWha0RqZ4.jpg"
self.nam.get(QNetworkRequest(QUrl(url)))
layout = QVBoxLayout()
layout.addWidget(self.lbl)
self.setLayout(layout)
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)))
def __init__(self, worker: ClientWorker, parent=None, *args, **kwargs):
QWidget.__init__(self, parent)
Requset_Ui.setupUi(self, **kwargs)
self.manager = QNetworkAccessManager(self)
self.worker = worker
self.button.clicked.connect(self.send)
self.send.connect(self.on_run)
self.manager.finished.connect(self.on_response)
self.read_response.connect(self.worker.on_response)
self.worker.finish.connect(self.finish)
self.progress_bar.finish.connect(self.exit)
self.progress_bar.finish.connect(self.close)
self.error.connect(self.on_error)
def __init__(self, parent=None):
super().__init__("DiscoverOctoPrintAction",
catalog.i18nc("@action", "Connect OctoPrint"))
self._qml_url = "DiscoverOctoPrintAction.qml"
self._window = None
self._context = None
self._network_plugin = None
# QNetwork manager needs to be created in advance. If we don't it can happen that it doesn't correctly
# hook itself into the event loop, which results in events never being fired / done.
self._manager = QNetworkAccessManager()
self._manager.finished.connect(self._onRequestFinished)
self._settings_reply = None
# Try to get version information from plugin.json
plugin_file_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)), "plugin.json")
try:
with open(plugin_file_path) as plugin_file:
plugin_info = json.load(plugin_file)
plugin_version = plugin_info["version"]
except:
# The actual version info is not critical to have so we can continue
plugin_version = "Unknown"
Logger.logException(
"w", "Could not get version information for the plugin")
self._user_agent = (
"%s/%s %s/%s" %
(Application.getInstance().getApplicationName(),
Application.getInstance().getVersion(), "OctoPrintPlugin",
Application.getInstance().getVersion())).encode()
self._instance_responded = False
self._instance_api_key_accepted = False
self._instance_supports_sd = False
self._instance_supports_camera = False
self._additional_components = None
ContainerRegistry.getInstance().containerAdded.connect(
self._onContainerAdded)
Application.getInstance().engineCreatedSignal.connect(
self._createAdditionalComponentsView)
def doRequest(self):
print(self.slider.value())
data = QByteArray()
data.append("'brightness':")
data.append(str(self.slider.value()))
#url = "https://httpbin.org/post"
url = "https://postman-echo.com/post"
req = QNetworkRequest(QUrl(url))
req.setHeader(QNetworkRequest.ContentTypeHeader,
'"Content-Type": "application/json; charset=UTF-8"',)
self.nam = QNetworkAccessManager()
self.nam.finished.connect(self.handleResponse)
self.nam.post(req, data)
def __init__(self):
super().__init__()
self._zero_conf = None
self._browser = None
self._printers = {}
self._cluster_printers_seen = {
} # do not forget a cluster printer when we have seen one, to not 'downgrade' from Connect to legacy printer
self._api_version = "1"
self._api_prefix = "/api/v" + self._api_version + "/"
self._cluster_api_version = "1"
self._cluster_api_prefix = "/cluster-api/v" + self._cluster_api_version + "/"
self._network_manager = QNetworkAccessManager()
self._network_manager.finished.connect(self._onNetworkRequestFinished)
# List of old printer names. This is used to ensure that a refresh of zeroconf does not needlessly forces
# authentication requests.
self._old_printers = []
# Because the model needs to be created in the same thread as the QMLEngine, we use a signal.
self.addPrinterSignal.connect(self.addPrinter)
self.removePrinterSignal.connect(self.removePrinter)
Application.getInstance().globalContainerStackChanged.connect(
self.reCheckConnections)
# Get list of manual printers from preferences
self._preferences = Preferences.getInstance()
self._preferences.addPreference(
"um3networkprinting/manual_instances",
"") # A comma-separated list of ip adresses or hostnames
self._manual_instances = self._preferences.getValue(
"um3networkprinting/manual_instances").split(",")
self._network_requests_buffer = {
} # store api responses until data is complete
# The zeroconf service changed requests are handled in a separate thread, so we can re-schedule the requests
# which fail to get detailed service info.
# Any new or re-scheduled requests will be appended to the request queue, and the handling thread will pick
# them up and process them.
self._service_changed_request_queue = Queue()
self._service_changed_request_event = Event()
self._service_changed_request_thread = Thread(
target=self._handleOnServiceChangedRequests, daemon=True)
self._service_changed_request_thread.start()
def __init__(self, parent=None):
super(HttpWindow, self).__init__(parent)
self.title = "OraDocs by littleT"
self.left = 10
self.top = 10
self.width = 600
self.height = 400
self.docRoot = "https://oradocs-corp.documents.us2.oraclecloud.com/documents/"
self.url = QUrl()
self.qnam = QNetworkAccessManager()
self.reply = None
self.outFile = None
self.httpGetId = 0
self.httpRequestAborted = False
self.initUI()
def _fetchPackageData(self):
# Create the network manager:
# This was formerly its own function but really had no reason to be as
# it was never called more than once ever.
if self._network_manager is not None:
self._network_manager.finished.disconnect(self._onRequestFinished)
self._network_manager.networkAccessibleChanged.disconnect(self._onNetworkAccessibleChanged)
self._network_manager = QNetworkAccessManager()
self._network_manager.finished.connect(self._onRequestFinished)
self._network_manager.networkAccessibleChanged.connect(self._onNetworkAccessibleChanged)
# Make remote requests:
self._makeRequestByType("packages")
self._makeRequestByType("authors")
# Gather installed packages:
self._updateInstalledModels()
def __init__(self, parent=None, rfid_card=None):
QObject.__init__(self, parent)
self._rfid_card = rfid_card
self._startZeroConfThreads()
self._data = []
self._server_reachable = False
self._authentication_required = True
self._authentication_scanner_attached = False
self._network_manager = QNetworkAccessManager()
self._network_manager.finished.connect(self._onNetworkFinished)
# Since the serial handling is done on a seperate thread, we need an extra handler.
self._serial_network_manager = None
self._modifiers = []
self._failed_update_modifier_timer = QTimer()
self._failed_update_modifier_timer.setInterval(
FAILED_REQUEST_TRY_AGAIN * 1000)
self._failed_update_modifier_timer.setSingleShot(True)
self._failed_update_modifier_timer.timeout.connect(
self.requestModifiersData)
self._failed_update_nodes_timer = QTimer()
self._failed_update_nodes_timer.setInterval(FAILED_REQUEST_TRY_AGAIN *
1000)
self._failed_update_nodes_timer.setSingleShot(True)
self._failed_update_nodes_timer.timeout.connect(self.requestKnownNodes)
self._inactivity_timer = QTimer()
self._inactivity_timer.setInterval(INACTIVITY_TIMEOUT * 1000)
self._inactivity_timer.setSingleShot(True)
self._inactivity_timer.timeout.connect(self.inactivityTimeout)
self._serial = None
if self._rfid_card:
self.setAuthenticationRequired(False)
else:
# Check for RFID scanner as normal
self._createSerial()
self.inactivityTimeout.connect(self.onInactivityTimeout)
def _onRequestError(self, request_data: "HttpRequestData",
error: "QNetworkReply.NetworkError") -> None:
error_string = None
if request_data.reply is not None:
error_string = request_data.reply.errorString()
if error == QNetworkReply.UnknownNetworkError or QNetworkReply.HostNotFoundError:
self._setInternetReachable(False)
# manager seems not always able to recover from a total loss of network access, so re-create it
self._network_manager = QNetworkAccessManager(self)
# Use peek() to retrieve the reply's body instead of readAll(), because readAll consumes the content
reply_body = request_data.reply.peek(request_data.reply.bytesAvailable(
)) # unlike readAll(), peek doesn't consume the content
Logger.log("d",
"%s got an QNetworkReplyError %s. The server returned: %s",
request_data, error_string, reply_body)
with self._request_lock:
# Safeguard: make sure that we have the reply in the currently in-progress requests set
if request_data not in self._requests_in_progress:
# TODO: ERROR, should not happen
Logger.log("e", "%s not found in the in-progress set",
request_data)
pass
else:
# Disconnect callback signals
if request_data.reply is not None:
if request_data.download_progress_callback is not None:
request_data.reply.downloadProgress.disconnect(
request_data.onDownloadProgressCallback)
if request_data.upload_progress_callback is not None:
request_data.reply.uploadProgress.disconnect(
request_data.onUploadProgressCallback)
request_data.setDone()
self._requests_in_progress.remove(request_data)
# Schedule the error callback if there is one
if request_data.error_callback is not None:
self.callLater(0, request_data.error_callback, request_data.reply,
error)
# Continue to process the next request
self._processNextRequestsInQueue()
def __init__(self, port, **kwargs):
super().__init__()
self.setWindowTitle('Cooking your TinyGS station...')
self.setFixedWidth(400)
self.exception = None
esptool.sw.progress.connect(self.update_progress)
self.nam = QNetworkAccessManager()
self.nrBinFile = QNetworkRequest()
self.bin_data = b''
self.setLayout(VLayout(5, 5))
self.actions_layout = QFormLayout()
self.actions_layout.setSpacing(5)
self.layout().addLayout(self.actions_layout)
self._actions = []
self._action_widgets = {}
self.port = port
self.auto_reset = kwargs.get('auto_reset', False)
self.file_path = kwargs.get('file_path')
if self.file_path and self.file_path.startswith('http'):
self._actions.append('download')
self.backup = kwargs.get('backup')
if self.backup:
self._actions.append('backup')
self.backup_size = kwargs.get('backup_size')
self.erase = kwargs.get('erase')
if self.erase:
self._actions.append('erase')
if self.file_path:
self._actions.append('write')
self.create_ui()
self.start_process()
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 = '%s/%s/%s-%s' % (self.api_base_url, 'issue', CVTypeID.Issue, str(issue_id))
params = {'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)))
def __init__(self, parent=None):
"""
Constructor
@param parent parent
@type QObject
"""
super(Pip, self).__init__(parent)
# attributes for the network objects
self.__networkManager = QNetworkAccessManager(self)
self.__networkManager.proxyAuthenticationRequired.connect(
proxyAuthenticationRequired)
if SSL_AVAILABLE:
self.__sslErrorHandler = E5SslErrorHandler(self)
self.__networkManager.sslErrors.connect(
self.__sslErrorHandler.sslErrorsReply)
self.__replies = []
def __init__(self,
des_path,
source_path,
reqTimeout=10,
readTimeout=30,
try_time=3):
super(Downloader, self).__init__()
self.retStatus = False
self.source_path = source_path
self.des_path = des_path
self.bak_file = des_path + ".bak"
self.try_time = try_time
self.readTimeout = readTimeout * 1000
self.reqTimeout = reqTimeout * 1000
self.data = None
# request timer, default 5 sec
self.reqTimer = QTimer()
self.reqTimer.timeout.connect(self.onReqTimeOut)
# read data timer, default no time unlimit
self.readTimer = QTimer()
self.readTimer.timeout.connect(self.onReadTimeOut)
self.networkManager = QNetworkAccessManager()
self.request()
if os.path.exists(self.bak_file):
os.remove(self.bak_file)
if os.path.exists(self.des_path):
os.rename(self.des_path, self.bak_file)
self.fp = open(self.des_path, "wb")
self.reqTimer.start(self.reqTimeout)
self.eventLoop = QEventLoop()
self.finished.connect(self.eventLoop.quit)
self.eventLoop.exec_()
self.fp.close()
if self.retStatus is False:
if os.path.exists(self.des_path):
os.remove(self.des_path)
if os.path.exists(self.bak_file):
os.rename(self.bak_file, self.des_path)
else:
if os.path.exists(self.bak_file):
os.remove(self.bak_file)
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent object (QObject)
"""
super(TranslatorRequest, self).__init__(parent)
self.__contentTypes = {
"form": b"application/x-www-form-urlencoded",
"json": b"application/json",
}
self.__networkManager = QNetworkAccessManager(self)
self.__networkManager.proxyAuthenticationRequired.connect(
proxyAuthenticationRequired)
self.__loop = QEventLoop()
self.__networkManager.finished.connect(self.__loop.quit)
def postRequest(self):
url = QUrl("http://httpbin.org/post")
dataDict = {}
dataDict["fname"] = "Budi"
dataDict["lname"] = "Anton"
dataJson = json.dumps(dataDict)
data = QByteArray()
data.append(dataJson)
self.request = QNetworkRequest(url)
self.request.setHeader(QNetworkRequest.ContentTypeHeader,
"application/json")
self.manager = QNetworkAccessManager()
self.manager.post(self.request, data)
self.manager.finished.connect(self.getResponse)
def __init__(self):
super().__init__()
self.scene = QGraphicsScene()
self.scene.addItem(QGraphicsTextItem('loading...'))
self.view = QGraphicsView()
self.view.setScene(self.scene)
self.nam = QNetworkAccessManager()
self.nam.finished.connect(self.finish_request)
url = "http://pp.vk.me/c627626/v627626428/be07/wbpWha0RqZ4.jpg"
self.nam.get(QNetworkRequest(QUrl(url)))
layout = QVBoxLayout()
layout.addWidget(self.view)
self.setLayout(layout)
