magnax 1.0.0__py3-none-any.whl

magnax/__init__.py

@@ -0,0 +1,3 @@
+# -*- encoding: utf-8 -*-
+
+__version__ = '1.0.0'

magnax/__main__.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+MagnaX - Real-time performance monitoring tool for Android/iOS apps.
+
+Usage:
+    magnax [--host=HOST] [--port=PORT]
+    python -m magnax [--host=HOST] [--port=PORT]
+
+Examples:
+    magnax                          # Start with default settings (localhost:50003)
+    magnax --host=0.0.0.0 --port=8080  # Custom host and port
+"""
+
+import fire
+from magnax.web import main as web_main
+
+
+def main():
+    """Entry point for the magnax command."""
+    fire.Fire(web_main)
+
+
+if __name__ == '__main__':
+    main()

magnax/debug.py

@@ -0,0 +1,65 @@
+import multiprocessing
+import subprocess
+import time
+import os
+import webbrowser
+import requests
+import socket
+import psutil
+import sys
+from view.apis import api
+from view.pages import page
+from loguru import logger
+from flask import Flask
+from pyfiglet import Figlet
+from magnax import __version__
+
+app = Flask(__name__, template_folder='templates', static_folder='static')
+app.register_blueprint(api)
+app.register_blueprint(page)
+
+
+def ip() -> str:
+    try:
+        ip = socket.gethostbyname(socket.gethostname())
+    except:
+        ip = '127.0.0.1'    
+    return ip
+
+def listen(port):
+    net_connections = psutil.net_connections()
+    conn = [c for c in net_connections if c.status == "LISTEN" and c.laddr.port == port]
+    if conn:
+        pid = conn[0].pid
+        logger.warning('Port {} is used by process {}'.format(port, pid))
+        logger.info('you can start magnax : python -m magnax --host={ip} --port={port}')
+        return False
+    return True
+
+def status(host: str, port: int):
+    r = requests.get('http://{}:{}'.format(host, port), timeout=2.0)
+    flag = (True, False)[r.status_code == 200]
+    return flag
+
+
+def open_url(host: str, port: int):
+    flag = True
+    while flag:
+        logger.info('start magnax server ...')
+        f = Figlet(font="slant", width=300)
+        print(f.renderText("MAGNAX {}".format(__version__)))
+        flag = status(host, port)
+    webbrowser.open('http://{}:{}/?platform=Android&lan=en'.format(host, port), new=2)
+    logger.info('Running on http://{}:{}/?platform=Android&lan=en (Press CTRL+C to quit)'.format(host, port))
+
+
+def start(host: str, port: int):
+    logger.info('Running on http://{}:{}/?platform=Android&lan=en (Press CTRL+C to quit)'.format(host, port))
+    app.run(host=host, port=port, debug=True)
+
+def main(host=ip(), port=50003):
+    start(host, port)      
+
+
+if __name__ == '__main__':
+    main()

magnax/public/__init__.py

@@ -0,0 +1 @@
+

magnax/public/adb.py

@@ -0,0 +1,96 @@
+#!/usr/bin/python
+# encoding=utf-8
+
+"""
+@Author  :  Lijiawei
+@Date    :  2022/6/19
+@Desc    :  adb line.
+@Update  :  2022/7/14 by Rafa chen
+"""
+import os
+import platform
+import stat
+import subprocess
+
+STATICPATH = os.path.dirname(os.path.realpath(__file__))
+DEFAULT_ADB_PATH = {
+    "Windows": os.path.join(STATICPATH, "adb", "windows", "adb.exe"),
+    "Darwin": os.path.join(STATICPATH, "adb", "mac", "adb"),
+    "Linux": os.path.join(STATICPATH, "adb", "linux", "adb"),
+    "Linux-x86_64": os.path.join(STATICPATH, "adb", "linux", "adb"),
+    "Linux-armv7l": os.path.join(STATICPATH, "adb", "linux_arm", "adb"),
+}
+
+
+def make_file_executable(file_path):
+    """
+    If the path does not have executable permissions, execute chmod +x
+    :param file_path:
+    :return:
+    """
+    if os.path.isfile(file_path):
+        mode = os.lstat(file_path)[stat.ST_MODE]
+        executable = True if mode & stat.S_IXUSR else False
+        if not executable:
+            os.chmod(file_path, mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+        return True
+    return False
+
+
+def builtin_adb_path():
+    """
+    Return built-in adb executable path
+
+    Returns:
+        adb executable path
+
+    """
+    system = platform.system()
+    machine = platform.machine()
+    adb_path = DEFAULT_ADB_PATH.get('{}-{}'.format(system, machine))
+    proc = subprocess.Popen('adb devices', stdout=subprocess.PIPE, shell=True)
+    result = proc.stdout.read()
+    if not isinstance(result, str):
+        result = str(result, 'utf-8')
+    if result and "command not found" not in result:
+        adb_path = "adb"
+        return adb_path
+
+    if not adb_path:
+        adb_path = DEFAULT_ADB_PATH.get(system)
+    if not adb_path:
+        raise RuntimeError("No adb executable supports this platform({}-{}).".format(system, machine))
+
+    # overwrite uiautomator adb
+    if "ANDROID_HOME" in os.environ:
+        del os.environ["ANDROID_HOME"]
+    if system != "Windows":
+        # chmod +x adb
+        make_file_executable(adb_path)
+    return adb_path
+
+
+class ADB(object):
+
+    def __init__(self):
+        self.adb_path = builtin_adb_path()
+
+    def shell(self, cmd, deviceId):
+        run_cmd = f'{self.adb_path} -s {deviceId} shell {cmd}'
+        result = subprocess.Popen(run_cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()[
+            0].decode("utf-8").strip()
+        return result
+    
+    def tcp_shell(self, deviceId, cmd):
+        run_cmd = f'{self.adb_path} -s {deviceId} {cmd}'
+        result = os.system(run_cmd)
+        return result
+
+    def shell_noDevice(self, cmd):
+        run_cmd = f'{self.adb_path} {cmd}'
+        result = os.system(run_cmd)
+        return result    
+
+
+
+adb = ADB()