def get_not_recommended_count_by_shop(shop):
     try:
         return UserShopRelationMethods.get_by_shop(shop).filter(
             is_recommended=UserShopRelationMethods.NOT_RECOMMENDED).count()
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return 0
Exemple #2
0
    def __init__(self,
                 db_path,
                 profile_path,
                 plugin_path,
                 _notification_disable_all_,
                 _logs_,
                 scriptname="O2TVGO/IPTVSimple",
                 logId="O2TVGO/IPTVSimple"):
        self.db_path = db_path
        self.connection = False
        self.cursor = False
        self.connectDB()
        self.profile_path = profile_path
        self.plugin_path = plugin_path
        self._notification_disable_all_ = _notification_disable_all_
        if _logs_:
            self._logs_ = _logs_
        else:
            from logs import Logs
            self._logs_ = Logs(scriptname, logId)
        self.logIdSuffix = "/db.py/O2tvgoDB"
        self.scriptname = scriptname
        self.logId = logId
        self.exceptionRes = -1000
        self.lockDefaultValue = -2000

        self.tablesOK = False

        self.check_tables()
        self.cleanEpgDuplicates(doDelete=True)
        self.cleanChannelDuplicates(doDelete=True)
Exemple #3
0
    def __init__(self, environment, general_nn=None, inherit_nn=None):
        self.params = Params()
        if self.params.seed:
            seed(self.params.seed)
        self.creatures = []
        self.entity_grid = np.zeros(
            (self.params.grid_size, self.params.grid_size,
             4))  # 4 is for has_entity, id, strength, energy
        self.environment = environment
        if self.params.general_nn:  # T
            self.random_policy = True
        else:
            self.random_policy = False

        self.general_nn = general_nn
        self.inherit_nn = inherit_nn

        self.exploration_rate = self.params.exploration_rate

        for _ in range(self.params.starting_creatures):
            self.spawn_creature()

        if self.params.verbose:
            self.logs = Logs(self.environment)
            self.logs.log_run()
            self.logs.log_header()
            self.batch_counter = self.general_nn.align_counter  # starts 1
            self.logs_random = not self.params.logs_random and self.random_policy
 def get_file_name(url):
     try:
         names = url.split("/")
         return names[-1]
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return None
Exemple #5
0
class Sql(object):
  __instance__ = None
  
  def __new__(cls):
    if cls.__instance__ is None:
      cls.__instance__ = object.__new__(cls)
      cls.__construct__(cls.__instance__)
    return cls.__instance__
    
  def __construct__(self):
    object.__init__(self)

    self.__config = Config()
    self.__logs = Logs()
      
    # init connection param
    self._config_load()
      
    # connect
    try:
      self.__logs.debug('Try to connect to Mysql')
      self._connect = MySQLdb.connect(host=self.__host,
                                       user=self.__user,
                                       passwd=self.__pass,
                                       port=self.__port,
                                       db=self.__db)
    except Exception, e:
      self.__logs.fatal('Mysql connection failure: %s' % (e))
    
    self.__logs.debug('Connection okay.')
 def get_info(red_envelope):
     try:
         result = Objects.get_object_info(red_envelope)
         return result
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return dict()
 def get_publishes_by_device(device_id):
     try:
         publishes = Publish.objects.filter(device_id=device_id)
         return publishes
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return None
 def get_attribute_by_user_and_publish(user_id, publish_id):
     try:
         upr = UserPublishRelations.objects.get(user_id=user_id, publish_id=publish_id)
         return upr.attribute
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return -1
Exemple #9
0
    def process_queue(self, worker_id):
        """Continuously processes tasks on the queue."""

        # Create a new logs instance (with its own httplib2 instance) so that
        # there is a separate one for each thread.
        logs = Logs("twitter-listener-worker-%s" % worker_id,
                    to_cloud=self.logs_to_cloud)

        logs.debug("Started worker thread: %s" % worker_id)
        while not self.stop_event.is_set():
            try:
                data = self.queue.get(block=True, timeout=QUEUE_TIMEOUT_S)
                start_time = time()
                self.handle_data(logs, data)
                self.queue.task_done()
                end_time = time()
                qsize = self.queue.qsize()
                logs.debug("Worker %s took %.f ms with %d tasks remaining." %
                           (worker_id, end_time - start_time, qsize))
            except Empty:
                # Timed out on an empty queue.
                continue
            except Exception:
                # The main loop doesn't catch and report exceptions from
                # background threads, so do that here.
                logs.catch()
        logs.debug("Stopped worker thread: %s" % worker_id)
 def to_utc(dt):
     try:
         dt = Datetimes.transfer_datetime(dt, is_utc=False)
         return dt.replace(tzinfo=utc)
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return None
Exemple #11
0
    def __init__(self, logs_to_cloud):
        self.logs = Logs(name="trading", to_cloud=logs_to_cloud)

        # Get initial API keys from Questrade
        url = QUESTRADE_AUTH_API_URL % __builtin__.QUESTRADE_REFRESH_TOKEN
        method = "GET"
        body = ""
        headers = None
        client = Client(None, None)

        self.logs.debug("Questrade request: %s %s %s %s" %
                        (url, method, body, headers))
        response, content = client.request(url,
                                           method=method,
                                           body=body,
                                           headers=headers)
        self.logs.debug("Questrade response: %s %s" % (response, content))

        try:
            response = loads(content)
            self.access_token = response['access_token']
            self.api_server = response['api_server']
            self.expires_in = datetime.now() + datetime.timedelta(
                0, response['expires_in'])
            __builtin__.QUESTRADE_REFRESH_TOKEN = response['refresh_token']
            self.token_type = response['token_type']

        except ValueError:
            self.logs.error("Failed to retrieve initial API tokens: %s" %
                            content)
