class PagesTest(unittest.TestCase):
    def __init__(self, method_name):
        super().__init__(method_name)
        self._toc = Pages(SystemConfig.pages_path())

    def test_page_filename(self):
        self.assertEqual(Pages.page_filename("Somewhere"), "Somewhere.txt")

    def test_path_to_page(self):
        path = self._toc.page_path("Junk")
        self.assertEqual(path, "pages/Junk.txt")

    def test_page_wiki_exists(self):
        self.assertTrue(self._toc.word_matches_a_page("Wiki"))

    def test_lower_case_wiki_does_exist(self):
        self.assertTrue(self._toc.word_matches_a_page("wiki"))

    def test_nothing_does_not_exist(self):
        self.assertFalse(self._toc.word_matches_a_page("Nothing"))

    def test_pages_are_in_all_pages(self):
        pages = self._toc.all_page_filenames()
        self.assertIn("Wiki.txt", pages)
        self.assertIn("Nelson.txt", pages)
        self.assertIn("Cunningham.txt", pages)
Esempio n. 2
0
def generate_wiki():
    """Reads each page in the pages directory and writes a markup page in the docs directory that will contain
    text that will link to other pages if they match the words. Also creates a table of contents ."""
    pages = Pages(SystemConfig.pages_path())

    index_file = open("{path}/index.md".format(path=SystemConfig.docs_path()),
                      "w+")
    index_file.write("# Table of Contents\n")

    for page_filename in pages.all_page_filenames():
        contents = read_contents(page_filename)
        write_contents(contents, page_filename, pages)
        write_to_index(page_filename, index_file)

    index_file.close()
Esempio n. 3
0
class TestPages(unittest.TestCase):

    def setUp(self):
        self.pages = Pages()

    def test_pages_list_all(self):
        num = len(self.pages.getAll())
        self.assertTrue(num>0)

    def test_page_get(self):
        page = Page(PAGE_NAME)
        self.assertEqual(PAGE_NAME, page.name)

    def test_page_pics(self):
        page = Page(PAGE_NAME)
        self.assertTrue(len(page.pics)>0)

    def test_first_page(self):
        page = self.pages.first_page
        self.assertEqual(page.name, PAGE_NAME)

    def test_order_list(self):
        page_list = self.pages.list
        page_names_list = [p.name for p in page_list]
        self.assertEqual([PAGE_NAME, PAGE_NAME2], page_names_list[0:2])
Esempio n. 4
0
 def before_scenario(self, context, scenario):
     super().before_scenario(context, scenario)
     context.base_e2e_url = os.getenv('E2E_URL')
     context.logger.info(f'Base E2E URL is: {context.base_e2e_url}')
     context.logger.info('Starting browser')
     context.driver = create_webdriver()
     context.pages = Pages(context)
    def getData(url, file, limit):
        results = Pages.getPages(url, limit)
        with open(file, mode='w') as csv_file:
            # sets up csv file
            writer = csv.writer(csv_file,
                                delimiter=',',
                                quotechar='"',
                                quoting=csv.QUOTE_MINIMAL)

            # creates columns
            writer.writerow([
                'date', 'abstract', 'rating', 'workLifeBalance',
                'cultureAndValues', 'careerOpportunities',
                'compensationAndBenefits', 'seniorManagement',
                'authorJobTitle', 'tenure', 'pro', 'con'
            ])

            # adds reviews
            for review in results:
                writer.writerow([
                    review.date, review.summary, review.rating,
                    review.workLifeBalance, review.cultureAndValues,
                    review.careerOpportunities, review.compensationAndBenefits,
                    review.seniorManagement, review.authorJobTitle,
                    review.mainText, review.pro, review.con
                ])
Esempio n. 6
0
 def __init__(self, access_token=''):
     self.Account = Account(access_token=access_token)
     self.Apps = Apps(access_token=access_token)
     self.Audio = Audio(access_token=access_token)
     self.Auth = Auth(access_token=access_token)
     self.Board = Board(access_token=access_token)
     self.Database = Database(access_token=access_token)
     self.Docs = Docs(access_token=access_token)
     self.Other = Other(access_token=access_token)
     self.Fave = Fave(access_token=access_token)
     self.Friends = Friends(access_token=access_token)
     self.Gifts = Gifts(access_token=access_token)
     self.Groups = Groups(access_token=access_token)
     self.Likes = Likes(access_token=access_token)
     self.Market = Market(access_token=access_token)
     self.Messages = Messages(access_token=access_token)
     self.Newsfeed = Newsfeed(access_token=access_token)
     self.Notes = Notes(access_token=access_token)
     self.Notifications = Notifications(access_token=access_token)
     self.Pages = Pages(access_token=access_token)
     self.Photos = Photos(access_token=access_token)
     self.Places = Places(access_token=access_token)
     self.Polls = Polls(access_token=access_token)
     self.Search = Search(access_token=access_token)
     self.Stats = Stats(access_token=access_token)
     self.Status = Status(access_token=access_token)
     self.Storage = Storage(access_token=access_token)
     self.Users = Users(access_token=access_token)
     self.Utils = Utils(access_token=access_token)
     self.Video = Video(access_token=access_token)
     self.Wall = Wall(access_token=access_token)
     self.Widgets = Widgets(access_token=access_token)
