Creating Proc methods.

api/wingui/cli.py

@@ -627,142 +627,108 @@ class Wingui:
 # Funções proc
     def proc_exec(self, cmd: str):
 
-        """Executa o comando cmd na maquina que executa o robo
+        """
-        Essa operação acontece dentro de um CMD. Ou seja, para inicializar uma instancia do finado
+        ## Process execute
-        Internet Explorer rodando:
+        Executa um comando cmd localmente na máquina. Para abertura de arquivos, é necessário informar o caminho absoluto do arquivo. No caso de arquivos nativos da Microsoft pode-se apenas escrever o nome do mesmo.
 
-        r.proc_exec("C:\\Program Files\\Internet Explorer\\iexplore.exe")
+        ---
+        ### Ex:
+            - wg.proc_exec("C:\\Program Files\\Internet Explorer\\iexplore.exe")
+            - wg.proc_exec("mspaint")
 
+        ---
+        Params:
+            - cmd: Comando CMD a ser executado
+        ---
+        Retorna:
+        
+            -> "ok"
         """
         cmd = urllib.parse.quote(cmd, "")
-        return self.__request__("proc/exec?cmd={}".format(cmd))
+        return self.__request__(f"/ipc/wingui/proc/exec?cmd={cmd}")
+
+    def proc_kill(self, pid: int):
 
-    def proc_kill(self, cmd: str):
-        """Mata processo pelo nome, ou seja se quiser matar o ie, vc passa como iexplore.exe.
-            ***ATENCAO*** todos os processos com o mesmo nome serao mortos por esse comando
         """
-        cmd = urllib.parse.quote(cmd, "")
+        ## Process kill
-        return self.__request__("proc/kill?cmd={}".format(cmd))
+        Finaliza o processo com PID informado como parâmetro.
+
+        ---
+        Params:
+            - pid: Identificador do processo que se deseja finalizar.
+        ---
+        Retorna:
+
+            - Sucesso: "Êxito, o processo com PID {num_do_pid} foi finalizado.".
+            - Falha: Erro.
+        """
+        return self.__request__(f"/ipc/wingui/proc/kill?cmd={pid}")
+    
+    def proc_all(self):
+
+        """
+        ## Process All
+        Lista todos os processos em execução na maquina robo.
+
+        ---
+        #### Params:
+
+            ---
+
+        ---
+        #### Retorna:
+            Um array de dicionários python. Cada um deles tem o formato:
+                {
+                    "Pid": xxx
+                    "Name":"str"
+                }
+            Onde Pid é um inteiro representando o PID do processo, e Name é o nome do processo.
+        """
+        return self.__request__("/ipc/wingui/proc/all")
 
     def proc_name(self, pid: int):
-        """Obtem o nome do processo através de seu PID. Para obter o PID, vide proc_all e window_list"""
+        """
-        return self.__request__("proc/name?pid={}".format(pid))
+        ## Process Name
+        Obtem o nome do processo através de seu PID.
+
+        ---
+        #### Params:
+
+            - pid: Número do identificador de processo que se quer saber o nome.
+
+        ---
+        #### Retorna:
+            -> Nome do processo correspondente ao PID.
+        """
+        return self.__request__(f"/ipc/wingui/proc/name?pid={pid}")
 
     def proc_path(self, pid: int):
-        """Retorna o PATH da imagem (.exe) que representa um processo, de acordo com seu PID"""
-        return self.__request__("proc/path?pid={}".format(pid))
-
-    def proc_all(self):
-        """Lista todos os processos em execução na maquina robo.
-        Retorna um array de dicts. Cada dict com o formato:
-        {
-            "Pid":0
-            "Name":"str"
-        }
-        Onde Pid é um inteiro representando o PID do processo, e Name é o nome do processo.
         """
