app.Filters.Filters Class Reference

Inheritance diagram for app.Filters.Filters:

Collaboration diagram for app.Filters.Filters:

Public Member Functions
def	__init__ (self, filters, dbTaskWrapper=None, siteId=None, readMode=0, fields=None, opCode=None, stage=None, selectSubject=None)
def	readFiltersFromDict (self, filters, opCode=None, stage=None, selectSubject=None)
def	readFiltersFromDB (self, dbTaskWrapper, siteId, readMode, opCode=None, stage=None, selectSubject=None)
def	macroReplace (self, pattern, values, marker, case=MACRO_CASE_ORIGINAL)
def	comparing (self, value1, value2, OCType)
def	searchFiltersWithStage (self, stage)
def	isExistStage (self, stage)
def	isExist (self, stage, opCode)
def	filterAll (self, stage, value, logic=LOGIC_AND, subject=None, excludeIncludeMode=None)
def	isExistInActions (self, value)
def	getGmtTime (self, localPattern, loggerIns)
def	checkSqlExpression (self, pattern, pubdate=None, fields=None)

Public Attributes
	patternCache
	reFlags
	dbTaskWrapper
	siteId
	readMode
	fields
	stage
	filters

Static Public Attributes
string	DB_NAME = "dc_sites"
string	REPLACE_MARKER = '%'
int	ACTION_MULTIPLE = -1
string	FILTER_SPLIT_PATTERN = '\r\n'
string	FILTER_NAME_PATTERN = "Pattern"
string	FILTER_NAME_SUBJECT = "Subject"
string	FILTER_NAME_OP_CODE = "OperationCode"
string	FILTER_NAME_STAGE = "Stage"
string	FILTER_NAME_ACTION = "Action"
string	FILTER_NAME_GROUP = "Group_Id"
string	FILTER_NAME_STATE = "State"
int	STAGE_COLLECT_URLS = 0
int	STAGE_BEFORE_DOM_PRE = 1
int	STAGE_AFTER_DOM_PRE = 2
int	STAGE_AFTER_DOM = 3
int	STAGE_AFTER_PROCESSOR = 4
int	STAGE_ALL = 5
int	STAGE_COLLECT_URLS_PROTOCOLS = 6
int	STAGE_BEFORE_PROCESSOR = 7
int	STAGE_REDIRECT_URL = 8
string	SELECT_SUBJECT_RAW_CONTENT = 'RAW_CONTENT'
string	SELECT_SUBJECT_HEADERS_ALL = 'HEADERS_ALL'
string	SELECT_SUBJECT_LAST_MODIFIED = 'LAST_MODIFIED'
int	LOGIC_OR = 0
int	LOGIC_AND = 1
int	OC_RE = 0
int	OC_EQ = 1
int	OC_NOTEQ = 2
int	OC_EQLESS = 3
int	OC_EQMORE = 4
int	OC_LESS = 5
int	OC_MORE = 6
int	OC_SQLE = 7
int	STATE_DISABLE = 0
int	STATE_ENABLE = 1
int	MACRO_CASE_ORIGINAL = 0
int	MACRO_CASE_UPPER = 1
int	MACRO_CASE_LOWER = 2

Detailed Description

Definition at line 25 of file Filters.py.

Constructor & Destructor Documentation

__init__()

def app.Filters.Filters.__init__	(		self,
			filters,
			dbTaskWrapper = None,
			siteId = None,
			readMode = 0,
			fields = None,
			opCode = None,
			stage = None,
			selectSubject = None
	)

Definition at line 87 of file Filters.py.

               selectSubject=None):
    self.patternCache = {}
    self.reFlags = re.M | re.U
    self.dbTaskWrapper = dbTaskWrapper
    self.siteId = siteId
    self.readMode = readMode
    self.fields = fields
    self.stage = stage

    self.filters = []

    if filters is not None:
      # if filters is not None istantiate self.filters directly
      self.readFiltersFromDict(filters, opCode, stage, selectSubject)
    # #else:
    # else fill self.filters from database, using dbTask and siteId params (make SiteStatusTask request)
    # Look CrawlerTask.readSiteFromDB method, return Site.filters field and parse it
    # #self.filters = []
    if dbTaskWrapper is not None and siteId is not None:
      self.readFiltersFromDB(dbTaskWrapper, siteId, readMode, opCode, stage, selectSubject)