Exemple #12
0
    def __init__(self, expirationMinutes):
        self.expirationMinutes = expirationMinutes
        self.cache = {}
        self.validUntil = datetime.now() + timedelta(
            minutes=self.expirationMinutes)

        self.logs = Logs(self.__class__.__name__)
Exemple #13
0
    def get_user_image(user):
        result = dict()
        if user:
            if user.userextension.big_image:
                user_image = files.BASE_URL_4_IMAGE + user.userextension.big_image.name
                # Logs.print_log("user_image", user_image)
            else:
                if user.userextension.gender == "M":
                    user_image = USER_DEFAULT_MALE_ICON
                else:
                    user_image = USER_DEFAULT_FEMALE_ICON
        else:
            user_image = USER_DEFAULT_ICON
        memory_file = files.Files.get_memory_file(user_image)
        user_image_path = "/".join(user_image.split("/")[:-1])
        user_image_name = user_image.split("/")[-1]
        big_user_image_name = ".".join(user_image_name.split(".")[:-1]) + "_big." + user_image_name.split(".")[-1]
        small_user_image_name = ".".join(user_image_name.split(".")[:-1]) + "_small." + user_image_name.split(".")[-1]
        big_user_image = user_image_path + "/" + big_user_image_name
        small_user_image = user_image_path + "/" + small_user_image_name
        try:
            Images.resize_image(memory_file, big_user_image, 240)
            Images.resize_image(memory_file, small_user_image, 96)
            result["big_user_image"] = big_user_image
            result["small_user_image"] = small_user_image
        except Exception as ex:
            Logs.print_current_function_name_and_line_number(ex)
            if user.userextension.gender == "M":
                result["big_user_image"] = USER_DEFAULT_MALE_ICON
                result["small_user_image"] = USER_DEFAULT_MALE_ICON
            else:
                result["big_user_image"] = USER_DEFAULT_FEMALE_ICON
                result["small_user_image"] = USER_DEFAULT_FEMALE_ICON

        return result
