Kea2-python 0.0.1a0__py3-none-any.whl

kea2_python-0.0.1a0.dist-info/METADATA

@@ -0,0 +1,433 @@
+Metadata-Version: 2.4
+Name: Kea2-python
+Version: 0.0.1a0
+Summary: A python library for supporting and customizing automated UI testing for mobile apps
+Author-email: Xixian Liang <xixian@stu.ecnu.edu.cn>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rtree>=1.4.0
+Requires-Dist: uiautomator2>=3.2.9
+Dynamic: license-file
+
+# Introduction 
+
+Kea2 is an easy-to-use Python library for supporting and customizing automated UI testing for mobile apps. The library is currently built on top of [Fastbot](https://github.com/bytedance/Fastbot_Android) and [uiautomator2](https://github.com/openatx/uiautomator2), and targeting [Android](https://en.wikipedia.org/wiki/Android_(operating_system)) apps.
+
+### Kea2 has three important features:
+- **Feature 1**(查找稳定性问题): coming with the full capability of [Fastbot](https://github.com/bytedance/Fastbot_Android) for stress testing and finding *stability problems* (i.e., *crashing bugs*); 
+- **Feature 2**(自定义测试场景或事件序列[^1]): customizing testing scenarios when running Fastbot (e.g., testing specific app functionalities, executing specific event traces, entering specifc UI pages, reaching specific app states) with the full capability and flexibility powered by *python* language and [uiautomator2](https://github.com/openatx/uiautomator2);
+- **Feature 3**(支持断言机制[^2]): supporting auto-assertions when running Fastbot, based on the idea of [property-based testing](https://en.wikipedia.org/wiki/Software_testing#Property_testing) inheritted from [Kea](https://github.com/ecnusse/Kea), for finding *logic bugs* (i.e., *non-crashing bugs*)
+
+These three features can be combined to customize and improve automated UI testing.
+
+<div align="center">
+    <div style="max-width:80%; max-height:80%">
+    <img src="docs/intro.png" style="border-radius: 14px; width: 80%; height: 80%;"/> 
+    </div>
+</div>
+
+> Kea2 is designed to be capable of fusing the (property-based) *scripteds* (e.g., written in uiautomator2) with automated UI testing tools (e.g., Fastbot), thus combining the strengths of human knowledge on app's business logics (empowered by the scripts) and random fuzzing. Many useful features (e.g., mimicing exploratory testing) can be implemented based on such a capability.
+
+**The ability of the three features in Kea2**
+|  | **Feature 1** | **Feature 2** | **Feature 3** |
+| --- | --- | --- | ---- |
+| **Finding crashes** | :+1: | :+1: | :+1: |
+| **Finding crashes in deep states** |  | :+1: | :+1: |
+| **Finding non-crashing functional bugs** |  |  | :+1: |
+ 
+Kea2, released as a Python library, currently works with:
+- [unittest](https://docs.python.org/3/library/unittest.html) as the testing framework;
+- [uiautomator2](https://github.com/openatx/uiautomator2) as the UI test driver; 
+- [Fastbot](https://github.com/bytedance/Fastbot_Android) as the backend automated UI testing tool.
+
+In the future, Kea2 will be extended to support
+- [pytest](https://docs.pytest.org/en/stable/)
+- [Appium](https://github.com/appium/appium), [Hypium]() (for HarmonyOS)
+- other automated UI testing tools (not limited to Fastbot)
+
+> Kea2 is inspired by many valuable insights, advices and lessons shared by experienced industrial practitioners from Bytedance (Zhao Zhang, Yuhui Su from the Fastbot team), OPay (Tiesong Liu), WeChat (Haochuan Lu), Huawei, Xiaomi and etc. Kudos!
+
+
+# Deploy Kea2
+
+## Installation
+
+Running requirements/environment:
+- support Windows, MacOS and Linux
+- python 3.8+
+- Android SDK installed
+- **VPN closed** (Features 2 and 3 required)
+
+1. Clone `Kea2` into your workspace.
+
+```bash
+git clone git@github.com:ecnusse/Kea2.git
+cd Kea2
+```
+
+2. Setup the python virtual environment with `uv`.
+
+> [uv](https://github.com/astral-sh/uv) is a extremely fast python package and project manager. We use `uv` to create a python virtual environment for Kea2 to avoid any dependency issues or conflicts with your existing python environment.
+`uv` is similar to `virtualenv` but much more powerful.
+Of course, you can also setup Kea2 in your [global environment](https://github.com/ecnusse/Kea2/tree/dev?tab=readme-ov-file#appendix-install-kea2-in-a-global-environment).
+
+```bash
+pip install --upgrade pip
+pip install uv
+uv sync
+```
+
+> MacOS users may have trouble with global pip install. In such cases, they can use `brew`.
+```bash
+# For macOS users
+brew install uv
+uv sync
+```
+
+3. Activate virtual environment
+
+- Linux and macOS
+```bash
+source .venv/bin/activate
+```
+
+- Windows cmd
+```cmd
+\.venv\Scripts\activate.bat
+```
+
+- Windows powershell
+```powershell
+\.venv\Scripts\activate.ps1
+```
+
+## Quick Test
+
+Kea2 connects to and runs on Android devices. We recommend you to do a quick test to ensure that Kea2 is compatible with your devices.
+
+1. Connect to an Android device and make sure you can see the connected device by running `adb devices`. 
+
+2. Run `quickstart.py` to test a sample app `omninotes` (released as `omninotes.apk` in Kea2's repository). The script `quickstart.py` will automatically install and test this sample app for a short time.
+
+```python
+python3 quickstart.py
+```
+
+If you can see the app `omninotes` is successfully running and tested, Kea2 works. Otherwise, please help [file a bug report](https://github.com/ecnusse/Kea2/issues) with the error message to us. Thank you!
+
+If you do not have an Android device at hand, you can use an Android emulator to run Kea2. The following commands can help create and start an Android emulator (Android version 12, API level 31) on a x86 machine (of course, you can create emulators by Android Studio):
+```bash
+sdkmanager "system-images;android-31;google_apis;x86_64"
+
+avdmanager create avd --force --name Android12 --package 'system-images;android-31;google_apis;x86_64' --abi google_apis/x86_64 --sdcard 1024M --device 'Nexus 7'
+
+emulator -avd Android12 -port 5554 &
+```
+
+> [quickstart.py](https://github.com/XixianLiang/KeaPlus/blob/main/quickstart.py) is a dead simple script which is ready-to-go with Fastbot. You can customize this script for testing your apps.
+
+## Feature 1(查找稳定性问题): running Fastbot
+
+Test your app with the full capability of [Fastbot](https://github.com/bytedance/Fastbot_Android) for stress testing and finding *stability problems* (i.e., *crashing bugs*); 
+
+
+```bash
+python3 kea_launcher.py driver -s "emulator-5554" -p it.feio.android.omninotes.alpha --agent native --running-minutes 10 --throttle 200
+```
+
+The usage is similar to the the original [Fastbot](https://github.com/bytedance/Fastbot_Android?tab=readme-ov-file#run-fastbot-with-shell-command)'s shell commands. 
+See more options by `python kea_launcher.py driver -h`
+
+
+## Feature 2(自定义测试场景或事件序列): customizing testing scenarios by scripts
+
+When running any automated UI testing tools like Fastbot to test your apps, you may find that some specifc UI pages or functionalities are difficult to reach or cover. The reason is that Fastbot lacks knowledge of your apps. Fortunately, this is the strength of script testing. In Feature 2, Kea2 can support writing small scripts to guide Fastbot to explore wherever we want.
+
+<div align="center">
+    <div>
+    <img src="docs/stage1.png" style="border-radius: 14px; width: 80%; height: 80%;"/> 
+    </div>
+</div>
+
+<div align="center">
+    <img src="docs/stage2.png" style="border-radius: 14px; width: 80%; height: 80%;"/> 
+</div>
+
+Kea2 can support you to test your app by customizing testing scenarios (e.g., testing specific app functionalities, executing specific event traces, entering specifc UI pages, reaching specific app states) with the full capability and flexibility powered by `python` language and [uiautomator2](https://github.com/openatx/uiautomator2);
+
+In Kea2, a script is composed of two elements:
+-  **Precondition:** When to execute the script.
+- **Interaction scenario:** The interaction logic (specified in the script's test method) to reach where we want.
+
+### Example
+
+Assuming `Privacy` is a hard-to-reach UI page during automated UI testing. Kea2 can easily guide Fastbot to reach this page.
+
+```python
+    @prob(0.5)
+    # precondition: when we are at the page `Home`
+    @precondition(lambda self: 
+        self.d(text="Home").exists
+    )
+    def test_goToPrivacy(self):
+        """
+        Guide Fastbot to the page `Privacy` by opening `Drawer`, 
+        clicking the option `Setting` and clicking `Privacy`.
+        """
+        self.d(description="Drawer").click()
+        self.d(text="Settings").click()
+        self.d(text="Privacy").click()
+```
+
+- By the decorator `@precondition`, we specify the precondition --- when we are at the `Home` page. 
+In this case, the `Home` page is the entry page of the `Privacy` page and the `Home` page can be easily reached by Fastbot. Thus, the script will be activated when we are at `Home` page by checking whether a unique widget `Home` exists. 
+- In script's test method `test_goToPrivacy`, we specify the interaction logic (i.e., opening `Drawer`, clicking the option `Setting` and clicking `Privacy`) to guide Fastbot to reach the `Privacy` page.
+- By the decorator `@prob`, we specify the probability (50% in this example) to do the guidance when we are at the `Home` page. As a result, Kea2 still allows Fastbot to explore other pages.
+
+You can find the full example in script `quickstart2.py` and run it by executing:
+
+
+```bash
+# Launch Kea2 and load one single script quickstart2.py.
+python3 kea_launcher.py driver -s "emulator-5554" -p it.feio.android.omninotes.alpha --agent u2 --running-minutes 10 --throttle 200 --driver-name d unittest quickstart2.py
+```
+
+or simply run:
+
+```python
+python3 quickstart2.py
+```
+
+
+
+## Feature 3(支持断言机制): Supporting auto-assertions by scripts.
+
+Kea2 supports auto-assertions when running Fastbot for finding *logic bugs* (i.e., *non-crashing bugs*). To achieve this, you can add assertions in the scripts. When an assertion fails during automated UI testing, we find a likely functional bug. This idea is inspired by  [property-based testing](https://en.wikipedia.org/wiki/Software_testing#Property_testing) inheritted from [Kea](https://github.com/ecnusse/Kea).
+
+<div align="center">
+    <img src="docs/stage3.png" style="border-radius: 14px; width: 80%; height: 80%;"/> 
+</div>
+
+In Feature 3, a script is composed of three elements:
+
+- **Precondition:** When to execute the script.
+- **Interaction scenario:** The interaction logic (specified in the script's test method).
+- **Assertion:** The expected app behaviour.
+
+### Example
+
+In a social media app, message sending is a common feature. On the message sending page, the `send` button should always appears when the input box is not empty (i.e., has some message).
+
+<div align="center" >
+    <div >
+        <img src="docs/socialAppBug.png" style="border-radius: 14px; width:60%; height:70%;"/>
+    </div>
+    <p>The expected behavior (the upper figure) and the buggy behavior (the lower figure).
+<p/>
+</div>
+
+For the preceding always-holding property, we can write the following script to validate the functional correctness: when there is an `input_box` widget on the message sending page, we can type any non-empty string text into the input box and assert `send_button` should always exists.
+
+
+```python
+    @precondition(
+        lambda self: self.d(description="input_box").exists
+    )
+    def test_input_box(self):
+        from hypothesis.strategies import text, ascii_letters
+        random_str = text(alphabet=ascii_letters).example()
+        self.d(description="input_box").set_text(random_str)
+        assert self.d(description="send_button").exist
+
+        # we can even do more assertions, e.g.,
+        #       the input string should exist on the message sending page
+        assert self.d(text=random_str).exist
+```
+>  We use [hypothesis](https://github.com/HypothesisWorks/hypothesis), a property-based testing library for Python, to generate random texts according to the given rules.
+
+# Documentation
+
+## Write scripts
+
+Kea2 uses [Unittest](https://docs.python.org/3/library/unittest.html) to manage scripts. All the Kea2's scripts can be found in unittest's rules (i.e., the test methods should start with `test_`, the test classes should extend `unittest.TestCase`).
+
+Kea2 uses [Uiautomator2](https://github.com/openatx/uiautomator2) to manipulate android devices. Refer to [Uiautomator2's docs](https://github.com/openatx/uiautomator2?tab=readme-ov-file#quick-start) for more details.
+
+Basically, you can write Kea2's scripts by following two steps:
+
+1. Create a test class which extends `unittest.TestCase`.
+
+```python
+import unittest
+
+class MyFirstTest(unittest.TestCase):
+    ...
+```
+
+2. Write your own script by defining test methods
+
+By default, only the test method starts with `test_` will be found by unittest. You can decorate the function with `@precondition`. The decorator `@precondition` takes a function which returns boolean as an arugment. When the function returns `True`, the precondition is satisified and the script will be activated, and Kea2 will run the script based on certain probability defined by the decorator `@prob`.
+
+Note that if a test method is not decorated with `@precondition`.
+This test method will never be activated during automated UI testing, and will be treated as a normal `unittset` test method.
+Thus, you need to explicitly specify `@precondition(lambda self: True)` when the test method should be always executed. When a test method is not decorated with `@prob`, the default probability is 1 (always execute when precondition satisfied).
+
+```python
+import unittest
+from kea2 import precondition
+
+class MyFirstTest(unittest.TestCase):
+
+    @prob(0.7)
+    @precondition(lambda self: ...)
+    def test_func1(self):
+        ...
+```
+
+You can read [Kea - Write your fisrt property](https://kea-docs.readthedocs.io/en/latest/part-keaUserManuel/first_property.html) for more details.
+
+
+## Launch Kea2
+
+We offer two ways to launch Kea2.
+
+### 1. Launch by shell commands
+
+Kea2 is compatible with `unittest` framework. You can manage your test cases in unittest style. You can launch Kea2 with `kea_launcher.py` with two sub-commands `driver` (for Kea2 options) and `unittest` (for unittest options).
+
+The shell command:
+```
+python3 kea_launcher.py driver <Kea2 cmds> unittest <unittest cmds> 
+```
+
+Sample shell commands:
+
+```bash
+# Launch Kea2 and load one single script quickstart.py.
+python3 kea_launcher.py driver -s "emulator-5554" -p it.feio.android.omninotes.alpha --agent u2 --running-minutes 10 --throttle 200 --driver-name d unittest quickstart.py
+
+# Launch Kea2 and load multiple scripts from the directory mytests/omni_notes
+python3 kea_launcher.py driver -s "emulator-5554" -p it.feio.android.omninotes.alpha --agent u2 --running-minutes 10 --throttle 200 --driver-name d unittest discover -s mytests/omni_notes
+```
+
+| arg | meaning |
+| --- | --- |
+| -s | The serial of your device, which can be found by `adb devices` |
+| -p | The tested app's package name (e.g., com.example.app) | 
+| --agent |  {native, u2}. By default, `u2` is used and supports all the three important features of Kea2. If you hope to run the orignal Fastbot, please use `native`.|
+| --running-minutes | The time (m) to run Kea2 | 
+| --max-step | The maxium number of monkey events to send (only available in `--agent u2`) | 
+| --throttle | The delay time (ms) between two monkey events |
+| --driver-name | The name of driver used in the script. If `--driver-name d` is specified, you should use `d` to interact with a device, e..g, `self.d(..).click()`. |
+| unittest | Specify to load which scripts. This  sub-command `unittest` is fully compatible with unittest. See `python3 -m unittest -h` for more options of unittest. This option is only available in `--agent u2`.
+
+
+### 2. Launch by `unittest.main`
+
+Like unittest, we can launch Kea2 through the method `unittest.main`.
+
+Here is an example (named as `mytest.py`). You can see that the options are directly defined in the script.
+
+```python
+import unittest
+
+from kea2 import KeaTestRunner, Options
+from kea2.u2Driver import U2Driver
+
+class MyTest(unittest.TestCase):
+    ...
+    # <your test methods here>
+
+if __name__ == "__main__":
+    KeaTestRunner.setOptions(
+        Options(
+            driverName="d",
+            Driver=U2Driver,
+            packageNames=[PACKAGE_NAME],
+            # serial="emulator-5554",   # specify the serial
+            maxStep=100,
+            # running_mins=10,  # specify the maximal running time in minutes, default value is 10m
+            # throttle=200,   # specify the throttle in milliseconds, default value is 200ms
+            # agent='native'  # 'native' for running the vanilla Fastbot
+        )
+    )
+    # Declare the KeaTestRunner
+    unittest.main(testRunner=KeaTestRunner)
+```
+
+We can directly run the script `mytest.py` to launch Kea2, e.g.,
+```python
+python3 mytest.py
+```
+
+Here's all the available options in `Options`.
+
+```python
+# the driver_name in script (if self.d, then d.) 
+driverName: str
+# the driver (only U2Driver available now)
+Driver: U2Driver
+# list of package names. Specify the apps under test
+packageNames: List[str]
+# target device
+serial: str = None
+# test agent. "u2" is the default agent
+agent: "u2" | "native" = "u2"
+# max step in exploration (availble in stage 2~3)
+maxStep: int # default "inf"
+# time(mins) for exploration
+running_mins: int = 10
+# time(ms) to wait when exploring the app
+throttle: int = 200
+```
+
+
+## Examining the running statistics of scripts .
+
+If you want to examine whether your scripts have been executed or how many times they have been executed during testing. Open the file `result.json` after the testing is finished.
+
+Here's an example.
+
+```json
+{
+    "test_goToPrivacy": {
+        "precond_satisfied": 8,
+        "executed": 2,
+        "fail": 0,
+        "error": 1
+    },
+    ...
+}
+```
+
+**How to read `result.json`**
+
+Field | Description | Meaning
+--- | --- | --- |
+precond_satisfied | During exploration, how many times has the test method's precondition been satisfied? | Does we reach the state during exploration? 
+executed | During UI testing, how many times the test method has been executed? | Has the test method ever been executed?
+fail | How many times did the test method fail the assertions during UI testing? | When failed, the test method found a likely functional bug. 
+error | How many times does the test method abort during UI tsting due to some unexpected errors (e.g. some UI widgets used in the test method cannot be found) | When some error happens, the script needs to be updated/fixed because the script leads to some unexpected errors.
+
+### Appendix: Install Kea2 in global environment
+
+```bash
+# In the working directory of Kea2
+python3 -m pip install --upgrade pip
+python3 -m pip install .
+```
+
+## Contributors/Maintainers
+
+Kea2 has been actively developed and maintained by the people in [ecnusse](https://github.com/ecnusse).
+
+### Open-source projects used by Kea2
+
+- [Fastbot](https://github.com/bytedance/Fastbot_Android)
+- [uiautomator2](https://github.com/openatx/uiautomator2)
+- [hypothesis](https://github.com/HypothesisWorks/hypothesis)
+
+[^1]: 不少UI自动化测试工具提供了“自定义事件序列”能力（如[Fastbot](https://github.com/bytedance/Fastbot_Android/blob/main/handbook-cn.md#%E8%87%AA%E5%AE%9A%E4%B9%89%E4%BA%8B%E4%BB%B6%E5%BA%8F%E5%88%97) 和[AppCrawler](https://github.com/seveniruby/AppCrawler)），但在实际使用中存在不少问题，如自定义能力有限、使用不灵活等。此前不少Fastbot用户抱怨过其“自定义事件序列”在使用中的问题，如[#209](https://github.com/bytedance/Fastbot_Android/issues/209), [#225](https://github.com/bytedance/Fastbot_Android/issues/225), [#286](https://github.com/bytedance/Fastbot_Android/issues/286)等。
+
+[^2]: 在UI自动化测试过程中支持自动断言是一个很重要的能力，但几乎没有测试工具提供这样的能力。我们注意到[AppCrawler](https://ceshiren.com/t/topic/15801/5)的开发者曾经希望提供一种断言机制，得到了用户的热切响应，不少用户从21年就开始催更，但始终未能实现。

kea2_python-0.0.1a0.dist-info/RECORD

@@ -0,0 +1,33 @@
+kea2/__init__.py,sha256=_IFDiyzb6OLyhjldBXrAol6OpOijTnJ2LYWMK4TqSno,121
+kea2/absDriver.py,sha256=1vXTkPqhhIosT8KpS6pwi7XKjNZTOuSb7mczhS_tMoQ,648
+kea2/adbUtils.py,sha256=IV-5G_3mc89YP1NJZJIWUrgxb13QECGGXTTANkGH_Rk,8986
+kea2/cli.py,sha256=MBNvw7utLfkAwFtoF3zbh7o44TBOrsWS0RF6EY0c9Do,4232
+kea2/keaUtils.py,sha256=pg6wsPaUf8BL91503bXm672DdYFoyi6NvgGNIASsblA,18718
+kea2/kea_launcher.py,sha256=phBIrtO8RIKhIXiaffIkoHMlU4QIt-pIEVxJ2Pn3nrk,3665
+kea2/logWatcher.py,sha256=hd8banPiCa6aCQ6d_MznWKOdzK_A2X_dPbrx-usjxgE,1927
+kea2/u2Driver.py,sha256=Uyj0C2DFUCI1LB07YJHtLfvTsU_aaMtjhiweAVZ3uAw,9896
+kea2/utils.py,sha256=zjuoVwts2qVX9GnTaPoiqarfcSvyfW6cAD3ESf_dmrQ,1284
+kea2/assets/fastbot-thirdpart.jar,sha256=0SZ_OoZFWDGMnazgXKceHgKvXdUDoIa3Gb2bcifaikk,85664
+kea2/assets/framework.jar,sha256=rTluOJJKj2DFwh7ascXso1udYdWv00BxBwSQ3Vmv-fw,1149240
+kea2/assets/monkeyq.jar,sha256=k1r0Rf4UPgA1tndCx0YEFL_5d6jY3W8hgi-rn8FdFVw,459851
+kea2/assets/quickstart.py,sha256=YsZCqLCwb5Mg8m0ybdyL-_TJ8FX2oKLyHZFJrk7fvkQ,2865
+kea2/assets/u2.jar,sha256=G9fFf-AZ0CdaZrk27V1-pfJE2Y5eO6PRzPShTnIe-U8,3746525
+kea2/assets/fastbot_configs/ADBKeyBoard.apk,sha256=L3Kva4gCQALo10EzinCvHrIbffGE3p94qSNbnS8CxP0,163634
+kea2/assets/fastbot_configs/abl.strings,sha256=Rn8_YEbVGOJqndIY_-kWnR5NaoFI-cuB-ij10Ddhl90,75
+kea2/assets/fastbot_configs/awl.strings,sha256=-j4980GoWQxGOM9ijAwXPQmziCwFBZJFmuiv2tOEaYI,101
+kea2/assets/fastbot_configs/max.config,sha256=rBgR4mdgBzqVPQ2lZaXqx2WN6tDzhe-FNizm4Y7tyA8,226
+kea2/assets/fastbot_configs/max.fuzzing.strings,sha256=_3bNHwgzlISgxB7RmMury5X3qIo2jhVhEn8jow8jfbk,27554
+kea2/assets/fastbot_configs/max.schema.strings,sha256=zYupzvmTtnbPYomI2UCPk0s6PE97t94myZU_j3HutRM,40
+kea2/assets/fastbot_configs/max.strings,sha256=k82GAAZZG7KbDI7bk7DUklp41WJJO7j-j8Ss1BcybUw,32
+kea2/assets/fastbot_configs/max.tree.pruning,sha256=dm0oesN75FFbVSkV7STDUmrNMpQUBEuO7Uymt6nEkBc,629
+kea2/assets/fastbot_configs/widget.block.py,sha256=hj5xT1SpIqwVv-Dtww8Povrxi5MY0gD9kX_orQrWSjc,647
+kea2/assets/fastbot_libs/arm64-v8a/libfastbot_native.so,sha256=dA2Tf74-gDrCFdeClsf7qZAy0RqDZQOLlBZ-FViuorw,2005832
+kea2/assets/fastbot_libs/armeabi-v7a/libfastbot_native.so,sha256=GWcL8M8WfQAd9CfOM6pRYbOnxeycN-LiL7Mf59YIadE,1334420
+kea2/assets/fastbot_libs/x86/libfastbot_native.so,sha256=k-aw1gEXRWMKZRNHIggKNuZy0wC1y2BnveJGEIO6rbo,2036856
+kea2/assets/fastbot_libs/x86_64/libfastbot_native.so,sha256=tiofhlf4uMQcU5WAvrdLgTBME0lb83hVUoGtTwxmE8A,2121416
+kea2_python-0.0.1a0.dist-info/licenses/LICENSE,sha256=nM9PPjcsXVo5SzNsjRqWgA-gdJlwqZZcRDSC6Qf6bVE,2034
+kea2_python-0.0.1a0.dist-info/METADATA,sha256=Z6AWldJv7WwDnR3ybfaIhRFnYZedbP8Yd8u5KGLAyLo,20168
+kea2_python-0.0.1a0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+kea2_python-0.0.1a0.dist-info/entry_points.txt,sha256=mFX06TyxXiUAJQ6JZn8QHzfn8n5R8_KJ5W-pTm_fRCA,39
+kea2_python-0.0.1a0.dist-info/top_level.txt,sha256=TsgNH4PQoNOVhegpO7AcjutMVWp6Z4KDL1pBH9FnMmk,5
+kea2_python-0.0.1a0.dist-info/RECORD,,

kea2_python-0.0.1a0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.7.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

kea2_python-0.0.1a0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kea2 = kea2.cli:main

kea2_python-0.0.1a0.dist-info/licenses/LICENSE

@@ -0,0 +1,16 @@
+Kea2 Revised License
+
+Effective from May 1st, 2025, The Kea2 SDK is hereby licensed as follows:
+ 
+Copyright (c) 2024-2025 ECNU Smart Software Lab. (The “Licensor”)
+The Licensor grants you a non-exclusive, royalty-free, worldwide, non-sublicensable, non-transferable license to use, copy, distribute, make available, and prepare derivative works of the software, in each case subject to the limitations and conditions below (“Rights and Limitations”):
+
+You may not provide or distribute the software to third parties. You may use it solely for your own internal use. “Internal use” permits distribution to your affiliates and to contractors where those contractors are permitted to exercise the Rights and Limitations solely on your and your affiliates’
+behalf. An “affiliate” is an entity that controls, is controlled by, or is under common control with you. For the purposes of this definition "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty
+percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+ 
+You may not alter, remove, or obscure any licensing, copyright, or other notices of the Licensor in the software. Any use of the Licensor's trademarks is prohibited unless otherwise permitted by applicable law.
+ 
+This License will terminate immediately without notice should you breach any term.
+ 
+TO THE EXTENT THAT SUCH EXCLUSION IS PERMITTED BY LAW, (1)THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF SATISFACTORY QUALITY, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT, AND (2) IN NO EVENT SHALL THE LICENSOR, AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

kea2_python-0.0.1a0.dist-info/top_level.txt

@@ -0,0 +1 @@
+kea2