Member Function Documentation

checkSqlExpression()

def app.Filters.Filters.checkSqlExpression	(		self,
			pattern,
			pubdate = None,
			fields = None
	)

Definition at line 437 of file Filters.py.

  def checkSqlExpression(self, pattern, pubdate=None, fields=None):
    # variable for result
    ret = False

    if self.dbTaskWrapper is None:
      ret = True
    else:
      if fields is None:
        logger.debug('pattern: ' + str(pattern))
        logger.debug('pubdate: ' + str(pubdate))

        if pubdate is not None:
          dt = DateTimeType.parse(pubdate, True, logger, False)
          if dt is not None:
            dateStr = "'" + dt.strftime("%Y-%m-%d %H:%M:%S") + "'"
            localPattern = self.macroReplace(pattern, {'PDATE':dateStr}, self.REPLACE_MARKER)
            logger.debug('localPattern: ' + str(localPattern))

            sqlQuery = "SELECT * FROM `sites_filters` WHERE `Mode`='%s' AND `State`='1' AND `Site_Id`='%s'" % \
            (str(self.readMode), str(self.siteId))

            if localPattern:
              sqlQuery += " AND " + localPattern

            logger.debug("sqlQuery: " + str(sqlQuery))

            customResponse = self.dbTaskWrapper.customRequest(sqlQuery, self.DB_NAME)
            logger.debug("customResponse: " + str(customResponse))
            if customResponse is not None:
              for elem in customResponse:
                if elem is not None:
                  logger.debug("elem: " + str(elem))

              ret = bool(len(customResponse) > 0)
      else:
        pattern = self.macroReplace(pattern, fields, self.REPLACE_MARKER, case=1)
        sqlQuery = 'SELECT ' + pattern
        logger.debug("sqlQuery: " + str(sqlQuery))
        affectDB = self.dbTaskWrapper.affect_db
        self.dbTaskWrapper.affect_db = True
        customResponse = self.dbTaskWrapper.customRequest(sqlQuery, self.DB_NAME)
        self.dbTaskWrapper.affect_db = affectDB
        logger.debug("customResponse: " + str(customResponse))
        if customResponse is not None and len(customResponse) > 0 and len(customResponse[0]) > 0 and \
          int(customResponse[0][0]) > 0:
          ret = True

    return ret

comparing()

def app.Filters.Filters.comparing	(		self,
			value1,
			value2,
			OCType
	)

Definition at line 230 of file Filters.py.

  def comparing(self, value1, value2, OCType):
    ret = False
    # logger.debug("Value1:\n%s\nValue2:\n%s\nOCType:\n%s", str(value1), str(value2), str(OCType))
#     logger.debug("Value1:\n%s\nValue2:\n%s\nOCType:\n%s", str(value1[:255] + ' . . . '), str(value2), str(OCType))
    try:
      if OCType == self.OC_RE:
        # if str(value2 + str(self.reFlags)) in self.patternCache:
        #  pattern = self.patternCache[str(value2 + str(self.reFlags))]
        #  logger.debug("Use pattern '" + str(value2 + str(self.reFlags)) + "' from cache")
        # else:
        # #pattern = re.compile(value2, self.reFlags)
        # logger.debug("Use pattern '" + str(value2 + str(self.reFlags)) + "' without cache")
        # logger.debug('patternCache: ' + str(self.patternCache.keys()))
        # #if pattern.match(value1, self.reFlags) is not None:
        # #  ret = True

        if re.search(value2, value1, self.reFlags) is not None:
          ret = True

      elif OCType == self.OC_EQ:
        ret = (int(value1) == int(value2))
      elif OCType == self.OC_NOTEQ:
        ret = (int(value1) != int(value2))
      elif OCType == self.OC_EQLESS:
        ret = (int(value1) <= int(value2))
      elif OCType == self.OC_EQMORE:
        ret = (int(value1) >= int(value2))
      elif OCType == self.OC_LESS:
        ret = (int(value1) < int(value2))
      elif OCType == self.OC_MORE:
        ret = (int(value1) > int(value2))
      elif OCType == self.OC_SQLE:
        ret = self.checkSqlExpression(value2, None, self.fields)  # value2 content value of 'Pattern'
    except ValueError as exp:
      logger.debug(">>> Value error = " + str(exp))
    except Exception, err:
      logger.debug(">>> Common exception, OCType = " + str(OCType) + ", val1 = " + str(value1) + ", val2 = " \
                    + str(value2) + ", error: " + str(err))