Exemple #14
0
 def set_node_text(node, text):
     try:
         node.text = text
         return node
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return None
Exemple #15
0
 def get_file_content(path):
     try:
         f = open(path, "r")
         return f.read()
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return None
Exemple #16
0
    def sendMessage(self, fpath, folder):
        try:
            fname = ntpath.basename(fpath)

            Logs.Print("Sending email for " + folder + " and file:    " +
                       str(fname))

            msg = MIMEMultipart()
            msg['Subject'] = "ALARM DETECTED ON " + folder
            msg['From'] = "ALERT! " + "<" + self.mail_from + ">"
            msg['To'] = self.mail_to

            part = MIMEBase('application', "octet-stream")
            part.set_payload(open(fpath, "rb").read())
            encoders.encode_base64(part)
            part.add_header('Content-Disposition',
                            'attachment; filename="' + fname + '"')
            msg.attach(part)

            server = SMTP(self.smtp_server, timeout=10)
            server.set_debuglevel(0)

            #server.login(self.username, self.password)
            server.sendmail(msg['From'], msg['To'], msg.as_string())
            Logs.Print('Message sent')

        except Exception as e:
            Logs.Print("Exception: " + str(e))

        finally:
            if server:
                server.quit()
 def get_category_id(name):
     try:
         category = ShopCategory.objects.get(name=name)
         return category.id
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return 0
 def get_articles(user_id, status):
     try:
         ufs = UserForumArticle.objects.filter(user_id=user_id, status=status, count__gt=0)
         return ufs
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return UserForumArticleMethod.get_none()
Exemple #19
0
    def __init__(self):
        super().__init__(command_prefix=["봇 ", "봇"], shard_count=2)
        self.logger = Logs.create_logger(self)
        self.main_logger = Logs.main_logger()

        self.loop = asyncio.get_event_loop()
        self.loop.create_task(change_activity(self))
        self.loop.create_task(self.set_db())

        self.afk = {}
        self.blacklist = []
        additional_commands = [
            self.add_to_black,
            self.rest_black,
            self.show_black,
        ]

        with open("blacklist.pickle", "rb") as f:
            self.blacklist = pickle.load(f)

        with open("argument_help.json", "r", encoding="utf-8") as f:
            self.argument_data = json.load(f)

        for i in TOKEN.initial_extensions:
            self.load_extension(i)

        for cmd in additional_commands:
            self.add_command(cmd)
Exemple #20
0
 def __init__(self,logs_to_cloud):
     self.logs_to_cloud=logs_to_cloud
     self.logs=Logs(name="twitter",to_cloud=self.logs_to_cloud)
     self.twitter_auth=OAuthHandler(TWITTER_CONSUMER_KEY,TWITTER_CONSUMER_SECRET)
     self.twitter_auth.set_access_token(TWITTER_ACCESS_TOKEN, TWITTER_ACCESS_TOKEN_SECRET)
     self.twitter_api=API(auth_handler=self.twitter_auth,retry_count=API_RETRY_COUNT,retry_delay=API_RETRY_DELAY_S,retry_errors=API_RETRY_ERRORS,wait_on_rate_limit="True",wait_on_rate_limit_notify=True)
     self.twitter_listener=None
Exemple #21
0
 def get_memory_file(url):
     try:
         # Logs.print_log("get memory file url", url)
         return cStringIO.StringIO(urllib2.urlopen(url, data=None, timeout=10).read())
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return None
Exemple #22
0
 def set_node_attribute(node, attribute_key, attribute_value):
     try:
         node.set(attribute_key, attribute_value)
         return node
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return None
Exemple #23
0
 def get_user_by_id(user_id):
     try:
         u = User.objects.get(id=user_id)
         return u
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return Users.get_none()
Exemple #24
0
 def __init__(self,
              device_id,
              username,
              password,
              _logs_=None,
              scriptname=None,
              logId="O2TVGO/IPTVSimple"):
     self.username = username
     self.password = password
     self._live_channels = {}
     self.access_token = None
     self.subscription_code = None
     self.locality = None
     self.offer = None
     self.device_id = device_id
     ######## ADDED ########
     self.channel_key = None
     self.epg_id = None
     self.forceFromTimestamp = None
     self.hoursToLoadFrom = None
     self.hoursToLoad = None
     self.logIdSuffix = "/o2tvgo.py/O2TVGO"
     self.scriptname = scriptname
     self.logId = logId
     if _logs_:
         self._logs_ = _logs_
     else:
         from logs import Logs
         self._logs_ = Logs(scriptname, logId)
