def setUp(self):
unittest.TestCase.setUp(self)
self.src = sources.Sources(dbfile=self._dbName)
self.util = tests.utils.Utils(dbfile=self._dbName,
logger=self.src.logger)
self.util.checkDbDataTestNames()
def __init__(self, dbfile=None):
"""
Builds a local instance of the Sources class and
one of the MovieLogger engine.
"""
self._source = sources.Sources(dbfile=dbfile)
self.logger = logging.getLogger(movieLogger.MovieLoggger.LOGGER_NAME)
self.logger.info("Scraper instance inited.")
def __init__(self, dbfile=None):
"""
Builds a local instance of the Sources class and
one of the MovieLogger engine.
"""
self.sources = sources.Sources(dbfile=dbfile)
self.logger = logging.getLogger(movieLogger.MovieLoggger.LOGGER_NAME)
self.tmdbClient = tmdb.tmdbRestClient()
self.logger.info("TranslationMatcher instance inited.")
def main(argv):
global locations
locations = read_json()
ruta = "C:\\Users\\devel\\Downloads\\SQM\\Financieros"
lst_sources = sources.Sources(ruta).walk_folder()
for file in lst_sources:
if '.xlsx' in file:
read_excel_book(file)
roe_trimestral.rename(columns={
0: 'Anio',
1: 'Quarter',
2: 'BN',
3: 'Patrimonio',
4: 'ROE'
},
inplace=True)
print(roe_trimestral)
BAN_LIST = 'banned_players.yml'
locale.setlocale(locale.LC_ALL, "en_US.UTF-8")
LOGFORMAT = "%(asctime)s [%(levelname)s] %(message)s"
# TODO:
# * add a way to ban player-server combinations
try:
BANNED = set(
[x.lower() for x in yaml.safe_load(open(BAN_LIST).read())['banned']])
except:
BANNED = set()
# load the config file and set up useful variables in the `config` module
CONFIG = yaml.safe_load(open(CONFIG_FILE).read())
SOURCES = sources.Sources(CONFIG_FILE)
USE_MILESTONES = CONFIG['use-milestones']
LOCALBASE = CONFIG.get('local-base', '.')
SCORING_KEY = CONFIG.get('daemon-name', 'scoresd')
LOCKFILE = os.path.join(LOCALBASE, '%s.lock' % SCORING_KEY)
LOGFILE = os.path.join(LOCALBASE, '%s.log' % SCORING_KEY)
SCORESD_STOP_REQUEST_FILE = os.path.join(LOCALBASE, '%s.stop' % SCORING_KEY)
SCORE_FILE_DIR = CONFIG.get('scoring-local', 'scoring')
PLAYER_BASE = 'players' # subdirectory under scoring-local
PLAYER_FILE_DIR = os.path.join(SCORE_FILE_DIR, PLAYER_BASE)
# default for running scoring locally -- not useful for server setups
SCORING_BASE_URL = CONFIG.get('scoring-base-url',
"file://" + os.path.abspath(SCORE_FILE_DIR))
def setup(self):
# CONFIG PARAMETERS
try:
with open('config.ini') as self._cfg:
self._config.read_file(self._cfg)
self._hname = self._config.get("TestHost", "hostname")
self._dd_dir = self._config.get("Dir", "dd_dir")
self._src = self._config.get("Sources", "sources")
self._a_filters = (self._config.get("Filters",
"filters")).split(', ')
self._n_batch = self._config.get("Batch", "n_batch")
if self._n_batch:
self._n_batch = int(self._n_batch)
print("\n[NOTICE] Check your settings in 'config.ini' file. ")
except (IOError, OSError):
print("[ERROR] Unable to find config file (config.ini)")
sys.exit()
# NETWORK TEST
try:
print("\n>>Test network connection...")
self._hostname = hostname.Test_hostname()
self._hostname.set_hostname(self._hname)
self._hostname.get_hostname()
self._hostname.test_conn()
except (IOError, OSError):
print("[ERROR] Unable to get test_hostname.")
# Logging...
self._setup_log = utility.Logger()
self._setup_log.set_file('log.txt')
self._setup_log.get_file()
# BEGIN SETUP
#########################
try:
# DIRECTORY
self._dd_directory = directory.Download_dir()
self._dd_directory.set_directory(self._dd_dir)
self._dd_directory = self._dd_directory.get_directory()
# BATCH FOR TASK POOL
self._batch = batch.Batch()
self._batch.set_batch(self._n_batch)
self._batch = self._batch.get_batch()
# FILTERS
self._filters = filters.Filters()
self._filters.set_filters(self._a_filters)
self._filters = self._filters.get_filters()
# SOURCES
# There is no need to set a default action. If the source file doesn't exist or it's corrupted,
# the script will terminate its operation instantly.
print("\n>>Source File:")
print(self._src)
self._sources = sources.Sources()
self._sources.set_urls(self._src)
self._sources = self._sources.get_urls()
print("\n>>Options")
print("Download directory: ", self._dd_dir)
# If filters is empty in config.ini, don't apply filters.
if self._a_filters[0] == '' and len(self._a_filters) == 1:
self._filtered_urls = self._sources
print("No filter rules applied.\n")
else:
print("Filter rules: ", self._a_filters, "\n")
self._filtered_urls = utility.Filtered_urls()
self._filtered_urls = self._filtered_urls.apply_filters(
self._a_filters, self._sources)
# for logging...
self._conf_log = "\n[CONFIG] [time: " + str(
(datetime.now()
).strftime('%Y/%m/%d %H:%M:%S')) + "] Setup complete. [OK]"
self._setup_log.logger(self._conf_log)
except BaseException:
print("[ERROR] Unable to complete script setup.")
self._fail_conf_log = "\n[ERROR] [time: " + str(
(datetime.now()
).strftime('%Y/%m/%d %H:%M:%S')) + "] Setup Failed!!!"
self._setup_log.logger(self._fail_conf_log)
sys.exit()
return self._filtered_urls, self._dd_directory, self._n_batch
movieLogger.MovieLoggger().initLogger(level=args.logLevel)
engine = create_engine("sqlite:///" + args.dbfile)
Base.metadata.bind = engine
from sqlalchemy.orm import sessionmaker
DBSession = sessionmaker()
DBSession.bind = engine
session = DBSession()
# Make a query to find all Locations in the database
session.query(Locations).all()
# Return the first Person from all Persons in the database
person = session.query(Locations).first()
###
S = sources.Sources(dbfile=args.dbfile)
S.logger.info("Analytics module")
allLocations = S.getAllLocations()
S.logger.info("Locations definitions found for: %s",
[x['name'] for x in allLocations])
S.logger.info("Looking for: %s...", args.location)
S.logger.fatal("Analytics not yet implemented!")
allData = S.getAllTitlesInLocation()
S.logger.info("End run.")
y_l, y_h = 0, height #fixes to screen dimension
#####################################################################
#base colors, randomize point colors
red, green, blue, black = (0, 0, 255), (0, 255, 0), (255, 0, 0), (255, 255,
255)
yellow, purple, gray, white = (0, 255, 255), (200, 0, 200), (100, 100,
100), (0, 0, 0)
#RT control keys:
#esc key exits the RT loop (with a variable pause in seconds)
KEY_ESC, KEY_W, KEY_1, KEY_2, KEY_R = 27, 119, 49, 50, 114
KEY_C, KEY_L, KEY_P = 99, 108, 112
#new video source object (makes windows, opens videos, camera,ect)
source = sources.Sources()
#new window to view video streams
source.win_start('video_input')
p = perform.CPU()
#captures video files or default webcam = 0
f, M = 1, 10 #n=number of max frames, m= a divsor for output
RT, IM, frame, diag = True, True, 0, white
CL, LIN, PO = False, False, True # for display of clusters and lines
p_colors, c_colors, clust, c_map = [], [], [], {}
c_colors.append(rwhite()) #clusters draw white/grey?
c_map = {} #color map
while RT and (frame < f): #Real-Time Loop=> 'esc' key turns off
p.stop()
imc = np.zeros((height, width, 4), np.uint8)
ims = filters.invert(imc)
#check for background toggle
def __init__(self):
self.interface = gtk.Builder()
self.interface.add_from_file(UI_DIR + "/sltv.ui")
self.main_window = self.interface.get_object("window1")
self.main_window.show_all()
self.about = about.About(self)
self.sltv = Sltv()
self.sltv.connect("stopped", self.stopped)
self.sltv.connect("playing", self.playing)
self.sltv.connect("error", self.error)
self.sltv.connect("pipeline-ready", self.on_pipeline_ready)
self.preview_frame = self.interface.get_object("preview_frame")
self.preview_box = self.interface.get_object("preview_vbox")
self.preview = preview.PreviewUI(self, self.sltv)
self.preview_box.pack_start(self.preview.get_widget(), False, False)
self.preview_area = PreviewArea()
self.preview_frame.add(self.preview_area)
self.preview_area.show()
self.box = self.interface.get_object("paned")
self.settings = settings.SettingsUI(self, self.sltv)
self.box.add(self.settings.get_widget())
self.play_button = self.interface.get_object("play_button")
self.stop_button = self.interface.get_object("stop_button")
self.settings_dialog = gtk.Dialog('Settings', self.main_window)
self.settings_dialog.set_default_size(400, 400)
self.encoders = self.sltv.encoders
self.videoconverters = self.sltv.videoconverters
self.encoders_ui = encoders.Encoders(self, self.encoders,
self.videoconverters)
self.metadata_ui = metadata.MetadataUI(self.sltv, self.settings_dialog)
self.hbuttonbox = self.interface.get_object("hbuttonbox1")
self.volume = volume.VolumeUI(self, self.sltv)
self.volume_button = self.volume.get_widget()
self.volume_button.show()
self.hbuttonbox.pack_start(self.volume_button)
self.sltv.vus = []
meter = fvumeter.FVUMeter()
meter.only_draw_peak = True
self.sltv.vus.append(meter)
meter = fvumeter.FVUMeter()
self.sltv.vus.append(meter)
self.sltv.vus[0].show()
self.sltv.vus[1].show()
self.vumeter_box = self.interface.get_object("vumeter_box")
if self.vumeter_box:
self.vumeter_box.add(self.sltv.vus[0])
self.vumeter_box.add(self.sltv.vus[1])
# pip
pip_box = self.interface.get_object("pip_box")
self.pip_selector = pip_widget.PIPSelector()
self.pip_selector.connect("changed", self.on_pip_changed)
pip_box.add(self.pip_selector)
pip_box.show_all()
# sources
self.sources = self.sltv.sources
self.audioconvs = self.sltv.audioconvs
self.sources_ui = sources.Sources(self, self.sources, self.audioconvs)
self.video_source_box = self.interface.get_object("video_source_box")
self.sources_view = sources_view.SourcesView(self.sltv, self.sources)
self.sources_view.show_all()
self.video_source_box.pack_start(self.sources_view, False, False)
# audio combobox
self.audio_sources_combobox = self.interface.get_object(
"audio_sources_combobox")
self.audio_sources_combobox.set_model(
sources.AudioModel(self.sources).model)
cell = gtk.CellRendererText()
self.audio_sources_combobox.pack_start(cell, True)
self.audio_sources_combobox.add_attribute(cell, "text", 0)
self.audio_sources_combobox.connect("changed",
self.on_select_audio_source)
self.audio_sources_combobox.set_active(0)
# outputs
self.outputs = self.sltv.outputs
self.outputs_ui = outputs.Outputs(self, self.outputs, self.encoders)
self.outputs_box = self.interface.get_object("outputs_box")
self.outputs_view = outputs_view.OutputsView(self.sltv, self.outputs)
self.outputs_view.show_all()
self.outputs_box.pack_start(self.outputs_view, False, False)
# settings dialog
self.settings_dialog.set_has_separator(False)
self.settings_dialog.add_button(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)
self.settings_dialog.connect('delete-event', self.hide_settings)
self.settings_dialog.connect('response', self.hide_settings)
vbox = self.settings_dialog.get_content_area()
vbox.set_border_width(12)
notebook = gtk.Notebook()
self.settings_notebook = notebook
vbox.add(notebook)
vbox = gtk.VBox()
vbox.set_border_width(12)
vbox.pack_start(self.sources_ui.get_widget())
notebook.append_page(vbox, gtk.Label('Sources'))
vbox = gtk.VBox()
vbox.set_border_width(12)
vbox.pack_start(self.encoders_ui.get_widget())
notebook.append_page(vbox, gtk.Label('Encoders'))
vbox = gtk.VBox()
vbox.set_border_width(12)
vbox.pack_start(self.outputs_ui.get_widget())
notebook.append_page(vbox, gtk.Label('Outputs'))
vbox = gtk.VBox()
vbox.set_border_width(12)
vbox.pack_start(self.metadata_ui.get_widget())
notebook.append_page(vbox, gtk.Label('Metadata'))
#menu
self.settings_menuitem = self.interface.get_object("settings_menuitem")
self.quit_menuitem = self.interface.get_object("quit_menuitem")
self.about_menu = self.interface.get_object("about_menu")
self.play_button.connect("clicked", self.on_play_press)
self.stop_button.connect("clicked", self.on_stop_press)
self.main_window.connect("delete_event", self.on_window_closed)
self.settings_menuitem.connect("activate", self.show_settings)
self.quit_menuitem.connect("activate", gtk.main_quit)
self.about_menu.connect("activate", self.show_about)