#     logger.debug('comparing ret = ' + str(ret))
    return ret

Here is the call graph for this function:

Here is the caller graph for this function:

filterAll()

def app.Filters.Filters.filterAll	(		self,
			stage,
			value,
			logic = LOGIC_AND,
			subject = None,
			excludeIncludeMode = None
	)

Definition at line 323 of file Filters.py.

  def filterAll(self, stage, value, logic=LOGIC_AND, subject=None, excludeIncludeMode=None):
#     logger.debug('filterAll() enter...  filters count = ' + str(len(self.filters)) + '\nstage = ' + str(stage) + \
#                  # '\nvalue: ' + str(value) + \
#                  '\nlogic: ' + str(logic) + \
#                  '\nsubject: ' + str(subject[:255]) + \
#                  '\nexcludeIncludeMode: ' + str(excludeIncludeMode))
    if stage is None:
      stage = self.stage

    ret = []
#     localGroupDict = {}
    resValues = []
    for localFilter in self.filters:
      if int(localFilter[self.FILTER_NAME_STATE]) == self.STATE_ENABLE and \
      (stage == self.STAGE_ALL or localFilter[self.FILTER_NAME_STAGE] == self.STAGE_ALL or \
      localFilter[self.FILTER_NAME_STAGE] == stage) and ((excludeIncludeMode is None) or\
                                                         (int(excludeIncludeMode) == int(localFilter["Action"]))):
#         logger.debug('Use filter: %s', varDump(localFilter))

        if subject is not None and (localFilter[self.FILTER_NAME_SUBJECT] == "" or \
                                    localFilter[self.FILTER_NAME_SUBJECT] == self.SELECT_SUBJECT_RAW_CONTENT or \
                                    localFilter[self.FILTER_NAME_SUBJECT] == self.SELECT_SUBJECT_HEADERS_ALL or \
                                    localFilter[self.FILTER_NAME_SUBJECT] == self.SELECT_SUBJECT_LAST_MODIFIED):
          localStage = subject
        else:
          localStage = localFilter[self.FILTER_NAME_SUBJECT]

        #   make macroreplacement localFilter["Subject"] by correspond value from value param dict
        #   apply localFilter["Patter"] for previously getted result (result of macroreplacement)
        if localFilter[self.FILTER_NAME_PATTERN] is not None:
          localPattern = self.macroReplace(localFilter[self.FILTER_NAME_PATTERN], value, self.REPLACE_MARKER)

#           logger.info('>>> filterAll  macroReplace localPattern: ' + str(localPattern))
          localPattern = self.getGmtTime(localPattern, logger)