Exemple #25
0
 def get_user_extension(username):
     try:
         u = UserExtension.objects.get(user__username=username)
         return u
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return Users.get_none()
 def get(name):
     try:
         # Logs.print_log("name", name)
         return Company.objects.get(name=name)
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return None
Exemple #27
0
class Twitter:
    """A helper for talking to Twitter APIs."""

    def __init__(self, logs_to_cloud):
        self.logs_to_cloud = logs_to_cloud
        self.logs = Logs(name="twitter", to_cloud=self.logs_to_cloud)
        self.twitter_auth = OAuthHandler(TWITTER_CONSUMER_KEY,
                                         TWITTER_CONSUMER_SECRET)
        self.twitter_auth.set_access_token(TWITTER_ACCESS_TOKEN,
                                           TWITTER_ACCESS_TOKEN_SECRET)
        self.twitter_api = API(auth_handler=self.twitter_auth,
                               retry_count=API_RETRY_COUNT,
                               retry_delay=API_RETRY_DELAY_S,
                               retry_errors=API_RETRY_ERRORS,
                               wait_on_rate_limit=True,
                               wait_on_rate_limit_notify=True)
        self.twitter_listener = None

    def start_streaming(self, callback):
        """Starts streaming tweets and returning data to the callback."""

        self.twitter_listener = TwitterListener(
            callback=callback, logs_to_cloud=self.logs_to_cloud)
        twitter_stream = Stream(self.twitter_auth, self.twitter_listener)

        self.logs.debug("Starting stream.")
        twitter_stream.filter(follow=[TRUMP_USER_ID]), ELONMUSK_USER_ID, WARRENBUFFETT_USER_ID, YOURANONNEWS_USER_ID, WIKILEAKS_USER_ID, SEC_NEWS_USER_ID, SEC_ENFORCEMENT_USER_ID, RICHARDBRANSON_USER_ID])

        # If we got here because of an API error, raise it.
        if self.twitter_listener and self.twitter_listener.get_error_status():
            raise Exception("Twitter API error: %s" %
                            self.twitter_listener.get_error_status())
 def __init__(self, enabled: bool, expirationSeconds: int,
              blockAfterFailures: int):
     self.database = {}
     self.enabled = enabled
     self.expirationSeconds = expirationSeconds
     self.blockAfterFailures = blockAfterFailures
     self.logs = Logs(self.__class__.__name__)
     self.security = Security()
Exemple #29
0
 def create_directory_path(path):
     if not Files.exists(path):
         try:
             Files.makedirs(path)
         except Exception as ex:
             Logs.print_current_function_name_and_line_number(ex)
             return None
     return path
 def update(user_forum_article, increment=1):
     try:
         user_forum_article.count += increment
         user_forum_article.save()
         return user_forum_article
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return UserForumArticleMethod.get_none()
Exemple #31
0
 def set_shop_has_detector(shop, has_detector):
     try:
         shop.has_detector = has_detector
         shop.save()
         return shop
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return Shops.get_none()
 def get_count_by_user(user_id, status):
     try:
         ufs = UserForumArticle.objects.filter(user_id=user_id, status=status)
         counts = [o.count for o in ufs]
         return reduce(operator.add, counts, 0)
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return 0
Exemple #33
0
 def __init__(self, logs_to_cloud):
     self.logs_to_cloud = logs_to_cloud
     self.logs = Logs(name="twitter", to_cloud=self.logs_to_cloud)
     self.twitter_auth = OAuthHandler(TWITTER_CONSUMER_KEY,
                                      TWITTER_CONSUMER_SECRET)
     self.twitter_auth.set_access_token(TWITTER_ACCESS_TOKEN,
                                        TWITTER_ACCESS_TOKEN_SECRET)
     self.twitter_api = API(self.twitter_auth)
 def add(user_id, article_id, status):
     try:
         ufa = UserForumArticle(user_id=user_id, article_id=article_id, status=status)
         ufa.save()
         return ufa
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return UserForumArticleMethod.get_none()
 def activate_detector_relation(detector_relation):
     try:
         detector_relation.state = True
         detector_relation.save()
         return detector_relation
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return None
 def update_unread(comment):
     try:
         comment.is_read = True
         comment.save()
         return True
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return False
Exemple #37
0
def main():
    Logs.setup_logger()
    setup_minimal_vpn_platform(message_client_name='vpn_service')

    logger.info('Starting VPN service')
    heartbeat_service = HeartbeatService()
    heartbeat_service.start()
    heartbeat_service.run_heartbeat()
 def static_update(address, address_dict):
     try:
         for (key, value) in address_dict.items():
             Objects.set_value(address, key, value)
         address.save()
         return address
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return Address.get_none()
 def save_image(memory_file, path):
     data = {}
     try:
         img = Image.open(memory_file)
         img.save(path)
         return True
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return False
 def update(publish, publish_dict):
     try:
         for (key, value) in publish_dict.items():
             Objects.set_value(publish, key, value)
         publish.save()
         return publish
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return None
Exemple #41
0
	def _web_info(self):
		if self.status_code == 200 or self.req_info != False:
			self.soup = BeautifulSoup(self.req_info.text,'lxml')
			return True
		else:
			#如果状态码不等于200,写入错误日志
			logs = Logs(self.url,self.status_code,self.date_time)
			logs.logs_write()
			return False
