def getEntitiesByRegexp(data = None, listRegexp = None, verbosity=1, logFolder="./logs"):
'''
Method to obtain entities by Regexp.
:param data: text where the entities will be looked for.
:param listRegexp: list of selected regular expressions to be looked for. If None was provided, all the available will be chosen instead.
:param verbosity: Verbosity level.
:param logFolder: Folder to store the logs.
:return: a list of the available objects containing the expressions found in the provided data.
[
{
"attributes": [],
"type": "i3visio.email",
"value": "*****@*****.**"
},
{
"attributes": [],
"type": "i3visio.email",
"value": "*****@*****.**"
]
'''
logSet.setupLogger(loggerName="osrframework.entify", verbosity=verbosity, logFolder=logFolder)
logInstance = logging.getLogger("osrframework.entify")
if listRegexp == None:
listRegexp = regexp_selection.getAllRegexp()
foundExpr = []
for r in listRegexp:
foundExpr += r.findExp(data)
return foundExpr
def getEntitiesByRegexp(data = None, listRegexp = None, verbosity=1, logFolder="./logs"):
'''
Method to obtain entities by Regexp.
:param data: text where the entities will be looked for.
:param listRegexp: list of selected regular expressions to be looked for. If None was provided, all the available will be chosen instead.
:param verbosity: Verbosity level.
:param logFolder: Folder to store the logs.
:return: a list of the available objects containing the expressions found in the provided data.
[
{
"attributes": [],
"type": "i3visio.email",
"value": "*****@*****.**"
},
{
"attributes": [],
"type": "i3visio.email",
"value": "*****@*****.**"
]
'''
logSet.setupLogger(loggerName="osrframework.entify", verbosity=verbosity, logFolder=logFolder)
logInstance = logging.getLogger("osrframework.entify")
if listRegexp == None:
listRegexp = regexp_selection.getAllRegexp()
foundExpr = []
for r in listRegexp:
foundExpr += r.findExp(data)
return foundExpr
def scanResource(uri=None, listRegexp=None, verbosity=1, logFolder="./logs"):
"""
[Optionally] recursive method to scan the files in a given folder.
Args:
-----
uri: the URI to be scanned.
listRegexp: listRegexp is an array of <RegexpObject>.
Returns:
-------
dict: the key is the name of the file.
"""
logSet.setupLogger(loggerName="osrframework.entify",
verbosity=verbosity,
logFolder=logFolder)
logger = logging.getLogger("osrframework.entify")
results = []
logger.debug("Looking for regular expressions in: " + uri)
data = urllib2.urlopen(uri).read()
foundExpr = getEntitiesByRegexp(data=data, listRegexp=listRegexp)
logger.debug("Updating the " + str(len(foundExpr)) +
" results found on: " + uri)
# Creating the output structure
for f in foundExpr:
aux = {}
aux = {}
aux["type"] = "i3visio.search"
aux["value"] = "URI - " + f["value"]
aux["attributes"] = []
for a in f["attributes"]:
aux["attributes"].append(a)
#Appending the entity itself
entity = {}
entity["type"] = f["type"]
entity["value"] = f["value"]
entity["attributes"] = []
aux["attributes"].append(entity)
#Appending the uri
entity = {}
entity["type"] = "i3visio.uri"
entity["value"] = uri
entity["attributes"] = []
aux["attributes"].append(entity)
results.append(aux)
return results
def scanFolderForRegexp(folder = None, listRegexp = None, recursive = False, verbosity=1, logFolder= "./logs"):
'''
[Optionally] recursive method to scan the files in a given folder.
:param folder: the folder to be scanned.
:param listRegexp: listRegexp is an array of <RegexpObject>.
:param recursive: when True, it performs a recursive search on the subfolders.
:return: a list of the available objects containing the expressions found in the provided data.
[
{
"attributes": [],
"type": "i3visio.email",
"value": "*****@*****.**"
},
{
"attributes": [],
"type": "i3visio.email",
"value": "*****@*****.**"
}
]
'''
logSet.setupLogger(loggerName="osrframework.entify", verbosity=verbosity, logFolder=logFolder)
logger = logging.getLogger("osrframework.entify")
logger.info("Scanning the folder: " + folder)
results = {}
#onlyfiles = []
#for f in listdir(args.input_folder):
# if isfile(join(args.input_folder, f)):
# onlyfiles.append(f)
onlyfiles = [ f for f in listdir(folder) if isfile(join(folder,f)) ]
for f in onlyfiles:
filePath = join(folder,f)
logger.debug("Looking for regular expressions in: " + filePath)
with open(filePath, "r") as tempF:
# reading data
foundExpr = getEntitiesByRegexp(data = tempF.read(), listRegexp = listRegexp)
logger.debug("Updating the " + str(len(foundExpr)) + " results found on: " + filePath)
results[filePath] = foundExpr
if recursive:
onlyfolders = [ f for f in listdir(folder) if isdir(join(folder,f)) ]
for f in onlyfolders:
folderPath = join(folder, f)
logger.debug("Looking for additional in the folder: "+ folderPath)
results.update(scanFolderForRegexp(folder = folderPath,listRegexp = listRegexp, recursive = recursive))
return results
def scanResource(uri = None, listRegexp = None, verbosity=1, logFolder= "./logs"):
'''
[Optionally] recursive method to scan the files in a given folder.
:param uri: the URI to be scanned.
:param listRegexp: listRegexp is an array of <RegexpObject>.
:return: a dictionary where the key is the name of the file.
'''
logSet.setupLogger(loggerName="osrframework.entify", verbosity=verbosity, logFolder=logFolder)
logger = logging.getLogger("osrframework.entify")
results = []
logger.debug("Looking for regular expressions in: " + uri)
import urllib2
data = urllib2.urlopen(uri).read()
foundExpr = getEntitiesByRegexp(data = data, listRegexp = listRegexp)
logger.debug("Updating the " + str(len(foundExpr)) + " results found on: " + uri)
# Creating the output structure
for f in foundExpr:
aux = {}
aux={}
aux["type"] = "i3visio.search"
aux["value"] = "URI - " +f["value"]
aux["attributes"] = []
for a in f["attributes"]:
aux["attributes"].append(a)
#Appending the entity itself
entity={}
entity["type"] = f["type"]
entity["value"] = f["value"]
entity["attributes"] = []
aux["attributes"].append(entity)
#Appending the uri
entity={}
entity["type"] = "i3visio.uri"
entity["value"] = uri
entity["attributes"] = []
aux["attributes"].append(entity)
results.append(aux)
return results
def entify_main(args):
'''
Main function. This function is created in this way so as to let other applications make use of the full configuration capabilities of the application.
'''
# Recovering the logger
# Calling the logger when being imported
logSet.setupLogger(loggerName="osrframework.entify", verbosity=args.verbose, logFolder=args.logfolder)
# From now on, the logger can be recovered like this:
logger = logging.getLogger("osrframework.entify")
logger.info("""entify.py Copyright (C) F. Brezo and Y. Rubio (i3visio) 2014
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it under certain conditions.
For details, run:
\tpython entify.py --license""")
logger.info("Selecting the regular expressions to be analysed...")
listRegexp = []
if args.regexp:
listRegexp = regexp_selection.getRegexpsByName(args.regexp)
elif args.new_regexp:
for i, r in enumerate(args.new_regexp):
listRegexp.append(RegexpObject(name = "NewRegexp"+str(i), reg_exp = args.new_regexp))
if not args.web:
results = scanFolderForRegexp(folder = args.input_folder, listRegexp= listRegexp, recursive = args.recursive, verbosity=args.verbose, logFolder= args.logfolder)
else:
results = scanResource(uri = args.web, listRegexp= listRegexp, verbosity=args.verbose, logFolder= args.logfolder)
logger.info("Logging the results:\n" + general.dictToJson(results))
if not args.quiet:
print general.dictToJson(results)
if args.output_folder:
logger.info("Preparing the output folder...")
if not os.path.exists(args.output_folder):
logger.warning("The output folder \'" + args.output_folder + "\' does not exist. The system will try to create it.")
os.makedirs(args.output_folder)
logger.info("Storing the results...")
"""if "csv" in args.extension:
with open(os.path.join(args.output_folder, "results.csv"), "w") as oF:
oF.write(resultsToCSV(results))"""
if "json" in args.extension:
with open(os.path.join(args.output_folder, "results.json"), "w") as oF:
oF.write(general.dictToJson(results))
return results
def scanResource(uri = None, listRegexp = None, verbosity=1, logFolder= "./logs"):
'''
[Optionally] recursive method to scan the files in a given folder.
:param uri: the URI to be scanned.
:param listRegexp: listRegexp is an array of <RegexpObject>.
:return: a dictionary where the key is the name of the file.
'''
logSet.setupLogger(loggerName="osrframework.entify", verbosity=verbosity, logFolder=logFolder)
logger = logging.getLogger("osrframework.entify")
results = {}
logger.debug("Looking for regular expressions in: " + uri)
import urllib2
data = urllib2.urlopen(uri).read()
foundExpr = getEntitiesByRegexp(data = data, listRegexp = listRegexp)
logger.debug("Updating the " + str(len(foundExpr)) + " results found on: " + uri)
results[uri] = foundExpr
return results
# -*- coding: cp1252 -*- # ################################################################################## # # Copyright 2015 Félix Brezo and Yaiza Rubio (i3visio, [email protected]) # # This file is part of OSRFramework. You can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # ################################################################################## import osrframework.utils.logger as logger # Calling the logger when being imported logger.setupLogger(loggerName="osrframework.transforms")
def scanFolderForRegexp(folder=None,
listRegexp=None,
recursive=False,
verbosity=1,
logFolder="./logs",
quiet=False):
"""
[Optionally] recursive method to scan the files in a given folder.
Args:
-----
folder: the folder to be scanned.
listRegexp: listRegexp is an array of <RegexpObject>.
recursive: when True, it performs a recursive search on the subfolders.
Returns:
--------
list: Available objects containing the expressions found in the
provided data. An example of the returned data is as follows:
```
[
{
"attributes": [],
"type": "i3visio.email",
"value": "*****@*****.**"
},
{
"attributes": [],
"type": "i3visio.email",
"value": "*****@*****.**"
}
]
```
"""
logSet.setupLogger(loggerName="osrframework.entify",
verbosity=verbosity,
logFolder=logFolder)
logger = logging.getLogger("osrframework.entify")
logger.info("Scanning the folder: " + folder)
results = []
#onlyfiles = []
#for f in listdir(args.input_folder):
# if isfile(join(args.input_folder, f)):
# onlyfiles.append(f)
onlyfiles = [f for f in listdir(folder) if isfile(join(folder, f))]
for i, f in enumerate(onlyfiles):
filePath = join(folder, f)
logger.debug("Looking for regular expressions in: " + filePath)
if not quiet:
print(
str(i) + "/" + str(len(onlyfiles)) +
"\tLooking for regular expressions in: " + filePath)
with open(filePath, "r") as tempF:
# reading data
foundExpr = getEntitiesByRegexp(data=tempF.read(),
listRegexp=listRegexp)
logger.debug("Updating the " + str(len(foundExpr)) +
" results found on: " + filePath)
aux = {}
aux["type"] = "i3visio.uri"
aux["value"] = filePath
aux["attributes"] = foundExpr
results.append(aux)
if recursive:
onlyfolders = [f for f in listdir(folder) if isdir(join(folder, f))]
for f in onlyfolders:
folderPath = join(folder, f)
logger.debug("Looking for additional in the folder: " + folderPath)
results.update(
scanFolderForRegexp(folder=folderPath,
listRegexp=listRegexp,
recursive=recursive))
# Printing the information if not in quiet mode
if not quiet:
print(general.success(json.dumps(results, indent=2)))
return results
def main(params=None):
"""
Main function to launch phonefy.
The function is created in this way so as to let other applications make
use of the full configuration capabilities of the application. The
parameters received are used as parsed by this modules `getParser()`.
Args:
-----
params: A list with the parameters as grabbed by the terminal. It is
None when this is called by an entry_point. If it is called by osrf
the data is already parsed.
Results:
--------
Returns a list with i3visio entities.
"""
if params == None:
parser = getParser()
args = parser.parse_args(params)
else:
args = params
results = []
# Recovering the logger
# Calling the logger when being imported
logSet.setupLogger(loggerName="osrframework.entify",
verbosity=args.verbose,
logFolder=args.logfolder)
# From now on, the logger can be recovered like this:
logger = logging.getLogger("osrframework.entify")
logger.info("Selecting the regular expressions to be analysed...")
if not args.quiet:
print(general.title(banner.text))
sayingHello = """
Entify | Copyright (C) Yaiza Rubio & Félix Brezo (i3visio) 2014-2018
This program comes with ABSOLUTELY NO WARRANTY. This is free software, and you
are welcome to redistribute it under certain conditions. For additional info,
visit <{}>.
""".format(general.LICENSE_URL)
print(general.info(sayingHello))
if args.license:
general.showLicense()
else:
listRegexp = []
if args.regexp:
listRegexp = regexp_selection.getRegexpsByName(args.regexp)
elif args.new_regexp:
for i, r in enumerate(args.new_regexp):
listRegexp.append(
RegexpObject(name="NewRegexp" + str(i),
reg_exp=args.new_regexp))
if not args.web:
results = scanFolderForRegexp(folder=args.input_folder,
listRegexp=listRegexp,
recursive=args.recursive,
verbosity=args.verbose,
logFolder=args.logfolder,
quiet=args.quiet)
else:
results = scanResource(uri=args.web,
listRegexp=listRegexp,
verbosity=args.verbose,
logFolder=args.logfolder)
logger.info("Logging the results:\n" +
json.dumps(results, indent=2, sort_keys=True))
# Trying to store the information recovered
if args.output_folder != None:
# Verifying an output folder was selected
logger.debug("Preparing the output folder...")
if not os.path.exists(args.output_folder):
logger.warning(
"The output folder \'" + args.output_folder +
"\' does not exist. The system will try to create it.")
os.makedirs(args.output_folder)
# Grabbing the results
fileHeader = os.path.join(args.output_folder, args.file_header)
for ext in args.extension:
# Generating output files
general.exportUsufy(results, ext, fileHeader)
# Showing the information gathered if requested
if not args.quiet:
now = dt.datetime.now()
print("\n{}\tResults obtained:\n".format(str(now)))
print(general.success(general.usufyToTextExport(results)))
now = dt.datetime.now()
print(
str(now) +
"\tYou can find all the information collected in the following files:"
)
for ext in args.extension:
# Showing the output files
print("\t-" + general.emphasis(fileHeader + "." + ext))
# Urging users to place an issue on Github...
print(banner.footer)
if params:
return results
def main(args):
'''
Main function. This function is created in this way so as to let other applications make use of the full configuration capabilities of the application.
'''
# Recovering the logger
# Calling the logger when being imported
logSet.setupLogger(loggerName="osrframework.entify", verbosity=args.verbose, logFolder=args.logfolder)
# From now on, the logger can be recovered like this:
logger = logging.getLogger("osrframework.entify")
logger.info("""entify.py Copyright (C) F. Brezo and Y. Rubio (i3visio) 2014
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it under certain conditions. For additional info, visit to <http://www.gnu.org/licenses/gpl-3.0.txt>.""")
logger.info("Selecting the regular expressions to be analysed...")
sayingHello = """entify.py Copyright (C) F. Brezo and Y. Rubio (i3visio) 2015
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it under certain conditions. For additional info, visit <http://www.gnu.org/licenses/gpl-3.0.txt>."""
if not args.quiet:
print sayingHello
print
logger.info("Starting entify.py")
listRegexp = []
if args.regexp:
listRegexp = regexp_selection.getRegexpsByName(args.regexp)
elif args.new_regexp:
for i, r in enumerate(args.new_regexp):
listRegexp.append(RegexpObject(name = "NewRegexp"+str(i), reg_exp = args.new_regexp))
if not args.web:
results = scanFolderForRegexp(folder = args.input_folder, listRegexp= listRegexp, recursive = args.recursive, verbosity=args.verbose, logFolder= args.logfolder, quiet=args.quiet)
else:
results = scanResource(uri = args.web, listRegexp= listRegexp, verbosity=args.verbose, logFolder= args.logfolder)
logger.info("Logging the results:\n" + general.dictToJson(results))
# Trying to store the information recovered
if args.output_folder != None:
# Verifying an output folder was selected
logger.debug("Preparing the output folder...")
if not os.path.exists(args.output_folder):
logger.warning("The output folder \'" + args.output_folder + "\' does not exist. The system will try to create it.")
os.makedirs(args.output_folder)
# Grabbing the results
fileHeader = os.path.join(args.output_folder, args.file_header)
for ext in args.extension:
# Generating output files
general.exportUsufy(results, ext, fileHeader)
# Showing the information gathered if requested
if not args.quiet:
print "A summary of the results obtained are shown in the following table:"
print unicode(general.usufyToTextExport(results))
print
print "You can find all the information collected in the following files:"
for ext in args.extension:
# Showing the output files
print "\t-" + fileHeader + "." + ext
return results
# adding the option
groupProcessing = parser.add_argument_group('Processing arguments', 'Configuring the processing parameters.')
groupProcessing.add_argument('-e', '--extension', metavar='<sum_ext>', nargs='+', choices=['csv', 'gml', 'json', 'mtz', 'ods', 'png', 'txt', 'xls', 'xlsx' ], required=False, default = ['csv'], action='store', help='output extension for the summary files. Default: xls.')
groupProcessing.add_argument('-o', '--output_folder', metavar='<path_to_output_folder>', required=False, default = './results', action='store', help='output folder for the generated documents. While if the paths does not exist, usufy.py will try to create; if this argument is not provided, usufy will NOT write any down any data. Check permissions if something goes wrong.')
groupProcessing.add_argument('-v', '--verbose', metavar='<verbosity>', choices=[0, 1, 2], required=False, action='store', default=1, help='select the verbosity level: 0 - none; 1 - normal (default); 2 - debug.', type=int)
# Getting a sample header for the output files
groupProcessing.add_argument('-F', '--file_header', metavar='<alternative_header_file>', required=False, default = "profiles", action='store', help='Header for the output filenames to be generated. If None was provided the following will be used: profiles.<extension>.' )
groupProcessing.add_argument('-q', '--quiet', required=False, action='store_true', default=False, help='Asking the program not to show any output.')
groupProcessing.add_argument('-L', '--logfolder', metavar='<path_to_log_folder', required=False, default = './logs', action='store', help='path to the log folder. If none was provided, ./logs is assumed.')
groupProcessing.add_argument('--recursive', action='store_true', default=False, required=False, help='Variable to tell the system to perform a recursive search on the folder tree.')
groupAbout = parser.add_argument_group('About arguments', 'Showing additional information about this program.')
groupAbout.add_argument('-h', '--help', action='help', help='shows this help and exists.')
groupAbout.add_argument('--version', action='version', version='%(prog)s '+" " +__version__, help='shows the version of the program and exists.')
return parser
if __name__ == "__main__":
# Grabbing the parser
parser = getParser()
args = parser.parse_args()
# Recovering the logger
# Calling the logger when being imported
logSet.setupLogger(loggerName="osrframework", verbosity=args.verbose, logFolder=args.logfolder)
# From now on, the logger can be recovered like this:
logger = logging.getLogger("osrframework")
main(args)
def main(args):
'''
Main function. This function is created in this way so as to let other applications make use of the full configuration capabilities of the application.
'''
# Recovering the logger
# Calling the logger when being imported
logSet.setupLogger(loggerName="osrframework.entify", verbosity=args.verbose, logFolder=args.logfolder)
# From now on, the logger can be recovered like this:
logger = logging.getLogger("osrframework.entify")
logger.info("""entify.py Copyright (C) F. Brezo and Y. Rubio (i3visio) 2015-2017
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it under certain conditions. For additional info, visit to <http://www.gnu.org/licenses/gpl-3.0.txt>.""")
logger.info("Selecting the regular expressions to be analysed...")
sayingHello = """entify.py Copyright (C) F. Brezo and Y. Rubio (i3visio) 2015-2017
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it under certain conditions. For additional info, visit <http://www.gnu.org/licenses/gpl-3.0.txt>."""
if not args.quiet:
print banner.text
print sayingHello
print
logger.info("Starting entify.py")
listRegexp = []
if args.regexp:
listRegexp = regexp_selection.getRegexpsByName(args.regexp)
elif args.new_regexp:
for i, r in enumerate(args.new_regexp):
listRegexp.append(RegexpObject(name = "NewRegexp"+str(i), reg_exp = args.new_regexp))
if not args.web:
results = scanFolderForRegexp(folder = args.input_folder, listRegexp= listRegexp, recursive = args.recursive, verbosity=args.verbose, logFolder= args.logfolder, quiet=args.quiet)
else:
results = scanResource(uri = args.web, listRegexp= listRegexp, verbosity=args.verbose, logFolder= args.logfolder)
logger.info("Logging the results:\n" + json.dumps(results, indent=2, sort_keys=True))
# Trying to store the information recovered
if args.output_folder != None:
# Verifying an output folder was selected
logger.debug("Preparing the output folder...")
if not os.path.exists(args.output_folder):
logger.warning("The output folder \'" + args.output_folder + "\' does not exist. The system will try to create it.")
os.makedirs(args.output_folder)
# Grabbing the results
fileHeader = os.path.join(args.output_folder, args.file_header)
for ext in args.extension:
# Generating output files
general.exportUsufy(results, ext, fileHeader)
# Showing the information gathered if requested
if not args.quiet:
print "A summary of the results obtained are shown in the following table:"
print unicode(general.usufyToTextExport(results))
print
print "You can find all the information collected in the following files:"
for ext in args.extension:
# Showing the output files
print "\t-" + fileHeader + "." + ext
# Urging users to place an issue on Github...
if not args.quiet:
print
print "Did something go wrong? Is a platform reporting false positives? Do you need to integrate a new one?"
print "Then, place an issue in the Github project: <https://github.com/i3visio/osrframework/issues>."
print "Note that otherwise, we won't know about it!"
print
return results
# adding the option
groupProcessing = parser.add_argument_group('Processing arguments', 'Configuring the processing parameters.')
groupProcessing.add_argument('-e', '--extension', metavar='<sum_ext>', nargs='+', choices=['csv', 'gml', 'json', 'mtz', 'ods', 'png', 'txt', 'xls', 'xlsx' ], required=False, default = DEFAULT_VALUES["extension"], action='store', help='output extension for the summary files. Default: xls.')
groupProcessing.add_argument('-o', '--output_folder', metavar='<path_to_output_folder>', required=False, default = DEFAULT_VALUES["output_folder"], action='store', help='output folder for the generated documents. While if the paths does not exist, usufy.py will try to create; if this argument is not provided, usufy will NOT write any down any data. Check permissions if something goes wrong.')
groupProcessing.add_argument('-v', '--verbose', metavar='<verbosity>', choices=[0, 1, 2], required=False, action='store', default=1, help='select the verbosity level: 0 - none; 1 - normal (default); 2 - debug.', type=int)
# Getting a sample header for the output files
groupProcessing.add_argument('-F', '--file_header', metavar='<alternative_header_file>', required=False, default = DEFAULT_VALUES["file_header"], action='store', help='Header for the output filenames to be generated. If None was provided the following will be used: profiles.<extension>.' )
groupProcessing.add_argument('-q', '--quiet', required=False, action='store_true', default=False, help='Asking the program not to show any output.')
groupProcessing.add_argument('-L', '--logfolder', metavar='<path_to_log_folder', required=False, default = './logs', action='store', help='path to the log folder. If none was provided, ./logs is assumed.')
groupProcessing.add_argument('--recursive', action='store_true', default=False, required=False, help='Variable to tell the system to perform a recursive search on the folder tree.')
groupAbout = parser.add_argument_group('About arguments', 'Showing additional information about this program.')
groupAbout.add_argument('-h', '--help', action='help', help='shows this help and exists.')
groupAbout.add_argument('--version', action='version', version='%(prog)s '+" " +__version__, help='shows the version of the program and exists.')
return parser
if __name__ == "__main__":
# Grabbing the parser
parser = getParser()
args = parser.parse_args()
# Recovering the logger
# Calling the logger when being imported
logSet.setupLogger(loggerName="osrframework", verbosity=args.verbose, logFolder=args.logfolder)
# From now on, the logger can be recovered like this:
logger = logging.getLogger("osrframework")
main(args)
# -*- coding: cp1252 -*- # ################################################################################## # # OSRFramework is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # ################################################################################## import osrframework.utils.logger as logger # Calling the logger when being imported logger.setupLogger(loggerName="osrframework.searchengines")