#           logger.info('>>> filterAll  getGmtTime localPattern: ' + str(localPattern))
#           logger.info('>>> filterAll  logic = ' + str(logic))

          if logic == self.LOGIC_OR:
          # Return ret = [x1, x2, ... xN] where (xN = +/- localFilter["Action"] value) of applying pattern
          # and +/- depend on corresponds filter for own "Pattern" or not.
          # for example:
          # we have 3 applying filters with localFilter["Action"] = {3, 4, 5} correspondingly,
          # 1th filter doesn't correspond own localFilter["Pattern"] , 2th and 3th - correspond
          # that we return ret = [-3, 4, 5]
            # if self.comparing(localStage, localPattern, localFilter[self.FILTER_NAME_OP_CODE]):
            #  localRes = localFilter[self.FILTER_NAME_ACTION]
            # else:
            #  localRes = localFilter[self.FILTER_NAME_ACTION] * self.ACTION_MULTIPLE

            localRes = int(self.comparing(localStage, localPattern, localFilter[self.FILTER_NAME_OP_CODE]))

#             logger.info('>>> localRes: ' + str(localRes))

#             if localFilter[self.FILTER_NAME_GROUP] in localGroupDict:
#               logger.info('>>> localFilter[self.FILTER_NAME_GROUP]: ' + str(localFilter[self.FILTER_NAME_GROUP]))
#               if localGroupDict[localFilter[self.FILTER_NAME_GROUP]] > 0:
#                 localGroupDict[localFilter[self.FILTER_NAME_GROUP]] = localRes
#             else:
#               localGroupDict[localFilter[self.FILTER_NAME_GROUP]] = localRes
#             # set result values
#             ret = localGroupDict.values()

            # add by alexv 22.06.2017
            resValues.append(localRes)
            ret = resValues

          elif logic == self.LOGIC_AND:
          # If all applying filters correspond own "Pattern"s that ret = [True], else ret = [False]
            if self.comparing(localStage, localPattern, localFilter[self.FILTER_NAME_OP_CODE]):
              ret = [True]
            else:
              ret = [False]
              break

    return ret

Here is the call graph for this function:

getGmtTime()

def app.Filters.Filters.getGmtTime	(		self,
			localPattern,
			loggerIns
	)

Definition at line 416 of file Filters.py.

  def getGmtTime(self, localPattern, loggerIns):
    try:
      d = {"SHORTYEAR":"y", "YEAR":"Y", "MONTH":"m", "DAY":"d", "HOUR":"H", "MINUTE":"M", "SECOND":"S"}
      regex = re.compile("%@(SHORTYEAR|YEAR|MONTH|DAY|HOUR|MINUTE|SECOND)\\(([\\+|\\-]\\d{1,2})\\)%")
      matchArray = regex.findall(localPattern)

      for i in matchArray:
        ii = time.strftime("%" + d[i[0]], time.gmtime(time.time() + datetime.timedelta(hours=(+int(i[1]))).seconds))
        localPattern = localPattern.replace("%@" + i[0] + "(" + i[1] + ")%", ii)
    except Exception, err:
      loggerIns.error(str(err))

    return localPattern

Here is the caller graph for this function:

isExist()

def app.Filters.Filters.isExist	(		self,
			stage,
			opCode
	)

Definition at line 302 of file Filters.py.

  def isExist(self, stage, opCode):
    # variable for result
    ret = False
    if self.filters is not None:
      for localFilter in self.filters:
        if int(localFilter[self.FILTER_NAME_STAGE]) == int(stage) and \
          int(localFilter[self.FILTER_NAME_OP_CODE]) == int(opCode):
          ret = True
          break

    return ret

isExistInActions()

def app.Filters.Filters.isExistInActions	(		self,
			value
	)

Definition at line 402 of file Filters.py.

  def isExistInActions(self, value):
    ret = False
    for localFilter in self.filters:
      if localFilter is not None and localFilter[self.FILTER_NAME_ACTION] == value:
        ret = True
        break
    return ret

isExistStage()

def app.Filters.Filters.isExistStage	(		self,
			stage
	)

Definition at line 285 of file Filters.py.

  def isExistStage(self, stage):
    # variable for result
    ret = False
    if self.filters is not None:
      for localFilter in self.filters:
        if localFilter[self.FILTER_NAME_STAGE] == stage:
          ret = True
          break

    return ret

macroReplace()

def app.Filters.Filters.macroReplace	(		self,
			pattern,
			values,
			marker,
			case = MACRO_CASE_ORIGINAL
	)