Exemple #42
0
 def update_shop(shop, shop_dict):
     try:
         for (key, value) in shop_dict.items():
             Objects.set_value(shop, key, value)
         shop.save()
         return shop
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return Shops.get_none()
Exemple #43
0
 def __init__(self,  _logs_ = None,  scriptname="O2TVGO/IPTVSimple", logId="O2TVGO/IPTVSimple"):
     if _logs_:
         self._logs_ = _logs_
     else:
         from logs import Logs
         self._logs_ = Logs(scriptname, logId)
     self.logIdSuffix = "/jsonrpc.py/JsonRPC"
     self.scriptname = scriptname
     self.logId = logId
Exemple #44
0
    def __init__(self, expirationMinutes: int):
        self.expirationMinutes = expirationMinutes
        self.cache = {}
        self.validUntil = datetime.now() + timedelta(
            minutes=self.expirationMinutes)
        self.groupCaseSensitive = True
        self.groupConditional = 'and'

        self.logs = Logs(self.__class__.__name__)
Exemple #45
0
 def get(username, start_datetime, end_datetime):
     try:
         start_datetime = Datetimes.string_to_utc(start_datetime)
         end_datetime = Datetimes.string_to_utc(end_datetime)
         return Game.objects.filter(username=username, created_at__gte=start_datetime,
                                    created_at__lte=end_datetime).order_by("id")
     except Exception as ex:
         Logs.print_current_function_name_and_line_number(ex)
         return None
Exemple #46
0
 def _web_info(self):
     if self.status_code == 200 or self.req_info != False:
         self.soup = BeautifulSoup(self.req_info.text, 'lxml')
         return True
     else:
         #如果状态码不等于200,写入错误日志
         logs = Logs(self.url, self.status_code, self.date_time)
         logs.logs_write()
         return False
Exemple #47
0
 def _get_404(self):
     #通过bs中的select来获取
     info = self._get_select('header')
     try:
         for index in info:
             if index.text[:3] == '404':
                 log = Logs(self.root_url, '404', str(self.date_time)[:-7])
                 log.logs_write()
                 return False
             else:
                 return True
     except:
         return True
Exemple #48
0
    def app(self):

        Logs.Print("Starting Hermes App..")

        Logs.Print("Paths to monitor:")
        for monitor_path in self.conf_data['monitor_paths']:
            Logs.Print("{0}: {1}".format(monitor_path['name'],
                                         monitor_path['path']))

        Logs.Print("Archive path: {0}".format(self.conf_data['archive_path']))

        while 1:
            try:
                for monitor_path in self.conf_data['monitor_paths']:

                    # Check if there are any files in these paths
                    files = self.file_system.list_files(monitor_path['path'])

                    # check if the files are ok to be processed
                    for file in files:
                        if os.path.getsize(
                                file) < self.conf_data['file_size_min']:
                            current_time = time.time()
                            creation_time = os.path.getctime(file)
                            if (
                                    current_time - creation_time
                            ) < 60:  # older than 1 minutes are ok to be processed
                                Logs.Print(
                                    "File: {0} is too small to be processed.".
                                    format(file))
                                files.remove(file)

                    # wait 2 seconds
                    time.sleep(2)

                    if files:
                        time_now = datetime.datetime.utcnow()
                        print("\n\n")
                        Logs.Print(
                            "======================================================"
                        )
                        Logs.Print(
                            str(time_now) + ":    Found alarm on " +
                            monitor_path['name'])

                        # Create google_drive object
                        google_drive = MyGoogleDrive(
                            self.conf_data['gdrive_cred_path'])

                        # Upload images into google drive
                        for file in files:
                            google_drive.push(file,
                                              monitor_path['gdrive_folder_id'])

                        self.mail.sendMessage(file, monitor_path['name'])
                        self.file_system.archive_files(files,
                                                       monitor_path['name'])

            except Exception as e:
                Logs.Print("Exception: " + str(e))