Esempio n. 7
0
def main():

    display = Screen('marvinconfig.txt', parser)
    menu = Pages('marvinconfig.txt', parser)
    artifacts = Items('marvinconfig.txt', parser)
    players = Users('marvinconfig.txt', parser)
    universe = Devices('marvinconfig.txt', parser)
    while True:
        '''TODO:
Esempio n. 8
0
def test_page():
    print('Debug: Page-')

    page = Pages(['Timeline1', 'Timeline2'], 'button')

    print('Page: Full page- PASSED   ', page.get_items())

    page2 = Pages(None, None)

    print('Page: Empty page- PASSED   ', page2.get_items())

    x = [str(x) for x in range(20)]

    page3 = Pages(x, 'button')
    print('Page: 11+ pages- PASSED   ', page3.get_items())
Esempio n. 9
0
 def before_scenario(self, context, scenario):
     super().before_scenario(context, scenario)
     desired_caps = {
         'deviceName': os.getenv('DEVICE_NAME'),
         'fullReset': os.getenv('FULL_RESET'),
         'app': os.getenv('APP_PATH'),
         'platformName': os.getenv('PLATFORM_NAME'),
         'appPackage': os.getenv('APP_PACKAGE'),
         'appActivity': os.getenv('APP_ACTIVITY'),
         'automationName': os.getenv('AUTOMATION_NAME')
     }
     context.driver = webdriver.Remote(os.getenv('MOBILE_ADDRESS'), desired_caps)
     context.driver.implicitly_wait(5)
     context.pages = Pages(context)
Esempio n. 10
0
def main():
    pygame.init()
    pygame.mixer.init()

    # Groesse fuer das Fenster festlegen
    screen = pygame.display.set_mode((DISPLAY_WIDTH, DISPLAY_HEIGHT))

    # Standardmaessig mit Title Seite anfangen
    game_state = GameState.TITLE
    player = Player()

    # Aufrufen der Logik, die die Pages aufruft
    while True:
        game_state = Pages().game_state_logic(game_state, screen, player)

        if game_state == game_state.QUIT:
            pygame.quit()
            return
Esempio n. 11
0
    def add_timelines_to_dict(self):
        # loop through the split up timeline list and create buttons
        # for each timeline. Every new list is a new page.

        # example data-  {'1': {'1': (...button...}
        #			 	  '2': {'1': {...button...}

        pageCounter = 1
        for i in self.splitTimelineList:
            buttonPages = Pages(
                i, 'buttons')  # passing in buttons so it creates a button page
            actionPages = Pages(
                i,
                'actions')  # passing in actions so it creates an action page
            self.dictOfPages[str(pageCounter)] = buttonPages.get_items()
            self.dictOfActionPages[str(pageCounter)] = actionPages.get_items()
            pageCounter += 1

        return
Esempio n. 12
0
import config


# Setup
config.init()

Model.init(config)
Views.init(config)
JWT.init(config)

app = Flask('Note Taker')

api = API.create(config)  # REST interface
app.register_blueprint(api, url_prefix='/api')

pages = Pages.create(config)  # Views
app.register_blueprint(pages)

Markdown(app)


# Run flask app
if __name__ == "__main__":
    # Setup debug option
    debug = False
    if config.get('app.debug'):
        app.jinja_env.auto_reload = True
        app.config['TEMPLATES_AUTO_RELOAD'] = True
        debug = True

    # Setup sessions
 def test_page_filename(self):
     self.assertEqual(Pages.page_filename("Somewhere"), "Somewhere.txt")
Esempio n. 14
0
    def button(self,
               text,
               x,
               y,
               width,
               height,
               inactive_color,
               active_color,
               action=None,
               size="small",
               text_color=(0, 0, 0)):
        """
        Tworzy przyciski.
        :param text: tekst widniejący na przycisku,
        :param x: wartość z lewego górnego przycisku,
        :param y: wartość y lewego górnego roku przycisku,
        :param width: szerokość przycisku,
        :param height: wysokość przycisku,
        :param inactive_color: kolor nieaktywnego przycisku,
        :param active_color: kolor po najechaniu kursorem na przycisk,
        :param action: akcja jak ma się wykonać po naciśnięciu przycisku,
        :param size: rozmiar czcionki,
        :param text_color: kolor tekst.
        """

        #pozycja kursora
        cur = pygame.mouse.get_pos()

        #kliknięcie myszką
        click = pygame.mouse.get_pressed()

        if x + width > cur[0] > x and y + height > cur[1] > y:
            pygame.draw.rect(self.screen, active_color, (x, y, width, height))
            if click[0] == 1 and action != None:

                #opcje uruchomienia poszczególnych plansz
                if action == "board1":
                    self.board1 = True
                    self.board2 = False
                    self.board3 = False
                if action == "board2":
                    self.board2 = True
                    self.board1 = False
                    self.board3 = False
                if action == "board3":
                    self.board3 = True
                    self.board1 = False
                    self.board2 = False

                #parametry deski w zależności od wybranego rozmiaru
                if action == "short_paddle":
                    self.paddle_width = 70
                if action == "medium_paddle":
                    self.paddle_width = 100
                if action == "long_paddle":
                    self.paddle_width = 200

                #parametry piłki w zależności od wybranego rozmiaru
                if action == "small_ball":
                    self.ball_width = 18
                    self.ball_height = 15
                    self.check = 35
                if action == "medium_ball":
                    self.ball_width = 30
                    self.ball_height = 25
                    self.check = 40
                if action == "big_ball":
                    self.ball_width = 50
                    self.ball_height = 40
                    self.check = 45

                if action == "play":
                    #uruchomienie wybranych opcji z menu
                    if self.board1 == True and self.paddle_width == 0 and self.ball_width == 0:
                        self.sprites(self.plansza1())
                    elif self.board1 == True and self.paddle_width != 0 and self.ball_width == 0:
                        self.sprites(self.plansza1(), self.paddle_width)
                    elif self.board1 == True and self.paddle_width == 0 and self.ball_width != 0:
                        self.sprites(self.plansza1(),
                                     ball_width=self.ball_width,
                                     ball_height=self.ball_height)
                    elif self.board1 == True and self.paddle_width != 0 and self.ball_width != 0:
                        self.sprites(self.plansza1(), self.paddle_width,
                                     self.ball_width, self.ball_height)

                    elif self.board2 == True and self.paddle_width == 0 and self.ball_width == 0:
                        self.sprites(self.plansza2())
                    elif self.board2 == True and self.paddle_width != 0 and self.ball_width == 0:
                        self.sprites(self.plansza2(), self.paddle_width)
                    elif self.board2 == True and self.paddle_width == 0 and self.ball_width != 0:
                        self.sprites(self.plansza2(),
                                     ball_width=self.ball_width,
                                     ball_height=self.ball_height)
                    elif self.board2 == True and self.paddle_width != 0 and self.ball_width != 0:
                        self.sprites(self.plansza2(), self.paddle_width,
                                     self.ball_width, self.ball_height)

                    elif self.board3 == True and self.paddle_width == 0 and self.ball_width == 0:
                        self.sprites(self.plansza3())
                    elif self.board3 == True and self.paddle_width != 0 and self.ball_width == 0:
                        self.sprites(self.plansza3(), self.paddle_width)
                    elif self.board3 == True and self.paddle_width == 0 and self.ball_width != 0:
                        self.sprites(self.plansza3(),
                                     ball_width=self.ball_width,
                                     ball_height=self.ball_height)
                    elif self.board3 == True and self.paddle_width != 0 and self.ball_width != 0:
                        self.sprites(self.plansza3(), self.paddle_width,
                                     self.ball_width, self.ball_height)

                    elif self.board1 == False and self.board2 == False and self.board3 == False and self.paddle_width == 0 and self.ball_width == 0:
                        self.plansza1()
                        self.sprites()
                    elif self.board1 == False and self.board2 == False and self.board3 == False and self.paddle_width != 0 and self.ball_width == 0:
                        self.plansza1()
                        self.sprites(self.paddle_width)
                    elif self.board1 == False and self.board2 == False and self.board3 == False and self.paddle_width == 0 and self.ball_width != 0:
                        self.plansza1()
                        self.sprites(ball_width=self.ball_width,
                                     ball_height=self.ball_height)
                    elif self.board1 == False and self.board2 == False and self.board3 == False and self.paddle_width != 0 and self.ball_width != 0:
                        self.plansza1()
                        self.sprites(paddle_width=self.paddle_width,
                                     ball_width=self.ball_width,
                                     ball_height=self.ball_height)

                    Functions.reset_ball(self)
                    self.gameLoop()

                if action == "next":
                    Pages.second_options(self)

                if action == "about author":
                    Pages.about_author(self)

                if action == "quit":
                    Functions.invite(self)

                if action == "back to menu":
                    Pages.start(self)

                if action == "options":
                    self.options()

                if action == "back to options":
                    self.options()

        else:
            pygame.draw.rect(self.screen, inactive_color,
                             (x, y, width, height))

        Functions.text_to_button(self, text, text_color, x, y, width, height,
                                 size)
Esempio n. 15
0
    def __init__(self):

        #Inicjalizacja PyGame
        self.screen_width = 800
        self.screen_height = 600
        self.screen_size = (self.screen_width, self.screen_height)

        #kolory
        self.black = (0, 0, 0)
        self.white = (255, 255, 255)
        self.light_grey = (179, 179, 179)
        self.grey = (128, 128, 128)
        self.dark_grey = (115, 115, 115)

        #zmienne definiowane w celu utzryamania stałej prędkości piłki
        self.start_vel_x = 4
        self.start_vel_y = 4
        self.velocity = self.start_vel_x**2 + self.start_vel_y**2

        #zmienne potrzebne do zmiany parametrów
        self.board1 = False
        self.board2 = False
        self.board3 = False
        self.paddle_width = 0
        self.ball_width = 0
        self.check = 40

        #licznik żyć
        self.live_counter = 3

        #zdjęcia planszy
        self.board1_image = pygame.image.load("data/board1.png")
        self.board1_image = pygame.transform.scale(self.board1_image,
                                                   (225, 170))
        self.board2_image = pygame.image.load("data/board2.png")
        self.board2_image = pygame.transform.scale(self.board2_image,
                                                   (225, 170))
        self.board3_image = pygame.image.load("data/board3.png")
        self.board3_image = pygame.transform.scale(self.board3_image,
                                                   (225, 170))

        self.background = pygame.image.load("data/background.jpg")

        pygame.init()

        #dźwięki w grze
        self.sound_killed_bricks = Functions.loadSound(self, "wood_knock.wav")
        self.sound_bounced_ball = Functions.loadSound(self, "paddle_bound.wav")
        self.sound_start = Functions.loadSound(self, "start.wav")
        self.sound_game = Functions.loadSound(self, "game.wav")
        self.sound_loose = Functions.loadSound(self, "loose_sound.wav")
        self.sound_victory = Functions.loadSound(self, "victory.wav")

        #czcionki
        self.smallfont = pygame.font.SysFont("comicsansms", 25)
        self.mediumfont = pygame.font.SysFont("comicsansms", 38)
        self.bigfont = pygame.font.SysFont("comicsansms", 50)
        self.largefont = pygame.font.SysFont("comicsansms", 70)
        self.victoryfont = pygame.font.SysFont("comicsansms", 90)

        #Inicializacja okna
        self.screen = pygame.display.set_mode(self.screen_size)
        pygame.display.set_caption("Arkanoid")

        #Inicjalizacja grupy dla planszy
        self.BlocksSprite = pygame.sprite.Group()

        #Inicjalizacja rozszerzeń
        self.AddSpeedSprite = pygame.sprite.Group()
        self.SubstractSpeedSprite = pygame.sprite.Group()

        #uruchomienie strony startowej
        Pages.start(self)
        Functions.reset_ball(self)

        self.gameLoop()
Esempio n. 16
0
    def gameLoop(self):
        """Pętla gry właściwej."""
        self.sound_start.stop()
        self.sound_game.play()

        self.clock = pygame.time.Clock()
        self.delta = 0.0
        self.max_tps = 100.0

        self.exit = False
        self.gameover = False

        while not self.exit:

            #dzięlki temu zapewniam tą samą szybkość obiektów niezależnie od możliwości danego komputera
            self.delta += self.clock.tick() / 1000.0

            while self.delta > 1 / self.max_tps:
                self.delta -= 1 / self.max_tps

                for event in pygame.event.get():
                    if event.type == pygame.QUIT:
                        self.exit = True
                    elif event.type == pygame.KEYDOWN:
                        if event.key == pygame.K_ESCAPE:
                            self.exit = True
                        if event.key == pygame.K_SPACE:
                            self.ball.y_velocity = -4
                            self.ball.x_velocity = 0

                keys = pygame.key.get_pressed()
                if keys[pygame.K_LEFT]:
                    self.paddle.rect.x += -self.paddle.speed
                if keys[pygame.K_RIGHT]:
                    self.paddle.rect.x += self.paddle.speed
                elif keys[pygame.K_p]:
                    self.sound_game.stop()
                    self.pause()
                    self.clock = pygame.time.Clock()

                #przegrana
                if self.ball.rect.centery > self.screen_height - self.check:
                    Functions.reset_ball(self)
                    self.sound_game.stop()
                    if self.live_counter == 1:
                        self.sound_loose.play()
                        self.gameover = True
                    else:

                        self.ball.rect.top = self.screen_height - 100
                        self.ball.rect.centerx = self.screen_width / 2
                        self.paddle.rect.left = int(self.screen_width / 2 -
                                                    self.paddle_width / 2)
                        self.paddle.rect.top = int(self.screen_height - 30)
                        self.sound_game.play()
                        time.sleep(1)

                    self.live_counter -= 1

                self.update()

                #zderzenie piłki i bloków
                for hit in pygame.sprite.groupcollide(self.BallSprite,
                                                      self.BlocksSprite, 0, 1):
                    self.sound_killed_bricks.play()
                    self.ball.y_velocity = -self.ball.y_velocity
                self.killed_blocks = self.counter - len(self.BlocksSprite)

                #przspieszenie deski po zderzeniu pilki z rozszerzeniem
                for hit in pygame.sprite.groupcollide(self.BallSprite,
                                                      self.AddSpeedSprite, 0,
                                                      1):
                    self.ball.y_velocity = -self.ball.y_velocity
                    self.paddle.speed = 10

                # przspieszenie deski po zderzeniu pilki z rozszerzeniem
                for hit in pygame.sprite.groupcollide(
                        self.BallSprite, self.SubstractSpeedSprite, 0, 1):
                    self.ball.y_velocity = -self.ball.y_velocity
                    self.paddle.speed = 4

                #zwycięstwo
                if len(self.BlocksSprite) == 0:
                    self.sound_game.stop()
                    self.sound_victory.play()
                    self.live_counter = 3
                    Pages.victory(self)

                # zderzenie piłki i deski
                for hit in pygame.sprite.groupcollide(self.PaddleSprite,
                                                      self.BallSprite, 0, 0):

                    self.sound_bounced_ball.play()

                    # ustawienie różnych kątów odbicia piłki w zależności od miejsca jej odbicia na desce
                    if (self.paddle.get_pos() - self.paddle_width * 0.1
                        ) <= self.ball.get_pos() <= (self.paddle.get_pos() +
                                                     self.paddle_width * 0.1):
                        self.ball.x_velocity = 0
                        self.ball.y_velocity = -Functions.calculate_velocity(
                            self,
                            self.start_vel_y**2 + self.ball.x_velocity**2, 0)

                    elif self.paddle.get_pos() - self.paddle_width * 0.5 - (
                            self.ball_width /
                            2) < self.ball.get_pos() < self.paddle.get_pos(
                            ) - self.paddle_width * 0.3:
                        self.ball.x_velocity = -self.start_vel_x
                        self.ball.y_velocity = -self.ball.y_velocity

                    elif self.paddle.get_pos(
                    ) + self.paddle_width * 0.3 <= self.ball.get_pos(
                    ) < self.paddle.get_pos() + self.paddle_width * 0.5 + (
                            self.ball_width / 2):
                        self.ball.x_velocity = self.start_vel_x
                        self.ball.y_velocity = -self.ball.y_velocity

                    elif self.paddle.get_pos(
                    ) - self.paddle_width * 0.3 <= self.ball.get_pos(
                    ) < self.paddle.get_pos() - self.paddle_width * 0.1:
                        self.ball.x_velocity = -2
                        self.ball.y_velocity = Functions.calculate_velocity(
                            self, self.velocity, -2)
                        self.ball.y_velocity = -self.ball.y_velocity

                    elif self.paddle.get_pos(
                    ) + self.paddle_width * 0.1 < self.ball.get_pos(
                    ) < self.paddle.get_pos() + self.paddle_width * 0.3:
                        self.ball.x_velocity = 2
                        self.ball.y_velocity = Functions.calculate_velocity(
                            self, self.velocity, 2)
                        self.ball.y_velocity = -self.ball.y_velocity

                self.screen.fill(self.black)

                self.draw()

                #wysświetla wynik
                Functions.score(self, self.killed_blocks, self.counter)
                Functions.lives(self, self.live_counter)

                pygame.display.update()

                #pętla obsługująca przegraną
                while self.gameover == True:
                    self.sound_game.stop()

                    self.screen.fill(self.grey)
                    Functions.message(self,
                                      "Game over",
                                      self.white,
                                      y_displace=-50,
                                      size="large")
                    Functions.message(self,
                                      "Press M back to menu, or Q to quit",
                                      self.white,
                                      y_displace=50)
                    pygame.display.update()

                    for event in pygame.event.get():
                        if event.type == pygame.QUIT:
                            pygame.quit()
                            quit()
                        if event.type == pygame.KEYDOWN:
                            if event.key == pygame.K_q:
                                self.exit = True
                                self.gameover = False

                            if event.key == pygame.K_m:
                                Game()

                            if event.key == pygame.K_ESCAPE:
                                pygame.quit()
                                quit()

        Functions.invite(self)
 def __init__(self, method_name):
     super().__init__(method_name)
     self._toc = Pages(SystemConfig.pages_path())
Esempio n. 18
0
 def setUp(self):
     self.pages = Pages()
 def test_sentence_with_page_match_includes_markup_link(self):
     toc = Pages(path_to_pages="")
     toc.word_matches_a_page = return_true_if_param_is_junk
     rend = PageRenderer(toc=toc)
     self.assertEqual("Stuff is [Junk](junk.md).",
                      rend.transform("Stuff is Junk."))
 def test_sentence_without_a_word_matching_a_page_is_unchanged(self):
     toc = Pages(path_to_pages="")
     toc.word_matches_a_page = MagicMock(return_value=False)
     rend = PageRenderer(toc=toc)
     sentence = "A cow jumps over 3 moons, so it must be on Jupiter? I think so. "
     self.assertEqual(sentence, rend.transform(sentence))
Esempio n. 21
0
	def __init__(self):
		# detect args
		parser = OptionParser()
		parser.add_option("-d", "--debug", dest="debug",
				action="store_true", help="set debug mode", default=False)
		parser.add_option("-v", "--verbose", dest="verbose",
				action="store_true", help="verbose mode", default=False)
		parser.add_option("-p", "--page", dest="page",
				help="specify a page to handle")
		parser.add_option("--onepage", dest="onepage",
				action="store_true", help="only handle a single page (similar to `--pages=1')", default=False)
		parser.add_option("--task", dest="task",
				help="run builtin task (use `--task=help' for list of tasks)")
		parser.add_option("--pages", dest="pagestorun",
				help="number of pages to handle")
		parser.add_option("-s", "--search", dest="search",
				help="search string")
		parser.add_option("-t", "--time", dest="time",
				help="set time in format YYYY-MM-DDTHH:MM:SSZ")
		parser.add_option("--titlesearch", dest="titlesearch",
				action="store_true", help="search in titles rather than text", default=False)
		parser.add_option("--writetime", dest="writetime",
				action="store_true", help="write timestamp at end of run, even if other variables would disable that", default=False)
		parser.add_option("-r", "--ref", "--loadref", dest="loadref",
				action="store_true", help="force appearance reference load from wiki", default=False)
		parser.add_option("--localref", dest="localref",
				action="store_true", help="force appearance reference to be loaded locally", default=False)
		parser.add_option("--runtasks", dest="runtasks",
				action="store_true", help="force run tasks", default=False)
		parser.add_option("--changes", dest="changes",
				help="maximum recent changes to run")
		parser.add_option("--nochanges", dest="nochanges",
				action="store_true", help="don't check recent changes", default=False)
		parser.add_option("--donotfixpages", dest="donotfixpages",
				action="store_true", help="no page cleanup", default=False)
		parser.add_option("--donotrunpool", dest="donotrunpool",
				action="store_true", help="don't run changes for the pool", default=False)
		(options, args) = parser.parse_args()
		# set debug mode
		self.debugmode = options.debug
		self.verbose = options.verbose
		self.api = Api(debug=self.debugmode, server="theinfosphere.org")
		self.poolapi = Api(debug=self.debugmode, server="pool.theinfosphere.org")
		if self.debugmode:
			self.log("==== Debug mode!")
		if options.task!=None:
			# oh noes, we need to run a builtin task, so we should not run
			# regular tasks
			taskmanager = Taskmanager(debug=self.debugmode, api=self.api, verbose=self.verbose)
			if options.task == 'help':
				print taskmanager.help_response()
			else:
				self.log("Builtin task run...")
				if self.api.login(userdata.username, userdata.password):
					if not taskmanager.run_task(options.task):
						self.log("Task `%s' did not run properly or does not exist." % options.task)
				else:
					self.log("Could not log in.")
				self.writelog()
		else:
			if not options.nochanges:
				self.changes = Changes(debug=self.debugmode, api=self.api, verbose=self.verbose)
				if options.changes != None:
					self.changes.maximum = options.changes
			self.runtasks = options.runtasks
			self.pages = Pages(debug=self.debugmode, api=self.api, verbose=self.verbose)
			self.pages.singlepage = self.page = options.page
			pagestorun = 0
			if options.onepage:
				pagestorun = 1
			if options.pagestorun != None:
				pagestorun = options.pagestorun
			self.pages.pagestorun = self.pagestorun = pagestorun
			self.pages.search = self.search = options.search
			self.pages.titlesearch = self.titlesearch = options.titlesearch
			if options.time!=None:
				try:
					time.strptime(options.time, "%Y-%m-%dT%H:%M:%SZ")
					self.ts = options.time
					self.log("Using input time of `%s'." % self.ts)
				except ValueError:
					self.log("Input time given `%s' does not match format; ignoring." % self.ts)
					self.ts = None
			if self.debugmode or self.search!=None or self.pagestorun==1 or self.page!=None or self.ts!=None:
				# if any of these are the case, then writing a new time stamp could
				# mess up future runs
				self.writetime = False
			if options.writetime:
				# unless of course, it is forced by the user
				self.writetime = True
			self.pages.ar.loadref = options.loadref
			self.pages.ar.localref = options.localref
			# insure the api knows, so it won't make edits if debug mode
			if self.api.login(userdata.username, userdata.password):
				self.log("Logged in successfully.")
				if self.check_for_lock():		   
					self.initiate()
					if not options.nochanges:
						self.changes.set_ts(self.ts)
					self.pages.set_ts(self.ts)
					if self.runtasks or (self.pagestorun==0 and self.page == None):
						tasks = Tasks(self.debugmode, self.api, self.verbose, self.pages)
						self.log_obtain(tasks)
					if not options.nochanges:
						self.changes.handle_changes()
						self.log_obtain(self.changes)
					else:
						self.log("Not running recent changes checking...")
					if not options.donotfixpages:
						self.pages.routine_run()
					else:
						self.log("Not running page fixing...")
					self.log_obtain(self.pages)
					if not options.donotrunpool:
						self.images = Images(debug=self.debugmode, api=self.api, verbose=self.verbose, poolapi=self.poolapi)
						self.images.routine_job(self.ts)
						self.log_obtain(self.images)
					else:
						self.log("Not running through the pool...")
					self.finish()
			else:
				self.log("Could not log in.")
			self.writelog()
Esempio n. 22
0
class Svipbot(object):
	api = None
	poolapi = None
	loglines = []
	debugmode = False
	writetime = True
	oldts = None
	ts = None
	newts = None
	pages = None
	images = None
	
	def check_for_lock(self):
		if os.path.exists("botlock"):
			self.log("Botlock file exists.")
			return False
		self.log("No botlock.")
		return True
		
	def log(self, msg=None, view=True):
		if msg==None:
			return self.loglines
		else:
			self.loglines.append(msg)
			if (self.debugmode or self.verbose) and view:
				print msg
	
	def log_obtain(self, obj):
		if obj==None:
			return
		for l in obj.get_log():
			self.log(l, False)
		obj.clear_log()
	
	def initiate(self):
		f = open('botlock', 'w')
		f.write('x')
		f.close()
		self.log("Wrote botlock.")
		try:
			f = open('time', 'r')
			self.ts = f.read().strip()
			self.log("Found time of `%s'." % self.ts)
			f.close()
		except IOError:
			self.ts = None # just to make sure
		# create a timestamp now, because the edits may take time, and someone could
		# make an edit in between, and we want to catch that.
		self.newts = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
		
	def finish(self):
		# current time
		if self.newts==None:
			ts = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
		else:
			ts = self.newts
		if self.writetime:
			f = open('time', 'w')
			f.write(ts)
			f.close()
			self.log("Wrote timestamp of `%s'." % ts)
		# remove botlock
		os.remove("botlock")
		self.log("Removed botlock")
		
	def writelog(self):
		if not self.debugmode:
			# log
			fn = "logs/runlog-%s" % time.strftime("%Y%m%dT%H%M", time.gmtime())
			log = open(fn, 'w')
			log.writelines([unicode("%s\n"%s).encode('utf-8') for s in self.log()])
			log.close()
			
	def __init__(self):
		# detect args
		parser = OptionParser()
		parser.add_option("-d", "--debug", dest="debug",
				action="store_true", help="set debug mode", default=False)
		parser.add_option("-v", "--verbose", dest="verbose",
				action="store_true", help="verbose mode", default=False)
		parser.add_option("-p", "--page", dest="page",
				help="specify a page to handle")
		parser.add_option("--onepage", dest="onepage",
				action="store_true", help="only handle a single page (similar to `--pages=1')", default=False)
		parser.add_option("--task", dest="task",
				help="run builtin task (use `--task=help' for list of tasks)")
		parser.add_option("--pages", dest="pagestorun",
				help="number of pages to handle")
		parser.add_option("-s", "--search", dest="search",
				help="search string")
		parser.add_option("-t", "--time", dest="time",
				help="set time in format YYYY-MM-DDTHH:MM:SSZ")
		parser.add_option("--titlesearch", dest="titlesearch",
				action="store_true", help="search in titles rather than text", default=False)
		parser.add_option("--writetime", dest="writetime",
				action="store_true", help="write timestamp at end of run, even if other variables would disable that", default=False)
		parser.add_option("-r", "--ref", "--loadref", dest="loadref",
				action="store_true", help="force appearance reference load from wiki", default=False)
		parser.add_option("--localref", dest="localref",
				action="store_true", help="force appearance reference to be loaded locally", default=False)
		parser.add_option("--runtasks", dest="runtasks",
				action="store_true", help="force run tasks", default=False)
		parser.add_option("--changes", dest="changes",
				help="maximum recent changes to run")
		parser.add_option("--nochanges", dest="nochanges",
				action="store_true", help="don't check recent changes", default=False)
		parser.add_option("--donotfixpages", dest="donotfixpages",
				action="store_true", help="no page cleanup", default=False)
		parser.add_option("--donotrunpool", dest="donotrunpool",
				action="store_true", help="don't run changes for the pool", default=False)
		(options, args) = parser.parse_args()
		# set debug mode
		self.debugmode = options.debug
		self.verbose = options.verbose
		self.api = Api(debug=self.debugmode, server="theinfosphere.org")
		self.poolapi = Api(debug=self.debugmode, server="pool.theinfosphere.org")
		if self.debugmode:
			self.log("==== Debug mode!")
		if options.task!=None:
			# oh noes, we need to run a builtin task, so we should not run
			# regular tasks
			taskmanager = Taskmanager(debug=self.debugmode, api=self.api, verbose=self.verbose)
			if options.task == 'help':
				print taskmanager.help_response()
			else:
				self.log("Builtin task run...")
				if self.api.login(userdata.username, userdata.password):
					if not taskmanager.run_task(options.task):
						self.log("Task `%s' did not run properly or does not exist." % options.task)
				else:
					self.log("Could not log in.")
				self.writelog()
		else:
			if not options.nochanges:
				self.changes = Changes(debug=self.debugmode, api=self.api, verbose=self.verbose)
				if options.changes != None:
					self.changes.maximum = options.changes
			self.runtasks = options.runtasks
			self.pages = Pages(debug=self.debugmode, api=self.api, verbose=self.verbose)
			self.pages.singlepage = self.page = options.page
			pagestorun = 0
			if options.onepage:
				pagestorun = 1
			if options.pagestorun != None:
				pagestorun = options.pagestorun
			self.pages.pagestorun = self.pagestorun = pagestorun
			self.pages.search = self.search = options.search
			self.pages.titlesearch = self.titlesearch = options.titlesearch
			if options.time!=None:
				try:
					time.strptime(options.time, "%Y-%m-%dT%H:%M:%SZ")
					self.ts = options.time
					self.log("Using input time of `%s'." % self.ts)
				except ValueError:
					self.log("Input time given `%s' does not match format; ignoring." % self.ts)
					self.ts = None
			if self.debugmode or self.search!=None or self.pagestorun==1 or self.page!=None or self.ts!=None:
				# if any of these are the case, then writing a new time stamp could
				# mess up future runs
				self.writetime = False
			if options.writetime:
				# unless of course, it is forced by the user
				self.writetime = True
			self.pages.ar.loadref = options.loadref
			self.pages.ar.localref = options.localref
			# insure the api knows, so it won't make edits if debug mode
			if self.api.login(userdata.username, userdata.password):
				self.log("Logged in successfully.")
				if self.check_for_lock():		   
					self.initiate()
					if not options.nochanges:
						self.changes.set_ts(self.ts)
					self.pages.set_ts(self.ts)
					if self.runtasks or (self.pagestorun==0 and self.page == None):
						tasks = Tasks(self.debugmode, self.api, self.verbose, self.pages)
						self.log_obtain(tasks)
					if not options.nochanges:
						self.changes.handle_changes()
						self.log_obtain(self.changes)
					else:
						self.log("Not running recent changes checking...")
					if not options.donotfixpages:
						self.pages.routine_run()
					else:
						self.log("Not running page fixing...")
					self.log_obtain(self.pages)
					if not options.donotrunpool:
						self.images = Images(debug=self.debugmode, api=self.api, verbose=self.verbose, poolapi=self.poolapi)
						self.images.routine_job(self.ts)
						self.log_obtain(self.images)
					else:
						self.log("Not running through the pool...")
					self.finish()
			else:
				self.log("Could not log in.")
			self.writelog()