matlab-proxy 0.16.0__tar.gz → 0.18.0__tar.gz

{matlab-proxy-0.16.0/matlab_proxy.egg-info → matlab-proxy-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: matlab-proxy
-Version: 0.16.0
+Version: 0.18.0
 Summary: Python® package enables you to launch MATLAB® and access it from a web browser.
 Home-page: https://github.com/mathworks/matlab-proxy/
 Author: The MathWorks, Inc.

{matlab-proxy-0.16.0 → matlab-proxy-0.18.0}/gui/src/components/App/index.js

@@ -175,6 +175,22 @@ function App () {
         }
     }
 
+    useEffect(() => {
+        const handlePageHide = (event) => {
+            // Performs actions before the component unloads
+            if (isConcurrencyEnabled && !isSessionConcurrent && hasFetchedServerStatus) {
+                // A POST request to clear the active client when the tab/browser is closed
+                navigator.sendBeacon('./clear_client_id');
+            }
+            event.preventDefault();
+            event.returnValue = '';
+        };
+        window.addEventListener('pagehide', handlePageHide);
+        return () => {
+            window.removeEventListener('pagehide', handlePageHide);
+        };
+    }, [isConcurrencyEnabled, isSessionConcurrent, hasFetchedServerStatus]);
+
     useEffect(() => {
         // Initial fetch environment configuration
         if (!hasFetchedEnvConfig) {

{matlab-proxy-0.16.0 → matlab-proxy-0.18.0}/matlab_proxy/app.py

@@ -6,7 +6,6 @@ import mimetypes
 import pkgutil
 import secrets
 import sys
-import uuid
 
 import aiohttp
 from aiohttp import client_exceptions, web
@@ -17,12 +16,11 @@ from cryptography import fernet
 import matlab_proxy
 from matlab_proxy import constants, settings, util
 from matlab_proxy.app_state import AppState
+from matlab_proxy.constants import IS_CONCURRENCY_CHECK_ENABLED
 from matlab_proxy.util import mwi
+from matlab_proxy.util.mwi import download, token_auth
 from matlab_proxy.util.mwi import environment_variables as mwi_env
-from matlab_proxy.util.mwi import token_auth, download
 from matlab_proxy.util.mwi.exceptions import AppError, InvalidTokenError, LicensingError
-from matlab_proxy.constants import IS_CONCURRENCY_CHECK_ENABLED
-
 
 mimetypes.add_type("font/woff", ".woff")
 mimetypes.add_type("font/woff2", ".woff2")
@@ -97,16 +95,15 @@ def marshal_error(error):
 
 
 async def create_status_response(
-    app, loadUrl=None, client_id=None, transfer_session=False, is_desktop=False
+    app, loadUrl=None, client_id=None, is_active_client=None
 ):
     """Send a generic status response about the state of server, MATLAB, MATLAB Licensing and the client session status.
 
     Args:
         app (aiohttp.web.Application): Web Server
         loadUrl (String, optional): Represents the root URL. Defaults to None.
-        client_id (String, optional): Represents the unique client_id when concurrency check is enabled. Defaults to None.
-        transfer_session (Boolean, optional): Represents whether the connection should be transfered or not when concurrency check is enabled. Defaults to False.
-        is_desktop (Boolean, optional): Represents whether the request is made by the desktop app or some other kernel. Defaults to False.
+        client_id (String, optional): Represents the generated client_id when concurrency check is enabled and client does not have a client_id. Defaults to None.
+        is_active_client (Boolean, optional): Represents whether the current client is the active_client when concurrency check is enabled. Defaults to None.
 
     Returns:
         JSONResponse: A JSONResponse object containing the generic state of the server, MATLAB, MATLAB Licensing and the client session status.
@@ -124,17 +121,30 @@ async def create_status_response(
         "wsEnv": state.settings.get("ws_env", ""),
     }
 
-    if IS_CONCURRENCY_CHECK_ENABLED and is_desktop:
-        if not client_id:
-            client_id = str(uuid.uuid4())
-            status["clientId"] = client_id
+    if client_id:
+        status["clientId"] = client_id
+    if is_active_client is not None:
+        status["isActiveClient"] = is_active_client
+
+    return web.json_response(status)
 
-        if not state.active_client or transfer_session:
-            state.active_client = client_id
 
-        status["isActiveClient"] = True if state.active_client == client_id else False
+@token_auth.authenticate_access_decorator
+async def clear_client_id(req):
+    """API endpoint to reset the active client
 
-    return web.json_response(status)
+    Args:
+        req (HTTPRequest): HTTPRequest Object
+
+    Returns:
+        Response: an empty response in JSON format
+    """
+    # Sleep for one second prior to clearing the client id to ensure that any remaining get_status responses are fully processed first.
+    await asyncio.sleep(1)
+    state = req.app["state"]
+    state.active_client = None
+    # This response is of no relevance to the front-end as the client has already exited
+    return web.json_response({})
 
 
 @token_auth.authenticate_access_decorator
@@ -201,15 +211,17 @@ async def get_status(req):
         JSONResponse: JSONResponse object containing information about the server, MATLAB and MATLAB Licensing.
     """
     # The client sends the CLIENT_ID as a query parameter if the concurrency check has been set to true.
+    state = req.app["state"]
     client_id = req.query.get("MWI_CLIENT_ID", None)
     transfer_session = json.loads(req.query.get("TRANSFER_SESSION", "false"))
     is_desktop = req.query.get("IS_DESKTOP", False)
 
+    generated_client_id, is_active_client = state.get_session_status(
+        is_desktop, client_id, transfer_session
+    )
+
     return await create_status_response(
-        req.app,
-        client_id=client_id,
-        transfer_session=transfer_session,
-        is_desktop=is_desktop,
+        req.app, client_id=generated_client_id, is_active_client=is_active_client
     )
 
 
@@ -409,7 +421,7 @@ async def termination_integration_delete(req):
     await req.app.cleanup()
     """When testing with pytest, its not possible to catch sys.exit(0) using the construct
     'with pytest.raises()', there by causing the test : test_termination_integration_delete()
-    to fail. Inorder to avoid this, adding the below if condition to check to skip sys.exit(0) when testing
+    to fail. In order to avoid this, adding the below if condition to check to skip sys.exit(0) when testing
     """
     logger.debug("Exiting with return code 0")
     if not mwi_env.is_testing_mode_enabled():
@@ -462,7 +474,7 @@ def make_static_route_table(app):
     Returns:
         Dict: Containing information about the static files and header information.
     """
-    from pkg_resources import resource_isdir, resource_listdir
+    import importlib_resources
 
     from matlab_proxy import gui
     from matlab_proxy.gui import static
@@ -479,8 +491,9 @@ def make_static_route_table(app):
         (gui.static.js.__name__, "/static/js"),
         (gui.static.media.__name__, "/static/media"),
     ]:
-        for name in resource_listdir(mod, ""):
-            if not resource_isdir(mod, name):
+        for entry in importlib_resources.files(mod).iterdir():
+            name = entry.name
+            if not importlib_resources.files(mod).joinpath(name).is_dir():
                 if name != "__init__.py":
                     # Special case for manifest.json
                     if "manifest.json" in name:
@@ -773,6 +786,8 @@ async def cleanup_background_tasks(app):
     # Stop any running async tasks
     logger = mwi.logger.get()
     tasks = state.tasks
+    if state.task_detect_client_status:
+        tasks["detect_client_status"] = state.task_detect_client_status
     for task_name, task in tasks.items():
         if not task.cancelled():
             logger.debug(f"Cancelling MWI task: {task_name} : {task} ")
@@ -868,6 +883,7 @@ def create_app(config_name=matlab_proxy.get_default_config_name()):
     app.router.add_route("GET", f"{base_url}/get_auth_token", get_auth_token)
     app.router.add_route("GET", f"{base_url}/get_env_config", get_env_config)
     app.router.add_route("PUT", f"{base_url}/start_matlab", start_matlab)
+    app.router.add_route("POST", f"{base_url}/clear_client_id", clear_client_id)
     app.router.add_route("DELETE", f"{base_url}/stop_matlab", stop_matlab)
     app.router.add_route("PUT", f"{base_url}/set_licensing_info", set_licensing_info)
     app.router.add_route("PUT", f"{base_url}/update_entitlement", update_entitlement)

{matlab-proxy-0.16.0 → matlab-proxy-0.18.0}/matlab_proxy/app_state.py

@@ -9,15 +9,18 @@ import time
 from collections import deque
 from datetime import datetime, timedelta, timezone
 from typing import Final, Optional
+import uuid
 
 from matlab_proxy import util
 from matlab_proxy.constants import (
     CONNECTOR_SECUREPORT_FILENAME,
     MATLAB_LOGS_FILE_NAME,
+    IS_CONCURRENCY_CHECK_ENABLED,
+    USER_CODE_OUTPUT_FILE_NAME,
 )
-from matlab_proxy.settings import (
-    get_process_startup_timeout,
-)
+
+from matlab_proxy.settings import get_process_startup_timeout
+
 from matlab_proxy.util import mw, mwi, system, windows
 from matlab_proxy.util.mwi import environment_variables as mwi_env
 from matlab_proxy.util.mwi import token_auth
@@ -103,6 +106,12 @@ class AppState:
         # connected to the backend
         self.active_client = None
 
+        # Used to detect whether the active client is actively sending out request or is inactive
+        self.active_client_request_detected = False
+
+        # An event loop task to handle the detection of client activity
+        self.task_detect_client_status = None
+
     def __get_cached_config_file(self):
         """Get the cached config file
 
@@ -586,6 +595,24 @@ class AppState:
             self.matlab_session_files["matlab_ready_file"] = matlab_ready_file
 
             logger.debug(f"matlab_session_files:{self.matlab_session_files}")
+
+            # check if the user has provided any code or not
+            if self.settings.get("has_custom_code_to_execute"):
+                # Keep a reference to the user code output file in the matlab_session_files for cleanup
+                user_code_output_file = mwi_logs_dir / USER_CODE_OUTPUT_FILE_NAME
+                self.matlab_session_files["startup_code_output_file"] = (
+                    user_code_output_file
+                )
+                logger.info(
+                    util.prettify(
+                        boundary_filler="*",
+                        text_arr=[
+                            f"When MATLAB starts, you can see the output for your startup code at:",
+                            f"{self.matlab_session_files.get('startup_code_output_file', ' ')}",
+                        ],
+                    )
+                )
+
             return
 
     def create_server_info_file(self):
@@ -838,6 +865,10 @@ class AppState:
 
                 return matlab
 
+            except UIVisibleFatalError as e:
+                self.error = e
+                log_error(logger, e)
+
             except Exception as err:
                 self.error = err
                 log_error(logger, err)
@@ -964,7 +995,7 @@ class AppState:
             )
             await self.stop_matlab(force_quit=True)
             self.error = MatlabError(
-                "Unable to start MATLAB because of a timeout. Try again by clicking Start MATLAB."
+                "MATLAB startup has timed out. Click Start MATLAB to try again."
             )
 
     async def __read_matlab_ready_file(self, delay):
@@ -1304,3 +1335,76 @@ class AppState:
             if err is not None:
                 self.error = err
                 log_error(logger, err)
+
+    def get_session_status(self, is_desktop, client_id, transfer_session):
+        """
+        Determines the session status for a client, potentially generating a new client ID.
+
+        This function is responsible for managing and tracking the session status of a client.
+        It can generate a new client ID if one is not provided and the conditions are met.
+        It also manages the active client status within the session, especially in scenarios
+        involving desktop clients and when concurrency checks are enabled.
+
+        Args:
+            is_desktop (bool): A flag indicating whether the client is a desktop client.
+            client_id (str or None): The client ID. If None, a new client ID may be generated.
+            transfer_session (bool): Indicates whether the session should be transferred to this client.
+
+        Returns:
+            tuple:
+                - A 2-tuple containing the generated client ID (or None if not generated) and
+                a boolean indicating whether the client is considered the active client.
+                - If concurrency checks are not enabled or the client is not a desktop client, it returns None for both
+                the generated client ID and the active client status.
+        """
+        if IS_CONCURRENCY_CHECK_ENABLED and is_desktop:
+            generated_client_id = None
+            if not client_id:
+                generated_client_id = str(uuid.uuid4())
+                client_id = generated_client_id
+
+            if not self.active_client or transfer_session:
+                self.active_client = client_id
+
+                if not self.task_detect_client_status:
+                    # Create the loop to detect the active status of the client
+                    loop = util.get_event_loop()
+                    self.task_detect_client_status = loop.create_task(
+                        self.detect_active_client_status()
+                    )
+
+            if self.active_client == client_id:
+                is_active_client = True
+                self.active_client_request_detected = True
+            else:
+                is_active_client = False
+            return generated_client_id, is_active_client
+        return None, None
+
+    async def detect_active_client_status(self, sleep_time=1, max_inactive_count=10):
+        """Detects whether the client is online or not by continuously checking if the active client is making requests
+
+        Args:
+            sleep_time (int): The time in seconds for which the process waits before checking for the next get_status request from the active client.
+            max_inactive_count (int): The maximum number of times the check for the request from the active_client fails before reseting the active client id.
+        """
+        inactive_count = 0
+        while self.active_client:
+            # Check if the get_status request from the active client is received or not
+            await asyncio.sleep(sleep_time)
+            if self.active_client_request_detected:
+                self.active_client_request_detected = False
+                inactive_count = 0
+            else:
+                inactive_count = inactive_count + 1
+            if inactive_count > max_inactive_count:
+                # If no request is received from the active_client for more than 10 seconds then clear the active client id
+                inactive_count = 0
+                self.active_client = None
+        if self.task_detect_client_status:
+            try:
+                # Self cleanup of the task
+                self.task_detect_client_status.cancel()
+                self.task_detect_client_status = None
+            except Exception as e:
+                logger.error("Cleaning of task: 'detect_client_status' failed.")

{matlab-proxy-0.16.0 → matlab-proxy-0.18.0}/matlab_proxy/constants.py

@@ -7,6 +7,7 @@ CONNECTOR_SECUREPORT_FILENAME: Final[str] = "connector.securePort"
 VERSION_INFO_FILE_NAME: Final[str] = "VersionInfo.xml"
 MAX_HTTP_REQUEST_SIZE: Final[int] = 500_000_000  # 500MB
 MATLAB_LOGS_FILE_NAME: Final[str] = "matlab_logs.txt"
+USER_CODE_OUTPUT_FILE_NAME: Final[str] = "startup_code_output.txt"
 
 # Max startup duration in seconds for processes launched by matlab-proxy
 # This constant is meant for internal use within matlab-proxy

matlab-proxy-0.18.0/matlab_proxy/matlab/evaluateUserMatlabCode.m

@@ -0,0 +1,51 @@
+% Copyright 2024 The MathWorks, Inc.
+
+% Note:
+% Any extra variable we are creating begins with `mwiInternal` to prevent
+% potential conflicts with variables created by user code evaluated using evalc.
+% Since evalc("user code") is executed in the base workspace, it might create
+% variables that could overwrite our internal variables. To avoid polluting the
+% user's workspace when MATLAB starts, we ensure to clear any internal variable
+% that we create in the base workspace. We do not need to be concerned about
+% variables in the function's workspace.
+
+if ~isempty(getenv('MWI_MATLAB_STARTUP_SCRIPT')) && ~all(isspace(getenv('MWI_MATLAB_STARTUP_SCRIPT')))
+    try
+        % Evaluate the code from the environment variable and capture the output
+        mwiInternalResults = evalc(getenv('MWI_MATLAB_STARTUP_SCRIPT'));
+        % Write the results to the file
+        logOutputOrError(mwiInternalResults);
+        clear mwiInternalResults;
+    catch mwiInternalException
+        % Log the error message to the file
+        logOutputOrError(" ", mwiInternalException);
+        clear mwiInternalResults mwiInternalException;
+        error("Unable to run the startup code you specified. For details of the error, see the output file at " + fullfile(getenv('MATLAB_LOG_DIR'), "startup_code_output.txt"));
+    end
+
+end
+
+function logOutputOrError(userCodeResults, mwiInternalException)
+    %   Logs the results of the user code execution if successful, otherwise logs the
+    %   error information. It then closes the file handle.
+    %
+    %   Inputs:
+    %       userCodeResults       - String containing the output from the user code.
+    %       mwiInternalException  - (Optional) MException object containing error details.
+    filePath = fullfile(getenv('MATLAB_LOG_DIR'), "startup_code_output.txt");
+    [fileHandle, ~] = fopen(filePath, 'w');
+    if nargin < 2
+        % Log the successful output of the user code
+        fprintf(fileHandle, " ");
+        fprintf(fileHandle, userCodeResults);
+    else
+        % Log the error information
+        fprintf(fileHandle, 'An error occurred in the following code:\n');
+        fprintf(fileHandle, getenv('MWI_MATLAB_STARTUP_SCRIPT'));
+        fprintf(fileHandle, '\n\nMessage: %s\n', mwiInternalException.message);
+        fprintf(fileHandle, '\nError Identifier: %s\n', mwiInternalException.identifier);
+    end
+    % Close the file handle
+    fclose(fileHandle);
+end
+

{matlab-proxy-0.16.0 → matlab-proxy-0.18.0}/matlab_proxy/matlab/startup.m

@@ -1,4 +1,4 @@
-% Copyright (c) 2020-2023 The MathWorks, Inc.
+% Copyright 2020-2024 The MathWorks, Inc.
 
 % Configure logged in user if possible
 if ~isempty(getenv('MW_LOGIN_USER_ID'))
@@ -34,4 +34,4 @@ end
 matlab_settings.matlab.addons.explorer.isExplorerSupported.TemporaryValue = false;
 
 clear
-clc
+clc

{matlab-proxy-0.16.0 → matlab-proxy-0.18.0}/matlab_proxy/settings.py

@@ -366,7 +366,10 @@ def get_matlab_settings():
     flag_to_hide_desktop = ["-nodesktop"]
     if system.is_windows():
         flag_to_hide_desktop.extend(["-noDisplayDesktop", "-wait", "-log"])
-    matlab_startup_file = str(Path(__file__).resolve().parent / "matlab" / "startup.m")
+
+    matlab_code_dir = Path(__file__).resolve().parent / "matlab"
+    matlab_startup_file = str(matlab_code_dir / "startup.m")
+    matlab_code_file = str(matlab_code_dir / "evaluateUserMatlabCode.m")
 
     matlab_version = get_matlab_version(matlab_root_path)
 
@@ -388,6 +391,18 @@ def get_matlab_settings():
     profile_matlab_startup = (
         "-timing" if mwi_env.Experimental.is_matlab_startup_profiling_enabled() else ""
     )
+
+    has_custom_code_to_execute = (
+        len(os.getenv(mwi_env.get_env_name_custom_matlab_code(), "").strip()) > 0
+    )
+    mp_code_to_execute = f"try; run('{matlab_startup_file}'); catch MATLABProxyInitializationError; disp(MATLABProxyInitializationError.message); end;"
+    custom_code_to_execute = f"try; run('{matlab_code_file}'); catch MATLABCustomStartupCodeError; disp(MATLABCustomStartupCodeError.message); end;"
+    code_to_execute = (
+        mp_code_to_execute + custom_code_to_execute
+        if has_custom_code_to_execute
+        else mp_code_to_execute
+    )
+
     return {
         "matlab_path": matlab_root_path,
         "matlab_version": matlab_version,
@@ -402,13 +417,14 @@ def get_matlab_settings():
             *mpa_flags,
             profile_matlab_startup,
             "-r",
-            f"try; run('{matlab_startup_file}'); catch ME; disp(ME.message); end;",
+            code_to_execute,
         ],
         "ws_env": ws_env,
         "mwa_api_endpoint": f"https://login{ws_env_suffix}.mathworks.com/authenticationws/service/v4",
         "mhlm_api_endpoint": f"https://licensing{ws_env_suffix}.mathworks.com/mls/service/v1/entitlement/list",
         "mwa_login": f"https://login{ws_env_suffix}.mathworks.com",
         "nlm_conn_str": nlm_conn_str,
+        "has_custom_code_to_execute": has_custom_code_to_execute,
     }
 
 

{matlab-proxy-0.16.0 → matlab-proxy-0.18.0}/matlab_proxy/util/__init__.py

@@ -11,6 +11,9 @@ import matlab_proxy
 from matlab_proxy.util import mwi, system
 from matlab_proxy.util.event_loop import *
 from matlab_proxy.util.mwi import environment_variables as mwi_env
+from matlab_proxy.util.mwi.exceptions import (
+    UIVisibleFatalError,
+)
 
 logger = mwi.logger.get()
 
@@ -181,7 +184,7 @@ def prettify(boundary_filler=" ", text_arr=[]):
     return result
 
 
-def get_child_processes(parent_process):
+def get_child_processes(parent_process, max_attempts=10, sleep_interval=1):
     """Get list of child processes from a parent process.
 
     Args:
@@ -199,7 +202,6 @@ def get_child_processes(parent_process):
     # to get hold child processes
     parent_process_psutil = psutil.Process(parent_process.pid)
 
-    max_attempts = 10
     child_processes = None
     for _ in range(max_attempts):
         try:
@@ -212,17 +214,24 @@ def get_child_processes(parent_process):
 
             if not child_processes:
                 logger.debug("Waiting for the child processes to be created...")
+                time.sleep(sleep_interval)
                 continue
 
+            else:
+                logger.debug(f"Found the child process: {child_processes[0]}")
+                break
+
         except AssertionError as err:
             raise err
 
-        if child_processes:
-            break
-        time.sleep(0.1)
-
     if not child_processes:
-        raise RuntimeError("No child processes found after multiple attempts.")
+        logger.debug(
+            f"MATLAB process was not found while searching for the child processes."
+        )
+
+        raise UIVisibleFatalError(
+            "Unable to create MATLAB process. Click Start MATLAB to try again."
+        )
 
     return child_processes
 

{matlab-proxy-0.16.0 → matlab-proxy-0.18.0}/matlab_proxy/util/mwi/environment_variables.py

@@ -162,6 +162,11 @@ def get_env_name_process_startup_timeout():
     return "MWI_PROCESS_START_TIMEOUT"
 
 
+def get_env_name_custom_matlab_code():
+    """User specified MATLAB code that will be executed by matlab-proxy upon its start"""
+    return "MWI_MATLAB_STARTUP_SCRIPT"
+
+
 class Experimental:
     """This class houses functions which are undocumented APIs and Environment variables.
     Note: Never add any state to this class. Its only intended for use as an abstraction layer

{matlab-proxy-0.16.0 → matlab-proxy-0.18.0}/matlab_proxy/util/mwi/validators.py

@@ -1,31 +1,30 @@
 # Copyright 2020-2024 The MathWorks, Inc.
 """This file contains validators for various runtime artifacts.
-A validator is defined as a function which verifies the input and 
-returns it unchanged if validation passes. 
+A validator is defined as a function which verifies the input and
+returns it unchanged if validation passes.
 Returning inputs allows validators to be used inline with the input.
 
-Example: 
+Example:
 Original code: if( input ):
 With validator: if (valid(input)):
 
 Exceptions are thrown to signal failure.
 """
+
 import errno
 import os
-from pathlib import Path
-import pkg_resources
 import socket
+from pathlib import Path
 from typing import List
 
-
 import matlab_proxy
 from matlab_proxy import util
-from matlab_proxy.util import system
 from matlab_proxy.constants import VERSION_INFO_FILE_NAME
+from matlab_proxy.util import system
 
 from . import environment_variables as mwi_env
 from . import logger as mwi_logger
-from .exceptions import MatlabInstallError, FatalError
+from .exceptions import FatalError, MatlabInstallError
 
 logger = mwi_logger.get()
 
@@ -213,10 +212,13 @@ def __get_configs():
         Dict: Contains all the values present in 'matlab_web_desktop_configs' entry_point from all the packages
         installed in the current environment.
     """
+    import importlib_metadata
+
+    matlab_proxy_eps = importlib_metadata.entry_points(
+        group=matlab_proxy.get_entrypoint_name()
+    )
     configs = {}
-    for entry_point in pkg_resources.iter_entry_points(
-        matlab_proxy.get_entrypoint_name()
-    ):
+    for entry_point in matlab_proxy_eps:
         configs[entry_point.name.lower()] = entry_point.load()
 
     return configs

{matlab-proxy-0.16.0 → matlab-proxy-0.18.0}/matlab_proxy/util/windows.py

@@ -1,9 +1,12 @@
-# Copyright 2022-2023 The MathWorks, Inc.
+# Copyright 2022-2024 The MathWorks, Inc.
 import asyncio
 
 from matlab_proxy import util
 from matlab_proxy.util import mwi
 from matlab_proxy.util.mwi import environment_variables as mwi_env
+from matlab_proxy.util.mwi.exceptions import (
+    UIVisibleFatalError,
+)
 
 
 """ This file contains methods specific to non-posix / windows OS.
@@ -77,8 +80,9 @@ async def start_matlab(matlab_cmd, matlab_env):
             "MATLAB.exe" == matlab.name()
         ), "Expecting the child process name to be MATLAB.exe"
 
