fix pylint hints about (internal) variable names

OMPython/OMCSession.py:1106:8: C0103: Attribute name "_dockerExtraArgs" doesn't conform to snake_case naming style (invalid-name)
OMPython/OMCSession.py:1107:8: C0103: Attribute name "_dockerOpenModelicaPath" doesn't conform to snake_case naming style (invalid-name)
OMPython/OMCSession.py:1108:8: C0103: Attribute name "_dockerNetwork" doesn't conform to snake_case naming style (invalid-name)
OMPython/OMCSession.py:1110:8: C0103: Attribute name "_interactivePort" doesn't conform to snake_case naming style (invalid-name)
OMPython/OMCSession.py:1112:8: C0103: Attribute name "_dockerCid" doesn't conform to snake_case naming style (invalid-name)
OMPython/OMCSession.py:1121:12: C0103: Variable name "dockerTop" doesn't conform to snake_case naming style (invalid-name)
OMPython/OMCSession.py:1282:8: C0103: Variable name "extraFlags" doesn't conform to snake_case naming style (invalid-name)
OMPython/OMCSession.py:1297:12: C0103: Variable name "dockerNetworkStr" doesn't conform to snake_case naming style (invalid-name)

Author: syntron

OMPython/OMCSession.py

@@ -1109,13 +1109,13 @@ def __init__(
         if dockerExtraArgs is None:
             dockerExtraArgs = []
 
-        self._dockerExtraArgs = dockerExtraArgs
-        self._dockerOpenModelicaPath = pathlib.PurePosixPath(dockerOpenModelicaPath)
-        self._dockerNetwork = dockerNetwork
+        self._docker_extra_args = dockerExtraArgs
+        self._docker_open_modelica_path = pathlib.PurePosixPath(dockerOpenModelicaPath)
+        self._docker_network = dockerNetwork
 
-        self._interactivePort = port
+        self._interactive_port = port
 
-        self._dockerCid: Optional[str] = None
+        self._docker_container_id: Optional[str] = None
         self._docker_process: Optional[DockerPopen] = None
 
     def _docker_process_get(self, docker_cid: str) -> Optional[DockerPopen]:
@@ -1124,15 +1124,15 @@ def _docker_process_get(self, docker_cid: str) -> Optional[DockerPopen]:
 
         docker_process = None
         for _ in range(0, 40):
-            dockerTop = subprocess.check_output(["docker", "top", docker_cid]).decode().strip()
+            docker_top = subprocess.check_output(["docker", "top", docker_cid]).decode().strip()
             docker_process = None
-            for line in dockerTop.split("\n"):
+            for line in docker_top.split("\n"):
                 columns = line.split()
                 if self._random_string in line:
                     try:
                         docker_process = DockerPopen(int(columns[1]))
                     except psutil.NoSuchProcess as ex:
-                        raise OMCSessionException(f"Could not find PID {dockerTop} - "
+                        raise OMCSessionException(f"Could not find PID {docker_top} - "
                                                   "is this a docker instance spawned without --pid=host?") from ex
 
             if docker_process is not None:
@@ -1155,8 +1155,8 @@ def _getuid() -> int:
     def _omc_port_get(self) -> str:
         port = None
 
-        if not isinstance(self._dockerCid, str):
-            raise OMCSessionException(f"Invalid docker container ID: {self._dockerCid}")
+        if not isinstance(self._docker_container_id, str):
+            raise OMCSessionException(f"Invalid docker container ID: {self._docker_container_id}")
 
         # See if the omc server is running
         attempts = 0
@@ -1165,7 +1165,7 @@ def _omc_port_get(self) -> str:
             if omc_portfile_path is not None:
                 try:
                     output = subprocess.check_output(args=["docker",
-                                                           "exec", self._dockerCid,
+                                                           "exec", self._docker_container_id,
                                                            "cat", omc_portfile_path.as_posix()],
                                                      stderr=subprocess.DEVNULL)
                     port = output.decode().strip()
@@ -1190,8 +1190,8 @@ def get_server_address(self) -> Optional[str]:
         """
         Get the server address of the OMC server running in a Docker container.
         """
-        if self._dockerNetwork == "separate" and isinstance(self._dockerCid, str):
-            output = subprocess.check_output(["docker", "inspect", self._dockerCid]).decode().strip()
+        if self._docker_network == "separate" and isinstance(self._docker_container_id, str):
+            output = subprocess.check_output(["docker", "inspect", self._docker_container_id]).decode().strip()
             return json.loads(output)[0]["NetworkSettings"]["IPAddress"]
 
         return None
@@ -1200,10 +1200,10 @@ def get_docker_container_id(self) -> str:
         """
         Get the Docker container ID of the Docker container with the OMC server.
         """
-        if not isinstance(self._dockerCid, str):
-            raise OMCSessionException(f"Invalid docker container ID: {self._dockerCid}!")
+        if not isinstance(self._docker_container_id, str):
+            raise OMCSessionException(f"Invalid docker container ID: {self._docker_container_id}!")
 
-        return self._dockerCid
+        return self._docker_container_id
 
     def omc_run_data_update(self, omc_run_data: OMCSessionRunData) -> OMCSessionRunData:
         """
@@ -1217,8 +1217,8 @@ def omc_run_data_update(self, omc_run_data: OMCSessionRunData) -> OMCSessionRunD
                     "--user", str(self._getuid()),
                     "--workdir", omc_run_data_copy.cmd_path,
                 ]
-                + self._dockerExtraArgs
-                + [self._dockerCid]
+                + self._docker_extra_args
+                + [self._docker_container_id]
         )
 
         cmd_path = pathlib.PurePosixPath(omc_run_data_copy.cmd_path)
@@ -1257,7 +1257,7 @@ def __init__(
         self._docker = docker
 
         # start up omc executable in docker container waiting for the ZMQ connection
-        self._omc_process, self._docker_process, self._dockerCid = self._docker_omc_start()
+        self._omc_process, self._docker_process, self._docker_container_id = self._docker_omc_start()
         # connect to the running omc instance using ZMQ
         self._omc_port = self._omc_port_get()
 
@@ -1285,45 +1285,45 @@ def _docker_omc_cmd(
         """
         Define the command that will be called by the subprocess module.
         """
-        extraFlags = []
+        extra_flags = []
 
         if sys.platform == "win32":
-            extraFlags = ["-d=zmqDangerousAcceptConnectionsFromAnywhere"]
-            if not self._interactivePort:
+            extra_flags = ["-d=zmqDangerousAcceptConnectionsFromAnywhere"]
+            if not self._interactive_port:
                 raise OMCSessionException("docker on Windows requires knowing which port to connect to - "
                                           "please set the interactivePort argument")
 
         if sys.platform == "win32":
-            if isinstance(self._interactivePort, str):
-                port = int(self._interactivePort)
-            elif isinstance(self._interactivePort, int):
-                port = self._interactivePort
+            if isinstance(self._interactive_port, str):
+                port = int(self._interactive_port)
+            elif isinstance(self._interactive_port, int):
+                port = self._interactive_port
             else:
                 raise OMCSessionException("Missing or invalid interactive port!")
-            dockerNetworkStr = ["-p", f"127.0.0.1:{port}:{port}"]
-        elif self._dockerNetwork == "host" or self._dockerNetwork is None:
-            dockerNetworkStr = ["--network=host"]
-        elif self._dockerNetwork == "separate":
-            dockerNetworkStr = []
-            extraFlags = ["-d=zmqDangerousAcceptConnectionsFromAnywhere"]
+            docker_network_str = ["-p", f"127.0.0.1:{port}:{port}"]
+        elif self._docker_network == "host" or self._docker_network is None:
+            docker_network_str = ["--network=host"]
+        elif self._docker_network == "separate":
+            docker_network_str = []
+            extra_flags = ["-d=zmqDangerousAcceptConnectionsFromAnywhere"]
         else:
-            raise OMCSessionException(f'dockerNetwork was set to {self._dockerNetwork}, '
+            raise OMCSessionException(f'dockerNetwork was set to {self._docker_network}, '
                                       'but only \"host\" or \"separate\" is allowed')
 
-        if isinstance(self._interactivePort, int):
-            extraFlags = extraFlags + [f"--interactivePort={int(self._interactivePort)}"]
+        if isinstance(self._interactive_port, int):
+            extra_flags = extra_flags + [f"--interactivePort={int(self._interactive_port)}"]
 
         omc_command = ([
                            "docker", "run",
                            "--cidfile", docker_cid_file.as_posix(),
                            "--rm",
                            "--user", str(self._getuid()),
                        ]
-                       + self._dockerExtraArgs
-                       + dockerNetworkStr
-                       + [self._docker, self._dockerOpenModelicaPath.as_posix()]
+                       + self._docker_extra_args
+                       + docker_network_str
+                       + [self._docker, self._docker_open_modelica_path.as_posix()]
                        + omc_path_and_args_list
-                       + extraFlags)
+                       + extra_flags)
 
         return omc_command
 
@@ -1397,7 +1397,7 @@ def __init__(
         if not isinstance(dockerContainer, str):
             raise OMCSessionException("Argument dockerContainer must be set!")
 
-        self._dockerCid = dockerContainer
+        self._docker_container_id = dockerContainer
 
         # start up omc executable in docker container waiting for the ZMQ connection
         self._omc_process, self._docker_process = self._docker_omc_start()
@@ -1415,27 +1415,27 @@ def _docker_omc_cmd(self, omc_path_and_args_list) -> list:
         """
         Define the command that will be called by the subprocess module.
         """
-        extraFlags: list[str] = []
+        extra_flags: list[str] = []
 
         if sys.platform == "win32":
-            extraFlags = ["-d=zmqDangerousAcceptConnectionsFromAnywhere"]
-            if not self._interactivePort:
+            extra_flags = ["-d=zmqDangerousAcceptConnectionsFromAnywhere"]
+            if not self._interactive_port:
                 raise OMCSessionException("Docker on Windows requires knowing which port to connect to - "
                                           "Please set the interactivePort argument. Furthermore, the container needs "
                                           "to have already manually exposed this port when it was started "
                                           "(-p 127.0.0.1:n:n) or you get an error later.")
 
-        if isinstance(self._interactivePort, int):
-            extraFlags = extraFlags + [f"--interactivePort={int(self._interactivePort)}"]
+        if isinstance(self._interactive_port, int):
+            extra_flags = extra_flags + [f"--interactivePort={int(self._interactive_port)}"]
 
         omc_command = ([
                            "docker", "exec",
                            "--user", str(self._getuid()),
                        ]
-                       + self._dockerExtraArgs
-                       + [self._dockerCid, self._dockerOpenModelicaPath.as_posix()]
+                       + self._docker_extra_args
+                       + [self._docker_container_id, self._docker_open_modelica_path.as_posix()]
                        + omc_path_and_args_list
-                       + extraFlags)
+                       + extra_flags)
 
         return omc_command
 
@@ -1454,12 +1454,12 @@ def _docker_omc_start(self) -> Tuple[subprocess.Popen, DockerPopen]:
                                        env=my_env)
 
         docker_process = None
-        if isinstance(self._dockerCid, str):
-            docker_process = self._docker_process_get(docker_cid=self._dockerCid)
+        if isinstance(self._docker_container_id, str):
+            docker_process = self._docker_process_get(docker_cid=self._docker_container_id)
 
         if docker_process is None:
             raise OMCSessionException(f"Docker top did not contain omc process {self._random_string} "
-                                      f"/ {self._dockerCid}. Log-file says:\n{self.get_log()}")
+                                      f"/ {self._docker_container_id}. Log-file says:\n{self.get_log()}")
 
         return omc_process, docker_process