def start_appium_server(self, server_arguments=None):
"""
used to start appium server before test executions
:param server_arguments: Server arguments list
"""
appium_service = AppiumService()
appium_service.start(args=server_arguments or [])
class AppiumSession(object):
def __init__(self, capabilities):
# Find free port for Appium server
port = self.free_port()
# Ensure we have driver if we test mobile web or hybrid apps
if "chromeDriverVersion" in capabilities:
driver_version = capabilities.get('chromeDriverVersion')
path = ChromeDriverManager(version=driver_version).install()
sys.path.append(path)
# Start Appium server and attach client
self.appium_service = AppiumService()
self.appium_service.start(args=['--address', '127.0.0.1', '-p', str(port)])
self.driver = webdriver.Remote("http://127.0.0.1:{0}/wd/hub".format(port), capabilities)
def stop(self):
if self.driver is not None:
self.driver.quit()
if self.appium_service is not None:
self.appium_service.stop()
@staticmethod
def free_port():
"""
Determines a free port using sockets.
"""
free_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
free_socket.bind(('0.0.0.0', 0))
free_socket.listen(5)
port = free_socket.getsockname()[1]
free_socket.close()
return port
def start_appium_server():
if not Utils.check_appium_is_already_running():
appium_service = AppiumService()
appium_service.start()
time.sleep(4)
print("Appium is started")
else:
print("Appium is already running")
class AppiumDriver(object):
def __init__(self, capabilities):
self.appium_service = AppiumService()
self.appium_service.start()
self.capabilities = capabilities
self.executor = 'http://0.0.0.0:4723/wd/hub'
self.driver = webdriver.Remote(self.executor, capabilities)
def quit(self):
self.appium_service.stop()
def start(_serial, _port):
# os.system("adb -s {} uninstall io.appium.android.ime".format(_serial))
# os.system("adb -s {} uninstall io.appium.unlock".format(_serial))
# os.system("adb -s {} uninstall io.appium.settings".format(_serial))
# os.system("adb -s {} uninstall io.appium.uiautomator2.server".format(_serial))
# os.system("adb -s {} uninstall io.appium.uiautomator2.server.test".format(_serial))
bp_port = utils.valid_port(int(_port) + 2000)
log_file = os.path.join('/tmp/appium_{}.log'.format(_serial))
service = AppiumService()
service.start(args=['-p', str(_port), '-bp', str(bp_port), '-U', _serial,
'--session-override', '--no-reset',
'--log-level', 'error', '--log', log_file], timeout_ms=2000)
class Appium(Logger):
def __init__(self, appium_args: List[str] = None, **kwargs: Any):
""" Initialize Appium wrapper """
super().__init__()
self.port = find_free_port()
self.service = AppiumService()
self._extra_args = kwargs
self._appium_args = appium_args or []
@atexit.register
def _exit():
nonlocal self
if self.service.is_running:
self.logger.warn("exit:stop appium")
self.stop()
def get_wd_hub_uri(self) -> str:
""" Get local appium uri """
assert self.service.is_running, 'Appium is not running'
return f'http://127.0.0.1:{self.port}/wd/hub'
def start(self):
assert not self.service.is_running, 'Appium already running'
# https://appium.io/docs/en/writing-running-appium/server-args/
args = ['-a', '127.0.0.1', '-p', f"{self.port}"]
args.extend(self._appium_args)
self.logger.info(
f'Start Appium with args: {" ".join(args)} {self._extra_args}')
self.service.start(args=args, **self._extra_args)
assert self.service.is_running, 'Appium did not started :o'
uri = self.get_wd_hub_uri()
self.logger.info(
f'Appium started: {uri} (pid: {self.service._process.pid})')
return uri
def stop(self):
assert self.service.is_running, 'Appium is not running'
self.logger.info(
f"Close appium server (port: {self.port}, pid: {self.service._process.pid})"
)
self.service.stop()
def __enter__(self):
self.start()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.stop()
def start(**kwargs):
port = str(free_port())
devices = Command().devices_and_version()[0]
caps = get_caps()["devices"]["samsung-10"]
caps.update(getattr(Context, "CAPS"))
if kwargs:
for key, value in kwargs.items():
caps[key] = value
caps["deviceName"] = devices[0]
caps["platformVersion"] = devices[1]
service = AppiumService()
service.start(args=["-a", "127.0.0.1", "-p", port, "--session-override"],
timeout_ms=2000)
driver = webdriver.Remote(
command_executor=f'http://127.0.0.1:{port}/wd/hub',
desired_capabilities=caps)
yield driver
driver.close()
driver.quit()
service.stop()
def base_args(*port, **kwargs):
if not port: # 寻找空闲端口
port = free_port()
caps = get_caps()
caps.update(getattr(Context, "ENV")["caps"])
devices = Command().devices_and_version()
n = 0
if kwargs:
for key, value in kwargs.items():
caps[key] = value
for res in devices:
caps["deviceName"] = res[0]
caps["platformVersion"] = res[1]
service = AppiumService()
service.start(
args=["-a", "127.0.0.1", "-p", port[n], "--session-override"],
timeout_ms=2000)
driver = webdriver.Remote(
command_executor='http://127.0.0.1:{}/wd/hub'.format(port[n]),
desired_capabilities=caps)
yield driver
service.stop()
def start_appium_server(self):
service = AppiumService()
service.start()
from appium.webdriver.appium_service import AppiumService appium_server = AppiumService() appium_server.start() appium_server.stop()
class MobileRunnerBase(RunnerBase):
def __init__(self, device_info, app_info, system_capabilities):
super().__init__(device_info, app_info, system_capabilities)
self._service = None
@property
def device_info(self):
return self._device_info
@property
def app_info(self):
return self._app_info
@property
def capabilities(self):
return self._capabilities
@property
def app_id(self):
raise Exception("Runner must implement 'app_id' property")
def supports_scenario(self, scenario: Scenario):
return True
def prepare(self):
self._start_appium_server_if_needed()
def start(self):
if not self._driver:
port = str(self._capabilities["port"])
self._driver = webdriver.Remote(f'http://localhost:{port}/wd/hub',
self._capabilities)
def reset(self):
if self._driver:
self._driver.reset()
def stop(self):
if self._driver:
self._driver.terminate_app(self.app_id)
def quit(self):
if self._driver:
self._driver.quit()
if self._service:
print("------ STOPPING APPIUM SERVER ------")
self._service.stop()
def _start_appium_server_if_needed(self):
caps = self._capabilities
port = caps['port']
udid = caps['udid']
system_port = caps['systemPort']
server_running = self._check_server_running(port)
if server_running:
print(
f"\n ℹ️ Using appium server at: host=127.0.0.1 port={port}\n")
return
print("\n------ LAUNCHING APPIUM SERVER ------\n")
self._service = AppiumService()
self._service.start(args=[
'-U',
str(udid), '-p',
str(port), '--webdriveragent-port',
str(system_port), '--allow-insecure', 'chromedriver_autodownload'
])
print(f"Server started (host=127.0.0.1 port={port})")
@staticmethod
def _check_server_running(port, host='127.0.0.1'):
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex((host, port))
sock.close()
server_running = result == 0
return server_running
class tc_android_calculator(aetest.Testcase):
@aetest.setup
def prepare_testcase(self, section):
""" Testcase Setup section """
log.info("Preparing the test")
# Make sure python client is installed "pip install Appium-Python-Client"
# Make sure appium is installed 'npm install -g appium'
self.appium_service = AppiumService()
# By default appium starts server at port 4723.
# You can pass port as argument in AppiumService to change it.
self.appium_service.start()
log.info(self.appium_service.is_running)
# Following is desired capabilities for Android app
desired_caps = {}
desired_caps['platformName'] = 'Android'
desired_caps['platformVersion'] = '6.0'
desired_caps['automationName'] = 'androidautomator'
desired_caps['deviceName'] = 'Android Emulator'
desired_caps['appPackage'] = 'com.android.calculator2'
desired_caps['appActivity'] = 'com.android.calculator2.Calculator'
self.driver = webdriver.Remote('http://localhost:4723/wd/hub',
desired_caps)
# Following is example of testing iOS app
# desired_caps['platformName'] = 'iOS'
# desired_caps['platformVersion'] = '11.0'
# desired_caps['automationName'] = 'iosautomator'
# desired_caps['deviceName'] = 'iPhone 7'
# desired_caps['app'] = '/path/to/my.app'
# First test section
@aetest.test
def pass_check(self):
no_7 = self.driver.find_element(value="digit_7", by=By.ID)
no_7.click()
plus = self.driver.find_element(value="op_add", by=By.ID)
plus.click()
no_4 = self.driver.find_element(value="digit_4", by=By.ID)
no_4.click()
equalTo = self.driver.find_element(value="eq", by=By.ID)
equalTo.click()
results = self.driver.find_element(value="formula", by=By.ID)
result_value = results.get_attribute('text')
if result_value == '11':
self.passed('Value is 11')
else:
self.failed('Value is not 11')
# Second test section
@aetest.test
def failure_check(self):
no_7 = self.driver.find_element(value="digit_7", by=By.ID)
no_7.click()
plus = self.driver.find_element(value="op_add", by=By.ID)
plus.click()
no_4 = self.driver.find_element(value="digit_4", by=By.ID)
no_4.click()
equalTo = self.driver.find_element(value="eq", by=By.ID)
equalTo.click()
results = self.driver.find_element(value="formula", by=By.ID)
result_value = results.get_attribute('text')
if result_value == '12':
self.passed('Value is 12')
else:
self.failed('Value is not 12')
@aetest.cleanup
def clean_testcase(self):
log.info("Pass testcase cleanup")
# Close app
self.driver.quit()
# Stop Appium Service
self.appium_service.stop()
import subprocess
from appium import webdriver
from appium.webdriver.appium_service import AppiumService
from selenium.common.exceptions import NoSuchElementException, TimeoutException
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as ec
from selenium.webdriver.common.by import By
subprocess.call(['adb', 'shell', 'input', 'keyevent', 'KEYCODE_HOME'])
appium_service = AppiumService()
appium_service.start()
desired_caps = {}
desired_caps['platformName'] = 'Android'
desired_caps['deviceName'] = 'raven'
desired_caps['automationName'] = 'UiAutomator2'
desired_caps['udid'] = '172.19.5.96:5555'
desired_caps['platformVersion'] = '7.0'
desired_caps['appPackage'] = 'tv.accedo.xdk.dishtv'
desired_caps['appActivity'] = 'MainActivity'
desired_caps['eventTimings'] = 'True'
desired_caps['recordDeviceVitals'] = 'True'
driver = webdriver.Remote('http://*****:*****@text, 'VIEW FULL TV GUIDE')]")))
driver.find_element_by_xpath(
"//android.view.View[contains(@resource-id, 'tv-guide')]").click()
WebDriverWait(driver, 30).until(
ec.presence_of_element_located(
def start_appium_server():
appium_service = AppiumService()
appium_service.start()
print("Server Started")
def setup(request):
subprocess.call(['adb', 'shell', 'input', 'keyevent', 'KEYCODE_HOME'])
appium_service = AppiumService()
appium_service.start()
desired_caps = {}
desired_caps['platformName'] = 'Android'
desired_caps['deviceName'] = 'raven'
desired_caps['automationName'] = 'UiAutomator2'
desired_caps['udid'] = '172.19.5.96:5555'
desired_caps['platformVersion'] = '7.0'
desired_caps['appPackage'] = 'tv.accedo.xdk.dishtv'
desired_caps['appActivity'] = 'MainActivity'
desired_caps['eventTimings'] = 'True'
desired_caps['recordDeviceVitals'] = 'True'
driver = webdriver.Remote('http://localhost:4723/wd/hub', desired_caps)
request.cls.driver = driver
yield
time_events = driver.get_events()
with open(
'/Users/dishbusiness/Desktop/OnStreamTestFiles/Duration/Event_Time_Log.json',
'w',
encoding='utf-8') as t:
json.dump(time_events, t, ensure_ascii=False, indent=4)
gfx = open(
'/Users/dishbusiness/Desktop/OnStreamTestFiles/Logs/GFX_Log.txt',
"w",
encoding='ISO-8859-1')
subprocess.run([
'adb', 'shell', 'dumpsys', 'gfxinfo', 'tv.accedo.xdk.dishtv',
'framestats'
],
stdout=gfx)
time.sleep(30)
with open('/Users/dishbusiness/Desktop/OnStreamTestFiles/Logs/GFX_Log.txt', encoding='ISO-8859-1') as infile, \
open('/Users/dishbusiness/Desktop/OnStreamTestFiles/Logs/OnStream_GFX_Stream.csv', 'w') as outfile:
copy = False
for line in infile:
if line.strip() == "---PROFILEDATA---":
copy = True
continue
elif line.strip() == "View hierarchy:":
copy = False
continue
elif copy:
outfile.write(line)
df = pd.read_csv(
r'/Users/dishbusiness/Desktop/OnStreamTestFiles/Logs/OnStream_GFX_Stream.csv'
)
flag = df.loc[df['Flags'] == 0]
mill = flag.div(10000000)
fld = (mill["FrameCompleted"] - mill["IntendedVsync"])
p = fld.plot()
p.axhline(y=16, linewidth=2, color='r')
plt.savefig(
'/Users/dishbusiness/Desktop/OnStreamTestFiles/Pictures/gfx_OnStream.png'
)
plt.clf()
cpu = driver.get_performance_data('tv.accedo.xdk.dishtv', 'memoryinfo', 10)
with open('/Users/dishbusiness/Desktop/OnStreamTestFiles/Duration/cpu.txt',
'w',
encoding='ISO-8859-1') as c:
print(cpu, file=c)
driver.quit()
class AddMoney:
def __init__(self, startServer=False, phone="RN8P"):
self.start_server = startServer # Flag to start inline server
# ============ START SERVER ============
if self.start_server:
self.appium_service = AppiumService()
self.appium_service.start()
# ============ LAUNCH APP ============
self.driver = webdriver.Remote("http://localhost:4723/wd/hub",
DESIRED_CAPS)
time.sleep(5) # Wait for App
self.dev_window_size = WIN_SIZE_RN8P if phone == "RN8P" else self.driver.get_window_size(
)
#print(dev_window_size) # debug
def tap_at(self, _x=0, _y=0, t=1):
TouchAction(self.driver).tap(x=_x * self.dev_window_size['width'] /
WIN_SIZE_RN8P['width'],
y=_y).perform()
time.sleep(t)
def _handle_fb_login(self):
CONTINUE_BTN_XPATH = "/hierarchy/android.widget.FrameLayout/android.widget.LinearLayout/android.widget.FrameLayout/android.widget.FrameLayout/android.widget.FrameLayout/android.view.ViewGroup/android.widget.FrameLayout[1]/android.widget.FrameLayout[2]/android.webkit.WebView/android.view.View/android.view.View[2]/android.view.View[2]/android.view.View/android.view.View/android.view.View/android.view.View/android.view.View/android.view.View[2]/android.view.View/android.view.View/android.widget.Button"
# Login to FB Account
self.tap_at(1656, 354)
time.sleep(5)
try:
print("Tap Continue")
fb_login_continue_elem = self.driver.find_element_by_xpath(
CONTINUE_BTN_XPATH) # Login to FB Account
TouchAction(self.driver).tap(fb_login_continue_elem).perform()
time.sleep(5) # Wait for Login
except Exception as e:
print(e)
pass
def _handle_set_DOB(self):
# Set DOB
self.tap_at(890, 500) # ^ (Mon)
self.tap_at(700, 250) # Jan
self.tap_at(1694, 504) # ^ (yr)
self.tap_at(1528, 460) #1961
self.tap_at(1100, 800) # Continue
def add_money(self, count=50):
for i in range(count):
#Start Ad
self.tap_at(409, 489) # free coins
time.sleep(35)
self.driver.back()
time.sleep(1)
self.tap_at(1115, 777) # Continue
if i == 0:
self.tap_at(1130, 883) # 1 Friend has used your code (Collect)
def teardown(self):
# ============ STOP SESSION ============
self.driver.quit() # End client
# ============ STOP SERVER ============
if self.start_server:
self.appium_service.stop() # End Server
def main(self, count=200):
# self.setup()
self._handle_fb_login()
self._handle_set_DOB()
self.add_money(count)
self.teardown()
class AppiumDriver(object):
service = None
driver = None
def __init__(self,
platform,
device,
bundle_id,
activity='com.tns.NativeScriptActivity',
wait_timeout=30):
"""
Init appium session.
:param platform: Platform enum value.
:param device: device instance.
:param bundle_id: bundle id of application under test (must be already deployed on device).
:param activity: default app activity (needed in Android only).
:param wait_timeout: timeout for finding elements (in seconds).
"""
capabilities = self.__get_capabilities(platform=platform,
device=device,
bundle_id=bundle_id,
activity=activity)
self.__start_server()
self.__start_client(capabilities, wait_timeout)
def stop(self):
"""
Stop appium session.
"""
self.__stop_client()
self.__stop_server()
@staticmethod
def kill():
"""
Kill all instance of appium server.
"""
Process.kill(proc_name='node', proc_cmdline='appium')
def __start_server(self):
Log.info("Starting appium server...")
self.service = AppiumService()
self.service.start(args=['-p', str(DEFAULT_PORT)])
assert self.service.is_running, "Failed to start appium server."
Log.info("Appium server started.")
def __stop_server(self):
if self.service is not None and self.service.is_running:
self.service.stop()
Log.info("Stop appium server.")
@staticmethod
def __get_capabilities(platform,
device,
bundle_id,
activity='com.tns.NativeScriptActivity'):
capabilities = {}
capabilities['platformName'] = str(platform)
capabilities['platformVersion'] = device.version
capabilities['deviceName'] = device.name
capabilities['udid'] = device.id
capabilities['noReset'] = 'true'
capabilities['fullReset'] = 'false'
if platform == Platform.ANDROID:
capabilities['automationName'] = 'uiautomator2'
capabilities['appPackage'] = bundle_id
capabilities['appActivity'] = activity
if platform == Platform.IOS:
capabilities['automationName'] = 'XCUITest'
capabilities['bundleId'] = bundle_id
# In case debug session is found increase 'newCommandTimeout' to allow debugging longer period of time.
capabilities['newCommandTimeout'] = 3600 if Settings.IS_DEBUG else 60
return capabilities
def __start_client(self, capabilities, wait_timeout):
Log.info("Starting appium client...")
self.driver = webdriver.Remote('http://0.0.0.0:4723/wd/hub',
capabilities)
self.driver.implicitly_wait(wait_timeout)
Log.info("Appium client started.")
def __stop_client(self):
if self.driver is not None:
self.driver.quit()
Log.info("Stop appium client.")
class BurbnBot:
actions = []
amount_followed: int = 0
amount_liked: int = 0
appiumservice = None
driver = ""
follow_percentage: int = 0
instabot = None
logPath: str = "log/"
logger = ""
posts_to_follow = ""
predict = ""
settings = {}
touchaction = None
def __init__(self, configfile: str = None):
self.configfile = configfile
parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-settings', type=str, help="json settings file")
args = parser.parse_args()
self.settings = json.load(open(args.settings))
self.logger = logger
self.logger.add("log/{}.log".format(
self.settings['instagram']['username']),
backtrace=True,
diagnose=True,
level="WARNING")
try:
self.logger.info("Lets do it!.")
self.predict = Predict(
api_key=self.settings['clarifai']['api_key'],
logger=self.logger)
self.instabot = instabot.Bot(base_path="InstaBot/")
self.instabot.logger = self.logger
self.instabot.api.logger = self.logger
self.instabot.login(
username=self.settings['instagram']['username'],
password=self.settings['instagram']['password'],
proxy=None)
except Exception as err:
self.treat_exception(err)
self.end()
pass
def start_driver(self):
try:
sys.stdout.flush()
self.logger.info("Starting Appium service.")
os.environ.setdefault(
key="ANDROID_HOME",
value=self.settings['android']['android_home'])
self.appiumservice = AppiumService()
self.appiumservice.stop()
self.appiumservice.start()
if self.appiumservice.is_running:
self.logger.info("Appium Server is running.")
self.driver = webdriver.Remote(
command_executor="http://*****:*****@{} again."
.format(user))
try:
self.driver.find_element_by_xpath(ElementXpath.btn_follow)
except NoSuchElementException:
return False
return True
def unfollow_non_followers(self, avoid_saved=True, amount=None):
self.logger.info("Unfollowing non-followers.")
following = []
for a in self.instabot.api.get_total_followings(
user_id=self.instabot.user_id):
following.append(a["username"])
followers = []
for b in self.instabot.api.get_total_followers(
user_id=self.instabot.user_id):
followers.append(b["username"])
if avoid_saved:
users_saved = self.get_owner_saved_post()
followers = followers + users_saved
non_followers = [x for x in following if x not in followers]
self.logger.info("Setting command to unfollow users.")
for username in tqdm(non_followers[:amount],
desc="Selecting user to unfollow.",
unit=" users"):
self.actions.append({"function": "unfollow", "argument": username})
def get_owner_saved_post(self):
self.instabot.api.get_saved_medias()
saveds = self.instabot.last_json['items']
r = []
self.logger.info("Getting owner of saved posts")
for p in saveds:
r.append(str(p['media']['user']['username']))
return r
def treat_exception(self, err):
self.logger.exception(err)
if isdebugging:
breakpoint()
def end(self):
self.appiumservice.stop()
self.logger.info("That's all folks! Bye bye!")
quit()
def check_element_exist(self, xpath):
try:
self.driver.find_element_by_xpath(xpath)
except NoSuchElementException:
return False
return True
def chimping_timeline(self):
try:
self.refreshing()
amount = random.randint(5, 15)
count = 0
self.logger.info("Let's chimping the timeline a bit.")
el1 = self.driver.find_element_by_id(
"com.instagram.android:id/action_bar_root")
start_x = el1.rect["width"] - 50
start_y = el1.rect["height"] - 50
end_x = el1.rect["x"] + 50
end_y = el1.rect["y"] + 50
while count < amount:
self.driver.swipe(start_x,
start_y,
end_x,
end_y,
duration=random.randint(2500, 4000))
count += 1
except Exception as err:
self.treat_exception(err)
pass
def refreshing(self):
try:
self.driver.get(url="https://www.instagram.com/")
self.driver.find_element_by_xpath(
ElementXpath.tab_bar_home).click()
self.driver.find_element_by_xpath(
ElementXpath.tab_bar_home).click()
self.driver.find_element_by_xpath(ElementXpath.top_title).click()
el1 = self.driver.find_element_by_xpath(
ElementXpath.row_feed_photo_profile_name)
el2 = self.driver.find_element_by_xpath(
ElementXpath.tab_bar_camera)
start_x = el1.rect["x"]
start_y = el1.rect["y"]
end_x = el2.rect["x"]
end_y = el2.rect["y"] - 100
self.driver.swipe(start_x,
start_y,
end_x,
end_y,
duration=random.randint(350, 400))
except Exception as err:
self.treat_exception(err)
pass
def chimping_stories(self):
self.refreshing()
count = 0
amount = random.randint(2, 5)
try:
stories_thumbnails = self.driver.find_elements_by_xpath(
ElementXpath.stories_thumbnails)
stories_thumbnails[1].click()
self.logger.info("Watching {} stories.".format(amount))
while count < amount:
t = random.randint(5, 10)
sleep(t)
if self.check_element_exist(
xpath=ElementXpath.reel_viewer_texture_view):
x1 = random.randint(750, 850)
y1 = random.randint(550, 650)
x2 = random.randint(200, 300)
y2 = random.randint(550, 650)
self.driver.swipe(x1, y1, x2, y2,
random.randint(500, 1000))
count += 1
except Exception as err:
self.logger.warning(
"Ops, something wrong while waching stories, sorry.")
self.treat_exception(err)
pass
self.driver.get(url="https://www.instagram.com/{}/".format(
self.settings['instagram']['username']))
self.driver.get(url="https://www.instagram.com/")
def interact_by_location(self, amount: int = 15, location_id: int = ""):
self.instabot.api.get_location_feed(location_id=213819997, max_id=9999)
last_json = self.instabot.last_json
if amount > len(last_json['items']):
amount = len(last_json['items'])
counter = 0
while counter < amount:
self.interact(last_json['items'][counter]['id'])
counter += 1
def check_item(self,
item,
concepts=[],
concepts_skip=[],
max_likes=1000,
min_likes=0):
if not item['like_count'] in range(min_likes, max_likes):
return False
if item['has_liked']:
return False
if isinstance(concepts, list) and isinstance(concepts_skip, list):
if item['media_type'] == MediaType.PHOTO:
url_image = item['image_versions2']['candidates'][0]['url']
elif item['media_type'] == MediaType.CAROUSEL:
url_image = item['carousel_media'][0]['image_versions2'][
'candidates'][0]['url']
else:
url_image = item['video_versions'][0]['url']
predict = self.predict.check(url=url_image,
tags=concepts,
tags_skip=concepts_skip,
is_video=item['media_type'] == 2)
else:
predict = True
return predict
def interact_by_hashtag(self,
amount: int = 15,
hashtag: str = "",
ranked_items: bool = True,
concepts=[],
concepts_skip=[],
max_likes=100,
min_likes=0):
try:
items = []
next_max_id = ""
while self.instabot.api.get_hashtag_feed(hashtag,
max_id=next_max_id):
last_json = self.instabot.api.last_json
next_max_id = last_json['next_max_id']
if ranked_items:
if "ranked_items" in last_json:
items = items + last_json['ranked_items']
items = items + last_json['items']
items = [
i for i in items[0:amount]
if self.check_item(item=i,
concepts=concepts,
concepts_skip=concepts_skip,
max_likes=max_likes,
min_likes=min_likes)
]
if amount == len(items[0:amount]):
items = items[0:amount]
break
return [item for item in items if self.add_action(item, "like")]
except Exception as err:
self.logger.warning(
"Ops, something wrong while working with hashtag #{}, sorry.".
format(hashtag))
self.treat_exception(err)
pass
def interact_by_location(self,
amount: int = 15,
location_id: int = "",
ranked_items: bool = True,
concepts=[],
concepts_skip=[],
max_likes=100,
min_likes=0):
try:
items = []
next_max_id = ""
while self.instabot.api.get_location_feed(location_id,
max_id=next_max_id):
last_json = self.instabot.api.last_json
next_max_id = last_json['next_max_id']
if ranked_items:
if "ranked_items" in last_json:
items = items + last_json['ranked_items']
items = items + last_json['items']
items = [
i for i in items
if self.check_item(item=i,
concepts=concepts,
concepts_skip=concepts_skip,
max_likes=max_likes,
min_likes=min_likes)
]
if amount == len(items[0:amount]):
items = items[0:amount]
break
return [item for item in items if self.add_action(item, "like")]
except Exception as err:
self.logger.warning(
"Ops, something wrong while working with location {}, sorry.".
format(location_id))
self.treat_exception(err)
pass
def add_action(self, item, function):
try:
self.actions.append({
"function": function,
"argument": {
"url":
"https://www.instagram.com/p/{}/".format(item["code"]),
"media_type": item['media_type']
}
})
return True
except:
return False
def set_do_follow(self, follow_percentage: int = 0):
self.follow_percentage = follow_percentage
def do_actions(self):
likes_actions = [i for i in self.actions if i["function"] == "like"]
self.posts_to_follow = []
if self.follow_percentage > 0:
self.posts_to_follow = random.sample(
range(0, len(likes_actions)),
int(len(likes_actions) * (self.follow_percentage / 100)))
amount_actions = int(len(self.actions) / 2)
if not isdebugging():
for i in tqdm(range(1, amount_actions),
desc="Let's include some (not so real) actions.",
unit=" actions"):
self.actions.append({"function": "chimping_timeline"})
self.actions.append({"function": "chimping_stories"})
random.shuffle(self.actions)
self.actions = [i[0] for i in groupby(self.actions)]
self.start_android()
for action in tqdm(self.actions,
desc="Execution actions on the phone/emulator",
unit=" actions"):
try:
method_to_call = getattr(self, action['function'])
if "argument" in action:
method_to_call(action['argument'])
sleep(random.randint(3, 10))
else:
method_to_call()
except Exception as err:
self.logger.warning(
"Ops, something with the action {} ({}), sorry.".format(
action['function'], action['argument']))
self.treat_exception(err)
pass
self.stop_driver()
def start_android(self):
starting_appium = threading.Thread(name='process',
target=self.start_driver)
starting_appium.start()
while starting_appium.isAlive():
self.animated_loading()
def follow(self):
if self.save_in_collection():
try:
self.driver.find_element_by_xpath(
ElementXpath.btn_follow).click()
user = self.driver.find_element_by_xpath(
ElementXpath.action_bar_textview_title).text
self.logger.info("Following user {}.".format(user))
self.amount_followed += 1
print(self.amount_followed)
return True
except Exception as err:
self.treat_exception(err)
return False
pass
else:
return False
def save_in_collection(self):
try:
button_save = self.driver.find_element_by_xpath(
ElementXpath.row_feed_button_save)
self.touchaction.long_press(button_save)
self.touchaction.perform()
strdate = datetime.now().strftime("%Y%m%d")
if self.check_element_exist(
ElementXpath.create_collection_edit_text):
self.logger.info(
"Zero collection, let's create the first one.")
collection_today = []
else:
collection_names = self.driver.find_elements_by_xpath(
ElementXpath.collection_name)
collection_today = [
i for i in collection_names if i.text == strdate
]
if len(collection_today) > 0:
collection_today[0].click()
else:
if self.check_element_exist(
ElementXpath.save_to_collection_new_collection_button):
self.driver.find_element_by_xpath(
ElementXpath.save_to_collection_new_collection_button
).click()
self.driver.find_element_by_xpath(
ElementXpath.create_collection_edit_text).send_keys(
strdate)
self.driver.find_element_by_xpath(
ElementXpath.save_to_collection_action_button).click()
self.driver.find_element_by_xpath(
ElementXpath.row_feed_photo_profile_name).click()
return True
except Exception as e:
self.logger.warning("Post not saved!")
self.treat_exception(e)
return False
def like(self, param):
url = param["url"]
media_type = param["media_type"]
self.driver.get(url=url)
try:
e = self.driver.find_element_by_xpath(
ElementXpath.row_feed_button_like)
if e.tag_name == "Liked":
self.logger.info("Ops, you already like this one, sorry.")
return False
else:
if media_type == MediaType.VIDEO:
self.wait_random()
elif media_type == MediaType.CAROUSEL:
self.swipe_carousel()
e.click()
# sleep(random.randint(1, 3))
self.logger.info("Image {} Liked.".format(url))
if self.amount_liked in self.posts_to_follow:
self.follow()
return True
except Exception as err:
self.logger.warning(
"Ops, something wrong on try to like {}, sorry.".format(url))
self.logger.error(err)
self.treat_exception(err)
return False
pass
def watch_stories(self):
try:
while self.check_element_exist(
xpath=ElementXpath.reel_viewer_texture_view):
t = random.randint(2, 10)
self.logger.info("Sleeping for {} seconds.".format(t))
sleep(t)
if self.check_element_exist(
xpath=ElementXpath.reel_viewer_texture_view):
self.logger.info("Tap")
self.driver.tap([(800, 600)], random.randint(3, 10))
except Exception as err:
self.logger.warning(
"Ops, something wrong while waching stories, sorry.")
self.treat_exception(err)
pass
def get_info(self):
row_feed_photo_profile_name = self.driver.find_element_by_xpath(
ElementXpath.row_feed_photo_profile_name)
owner_username = row_feed_photo_profile_name.text.replace(" •", "")
has_liked = self.driver.find_element_by_id(
"com.instagram.android:id/row_feed_button_like"
).tag_name == "Liked"
self.get_type_post()
def swipe_carousel(self):
try:
carousel_image = self.driver.find_element_by_xpath(
ElementXpath.carousel_image)
match = re.search(r"(\d+).*?(\d+)", carousel_image.tag_name)
n = int(match.group(2))
except NoSuchElementException as err:
n = 2 # if don't find the number of pictures work with only 2
pass
self.logger.warning("Let's check all the {} images here.".format(n))
for x in range(n - 1):
self.driver.swipe(800, 600, 250, 600, random.randint(500, 1000))
for x in range(n - 1):
self.driver.swipe(300, 650, 800, 600, random.randint(500, 1000))
@staticmethod
def wait_random():
t = random.randint(5, 15)
sleep(t)
def get_collections(self):
self.instabot.api.send_request("collections/list/")
return self.instabot.last_json
def get_collection(self, collection_id):
self.instabot.api.send_request(
"feed/collection/{}/".format(collection_id))
return self.instabot.last_json
def unfollow_by_collection(self, name):
collections = self.get_collections()
for c in collections["items"]:
if c['collection_name'] == name:
collection = self.get_collection(
collection_id=c['collection_id'])
for i in tqdm(
collection["items"],
desc="Getting users from colletion {} to unfollow.".
format(name)):
self.actions.append({
"function":
"unfollow",
"argument":
i['media']['user']['username']
})
self.actions.append({
"function": "unsave",
"argument": i['media']['code']
})
@staticmethod
def animated_loading():
chars = "/—\|"
for char in chars:
sys.stdout.write('\r' + 'loading service...' + char)
time.sleep(.1)
sys.stdout.flush()