{"id":15032185,"url":"https://github.com/pedrovgs/shot","last_synced_at":"2025-04-07T23:13:02.179Z","repository":{"id":40318989,"uuid":"91067584","full_name":"pedrovgs/Shot","owner":"pedrovgs","description":"Screenshot testing library for Android","archived":false,"fork":false,"pushed_at":"2024-02-12T15:17:10.000Z","size":24725,"stargazers_count":1194,"open_issues_count":59,"forks_count":113,"subscribers_count":19,"default_branch":"master","last_synced_at":"2025-04-07T23:12:48.625Z","etag":null,"topics":["android","gradle-plugin","java","jetpack-compose","screenshot-tests","testing","testing-tools"],"latest_commit_sha":null,"homepage":"","language":"Kotlin","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/pedrovgs.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":".github/CONTRIBUTING","funding":".github/FUNDING.yml","license":"LICENSE.txt","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null},"funding":{"github":["pedrovgs"]}},"created_at":"2017-05-12T08:10:45.000Z","updated_at":"2025-04-02T11:36:11.000Z","dependencies_parsed_at":"2024-07-31T03:01:40.918Z","dependency_job_id":"e2e10c68-e239-4b5d-8182-5b1cb2dddfd0","html_url":"https://github.com/pedrovgs/Shot","commit_stats":{"total_commits":279,"total_committers":41,"mean_commits":6.804878048780488,"dds":0.5878136200716846,"last_synced_commit":"7c98bbe348bc408c5ea60985c1aa8eb7fa361684"},"previous_names":["karumi/shot"],"tags_count":53,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/pedrovgs%2FShot","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/pedrovgs%2FShot/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/pedrovgs%2FShot/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/pedrovgs%2FShot/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/pedrovgs","download_url":"https://codeload.github.com/pedrovgs/Shot/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":247744335,"owners_count":20988783,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["android","gradle-plugin","java","jetpack-compose","screenshot-tests","testing","testing-tools"],"created_at":"2024-09-24T20:17:40.987Z","updated_at":"2025-04-07T23:13:02.161Z","avatar_url":"https://github.com/pedrovgs.png","language":"Kotlin","funding_links":["https://github.com/sponsors/pedrovgs"],"categories":[],"sub_categories":[],"readme":"# ![Karumi logo][karumilogo]Shot ![Build, lint, and test](https://github.com/Karumi/Shot/workflows/Build,%20lint,%20and%20test/badge.svg)\n\n🔝 Top sponsors 🔝 \n\n[![EmergeLogo](https://www.emergetools.com/images/emergetoolsstandard.png)](https://www.emergetools.com)\n\nShot is an Android project you can use to write screenshot for your apps in a simple and friendly way.\n\n## What is this?\n\n``Shot`` is a Gradle plugin and a core android library thought to run screenshot tests for Android. This project provides a handy interface named ``ScreenshotTest`` and a ready to use ``ShotTestRunner`` you can use in order to write tests like these:\n\n```kotlin\nclass GreetingScreenshotTest : ScreenshotTest {\n\n    // If you are using regular Android views\n\n    @Test\n    fun theActivityIsShownProperly() {\n        val mainActivity = startMainActivity()\n\n        compareScreenshot(activity)\n    }\n\n    // If you are using Jetpack Compose\n\n    @Test\n    fun rendersGreetingMessageForTheSpecifiedPerson() {\n        composeRule.setContent { Greeting(greeting) }\n\n        compareScreenshot(composeRule)\n    }\n}\n```\n\n**Since Shot 5.0.0 we provide screenshot testing support for [Jetpack Compose](https://developer.android.com/jetpack/compose).** If you are testing your components using Shot we strongly recommend you to configure your emulator using the gpu mode ``swiftshader_indirect``. This will help you to avoid rendering issues when verifying your screenshots from any CI environment.\n\n![smallVerificationReport1](./art/smallVerificationReport1.png)\n![smallVerificationReport2](./art/smallVerificationReport2.png)\n\nRecord your screenshots executing ``./gradlew executeScreenshotTests -Precord``\n\n![recording](./art/recording.gif)\n\nAnd verify your tests executing ``./gradlew executeScreenshotTests``\n\n![verifying](./art/verifying.gif)\n\nIf Shot finds any error in your tests execution the Gradle plugin will show a report as follows:\n\n![errorReport](./art/errorReport.png)\n\nYou can find the complete Facebook SDK documentation [here](https://facebook.github.io/screenshot-tests-for-android/).\n\n## Getting started\n\nSetup the Gradle plugin:\n\n\nModify your root ``build.gradle`` file:\n\n```groovy\n  buildscript {\n    // ...\n    dependencies {\n      // ...\n      classpath 'com.karumi:shot:\u003cLATEST_RELEASE\u003e'\n    }\n  }\n```\n\nApply the plugin from any of the modules configured in your project. In a simple Android app your ``app/build.gradle`` file:\n\n```groovy\napply plugin: 'shot'\n```\n\nYou will also have to configure the instrumentation test runner in your module ``build.gradle`` file as follows:\n\n```groovy\nandroid {\n    // ...\n    defaultConfig {\n        // ...\n        testInstrumentationRunner \"com.karumi.shot.ShotTestRunner\"\n    }\n    // ...\n```\n\nWe created this test runner for you extending from the Android one.\n\nThis plugin sets up a few convenience commands you can list executing ``./gradlew tasks`` and reviewing the ``Shot`` associated tasks:\n\n![shotTasksHelp](./art/tasksDescription.png)\n\n**If you are using flavors the available Shot gradle tasks will be configured based on your flavors and build types configuration.** You can find all the available shot tasks by executing ``./gradlew tasks``. For example, if your app has two flavors: ``green`` and ``blue`` the list of available Shot tasks will be:\n\n```groovy\nexecuteScreenshotTests - Checks the user interface screenshot tests. If you execute this task using -Precord param the screenshot will be regenerated.\nblueDebugDownloadScreenshots - Retrieves the screenshots stored into the Android device where the tests were executed for the build BlueDebug\nblueDebugExecuteScreenshotTests - Records the user interface tests screenshots. If you execute this task using -Precord param the screenshot will be regenerated for the build BlueDebug\nblueDebugRemoveScreenshotsBefore - Removes the screenshots recorded before the tests execution from the Android device where the tests were executed for the build BlueDebug\nblueDebugRemoveScreenshotsAfter - Removes the screenshots recorded after the tests execution from the Android device where the tests were executed for the build BlueDebug\ngreenDebugDownloadScreenshots - Retrieves the screenshots stored into the Android device where the tests were executed for the build GreenDebug\ngreenDebugExecuteScreenshotTests - Records the user interface tests screenshots. If you execute this task using -Precord param the screenshot will be regenerated for the build GreenDebug\ngreenDebugRemoveScreenshotsBefore - Removes the screenshots recorded before the tests execution from the Android device where the tests were executed for the build GreenDebug\ngreenDebugRemoveScreenshotsAfter - Removes the screenshots recorded after the tests execution from the Android device where the tests were executed for the build GreenDebug\n```\n\nYou can specify a directory suffix where screenshot \u0026 report will be saved (`{FLAVOR}/{BUILD_TYPE}/{DIRECTORY_SUFFIX}`) :  \n`./gradlew executeScreenshotTests -PdirectorySuffix=Api26`\n\nIf for some reason you are running your tests on a different machine and you want to skip the instrumentation tests execution and just compare the sources remember you can use the following shot configuration:\n\n```groovy\n  shot {\n    runInstrumentation = false\n  }\n```\n\nCreate this ``AndroidManifest.xml`` file inside your ``androidTest`` folder.\n\n```xml\n\u003c?xml version=\"1.0\" encoding=\"utf-8\"?\u003e\n\u003cmanifest xmlns:android=\"http://schemas.android.com/apk/res/android\"\n    package=\"\u003cYOUR_APP_ID\u003e.test\"\n    android:sharedUserId=\"\u003cYOUR_APP_ID\u003e.uid\"\u003e\n\n\u003c/manifest\u003e\n```\n\n**You'll have to add the same ``android:sharedUserId=\"\u003cYOUR_APP_ID\u003e.uid\"`` configuration to your ``app/AndroidManfiest.xml`` file in order to let the testing APK write into the SDCard.**. If you don't do this, you can end up facing a weird error with this message while running your tests:\n\n```\njava.lang.RuntimeException: Failed to create the directory /sdcard/screenshots/com.example.snapshottesting.test/screenshots-default for screenshots. Is your sdcard directory read-only?\n```\n\n**If you want to use Shot to test your Android libraries code, you will have to configure the ``testApplicationId`` parameter as follows**\n\n```groovy\nandroid {\n    // ...\n    defaultConfig {\n        // ...\n        testApplicationId \"\u003cMY_TEST_APPLICATION_ID\u003e\"\n    }\n    // ...\n```\n\n**If you are using AGP 7.X in your Android library you may need to configure the applicationId as part of the Shot extension configuration as follows:**\n\n```groovy\nshot {\n  applicationId = \"com.myapp\"\n}\n```\n\nAGP introduced a bug in 7.0.1-alpha4 we are not able to fix without this workaround for now. In the future, once AGP fixes the bug, we will remove this extension property.\n\nBe careful and do not use the same id you are using for any other of the installed apps.\n\nNow you are ready to use the ``ScreenshotTest`` interface from your tests:\n\n```kotlin\nclass MyActivityTest: ScreenshotTest {\n    @Test\n    fun theActivityIsShownProperly() {\n            val mainActivity = startMainActivity();\n           /*\n             * Take the actual screenshot. At the end of this call, the screenshot\n             * is stored on the device and the gradle plugin takes care of\n             * pulling it and displaying it to you in nice ways.\n             */\n            compareScreenshot(activity);\n    }\n}\n```\n\nSince Shot 5.0.0, if you are using Jetpack Compose your tests will look like this:\n\n```kotlin\nclass GreetingScreenshotTest : ScreenshotTest {\n\n    @Test\n    fun rendersGreetingMessageForTheSpecifiedPerson() {\n        composeRule.setContent { Greeting(greeting) }\n\n        compareScreenshot(composeRule)\n    }\n```\n\n***This interface is full of useful methods you can use to take your screenshots with your activities, dialogs fragments, view holders or even custom views***\n\nYou can find a complete example in this repository under the folder named ``shot-consumer`` or review [this kata](https://github.com/Karumi/KataScreenshotAndroid/).***\n\nNow you are ready to record and verify your screenshot tests!\n\n## Using shot on API 28+\nIf you want to use Shot on devices running API \u003e= 28, you will have to enable access to non-SDK interfaces.  \nExecute the following commands:  \n\nFor Android 9 (API level 28)\n```shell\nadb shell settings put global hidden_api_policy_pre_p_apps 1\nadb shell settings put global hidden_api_policy_p_apps 1\n```\nFor Android 10 (API level 29) or higher\n```shell\nadb shell settings put global hidden_api_policy 1\n```\n\n## Recording tests\n\nYou can record your screenshot tests executing this command:\n\n```shell\n./gradlew \u003cFlavor\u003e\u003cBuildType\u003eExecuteScreenshotTests -Precord\n```\n\nor\n\n```shell\n./gradlew executeScreenshotTests -Precord\n```\n\nThis will execute all your integration tests and it will pull all the generated screenshots into your repository so you can easily add them to the version control system.\n\n## Executing tests\n\nOnce you have a bunch of screenshot tests recorded you can easily verify if the behaviour of your app is the correct one executing this command:\n\n```shell\n./gradlew \u003cFlavor\u003e\u003cBuildType\u003eExecuteScreenshotTests\n```\n\nor\n\n```shell\n./gradlew executeScreenshotTests\n```\n\n**After executing your screenshot tests using the Gradle task ``\u003cFlavor\u003e\u003cBuildType\u003eExecuteScreenshotTests`` a report with all your screenshots will be generated.**\n\n[karumilogo]: https://cloud.githubusercontent.com/assets/858090/11626547/e5a1dc66-9ce3-11e5-908d-537e07e82090.png\n\n## ScreenshotTest interface\n\n``ScreenshotTest`` interface has been designed to simplify the usage of the library. These are the features you can use:\n\n* Take a screenshot of any activity by using ``compareScreenshot(activity)``. Activity height, width, background color and screenshot name are configurable.\n* Take a screenshot of any fragment by using ``compareScreenshot(fragment)``. Fragment height, width and screenshot name are configurable.\n* Take a screenshot of any dialog by using ``compareScreenshot(dialog)``. Dialog height, width and screenshot name are configurable.\n* Take a screenshot of any view by using ``compareScreenshot(view)``. View height, width and screenshot name are configurable.\n* Take a screenshot of any view holder by using ``compareScreenshot(holder)``. View holder height, width and screenshot name are configurable.\n* Take a screenshot of any Jetpack Component  ``compareScreenshot(composeTestRule)``. The screenshot name is configurable.\n* Take a screenshot of any SemanticInteractionNode  ``compareScreenshot(node)``. The screenshot name is configurable.\n\nBefore taking the screenshot, Shot performs some tasks in order to stabilize the screenshot. You can find the detail about the tasks performed in ``ScreenshotTest#disableFlakyComponentsAndWaitForIdle``:\n\n* Invokes ``disableFlakyComponentsAndWaitForIdle`` method you can override if you want to add any custom task before taking the screenshot.\n* Hides every ``EditText`` cursor.\n* Hides every ``ScrollView`` and ``HorizontalScrollView`` scrollbars.\n* Hides all the ignored views. You can specify the views you want to ignore by overriding ``viewToIgnore``.\n* Wait for animations to finish and also waits until Espresso considers the UI thread is idle. This is really interesting if you are using Espresso in your tests.\n\n**You can find examples of the usage of this interface and every feature mentioned inside the examples named ``shot-consumer`` and ``shot-consumer-flavors``.**\n\nIn case you need to override the inner dependency Shot includes in your project during the plugin configuration you can do it as follows:\n\n```groovy\ndependencies {\n  ....\n  shotDependencies \"com.karumi:shot-android:ANY_VERSION_YOU_WANT_TO_USE\"\n  ....\n}\n```\n\nKeep in mind you'll need to use a compatible version or Shot won't work as expected.\n\n## ActivityScenario support\n\n``ActivityTestRule`` has been deprecated and now the usage of ActivityScenario is recommended. However, Shot needs to be executed from the instrumentation thread to be able to extract all the test metadata needed to record and verify screenshots. That's why we've created an ``ActivityScenario`` extension method named ``waitForActivity``. This extension is needed get the activity instance from the instrumentation thread instead of running Shot from the app target thread. Using this extension you can write tests like this:\n\n```kotlin\nclass MainActivityTest: ScreenshotTest {\n    @Test\n    fun rendersTheDefaultActivityState() {\n        val activity = ActivityScenario.launch(MainActivity::class.java)\n\n        compareScreenshot(activity)\n    }\n}\n```\n\nI hope we can find a better solution for this issue in the future.\n\n## Executing tests from Android Studio\n\nShot is a Gradle plugin and it does not integrate with AS by default. After running your tests, Shot Gradle plugin will fetch the screenshots generated during tests' execution and use them to check if your tests are passing or not. You always can run your tests from command line as explained above. However, **if you want to run your tests from AS you can create a configuration like this**:\n\n![asConfig](./art/asConfig.png)\n\nKeep in mind the debugger may not work if use use this option. If you want to debug your tests you can run them from Android Studio as you'd do with any other instrumentation test and you may need to execute this command before running your test:\n\n```\nadb rm -rf /storage/emulated/0/Download/screenshots/*\n```\n\n## Executing tests in multiple devices\n\nIf after some time writing screenshot tests your build takes too long to run our recommendation is to run your tests in multiple devices. **Sharding your tests execution will split your test suite into different devices so your tests execution time will be reduced. This feature is not designed to test the UI across different platforms or screen resolutions, to do that we'd recommend you to configure the size of the screenshot taken by modifing the view height and width.** To run your tests in multiple devices you can use [Composer](https://github.com/gojuno/composer) and the official [Gradle Plugin they provide](https://github.com/trevjonez/composer-gradle-plugin). Composer will take all your tests and will split the test suite execution between all the connected devices. **Remember, if you are going to use more than one device all the devices should use the same Android OS and the same screen resolution and density!** Keep also in mind composer needs Gradle 5.4.1 to be able to run your tests using multiple devices.\n\nOnce you've configured composer to run your tests you only need to update Shot to use the composer task as the instrumentation test task as follows:\n\n```groovy\nshot {\n  useComposer = true\n}\n```\n\nIf you are using orchestrator remember to enable it in composer configuration:\n\n```groovy\ncomposer {\n  // ...\n  withOrchestrator true\n  // ...\n}\n```\n\n## Tolerance\n\nShot provides a simple mechanism to be able to configure a threshold value when comparing recorded images with the new ones during the verification stage. You may need to use tolerance in your tests when testing compose components because the API Shot uses to record screenshots depending on the device where your tests are executed. There are other scenarios where you may need to configure a tolerance value, but these are not so common. If you want to configure it you can use this config in your ``build.gradle`` file.\n\n```gradle\nshot {\n    tolerance =  0.1 // 0,1% tolerance\n}\n```\n\nIf you configure ``tolerance = 100`` it means the tolerance threshold will be 100% and all your tests will pass even if they should fail...so be careful when configuring this param. \n\nTake into account the ``instrumentationTestTask`` could be different if you use different flavors or build types. Remember also you should use Shot \u003e 3.0.0 because this feature was introduced in this release!\n \n## CI Reporting\n\nShot generates an HTML report you can review at the end of the recording or verification build. However, if you are running Shot in a CI environment which does not support saving the reporting files generated by the build you can verify your tests using this command ``./gradlew debugExecuteScreenshotTests -PprintBase64``. This will change how Shot show comparision errors displaying a command you can copy and paste on your local terminal for every screenshot test failed.\n\nIf you want to see only failing tests in output, please add `showOnlyFailingTestsInReports = true` as an option to your build.gradle.\n\n## Running only some tests\n\nYou can run a single test or test class, just add the `android.testInstrumentationRunnerArguments.class` parameter within your gradle call. This option works for both modes, verification and recording, just remember to add the `-Precord` if you want to do the latter.\n\n**Running all tests in a class:**\n\n```shell\n./gradlew \u003cFlavor\u003e\u003cBuildType\u003eexecuteScreenshotTests -Pandroid.testInstrumentationRunnerArguments.class=com.your.package.YourClassTest\n```\n\n**Running a single test:**\n\n```shell\n./gradlew \u003cFlavor\u003e\u003cBuildType\u003eexecuteScreenshotTests -Pandroid.testInstrumentationRunnerArguments.class=com.your.package.YourClassTest#yourTest\n```\n\n## Using shot on API 29+\n\nSince Shot 5.8.0 we provide support for devices running API \u003e= 29. There is no need to configure ``android:requestLegacyExternalStorage=\"true\"`` or provide any special storage permission in your test ``AndroidManifest`.\n\n## Development documentation\n\nInside this repository you'll find two types of projects. The first one is all the code related to the Gradle Plugin. The second one is all the code related to the example projects we use as consumers of the Gradle Plugin and also as end to end tests. Review the following folders when developing a new feature for Shot or fixing a bug:\n\nPlugin related folders:\n\n* shot: Main Gradle Plugin module.\n* core: Gradle Plugin independent module where all the shot business logic is placed.\n* shot-android: Android library included in the project where Shot is installed automatically when the Gradle Plugin is initialized.\n\nConsumers and end to end tests folder:\n\n* shot-consumer: A simple project created to test Shot and show how the library works.\n* shot-consumer-flavors: A simple project focused on testing how the flavors feature works.\n\nWhen developing a feature or fixing a bug, plugin related folders are the place where most of the code will be. When writing end to end tests you should review the consumers' folders. Unit or integration tests should be added in the first group of folders using all the tooling already installed and configured for you.\n\nWhen talking about the IDE we should use, our recommendation is simple. We should use [IntelliJ Idea](https://www.jetbrains.com/idea/) for the Gradle Plugin related code and [Android Studio](https://developer.android.com/studio) for the consumers. Keep in mind the consumers' configuration is not linked with the root Gradle file so you won't be able to build the consumers from the root of this project using Android Studio. That's why we recommend the usage of different IDEs using different root Gradle configurations when working with this repository.\n\n### Steps to develop a feature or fix a bug:\n\n* Review our ``CONTRIBUTING.md`` file. There you'll find some general development rules.\n* Open an issue or drop a comment to explain what you'd like to implement or to fix. Communication is really important for us and we recommend dropping a comment or opening an issue before to avoid development issues.\n* Fork this repository and create a new branch where you'll develop the new feature or fix.\n* Install IntelliJ and Android Studio.\n* Import the root Gradle file configuration with IntelliJ. You will have to install the Scala plugin recommended by IntelliJ, but don't worry, as soon as you start IntelliJ you'll see a pop-up with the recommended plugin.\n* Add ``RELEASE_SIGNING_ENABLED=false`` to your local properties to be able to install artifacts in your local maven repository without signing them.\n* Develop the code you'd like to implement. Remember to add the unit/integration test coverage to the code you are working on.\n* Execute the Gradle task ``./gradlew publishToMavenLocal`` from the root folder in order to update your plugin local installation.\n* Using Android Studio import ``shot-android`` or ``shot-consumer-flavors`` and write an example of the feature or fix you coded before. The example test you write will work as an end to end test.\n* Commit and push the code. Our CI configuration will ensure everything is working as expected!\n* Remember to execute ``./gradlew publishToMavenLocal`` whenever you change the Gradle plugin code related in order to update your local repository and be able to use it from the consumers folder.\n* Once you are ready, send a PR. We will review it and help you to contribute to the official repository. Once everything is ready, we will merge it and release a new version.\n\nIn case you need to start an Android emulator you have scripts inside the consumers' folder you can execute to create the emulators you'll need to run the tests :smiley:\n\nThis is the list of most useful Gradle tasks you might need divided by type of project:\n\n* Plugin related tasks:\n\n    * ``./gradlew publishToMavenLocal``: Install Shot in your local gradle repository.\n    * ``./gradlew test``: Execute all the tests related to the Gradle plugin.\n    * ``./gradlew scalafmtAll``: Review the Gradle Plugin's checkstyle.\n\n* Consumers related tasks:\n\n    * ``./gradlew executeScreenshotTests``: Execute all the screenshot tests for the associated consumer in verification mode.\n    * ``./gradlew executeScreenshotTests -Precord``: Execute all the screenshot tests for the associated consumer in record mode.\n\n## iOS support\n\nIf you want to apply the same testing technique on iOS you can use [Swift Snapshot Testing](https://github.com/pointfreeco/swift-snapshot-testing)\n\nDeveloped By\n------------\n\n* Pedro Vicente Gómez Sánchez - \u003cpedrovicente.gomez@gmail.com\u003e\n\n\u003ca href=\"https://twitter.com/pedro_g_s\"\u003e\n  \u003cimg alt=\"Follow me on Twitter\" src=\"https://image.freepik.com/iconos-gratis/twitter-logo_318-40209.jpg\" height=\"60\" width=\"60\"/\u003e\n\u003c/a\u003e\n\u003ca href=\"https://es.linkedin.com/in/pedrovgs\"\u003e\n  \u003cimg alt=\"Add me to Linkedin\" src=\"https://image.freepik.com/iconos-gratis/boton-del-logotipo-linkedin_318-84979.png\" height=\"60\" width=\"60\"/\u003e\n\u003c/a\u003e\n\nLicense\n-------\n\nCopyright 2022 Pedro Vicente Gómez Sánchez\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n   http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fpedrovgs%2Fshot","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fpedrovgs%2Fshot","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fpedrovgs%2Fshot/lists"}