def handle(c):
if c == "" or c[0] == "#": return
c = c.strip()
head = c.lower().split(" ")[0]
args = " ".join(c.split(" ")[1:])
try:
# Yeah, we don't have switch case in python...
if not Cli.general_commands(head, args, module_help):
if head in [
"database", "debug", "dev", "verbose", "reload", "refresh",
"list", "show", "resource", "os", "use", "exec", "search",
"info", "previous", "sessions", "jobs", "eval", "report"
]:
exec("Cli.command_{}(args)".format(head))
Settings.update_history(c)
else:
handler = globals()["command_{}".format(head)]
handler(args)
Settings.update_history(c)
except Exception as e:
if Settings.debug:
print("Exception -> " + str(e))
print(" Input -> " + str(c))
print("Trackback -> ")
traceback.print_exc()
error(head + " is not recognized as an internal command !")
#To check for the wanted command on typos
wanted = utils.grab_wanted(head, module_keywords)
if len(wanted) > 0:
status("Maybe you meant : " + wanted)
status("Type help or ? to learn more..")
def test_settings(email, password, zip_code, languages, categories, save,
file_name):
with mock.patch("builtins.input",
side_effect=[email, zip_code, languages, categories,
save]):
with mock.patch("getpass.getpass", return_value=password):
settings_path = f"test_tmp/{file_name}"
settings = Settings(settings_path)
assert settings.email == email
assert settings.password == password
assert settings.zip_code == zip_code
assert settings.languages == [] if languages is None else languages
assert settings.categories == [] if categories is None else categories
if save.upper() == "Y":
yaml = YAML()
with open(settings_path) as f:
settings = yaml.load(f)
assert settings["udemy"]["email"] == email
assert settings["udemy"]["password"] == password
assert settings["udemy"]["zipcode"] == zip_code
assert (settings["udemy"]["languages"] == []
if languages is None else ",".join(languages))
assert (settings["udemy"]["categories"] == []
if categories is None else categories)
# Load settings just created
Settings(settings_path)
else:
assert os.path.isdir(settings_path) is False
def command_handler(c):
#parsing a command and pass to its function
if c == "" or c[0] == "#": return
command = c.lower().split()[0]
args = " ".join(c.split()[1:])
try:
handler = globals()["command_{}".format(command)]
handler(args)
Settings.update_history(
c
) # Log the important commands and the ones that doesn't gave error :D
except Exception as e:
if command not in all_keywords:
error(command + " is not recognized as an internal command !")
#To check for the wanted command on typos
wanted = utils.grab_wanted(command, all_keywords)
if len(wanted) > 0:
status("Maybe you meant : " + wanted)
else:
error("Error in executing command " + command)
status("Type help or ? to learn more..")
if Settings.debug:
print("Exception -> " + str(e))
print(" Input -> " + str(c))
print(" Modules -> " + " ".join(modules))
print("Trackback -> ")
traceback.print_exc()
def handle(c):
if c=="" or c[0]=="#":return
c = c.strip()
head = c.lower().split(" ")[0]
args = " ".join(c.split(" ")[1:])
try:
# Yeah, we don't have switch case in python...
if not Cli.general_commands(head, args, module_help):
if head in ["database","debug","dev","verbose","reload","refresh","list","show","resource","os","use","exec",
"search","info","previous","sessions","jobs","eval","report"]:
exec("Cli.command_{}(args)".format(head))
Settings.update_history(c)
else:
handler = globals()["command_{}".format(head)]
handler(args)
Settings.update_history(c)
except Exception as e:
if Settings.debug:
print("Exception -> "+str(e))
print(" Input -> "+str(c))
print("Trackback -> ")
traceback.print_exc()
error( head + " is not recognized as an internal command !")
#To check for the wanted command on typos
wanted = utils.grab_wanted(head,module_keywords)
if len(wanted)>0:
status( "Maybe you meant : " + wanted )
status( "Type help or ? to learn more..")
def Exec(all_keywords):
global global_options, module_keywords, cli_keywords
module_keywords += all_keywords
cli_keywords = all_keywords
mod = importlib.import_module(
utils.pythonize("core.modules." + Settings.running_module))
global_options = getattr(mod, 'execution').module_type.options
if os.name != "nt":
utils.Input_completer(module_keywords + modules)
Settings.add_module(Settings.running_module)
def Exec(all_keywords):
global global_options, module_keywords, cli_keywords
module_keywords += all_keywords
cli_keywords = all_keywords
mod = importlib.import_module(utils.pythonize("core.modules."+Settings.running_module))
if Settings.development:
mod = utils.reload(mod)
global_options = getattr(mod, 'execution').module_type.options
if os.name !="nt":
utils.Input_completer(module_keywords+modules)
Settings.add_module(Settings.running_module)
def command_use(p=False):
p = p.lower()
if not p:
error("You must enter a module to use !")
return
else:
if p in modules:
if Settings.running_module:
Settings.update_previous()
Settings.running_module = p
module.Exec(all_keywords)
return
else:
error(p + " module not found!")
def test_load_existing_settings(email, password, zip_code, languages,
categories, save, file_name):
with mock.patch("builtins.input",
side_effect=[email, zip_code, languages, categories,
save]):
with mock.patch("getpass.getpass", return_value=password):
settings_path = f"test_tmp/{file_name}"
Settings(settings_path)
# Load existing settings
settings = Settings(settings_path)
assert settings.email == email
assert settings.password == password
assert settings.zip_code == zip_code
assert settings.languages == [] if languages is None else languages
assert settings.categories == [] if categories is None else categories
def __init__(self):
"""
Initialize
"""
super(QtCore.QObject, self).__init__()
self.central_state_monitor = CentralStateMonitor()
# News
self.news = News()
# settings
self.central_settings = Settings()
self.signals = Signals()
# path to modules directory
self.path_modules = os.path.normpath(
os.path.join(os.path.dirname(os.path.realpath(__file__)), "../../",
"modules"))
# dictionary to keep track of the instantiated modules
self._instantiated_modules = {}
# create window, show it
self.window = HQWindow(self)
self.window.show()
# connect signals: signal_stop_all_modules, which can be called from the modules to stop all other modules
self.signal_stop_all_modules.connect(self.stop_modules)
self.signals.write_signal("stop_all_modules",
self.signal_stop_all_modules)
class Window(QMainWindow):
conf = Settings.getInstance()
def __init__(self, MainQtApp=None, *args, **kwargs):
super(Window, self).__init__(MainQtApp, *args, **kwargs)
self.setWindowTitle("Oceana Navigation Data Package")
self.status = self.statusBar()
self.mdiArea = QMdiArea(self)
self.mdiArea.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.mdiArea.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.mdiArea.subWindowActivated.connect(self.updateMenus)
self.windowMapper = QSignalMapper(self)
self.windowMapper.mapped[QWidget].connect(self.setActiveSubWindow)
self.setCentralWidget(self.mdiArea)
def setActiveSubWindow(self, window):
if window:
self.mdiArea.setActiveSubWindow(window)
def updateMenus(self):
hasMdiChild = (self.activeMdiChild() is not None)
def activeMdiChild(self):
activeSubWindow = self.mdiArea.activeSubWindow()
if activeSubWindow:
return activeSubWindow.widget()
return None
def command_use(p=False):
p = p.lower()
if not p:
error("You must enter a module to use !")
return
else:
if p in modules:
if Settings.running_module:
Settings.update_previous()
Settings.running_module = p
module.Exec(all_keywords)
return
else:
if Settings.debug:
print("Module -> " + p)
print("Loaded modules ->" + "\t".join(modules))
error(p + " module not found!")
def test_load_ci_settings(_, monkeypatch, is_ci_run, email, password):
monkeypatch.setenv("CI_TEST", str(is_ci_run))
monkeypatch.setenv("UDEMY_EMAIL", email)
monkeypatch.setenv("UDEMY_PASSWORD", password)
settings = Settings("")
if is_ci_run:
assert settings.email == email
assert settings.password == password
def set_from_current_settings(self, settings_singleton: Settings):
"""
Set the base settings
:param settings_singleton:
:return:
"""
if self.all_conditions:
raise RuntimeError(
"The base settings of an experiment can only be modified when no conditions exist."
)
for module in self.modules_included:
self.base_settings[module] = copy.deepcopy(
settings_singleton.get_settings(module).as_dict()[str(
module)]) # not sure if .as_dict() is a good idea
def run(
browser: str,
max_pages: Union[int, None],
cache_hit_limit: int,
driver: WebDriver = None,
):
"""
Run the udemy enroller script
:param str browser: Name of the browser we want to create a driver for
:param int or None max_pages: Max number of pages to scrape from tutorialbar.com
:param int cache_hit_limit: If we hit the cache this many times in a row we exit the script
:param WebDriver driver:
:return:
"""
settings = Settings()
if driver is None:
dm = DriverManager(browser=browser, is_ci_build=settings.is_ci_build)
driver = dm.driver
redeem_courses(driver, settings, max_pages, cache_hit_limit)
def command_back(text=False): Settings.update_previous() Settings.running_module = False Settings.reset_name() if os.name!="nt": utils.Input_completer(cli_keywords+modules )
# Install all the requirements by running requirements.py in IDLE or follow the alternate instructions at
# https://github.com/aapatre/Automatic-Udemy-Course-Enroller-GET-PAID-UDEMY-COURSES-for-FREE/ Make sure you have
# cleared all saved payment details on your Udemy account & the browser! For firefox you need to manually install the
# driver on Arch Linux (sudo pacman -S geckodriver). Untested on other platforms.
from selenium import webdriver
from core import Settings
from core.utils import redeem_courses
settings = Settings()
driver = webdriver.Firefox()
# Maximizes the browser window since Udemy has a responsive design and the code only works
driver.maximize_window()
# in the maximized layout
try:
redeem_courses(driver, settings)
except KeyboardInterrupt:
print("Exiting the script")
except Exception as e:
print("Error: {}".format(e))
finally:
print("Closing browser")
driver.quit()
def settingsMenu(self):
if self.engine.advSettings:
self.settingsMenuObject = Settings.SettingsMenu(self.engine)
else:
self.settingsMenuObject = Settings.BasicSettingsMenu(self.engine)
return self.settingsMenuObject
import os
import sys
from PyQt5.Qt import QApplication
from PyQt5 import QtGui
from core.ui import Window
from core import Settings
if __name__ == "__main__":
appconf = {}
conf = Settings.getInstance()
QApp = QApplication(sys.argv)
QApp.setObjectName("Oceana")
mainWindow = Window()
if not QApp.objectName() in conf:
conf[QApp.objectName()] = {}
appconf = conf[QApp.objectName()]
appconf["x"] = mainWindow.pos().x()
appconf["y"] = mainWindow.pos().y()
appconf["width"] = mainWindow.width()
appconf["height"] = mainWindow.height()
appconf["lookandfeel"] = "native"
appconf = conf[QApp.objectName()]
mainWindow.setMinimumSize(appconf.as_int("width"),
appconf.as_int("height"))
mainWindow.show()
conf.write()
sys.exit(QApp.exec_())
def command_back(text=False):
Settings.update_previous()
Settings.running_module = False
Settings.reset_name()
if os.name != "nt":
utils.Input_completer(cli_keywords + modules)