-    except AssertionError as err:
+    except (AssertionError, UIVisibleFatalError) as err:
         raise err
+
     except psutil.NoSuchProcess:
         # We reach here when the intermediate process launched by matlab-proxy died
         # before we can query for its child processes. Hence, to find the actual MATLAB

{matlab-proxy-0.16.0 → matlab-proxy-0.18.0/matlab_proxy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: matlab-proxy
-Version: 0.16.0
+Version: 0.18.0
 Summary: Python® package enables you to launch MATLAB® and access it from a web browser.
 Home-page: https://github.com/mathworks/matlab-proxy/
 Author: The MathWorks, Inc.

{matlab-proxy-0.16.0 → matlab-proxy-0.18.0}/matlab_proxy.egg-info/SOURCES.txt

@@ -113,6 +113,7 @@ matlab_proxy.egg-info/not-zip-safe
 matlab_proxy.egg-info/requires.txt
 matlab_proxy.egg-info/top_level.txt
 matlab_proxy/icons/matlab.svg
+matlab_proxy/matlab/evaluateUserMatlabCode.m
 matlab_proxy/matlab/startup.m
 matlab_proxy/util/__init__.py
 matlab_proxy/util/event_loop.py

{matlab-proxy-0.16.0 → matlab-proxy-0.18.0}/matlab_proxy.egg-info/requires.txt

@@ -1,6 +1,8 @@
 aiohttp>=3.7.4
-psutil
 aiohttp_session[secure]
+importlib-metadata
+importlib-resources
+psutil
 
 [dev]
 aiohttp-devtools

{matlab-proxy-0.16.0 → matlab-proxy-0.18.0}/setup.py

@@ -63,14 +63,20 @@ TESTS_REQUIRES = [
     "pytest-playwright",
 ]
 
-INSTALL_REQUIRES = ["aiohttp>=3.7.4", "psutil", "aiohttp_session[secure]"]
+INSTALL_REQUIRES = [
+    "aiohttp>=3.7.4",
+    "aiohttp_session[secure]",
+    "importlib-metadata",
+    "importlib-resources",
+    "psutil",
+]
 
 HERE = Path(__file__).parent.resolve()
 long_description = (HERE / "README.md").read_text()
 
 setuptools.setup(
     name="matlab-proxy",
-    version="0.16.0",
+    version="0.18.0",
     url=config["doc_url"],
     author="The MathWorks, Inc.",
     author_email="cloud@mathworks.com",