Definition at line 206 of file Filters.py.

  def macroReplace(self, pattern, values, marker, case=MACRO_CASE_ORIGINAL):
#     logger.info('>>> macroReplace  values: ' + str(values) + ' pattern: ' + str(pattern))

    ret = copy.copy(pattern)
    for key in values:
      if values[key] is not None:
        if case == self.MACRO_CASE_UPPER:
          rkey = key.upper()
        elif case == self.MACRO_CASE_LOWER:
          rkey = key.lower()
        else:
          rkey = key
        ret = ret.replace(marker + rkey + marker, "'" + str(values[key]) + "'" if isinstance(values[key], basestring) \
                          else str(values[key]))

    return ret

Here is the caller graph for this function:

readFiltersFromDB()

def app.Filters.Filters.readFiltersFromDB	(		self,
			dbTaskWrapper,
			siteId,
			readMode,
			opCode = None,
			stage = None,
			selectSubject = None
	)

Definition at line 164 of file Filters.py.

  def readFiltersFromDB(self, dbTaskWrapper, siteId, readMode, opCode=None, stage=None, selectSubject=None):
    # SQL_SELECT_TEMPLATE = "SELECT `Pattern`, `Subject`, `OperationCode`, `Stage`, `Action`, `Group_Id` " + \
    # "FROM `sites_filters` WHERE `Mode`='%s' AND `State`='1' AND `Site_Id`='%s'"
    SQL_SELECT_TEMPLATE = "SELECT * FROM `sites_filters` WHERE `Mode`='%s' AND `State`='1' AND `Site_Id`='%s'"
    query = SQL_SELECT_TEMPLATE % (str(readMode), str(siteId))

    if opCode is not None:
      query += (" AND `OperationCode`='%s'" % str(opCode))

    if stage is not None:
      query += (" AND `Stage`='%s'" % str(stage))

    if selectSubject is not None and int(stage) == self.STAGE_BEFORE_DOM_PRE:
      query += (" AND `Subject`='%s'" % str(selectSubject))

    logger.debug(">>> Filter start SQL Req: " + str(query))
    affectDB = dbTaskWrapper.affect_db
    dbTaskWrapper.affect_db = True
    customResponse = dbTaskWrapper.customRequest(query, self.DB_NAME, dbi.EventObjects.CustomRequest.SQL_BY_NAME)
    dbTaskWrapper.affect_db = affectDB
    logger.debug(">>> Filter end SQL Req: " + str(customResponse))
    if customResponse is not None:
      for i in xrange(len(customResponse)):
#         logger.debug("customResponse[%s] = %s", str(i), str(customResponse[i]))
        if customResponse[i] is not None:
          patterns = customResponse[i][self.FILTER_NAME_PATTERN].split(self.FILTER_SPLIT_PATTERN)
#           logger.debug("patterns: " + str(patterns))
          for pattern in patterns:
            elem = copy.copy(customResponse[i])
            elem[self.FILTER_NAME_PATTERN] = pattern
            self.filters.append(elem)

#       logger.debug("customResponse self.filters: " + str(self.filters))

readFiltersFromDict()

def app.Filters.Filters.readFiltersFromDict	(		self,
			filters,
			opCode = None,
			stage = None,
			selectSubject = None
	)

Definition at line 116 of file Filters.py.

  def readFiltersFromDict(self, filters, opCode=None, stage=None, selectSubject=None):
    self.filters = []
    for localFilter in filters:
      if opCode is not None and int(opCode) != int(localFilter.opCode):
        continue
      if stage is not None and int(stage) != int(localFilter.stage):
        continue

      if localFilter.state == 0:
        logger.debug("Filter: '" + str(localFilter.pattern) + "' skipped as DISABLE")
        continue