Exemple #49
0
    def __init__(self):
        self.logs = Logs(name="twitter")
        self.twitter_auth = OAuthHandler(settings.CONSUMER_KEY,
                                         settings.CONSUMER_SECRET)

        self.twitter_auth.set_access_token(settings.ACCESS_TOKEN,
                                           settings.ACCESS_SECRET)

        self.twitter_api = API(auth_handler=self.twitter_auth,
                               retry_count=API_RETRY_COUNT,
                               retry_delay=API_RETRY_DELAY_S,
                               retry_errors=API_RETRY_ERRORS,
                               wait_on_rate_limit=True,
                               wait_on_rate_limit_notify=True)
        self.twitter_listener = None
Exemple #50
0
    def run(self):
        """ Fungsi awal saat program dijalankan """

        if (self._isDebug):
            print(s("Mode Debug Active"))

        if self._link is None:
            self.tanyaLink()

        cls()
        B = Banner()
        B.cetakbanner()
        cetakgaris("Pilih Resolusi Video")

        self._YT = YouTube(self._link)
        self._YT.check_availability

        self.infoVideo()
        print("")
        time.sleep(3)
        pilihan = self.resolusi()

        cek = Logs()
        if (not cek.cek()):
            print(s("%s" % prRed("Lokasi penyimpanan belum diset ")))
            cek.gantiPath()

        self._savePath = cek._path

        cls()
        B.cetakbanner()
        cetakgaris("Please Wait.. Downloading")

        try:
            if pilihan == 'video':
                super(DownloadYT,
                      self).Downloaderffmpeg(self._Audio, self._Video,
                                             self._savePath)
            elif (pilihan == 'audio'):
                super(DownloadYT, self).DownloadMP3(self._Audio,
                                                    self._savePath)
            else:
                raise ValueError("Error")
        except:
            print(s("Terjadi kesalahan!"))
            return

        sys.exit(prCyan("Terima kasih! ;) "))
Exemple #51
0
def main():
    logs = Logs()
    requestService = RequestService(api_name="Api_name", logs=logs)

    if not len(sys.argv[1:]):
        usage()
    args = parse_args()

    if args.log_file_name:
        logs.write_file(filename=args.log_file_name)
    if args.target_url:
        requestService.add_endpoints(args.target_url)
        print(requestService.start())
    elif args.file_to_read:
        requestService.read_endpoints_from_file(args.file_to_read)
        print(requestService.start())
Exemple #52
0
    def archive_files(self, files, folder):
        try:
            Logs.Print("Archiving files to " + folder)

            for file in files:
                oldfile = file
                file_date = str(self.get_creation_date(file))
                newfile = self.archive + "/" + str(file_date).replace(
                    ' ', '_').replace('-', '_').replace(
                        ':', '_') + "_" + folder + ".jpg"

                Logs.Print("Archiving file: " + oldfile + " to " + newfile)
                os.rename(oldfile, newfile)

        except Exception as e:
            Logs.Print("Exception: " + str(e))
Exemple #53
0
	def __init__(self, ldapEndpoint, dnUsername, dnPassword, bindDN, searchBase, searchFilter, groupCaseSensitive, groupConditional):
		self.ldapEndpoint = ldapEndpoint
		self.searchBase = searchBase
		self.dnUsername = dnUsername
		self.dnPassword = dnPassword
		self.bindDN = bindDN
		self.searchFilter = searchFilter
		self.groupConditional = groupConditional.lower()
		self.groupCaseSensitive = groupCaseSensitive

		ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_NEVER)
		self.connect = ldap.initialize(self.ldapEndpoint)
		self.connect.set_option(ldap.OPT_REFERRALS, 0)
		self.connect.set_option(ldap.OPT_DEBUG_LEVEL, 255)

		self.logs = Logs(self.__class__.__name__)