-        return self.__request__("proc/all")
+        ## Process Path
+        Retorna o caminho do arquivo que corresponde ao PID informado.
+
+        ---
+        #### Params:
+            - pid: Identificador do processo ativo que se quer saber o caminho.
+
+        ---
+        #### Retorna:
+            -> Caminho do arquivo correspondente ao PID.
+        """
+        return self.__request__(f"/ipc/wingui/proc/path?pid={pid}")
 
     def proc_pids(self):
-        """Retorna um array de inteiros, representando TODOS os processos em execução"""
+        """
-        return self.__request__("proc/pids")       
+        ## Process PIDS
+        Busca todos os processos ativos na máquina e retorna o PID deles.
 
-# Funções Window
+        ---
-    def window_activehwnd(self) -> int:
+        #### Params:
-        """
+            
-        Retorna o HWND da janela ativa.
+            ---
-        HWND é um indicador unico de um componente ajanelado no windows.
-        """
-        return self.__request__("window/activehwnd")
 
-    def window_activetitle(self) -> str:
+        ---
+        #### Retorna:
+            -> Array de inteiros contendo todos os PIDS ativos da máquina.
         """
-        Retorna o titulo da janela ativo.
+        return self.__request__("/ipc/wingui/proc/pids")       
-        """
-        return self.__request__("window/activetitle")
-
-    def window_list(self, s: str = "") -> List[dict]:
-
-        """
-        Lista as janelas disponiveis, fitrando por s, caso ele seja fornecido. Nesse caso, apenas janelas que
-        contenham o string s serao retornadas.
-
-        Retorna um array de dicts com o seguinte formato:
-        {
-            "Hwnd":0,
-            "Pid":0,
-            "Title":"str"
-
-        }
-
-        Onde Hwnd é o identificador da janela, pid é o numero do processo, e Title é o titulo da janela
-        """
-        if s == "":
-            return self.__request__("window/list")
-        s = urllib.parse.quote(s, "")
-        return self.__request__("window/list?s={}".format(s))
-
-    def window_hwnd(self, s: str = "") -> List[int]:
-        """
-        Semelhante a window_list, mas traz apenas um array de ints com os respectivos HWND's
-        """
-        s = urllib.parse.quote(s, "")
-        return self.__request__("window/Hwnd?s={}".format(s))
-
-    def window_activate(self, hwnd: int):
-        """
-        Ativa uma janela de acordo com seu hwnd
-        """
-        return self.__request__("window/activate?Hwnd={}".format(hwnd))
-
-    def window_close(self, hwnd: int):
-        """
-        Fecha janela de acordo com o hwnd.
-        """
-        return self.__request__("window/close?Hwnd={}".format(hwnd))
-
-    def window_max(self, s: int):
-        """
-        Maximiza janela de acordo com o hwnd.
-        """
-        return self.__request__("window/max?Hwnd={}".format(s))
-
-    def window_min(self, s: int):
-        """
-        Minimiza janela de acordo com o hwnd.
-        """
-        return self.__request__("window/min?Hwnd={}".format(s))
-
-    def window_postmsg(self, w: int, m: int) -> dict:
-        """
-        Envia msg para janela usando postmsg
-        :param w: handler da janela
-        :param m: codigo da mensagem
-        :return: valor de retorno
-        """
-        return self.__request__("window/postmsg?w={}&m={}".format(w, m))
-
-    def window_sendmsg(self, w: int, m: int) -> dict:
-        """
-        Envia msg para janela isando sendmsg
-        :param w: handler da janela
-        :param m: codigo da mensagem
-        :return: valor de retorno
-        """
-        return self.__request__("window/sendmsg?w={}&m={}".format(w, m))
-
-    def window_waitactivetitle(self, t: str, m: int = 30):
-        """
-        Aguarda por m segundos ate que o titulo da janela ativa tenha o substring t. Caso o tempo limite seja
-        alcançado, dispara exceção.
-        """
-        t = urllib.parse.quote(t, "")
-        return self.__request__("window/waitactivetitle?t={}&m={}".format(t, m))
-
-    def window_winfo(self, w: int) -> dict:
-        """
-        Obtem informações de uma janela Win32
-        :param w: int representando o hwnd da janela
-        :return: dict com informações da janela
-        """
-        return self.__request__("window/winfo?w={}".format(w))