#       logger.debug('opCode: ' + str(opCode) + ' type: ' + str(type(opCode)))
#       logger.debug('stage: ' + str(stage) + ' type: ' + str(type(stage)))
#       logger.debug('localFilter.stage: ' + str(localFilter.stage) + ' type: ' + str(type(localFilter.stage)))
#       logger.debug('selectSubject: ' + str(selectSubject) + ' type: ' + str(type(selectSubject)) + \
#                    ' localFilter.subject: ' + str(localFilter.subject) + ' type: ' + str(type(localFilter.subject)))

      if int(localFilter.stage) == self.STAGE_BEFORE_DOM_PRE and \
        selectSubject is not None and len(localFilter.subject) > 0 and \
        selectSubject != localFilter.subject:
        logger.debug('!!!! Skipped !!!!! ')
        continue

      for pattern in localFilter.pattern.split(self.FILTER_SPLIT_PATTERN):
        localDict = {}
        localDict[self.FILTER_NAME_PATTERN] = pattern
        if localFilter.pattern.find(self.REPLACE_MARKER) == -1:

searchFiltersWithStage()

def app.Filters.Filters.searchFiltersWithStage	(		self,
			stage
	)

Definition at line 272 of file Filters.py.

  def searchFiltersWithStage(self, stage):
    ret = 0
    if self.filters is not None:
      for localFilter in self.filters:
        if localFilter[self.FILTER_NAME_STAGE] == stage:
          ret += 1
    return ret

Member Data Documentation

ACTION_MULTIPLE

int app.Filters.Filters.ACTION_MULTIPLE = -1

static

Definition at line 29 of file Filters.py.

DB_NAME

string app.Filters.Filters.DB_NAME = "dc_sites"

static

Definition at line 27 of file Filters.py.

dbTaskWrapper

app.Filters.Filters.dbTaskWrapper

Definition at line 90 of file Filters.py.

fields

app.Filters.Filters.fields

Definition at line 93 of file Filters.py.

FILTER_NAME_ACTION

string app.Filters.Filters.FILTER_NAME_ACTION = "Action"

static

Definition at line 36 of file Filters.py.

FILTER_NAME_GROUP

string app.Filters.Filters.FILTER_NAME_GROUP = "Group_Id"

static

Definition at line 37 of file Filters.py.

FILTER_NAME_OP_CODE

string app.Filters.Filters.FILTER_NAME_OP_CODE = "OperationCode"

static

Definition at line 34 of file Filters.py.

FILTER_NAME_PATTERN

string app.Filters.Filters.FILTER_NAME_PATTERN = "Pattern"

static

Definition at line 32 of file Filters.py.

FILTER_NAME_STAGE

string app.Filters.Filters.FILTER_NAME_STAGE = "Stage"

static

Definition at line 35 of file Filters.py.

FILTER_NAME_STATE

string app.Filters.Filters.FILTER_NAME_STATE = "State"

static

Definition at line 38 of file Filters.py.

FILTER_NAME_SUBJECT

string app.Filters.Filters.FILTER_NAME_SUBJECT = "Subject"

static

Definition at line 33 of file Filters.py.

FILTER_SPLIT_PATTERN

string app.Filters.Filters.FILTER_SPLIT_PATTERN = '\r\n'

static

Definition at line 30 of file Filters.py.

filters

app.Filters.Filters.filters

Definition at line 96 of file Filters.py.

LOGIC_AND

int app.Filters.Filters.LOGIC_AND = 1

static

Definition at line 56 of file Filters.py.

LOGIC_OR

int app.Filters.Filters.LOGIC_OR = 0

static

Definition at line 55 of file Filters.py.

MACRO_CASE_LOWER

int app.Filters.Filters.MACRO_CASE_LOWER = 2

static

Definition at line 74 of file Filters.py.

MACRO_CASE_ORIGINAL

int app.Filters.Filters.MACRO_CASE_ORIGINAL = 0

static

Definition at line 72 of file Filters.py.

MACRO_CASE_UPPER

int app.Filters.Filters.MACRO_CASE_UPPER = 1

static

Definition at line 73 of file Filters.py.

OC_EQ

int app.Filters.Filters.OC_EQ = 1

static

Definition at line 60 of file Filters.py.

