appium-mcp 0.0.1 → 1.1.4

package/src/resources/submodules/appium/packages/appium/docs/en/intro/history.md

@@ -0,0 +1,196 @@
+---
+title: Appium Project History
+---
+
+Appium has been around in one form or another since 2012. It's been under the
+direction of various individuals and organizations, and it's even been
+implemented in 3 different programming languages! Welcome to more than you ever
+wanted to know about how Appium got to be what is it today...
+
+## Early Inspiration
+
+[Dan Cuellar](https://twitter.com/thedancuellar) was the Test Manager at Zoosk
+in 2011, when he encountered a problem. The length of the test passes on the
+iOS product was getting out of hand. Less testing was an option, but would come
+with additional risk, especially with it taking several days to get patches
+through the iOS App Store Review process. He thought back to his days working
+on websites and realized automation was the answer.
+
+Dan surveyed the existing landscape of tools, only to find that all of them
+hand major drawbacks. The tool supplied by Apple, UIAutomation, required tests
+to be written in JavaScript, and did not allow for real-time debugging or
+interpretation. It also had to be executed inside the Xcode profiling tool,
+Instruments. Other 3rd-party tools used private APIs and required SDKs and HTTP
+Servers to be embedded into the application. This seemed highly undesirable.
+
+Unsatisfied with the existing options, Dan asked his manager for some
+additional time to see if he could find a better way. He spent 2 weeks poking
+and prodding around to see if there was a way to use approved Apple
+technologies to automate an iOS application. The first implementation he tried
+used AppleScript to send messages to Mac UI elements using the OS
+X accessibility APIs. This worked to some degree, but would never work on real
+devices, not to mention other drawbacks.
+
+So he thought, what if I could get the UIAutomation framework to run in real
+time like an interpreter? He looked into it and he determined that all he would
+need to do is find a way to receive, execute, and reply to commands from within
+a UIAutomation javascript program. Using the utility Apple provided for
+executing shell commands he was able to `cat` sequentially ordered text files
+to receive commands, `eval()` the output to execute them, and write them back
+to disk with `python`. He then prepared code in C# that implemented the
+Selenium-style syntax to write the sequentially ordered javascript commands.
+iOSAuto is born.
+
+## Selenium Conference 2012
+
+Dan was selected to speak at Selenium Conference 2012 in London about an
+entirely different topic. As part of his presentation, he showed off iOS
+Automation using Selenium syntax to demonstrate writing platform-agnostic tests
+that use separate platform-specific page objects with a common interface. To
+his surprise, the cool test architecture would take a backseat to the spectacle
+of iOS tests running like WebDriver tests. Several people suggested that he
+give a lightning talk later in the conference to explain exactly how it worked.
+
+On the second day of the conference, Dan stepped up on stage to give the
+lightning talk.  Jason Huggins, co-creator of Selenium, moderated the lightning
+talks.  Dan experienced technical difficulties getting his presentation to
+load, and Jason nearly had to move on to the next lightning talk.  At the last
+moment, the screen turned on and Dan jumped into his presentation. He explained
+the details of his implementation and how it worked, begged for contributors,
+and in five minutes it was over. The crowd applauded politely, and he left the
+stage.
+
+## The Phone Rings
+
+Four months after the Selenium Conference, Jason called Dan. Jason had been
+working on iOS testing support for a client at Sauce Labs.  Jason remembered
+Dan's lightning talk and thought the project might be useful to Jason's work,
+but Dan's source code was not public. Jason asked Dan to meet up.  Later that
+week, Dan met Jason in a bar in San Francisco and showed him the source code
+for iOS Auto.
+
+A long-time open source advocate, Jason encouraged Dan to release his code
+under an open source license.  In August, Dan [released the source
+code](https://github.com/penguinho/appium-old/commit/3ab56d3a5601897b2790b5256351f9b5af3f9e90)
+on GitHub in C#. Jason encouraged Dan to change the language to make the
+project more appealing to potential contributors. Dan [uploaded a new version
+in
+Python](https://github.com/penguinho/appium-old/commit/9b891207be0957bf209a77242750da17d3eb8eda).
+In September, Jason added a web server and [began to implement the WebDriver
+wire
+protocol](https://github.com/hugs/appium-old/commit/ae8fe4578640d9af9137d0546190fa29317d1499)
+over HTTP, making iOS Auto scriptable from any Selenium WebDriver client
+library in any language.
+
+## The Mobile Testing Summit
+
+Jason decided that the project should be presented at the [Mobile Testing
+Summit](https://twitter.com/mobtestsummit) in November, but suggested that the
+project get a new name first. Many ideas were thrown out and they settled on
+AppleCart. A day later, while he was perusing some of Apple's guidance on
+copyright and trademarks, Jason noticed that under the section of examples for
+names Apple would defend its trademarks against, the first example was
+"AppleCart". He called Dan and informed him of the situation, and they
+brainstormed for a bit before Jason hit the jackpot. Appium... Selenium for
+Apps.
+
+## Sauce Labs and Node.js
+
+In January 2013, not long after the Mobile Testing Summit, Sauce Labs decided
+to fully back Appium and provide more developer power. A task force was created
+to evaluate the current state and how best to move forward with the project.
+The team, which included Jonathan Lipps (the current project lead), decided
+that Appium needed a rebirth, and ultimately settled on Node.js as the
+framework to use. Node is well-known as a fast and efficient web server
+backend, and at the end of the day, Appium is just a highly-specialized web
+server. It was also decided that JavaScript as a language was accessible enough
+that Appium would be able to grow into a larger community of open-source
+developers with JavaScript than the other options on the table.
+
+In just a few days, the team leveraged the existing work on Appium and had
+a new version of Appium with as much functionality as the previous Python
+version. The foundation had been laid for Appium's basic architecture, and we
+have been successfully building on it since. A few weeks into this sprint,
+Jonathan Lipps was formally designated project lead and he began to strategize
+how to get more people from the community involved with Appium's development.
+
+## Appium Around the World
+
+Ultimately, Jonathan decided that getting Appium in front of as many developers
+at conferences and meetups was the best way to attract users and contributions.
+Appium in its new incarnation was debuted at the [Google Test Automation
+Conference 2013](https://www.youtube.com/watch?v=1J0aXDbjiUE). Later in 2013,
+Appium was presented at conferences and meetups all around the US, as well as
+in England, Poland, Portugal, and Australia. Notably, Jonathan had Appium
+[perform as instruments in a band](https://www.youtube.com/watch?v=zsbNVkayYRQ)
+and Dan Cuellar put together a fun [Appium video
+montage](https://www.youtube.com/watch?v=xkzrEn0v0II) for Selenium Conference.
+
+But during all these presentations and conferences, the project continued to
+develop. Early in 2013 we released Android and Selendroid support, making
+Appium the first truly cross-platform automation framework. The project also
+continued to attract users and contributors, and by the end of 2013, we'd
+already had well over 1,000 commits.
+
+## The Road to Appium 1.0
+
+Appium began to grow and mature significantly. In May 2014,
+we released Appium 1.0, which stood as a milestone in Appium's development.
+Appium was given
+[various](https://www.prnewswire.com/news-releases/black-duck-announces-black-duck-open-source-rookies-of-the-year-winners-242383341.html)
+[awards](https://www.infoworld.com/article/2241247/164642-bossie-awards-2014-the-best-open-source-application-development-tools.html)
+and became the most popular open-source cross-platform mobile automation
+framework. Stability improved, bugs were prioritized and fixed, and features
+added. Sauce Labs increased the number of developers it donated to working
+on Appium, but the entire community stayed involved in guiding the project and
+contributing to it, and project governance continued to happen in the open, on
+public mailing lists and GitHub's issue tracker.
+
+## The Appium Umbrella Broadens
+
+Eventually, it became clear that the Appium codebase was not optimized for
+a large team of distributed, sometime contributors. We took the opportunity as
+a committer team to rewrite Appium from the ground up, using a more modern
+version of the JavaScript language, and redoing Appium's architecture so that
+it was easy for users or third-party developers to build their own Appium
+"drivers". We wanted for it to be easier for new contributors to get ramped up
+on the Appium codebase, and to see support for new platforms added to Appium by
+groups other than the core team. That vision has begun to be fulfilled, with
+groups like Microsoft and Youi.tv adding drivers to Appium for Windows desktop
+app automation and Youi.tv app automation, respectively.
+
+## Appium To The People
+
+In late 2016, Sauce Labs donated Appium as a project to the [JS
+Foundation](https://js.foundation), in order to cement for the world Sauce's
+commitment that Appium remains open source. The JS Foundation is a non-profit
+open source stewardship organization which takes responsibility for holding the
+copyright for open source projects, as well as ensuring they have a long and
+successful tenure in the community. As a result of our move to a non-profit
+foundation, we hope that the door will open even more widely for new
+contributors, either as individuals or representing one of the many companies
+which now have an interest in seeing Appium move forward.
+
+Eventually, the JS Foundation merged into the [OpenJS Foundation](https://openjsf.org),
+and Appium became an Impact Project in the foundation.
+
+## Appium 2.0
+
+Appium 2 was released in 2023 and introduced an entirely revamped architecture, shifting focus to Appium
+as an ecosystem rather than an all-in-one project. This unlocked the ability for anyone to develop
+and share their own Appium extensions (drivers and plugins), opening up a world of possibilities
+for automation-related development for platforms far beyond iOS and Android! As a result,
+many third-party extensions were created, such as new drivers for Flutter and Windows, plugins for
+mocking APIs and managing device farms, new Appium clients based on Rust and Swift, and much more.
+
+Around this time was also when we started a sponsorship program for Appium, which attracted various
+major and minor sponsors alike. This allowed us to give back to the Appium community, by compensating
+contributors for their voluntary work on the project.
+
+## Appium 3.0
+
+2025 saw the release of Appium 3. This update was a lot smaller than Appium 2 and included only a
+few behavioral changes, instead focusing on removing deprecated code and updating compatibility for
+more modern ecosystems. Still, this reduced scope was also to be expected: since Appium 2, the
+main feature development efforts had shifted to individual drivers and plugins, many of which had
+gone through multiple major updates during the Appium 2 era.

package/src/resources/submodules/appium/packages/appium/docs/en/intro/index.md

@@ -0,0 +1,39 @@
+---
+hide:
+  - toc
+
+title: Appium in a Nutshell
+---
+
+As mentioned on the main page, Appium aims to support UI automation of many _different platforms_
+(mobile, web, desktop, etc.). Not only that, but it also aims to support automation code written in
+_different languages_ (JS, Java, Python, etc.). Combining all of this functionality in a single
+program is a very daunting, if not impossible task!
+
+In order to achieve this, Appium is effectively split into four parts:
+
+<div class="grid cards" markdown>
+
+-   :material-image-filter-center-focus-strong: __Appium Core__ - defines the core APIs
+-   :material-car: __Drivers__ - implement connectivity to specific platforms
+-   :octicons-code-16: __Clients__ - implement Appium's API in specific languages
+-   :fontawesome-solid-plug: __Plugins__ - change or extend Appium's core functionality
+
+</div>
+
+Therefore, in order to start automating something with Appium, you need to:
+
+- Install Appium itself
+- Install a driver for your target platform
+- Install a client library for your target programming language
+- (Optional) install one or more plugins
+
+These are the basics! If you are ready to jump in, proceed with the [Quickstart](../quickstart/index.md)!
+
+If you wish to learn more details about how it all works, see these pages for background material:
+
+- [Appium Core](./appium.md)
+- [Appium Drivers](./drivers.md)
+- [Appium Clients](./clients.md)
+
+Finally, to learn about the origins of Appium, check out the [Appium Project History](./history.md).

package/src/resources/submodules/appium/packages/appium/docs/en/quickstart/index.md

@@ -0,0 +1,29 @@
+---
+hide:
+  - toc
+
+title: Getting Started
+---
+
+Let's get up and running with Appium! To successfully use this quickstart, it's recommended that
+you first have read the [Introduction](../intro/index.md), so that you understand the concepts involved in
+running Appium and writing Appium scripts.
+
+The basic plan for this quickstart is as follows:
+
+1. Install Appium
+1. Install an Appium driver and its dependencies
+    - This guide provides instructions for the [UiAutomator2 driver](https://github.com/appium/appium-uiautomator2-driver)
+1. Install an Appium client library in your language of choice
+    - This guide contains options for JavaScript, Python, Java, Ruby, and .NET
+1. Write and run a simple Appium automation script using a sample application
+
+### Requirements
+
+Before getting started, make sure your system satisfies the
+[requirements](../quickstart/requirements.md) for running the Appium server. Additional requirements
+will be discussed in conjunction with installing the UiAutomator2 driver. The guide also assumes
+you have basic command line proficiency on your platform, for example being able to run commands, set
+and persist environment variables, etc...
+
+Now you're ready to get started! So head on over to [Installing Appium](./install.md).

package/src/resources/submodules/appium/packages/appium/docs/en/quickstart/install.md

@@ -0,0 +1,50 @@
+---
+hide:
+  - toc
+
+title: Install Appium
+---
+
+!!! info
+
+    Before installing, make sure to check the [System Requirements](./requirements.md).
+
+Appium can be installed globally using `npm`:
+
+```bash
+npm install -g appium
+```
+
+!!! note
+
+    Other package managers are not currently supported.
+
+## Starting Appium
+
+Appium can be started [using the command line](../reference/cli/index.md):
+
+```
+appium
+```
+
+This launches the Appium server process, which loads all the installed Appium drivers, and
+begins waiting for new session requests from client connections (such as test automation scripts).
+Since the server process is independent from its clients, it must be explicitly launched before
+attempting to start a new session.
+
+When the server is launched, the console log will list all the valid URLs that clients can use to
+connect to this server:
+
+```
+[Appium] You can provide the following URLs in your client code to connect to this server:
+[Appium] 	http://127.0.0.1:4723/ (only accessible from the same host)
+(... any other URLs ...)
+```
+
+Once a client requests a new session, the Appium server process will start logging all details about
+this session until its termination. Keep this in mind - if you ever encounter issues with Appium
+tests, you can always check the server log for more details.
+
+So what's next? Even though Appium is installed and running, it does not come bundled with any
+drivers, which means it cannot automate anything yet. We will therefore set up automation for
+Android - continue to [Installing the UiAutomator2 Driver](./uiauto2-driver.md).

package/src/resources/submodules/appium/packages/appium/docs/en/quickstart/next-steps.md

@@ -0,0 +1,23 @@
+---
+hide:
+  - toc
+
+title: Next Steps
+---
+
+Now that you've successfully set up your system for Android automation and run a simple test,
+you'll want to continue exploring this documentation. In particular, these are good guides and
+reference materials especially for beginners:
+
+- The [Ecosystem](../ecosystem/index.md) page: browse the available drivers, clients, plugins, and tools
+- [Managing Appium Drivers and Plugins](../guides/managing-exts.md)
+- [Capabilities](../guides/caps.md)
+- [Settings](../guides/settings.md)
+
+You'll also find that the [Appium Inspector](https://github.com/appium/appium-inspector) is an
+indispensable tool for writing Appium tests, as it enables visual inspection of apps and
+helps you to discover element locators for use in your test scripts.
+
+You might also take advantage of one of the many online Appium courses available to you.
+
+Good luck and have fun!

package/src/resources/submodules/appium/packages/appium/docs/en/quickstart/requirements.md

@@ -0,0 +1,29 @@
+---
+hide:
+  - toc
+
+title: System Requirements
+---
+
+The basic requirements for the Appium server are:
+
+* A macOS, Linux, or Windows operating system
+* [Node.js](https://nodejs.org) version in the [SemVer](https://semver.org) range `^20.19.0 || ^22.12.0 || >=24.0.0`
+    * LTS is recommended
+* [`npm`](https://npmjs.com) version `>=10` (`npm` is usually bundled with Node.js, but can be upgraded
+independently)
+
+By itself, Appium is relatively lightweight and doesn't have significant disk space or RAM
+requirements. It can even be run in resource-constrained environments like Raspberry Pi, so long as
+Node.js is available.
+
+### Driver Requirements
+
+Drivers for automating specific platforms will likely have other requirements. Refer to the
+documentation of the [Appium driver(s)](../ecosystem/drivers.md) for that platform for additional
+dependencies. It is almost universally the case that Appium drivers for a given platform will
+require the developer toolchain and SDKs for that platform to be installed.
+
+In order to assist with driver requirements, each (official) driver comes with the Appium Doctor tool,
+which allows to verify if all requirements have been set up. Learn more about how to use this tool in
+the [Command-Line Usage documentation](../reference/cli/extensions.md#doctor).

package/src/resources/submodules/appium/packages/appium/docs/en/quickstart/test-dotnet.md

@@ -0,0 +1,105 @@
+---
+hide:
+  - toc
+
+title: Write a Test (.NET)
+---
+
+The [Appium .NET Client](https://github.com/appium/dotnet-client/) is
+an official Appium client in C#. This driver is an extension of the Selenium C# client. It has all the functionalities of the regular driver, but add Appium-specific methods on top of this. The driver is available on the public NuGet Gallery as [Appium.WebDriver](https://www.nuget.org/packages/Appium.WebDriver/).
+
+Now, we get inside the directory and create a new [NUnit](https://nunit.org/) project. We will also add the references to the Appium.Net driver, and other dependencies.
+
+```bash
+cd dotnet-client
+dotnet new nunit --name appiumtest
+
+cd appiumtest
+
+# This will install the latest 5.x version
+dotnet add package Appium.WebDriver  --prerelease
+dotnet add package Newtonsoft.Json --version 13.0.3
+```
+
+Once this is done, your project should have a placeholder file `UnitTest1.cs`. We will replace the code to include the OpenQA namespaces, an initialization of the driver, and the actual test.
+
+```C# title="UnitTest1.cs"
+using OpenQA.Selenium;
+using OpenQA.Selenium.Appium;
+using OpenQA.Selenium.Appium.Android;
+using OpenQA.Selenium.Appium.Enums;
+
+namespace appiumtest;
+
+public class Tests
+{
+    private AndroidDriver _driver;
+
+    [OneTimeSetUp]
+    public void SetUp()
+    {
+        var serverUri = new Uri(Environment.GetEnvironmentVariable("APPIUM_HOST") ?? "http://127.0.0.1:4723/");
+        var driverOptions = new AppiumOptions() {
+            AutomationName = AutomationName.AndroidUIAutomator2,
+            PlatformName = "Android",
+            DeviceName = "Android Emulator",
+        };
+
+        driverOptions.AddAdditionalAppiumOption("appPackage", "com.android.settings");
+        driverOptions.AddAdditionalAppiumOption("appActivity", ".Settings");
+        // NoReset assumes the app com.google.android is preinstalled on the emulator
+        driverOptions.AddAdditionalAppiumOption("noReset", true);
+
+        _driver = new AndroidDriver(serverUri, driverOptions, TimeSpan.FromSeconds(180));
+        _driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(10);
+    }
+
+    [OneTimeTearDown]
+    public void TearDown()
+    {
+        _driver.Dispose();
+    }
+
+    [Test]
+    public void TestFindApps()
+    {
+        _driver.StartActivity("com.android.settings", ".Settings");
+        _driver.FindElement(By.XPath("//*[@text='Apps']")).Click();
+    }
+}
+```
+
+!!! note
+
+    It's not within the scope of this guide to give a complete run-down on the dotnet client
+    library or everything that's happening here, so we'll leave the code itself unexplained in
+    detail for now. You may want to read up particularly on Appium
+    [Capabilities](../guides/caps.md) in addition to familiarizing yourself with the
+    [dotnet client driver documentation](https://github.com/appium/dotnet-client/) for a fuller explanation
+    of the various API commands you see and what their purpose is.
+
+Basically, this code is doing the following:
+
+1. Defining a set of "Capabilities" (parameters) to send to the Appium server so Appium knows what
+kind of thing you want to automate. Some of these parameters can be overridden using environment variables.
+1. Starting an Appium session on the built-in Android settings app.
+1. Finding the "Apps" list item and clicking it.
+1. Ending the Appium session.
+
+That's it! Let's give it a try. Before you run the test, make sure that you have an Appium server
+running in another terminal session, otherwise you'll get an error about not being able to connect
+to one. Then, you can execute the script:
+
+```bash
+dotnet test
+
+# Example output:
+# Starting test execution, please wait...
+# A total of 1 test files matched the specified pattern.
+
+# Passed!  - Failed:     0, Passed:     1, Skipped:     0, Total:     1, Duration: 323 ms - appiumtest.dll (net7.0)
+```
+
+If all goes well, you'll see the Settings app open up and navigate to the "Apps" view in the emulator before the app closes again.
+
+Congratulations, you've started your Appium journey! Read on for some [next steps](./next-steps.md) to explore.

package/src/resources/submodules/appium/packages/appium/docs/en/quickstart/test-java.md

@@ -0,0 +1,23 @@
+---
+hide:
+  - toc
+
+title: Write a Test (Java)
+---
+
+The Appium team maintains an official [client](https://github.com/appium/java-client) for the Java programming language.
+It is built on top of [Selenium](https://github.com/SeleniumHQ/selenium).
+You can also use this client in your Kotlin projects.
+
+Follow the [Add Appium java client to your test framework](https://github.com/appium/java-client#add-appium-java-client-to-your-test-framework)
+tutorial in order to connect the library to your test framework sources.
+
+The Appium Java client has dedicated classes to support most of the official Appium drivers. For other drivers
+you could simply use the [AppiumDriver](https://github.com/appium/java-client/blob/master/src/main/java/io/appium/java_client/AppiumDriver.java) class
+or build your custom derivatives from it. Check the [Drivers Support](https://github.com/appium/java-client#drivers-support)
+article to learn more about the current driver class implementations.
+
+Follow the [Usage Examples](https://github.com/appium/java-client#usage-examples) article in order understand
+how to invoke Java client features from your test framework.
+
+Once you've managed to successfully run a test, you can read on for some [next steps](./next-steps.md) to explore.

package/src/resources/submodules/appium/packages/appium/docs/en/quickstart/test-js.md

@@ -0,0 +1,75 @@
+---
+hide:
+  - toc
+
+title: Write a Test (JS)
+---
+
+To write an Appium test in JavaScript (Node.js), we need to choose an Appium-compatible client
+library. The best-maintained library and the one the Appium team recommends using is
+[WebdriverIO](https://webdriver.io), so let's use that. Since we already have Appium installed we
+know our Node and NPM requirements are already satisfied. So just create a new project directory
+somewhere on your computer and then initialize a new Node.js project in it:
+
+```bash
+npm init
+```
+
+It doesn't really matter what you put in the prompts, just so long as you end up with a valid
+`package.json`.
+
+
+Now, install the `webdriverio` package via NPM:
+
+```bash
+npm i --save-dev webdriverio
+```
+
+Once this is done, your `package.json` file should include a section like the following:
+
+```json title="package.json"
+--8<-- "./sample-code/quickstarts/js/package.json"
+```
+
+Now it's time to type up the test itself. Create a new file called `test.js` with the following
+contents:
+
+```js title="test.js"
+--8<-- "./sample-code/quickstarts/js/test.js"
+```
+
+!!! note
+
+    It's not within the scope of this guide to give a complete run-down on the WebdriverIO client
+    library or everything that's happening here, so we'll leave the code itself unexplained in
+    detail for now. You may want to read up particularly on Appium
+    [Capabilities](../guides/caps.md) in addition to familiarizing yourself with the excellent
+    [WebdriverIO documentation](https://webdriver.io/docs/gettingstarted) for a fuller explanation
+    of the various API commands you see and what their purpose is.
+
+!!! note
+
+    The sample code is available from [GitHub Appium repository](https://github.com/appium/appium/tree/master/packages/appium/sample-code/quickstarts/js).
+
+
+Basically, this code is doing the following:
+
+1. Defining a set of "Capabilities" (parameters) to send to the Appium server so Appium knows what
+kind of thing you want to automate.
+1. Starting an Appium session on the built-in Android settings app.
+1. Finding the "Apps" list item and clicking it.
+1. Pausing for a moment purely for visual effect.
+1. Ending the Appium session.
+
+That's it! Let's give it a try. Before you run the test, make sure that you have an Appium server
+running in another terminal session, otherwise you'll get an error about not being able to connect
+to one. Then, you can execute the script:
+
+```bash
+node test.js
+```
+
+If all goes well, you'll see the Settings app open up and navigate to the "Apps" view before the
+app closes again.
+
+Congratulations, you've started your Appium journey! Read on for some [next steps](./next-steps.md) to explore.

package/src/resources/submodules/appium/packages/appium/docs/en/quickstart/test-py.md

@@ -0,0 +1,60 @@
+---
+hide:
+  - toc
+
+title: Write a Test (Python)
+---
+
+The [Appium Python Client](https://github.com/appium/python-client) is
+an official Appium client in Python, which is available via pypi under the [Appium-Python-Client](https://pypi.org/project/Appium-Python-Client/) package name.
+It inherits from the [Selenium Python Binding](https://pypi.org/project/selenium/),
+so installing the Appium Python Client includes the selenium binding.
+
+```bash
+pip install Appium-Python-Client
+```
+
+This example uses Python's built-in `unittest` module, though you can use any Python test framework you want.
+The Appium Python client adds the `appium:` vendor prefix automatically.
+You usually do not need to worry about the prefix.
+
+```python title="test.py"
+--8<-- "./sample-code/quickstarts/py/test.py"
+```
+
+!!! note
+
+    It's not within the scope of this guide to give a complete run-down on the Python client
+    library or everything that's happening here, so we'll leave the code itself unexplained in detail for now.
+
+    - You may want to read up particularly on Appium [Capabilities](../guides/caps.md).
+    - [functional test code](https://github.com/appium/python-client/tree/master/test/functional) in Python Client GitHub repository should help to find more working example.
+    - [Documentation](https://appium.github.io/python-client-sphinx/) also helps to find methods
+    defined in the Appium Python Client.
+
+!!! note
+
+    The sample code is available from [GitHub Appium repository](https://github.com/appium/appium/tree/master/packages/appium/sample-code/quickstarts/py).
+
+
+Basically, this code is doing the following:
+
+1. Defining a set of "Capabilities" (parameters) to send to the Appium server so Appium knows what
+kind of thing you want to automate.
+1. Starting an Appium session on the built-in Android settings app.
+1. Finding the "Apps" list item and clicking it.
+1. Pausing for a moment purely for visual effect.
+1. Ending the Appium session.
+
+That's it! Let's give it a try. Before you run the test, make sure that you have an Appium server
+running in another terminal session, otherwise you'll get an error about not being able to connect
+to one. Then, you can execute the script:
+
+```bash
+python test.py
+```
+
+If all goes well, you'll see the Settings app open up and navigate to the "Apps" view before the
+app closes again.
+
+Congratulations, you've started your Appium journey! Read on for some [next steps](./next-steps.md) to explore.