Exemple #54
0
 def cleanup(self, days, gdrive_folder_ids):
     try:
         date_N_days_ago = datetime.now() - timedelta(days=days)
         files = self.drive.ListFile({
             "q":
             "trashed = false and modifiedDate < '" +
             str(date_N_days_ago).split(' ')[0] + "'",
             "maxResults":
             1000
         }).GetList()
         for file in files:
             if file['id'] not in gdrive_folder_ids:
                 Logs.Print(file['title'] + " will be deleted")
                 file.Delete()
     except Exception as e:
         Logs.Print("Exception: " + str(e))
Exemple #55
0
    def __lock_pid(self):
        self.pid = str(os.getpid())
        if os.path.isfile(self.pidfile):
            Logs.Print("%s already exists, exiting" % self.pidfile)
            sys.exit()

        with open(self.pidfile, 'w') as fwrie:
            fwrie.write(self.pid)
Exemple #56
0
    def __start_work(self, quest_name, timestamp):
        assert_person(quest_name in self.quests,
                      f'quest named {quest_name} not found')
        assert_person(self.quests[quest_name]['start_timestamp'] is None,
                      f'quest named {quest_name} is already started')

        quest = self.quests[quest_name]

        # проверить, что указанное время старта равно или позже последнего лога по этому квесту
        logs_obj = Logs(self.logs_path)
        logs = logs_obj.get_logs(select=['timestamp'],
                                 where=f'quest_id="{quest["id"]}" AND action="log_work"')
        if logs:
            last_log_timestamp = logs[-1][0]
            last_log_timestamp = parse_timestamp(last_log_timestamp)
            assert_person(last_log_timestamp <= timestamp,
                          f'the given start datetime ({timestamp})'
                          f' is before a last log of the quest ({last_log_timestamp})')

        quest['start_timestamp'] = timestamp

        logs_obj.log(
            timestamp=str(timestamp),
            quest_id=quest['id'],
            action='start_work',
            points={},
            bookmark='')
        logs_obj.close()
Exemple #57
0
    def twitter_callback(self, tweet):
        """Analyzes Trump tweets, trades stocks, and tweets about it."""

        # Initialize the Analysis, Logs, Trading, and Twitter instances inside
        # the callback to create separate httplib2 instances per thread.
        # analysis = Analysis()
        # logs = Logs(name="main-callback")
        logs = Logs(name="callback")
        self.logs.info("twitter_callback starts")
Exemple #58
0
 def push(self, file_path, folder_id):
     try:
         filename = os.path.basename(file_path)
         Logs.Print('Uploading file: ' + str(filename) +
                    " on gdrive folder: " + str(folder_id))
         textfile = self.drive.CreateFile({
             'title':
             filename,
             'mimeType':
             'image/jpg',
             "parents": [{
                 "kind": "drive#fileLink",
                 "id": folder_id
             }]
         })
         textfile.SetContentFile(file_path)
         textfile.Upload()
     except Exception as e:
         Logs.Print("Exception: " + str(e))
Exemple #59
0
 def __init__(self, my_binding, sendto_sock):
     # 事件定义
     self.path = None
     self.file_out = None  # 每一个实例只能存一个文件,接收完就关闭。再发送需要再新建一个实例
     self.my_binding = my_binding
     self.target = sendto_sock
     self.__running = Event()
     # 主线程
     self.__thread_main = Thread(target=self.__main_thread)
     self.__event_mainthread = Event()
     # 上一条接收的seq
     self.lastseq = -1
     # 接收窗口
     self.seq_expected = 0
     # send_seq&info
     self.seq_and_info = []
     # 接收到的信息
     self.recv_info = []
     self.info_len_expected = 1000
     self.logs = Logs()
Exemple #60
0
    def __init__(self, logs_to_cloud):
        self.logs_to_cloud = logs_to_cloud
        self.logs = Logs(name="twitter", to_cloud=self.logs_to_cloud)
        self.twitter = {}
        for account in accounts:
            auth = OAuthHandler(TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET)
            auth.set_access_token(
                account.twitter_access_token, account.twitter_access_token_secret
            )
            api = API(
                auth_handler=auth,
                retry_count=API_RETRY_COUNT,
                retry_delay=API_RETRY_DELAY_S,
                retry_errors=API_RETRY_ERRORS,
                wait_on_rate_limit=True,
                wait_on_rate_limit_notify=True,
            )
            self.twitter[account.bot_account_id] = (auth, api)

        self.twitter_listener = None