OC_EQLESS

int app.Filters.Filters.OC_EQLESS = 3

static

Definition at line 62 of file Filters.py.

OC_EQMORE

int app.Filters.Filters.OC_EQMORE = 4

static

Definition at line 63 of file Filters.py.

OC_LESS

int app.Filters.Filters.OC_LESS = 5

static

Definition at line 64 of file Filters.py.

OC_MORE

int app.Filters.Filters.OC_MORE = 6

static

Definition at line 65 of file Filters.py.

OC_NOTEQ

int app.Filters.Filters.OC_NOTEQ = 2

static

Definition at line 61 of file Filters.py.

OC_RE

int app.Filters.Filters.OC_RE = 0

static

Definition at line 59 of file Filters.py.

OC_SQLE

int app.Filters.Filters.OC_SQLE = 7

static

Definition at line 66 of file Filters.py.

patternCache

app.Filters.Filters.patternCache

Definition at line 88 of file Filters.py.

readMode

app.Filters.Filters.readMode

Definition at line 92 of file Filters.py.

reFlags

app.Filters.Filters.reFlags

Definition at line 89 of file Filters.py.

REPLACE_MARKER

string app.Filters.Filters.REPLACE_MARKER = '%'

static

Definition at line 28 of file Filters.py.

SELECT_SUBJECT_HEADERS_ALL

string app.Filters.Filters.SELECT_SUBJECT_HEADERS_ALL = 'HEADERS_ALL'

static

Definition at line 52 of file Filters.py.

SELECT_SUBJECT_LAST_MODIFIED

string app.Filters.Filters.SELECT_SUBJECT_LAST_MODIFIED = 'LAST_MODIFIED'

static

Definition at line 53 of file Filters.py.

SELECT_SUBJECT_RAW_CONTENT

string app.Filters.Filters.SELECT_SUBJECT_RAW_CONTENT = 'RAW_CONTENT'

static

Definition at line 51 of file Filters.py.

siteId

app.Filters.Filters.siteId

Definition at line 91 of file Filters.py.

stage

app.Filters.Filters.stage

Definition at line 94 of file Filters.py.

STAGE_AFTER_DOM

int app.Filters.Filters.STAGE_AFTER_DOM = 3

static

Definition at line 43 of file Filters.py.

STAGE_AFTER_DOM_PRE

int app.Filters.Filters.STAGE_AFTER_DOM_PRE = 2

static

Definition at line 42 of file Filters.py.

STAGE_AFTER_PROCESSOR

int app.Filters.Filters.STAGE_AFTER_PROCESSOR = 4

static

Definition at line 44 of file Filters.py.

STAGE_ALL

int app.Filters.Filters.STAGE_ALL = 5

static

Definition at line 45 of file Filters.py.

STAGE_BEFORE_DOM_PRE

int app.Filters.Filters.STAGE_BEFORE_DOM_PRE = 1

static

Definition at line 41 of file Filters.py.

STAGE_BEFORE_PROCESSOR

int app.Filters.Filters.STAGE_BEFORE_PROCESSOR = 7

static

Definition at line 47 of file Filters.py.

STAGE_COLLECT_URLS

int app.Filters.Filters.STAGE_COLLECT_URLS = 0

static

Definition at line 40 of file Filters.py.

STAGE_COLLECT_URLS_PROTOCOLS

int app.Filters.Filters.STAGE_COLLECT_URLS_PROTOCOLS = 6

static

Definition at line 46 of file Filters.py.

STAGE_REDIRECT_URL

int app.Filters.Filters.STAGE_REDIRECT_URL = 8

static

Definition at line 48 of file Filters.py.

STATE_DISABLE

int app.Filters.Filters.STATE_DISABLE = 0

static

Definition at line 69 of file Filters.py.

STATE_ENABLE

int app.Filters.Filters.STATE_ENABLE = 1

static

Definition at line 70 of file Filters.py.

---

The documentation for this class was generated from the following file:

• sources/hce/app/Filters.py