def VerifyEmail(self, string):
fm = FileManager()
match = re.match(r'\b[\w.-]+@[\w.-]+.\w{2,4}\b', string)
if match and fm.isUnique(string,2):
return True
else:
return False
def __init__(self, automaton):
# Valores definidos por el usuario
self.automaton = Automaton2D()
self.automaton = automaton
self.cells_y = automaton.iterations # Numero de filas
self.cells_x = automaton.size # NUmero de columnas (iteraciones)
self.state = []
# Tamaño de las celdas del lienzo
self.cell_width = 1000
self.cell_height = 600
# Colores
self.background_color = 25, 25, 25
self.cell_color = 255, 255, 255
self.death_cell_color = 128, 128, 128
# Otros valores por defecto
self.max_width = 50 # Tamaño maximo de las filas
self.current_row = 0 # Fila que estamos pintando actualmente
self.file_manager = FileManager()
# tamaño de celdas en el eje x
self.sizeX = self.cell_width / self.cells_x
self.sizeY = self.cell_height / self.cells_y
# Desplegar la pantalla de pygame
pygame.init()
pygame.display.set_caption('Automata celular ' +
str(self.automaton.rule))
self.screen = pygame.display.set_mode(
(self.cell_width, self.cell_height))
self.screen.fill(self.background_color) # pintar fondo
def test_getScrambles(self):
file = open('testing.txt', 'w')
sessionData1 = [
[[0,
28563], "U2 F2 L2 D2 L' U2 L' F2 L F2 U L' D B' F' L' U2 F' L'",
"", 1563232395],
[[0, 32727], "R F U F' L' D' B L B2 D2 R2 F' D2 R2 F' B2 D2 F D",
"", 1563232454],
[[0, 28053],
"D F2 R2 U R2 F2 L2 U2 B2 D' L2 U L' R' F' D2 U B F2 U2 R'", "",
1563232519]
]
sessionDict = {"session1": sessionData1}
json.dump(sessionDict, file)
file.close()
fileManager = FileManager('testing.txt')
sessionData = fileManager.getSessionData('session1')
sessionResults = SessionResults(sessionData)
self.assertEqual(sessionResults.getScrambles(), [
"U2 F2 L2 D2 L' U2 L' F2 L F2 U L' D B' F' L' U2 F' L'",
"R F U F' L' D' B L B2 D2 R2 F' D2 R2 F' B2 D2 F D",
"D F2 R2 U R2 F2 L2 U2 B2 D' L2 U L' R' F' D2 U B F2 U2 R'"
])
def main():
args = parseArguments()
fileManager = FileManager(args=args)
demoPathAttributes = fileManager.getAttributes()
uploader = Uploader(demoPathAttributes)
uploader.upload()
def login(self, username, password):
"""Calls the user manager to generate the Login request. Then initializes the FileManager for loggedIn user
Parameters:
------------------------------------------
username : string
username for the user
password: stirng
password for the user
Return : string
response from the UserManager class method login
"""
data = ""
status = self.checkLogin(username)
if status == 1:
data = "Some other user is already logged in. Open another client to user a new login."
return data
elif status == 2:
data = "This user is already logged in."
return data
else:
data = f"Welcome {username}. Use help command to show available commands"
data = self.usermanager.logIn(username, password)
self.user = self.usermanager.getUserCredentials(username)
self.fileManager = FileManager(self.absolutePath +
self.user.rootDirectory)
self.fileManager.createUserDirectory()
return data
def manager(self,rule, ruledef):
from MatchManager import Matching
from SearchManager import SearchManager
from Trigger import Trigger
from FileManager import FileManager
Matching = Matching(rule, ruledef)
Trigger = Trigger()
FileManager = FileManager()
log_location = self.log_check(rule)
log = FileManager.read_logfile(log_location)
logfile = log
endPoint = len(logfile)
while True:
if endPoint > self.startAt:
Searching = SearchManager(Matching.matchlist, rule, logfile)
Trigger.perform_action(Searching.action, rule)
print 'start at begin: ' , self.startAt
self.startAt = endPoint
print 'startat = ', self.startAt
print 'endpoint = ', endPoint
interval = self.interval_check(rule)
print 'Sleeping for ' + str(interval) + ' seconds'
time.sleep(interval)
print 'Searching in the new rule file'
log_location = self.log_check(rule)
log = FileManager.read_logfile(log_location)
del logfile[:]
for line in range (self.startAt, len(log)):
logfile.append(log[line])
endPoint = len(log)
def manager(self, rule, ruledef):
from MatchManager import Matching
from SearchManager import SearchManager
from Trigger import Trigger
from FileManager import FileManager
Matching = Matching(rule, ruledef)
Trigger = Trigger()
FileManager = FileManager()
log_location = self.log_check(rule)
log = FileManager.read_logfile(log_location)
logfile = log
endPoint = len(logfile)
while True:
if endPoint > self.startAt:
Searching = SearchManager(Matching.matchlist, rule, logfile)
Trigger.perform_action(Searching.action, rule)
print 'start at begin: ', self.startAt
self.startAt = endPoint
print 'startat = ', self.startAt
print 'endpoint = ', endPoint
interval = self.interval_check(rule)
print 'Sleeping for ' + str(interval) + ' seconds'
time.sleep(interval)
print 'Searching in the new rule file'
log_location = self.log_check(rule)
log = FileManager.read_logfile(log_location)
del logfile[:]
for line in range(self.startAt, len(log)):
logfile.append(log[line])
endPoint = len(log)
def build(self):
fileManager = FileManager()
cities = [dir for dir in os.listdir(self.source) if os.path.isdir(os.path.join(self.source, dir))]
for city in cities:
city_path = os.path.join(self.source, city)
self.logger.info("%s ..."% city)
files = [os.path.splitext(os.path.normcase(file))[0] for file in os.listdir(city_path) if os.path.splitext(file)[1] == '.json']
for file in files:
json_file = os.path.join(city_path, "%s.json"% file)
geojson_file = os.path.join(city_path, "%s.geojson"% file)
js_geojson_file = os.path.join(city_path, "%s.js"% file)
self.logger.info("%s.json"% file)
if not os.path.isfile(geojson_file) or not os.path.isfile(js_geojson_file):
f = open(json_file, 'r')
loaded_json = json.load(f)
f.close()
loaded_geojson = self.builder.build_geojson(loaded_json)
fileManager.write_geojson(loaded_geojson, self.source, city, file)
self.logger.info(" => %s.geojson"% file)
fileManager.write_js_geojson(loaded_geojson, self.source, city, file)
self.logger.info(" => %s.js"% file)
class SinNombreOntologia():
def suceso(self):
return {u"Dia": "", u"Mes": "", u"A\u00f1o": ""}
def lugar(self):
return {u"Nivel": u"Departamento", u"Nombre": u""}
def __init__(self, jsonLine):
self.jsonLine = jsonLine
self.fileManager = FileManager()
self.structure = {}
try:
with self.fileManager.readFile("structure.json") as z:
self.structure = json.loads(z.read().replace('\n', ''))
except Exception as e:
self.fileManager.recordError("Couldn't load the structures file ")
self.clear()
def clear(self):
self.suc = self.suceso()
self.depto = self.lugar()
self.municipio = self.lugar()
def process(self, case, value):
if case == "Dia":
self.suc = Charmer.addValue(self.suc, "Dia", value)
elif case == "Mes":
self.suc = Charmer.addValue(self.suc, "Mes", value)
elif case == u"A\u00f1o":
self.suc = Charmer.addValue(self.suc, u"A\u00f1o", value)
elif case == "Departamento":
self.depto = Charmer.addValue(self.depto, "Nombre", value)
def concatenate_directory_of_npz_files(path):
file_manager = FileManager()
file_paths = file_manager.get_file_paths_from_directory(
directory_path=path)
training_sets = list()
shapes = set()
for path in file_paths:
if path.endswith(".npz"):
array = numpy.load(path)['a']
# ignore empty arrays
if len(array[0]) > 0:
training_sets.append(numpy.load(path)['a'])
else:
print("omitted because empty: ", path)
shape = '-'.join(list(map(str, array.shape)))
shapes.add(shape)
training_data = numpy.concatenate(training_sets, axis=0)
return training_data
def test_get_datetime(self):
f = FileManager()
year, month, day, hour, minute, second = f._get_datetime()
# TODO: Should I mock the python now function to test for specific
# values?
# Checks that the year is between 2016 and 2099. 2099 is somewhat
# arbitrary - the test will work for many years ... probably more
# than is necessary.
self.assertIn(
year, range(2016, 2100),
"FileManger get_datetime returns a valid year")
self.assertIn(
month, range(1, 13),
"FileManger get_datetime returns a valid month")
self.assertIn(
day, range(1, 32),
"FileManger get_datetime returns a valid day")
self.assertIn(
hour, range(1, 25),
"FileManger get_datetime returns a valid hour")
self.assertIn(
minute, range(0, 60),
"FileManger get_datetime returns a valid minute")
self.assertIn(
second, range(0, 60),
"FileManger get_datetime returns a valid second")
def __init__(self):
self.lmLogger = logging.getLogger("ViPRLogManager")
self.analysisDir = "."
self.lmLogger.setLevel(logging.DEBUG)
logManagerFileName = "ViPRLogManager.log"
logFileLocation = os.path.join(self.analysisDir, logManagerFileName)
# create file handler which logs even debug messages
fileHandler = logging.FileHandler(logFileLocation, mode='a')
fileHandler.setLevel(logging.DEBUG)
# create console handler with a higher log level
consoleHandler = logging.StreamHandler()
consoleHandler.setLevel(logging.INFO)
# create formatter and add it to the handlers
FORMAT = "%(asctime)s - %(name)s:%(module)s - %(levelname)s - %(message)s"
formatter = logging.Formatter(FORMAT)
fileHandler.setFormatter(formatter)
consoleHandler.setFormatter(formatter)
# add the handlers to the logger
self.lmLogger.addHandler(fileHandler)
self.lmLogger.propagate = False
self.lmLogger.addHandler(consoleHandler)
self.lmLogger.info("ViPR Log Manager 1.2")
self.appConfig = self.readFile("applicationConfig.json")
self.exclusion_list = self.readFile("exclusionList.json")
self.regexManager = RegExManager(self.appConfig, self.lmLogger)
self.fileManager = FileManager(self.appConfig, self.regexManager,
self.lmLogger)
self.dataManager = DataManager(self.appConfig, self.fileManager,
self.regexManager, self.lmLogger)
self.logInquirer = LogInquirer(self.appConfig, self.fileManager,
self.dataManager, self.lmLogger)
self.userConfig = None
def VerifyCedula(self, string):
match = re.match(r'\d{4}-\d{4}-\d{5}', string)
fm = FileManager()
if match and fm.isUnique(string,3):
return True
else:
return False
def take_photo():
file_settings = FileSettings()
logging.basicConfig(
filename=file_settings.log_file(),
format='%(asctime)s %(levelname)s: %(message)s',
level=logging.INFO)
logging.debug('Starting take_photo')
try:
logging.debug('Creating FileManager')
file_mgr = FileManager(file_settings.project_dir)
logging.debug('Getting file path')
file_name_path = file_mgr.get_file_path()
logging.debug('Photo file path name: %s', file_name_path)
except:
# Got an error trying to create the directory.
# NEXT file_name_path isn't set on an exception. What exception
# message is raised? Print that? Yes, need to debug the error.
# NEXT Create a unit (or behavioral test) to check this logic - does
# it need to be put into a separate module?
logging.error('Failed to create: %s', os.path.dirname(file_name_path))
return
logging.info('Taking photo with file path: %s', file_name_path)
camera_settings = CameraSettings()
# Camera is mounted upside down in the weatherproof housing
# Need to rotate 180 degrees so photo is right side up
camera_settings.rotation = 180
take_and_save_photo(camera_settings, file_name_path)
def get_commits_for_path(self, path):
file_manager = FileManager()
print(file_manager.path_lists)
if file_manager.check(path):
json_data = TrackedFile.load_file(path).get_json()
return json_data
return json.dumps([])
def _prepare(self):
# ファイルを取得する準備
FileManager.BASE_DIR = self.input_base_dir
self.file_manager = FileManager()
# 保存先ディレクトリを作成
self.target_key = datetime.now().strftime("%Y%m%d_%H%M%S")
def test_getMultipleSessionData(self):
file = open('testing.txt', 'w')
sessionData1 = [
[[0,
28563], "U2 F2 L2 D2 L' U2 L' F2 L F2 U L' D B' F' L' U2 F' L'",
"", 1563232395],
[[0, 32727], "R F U F' L' D' B L B2 D2 R2 F' D2 R2 F' B2 D2 F D",
"", 1563232454],
[[0, 28053],
"D F2 R2 U R2 F2 L2 U2 B2 D' L2 U L' R' F' D2 U B F2 U2 R'", "",
1563232519]
]
sessionData2 = [
[[0, 73228], "L' U B2 L B R D2 F' U2 F2 U B2 R2 U2 B2 R2 U' R2 F",
"", 1563233503],
[[0, 30163],
"D2 R2 F' U2 B R2 D2 U2 B' L2 R2 D' B U R2 F L B' R' F R'", "",
1563233644],
[[0, 28436],
"U' L2 D2 R2 B' D2 B R2 B' F2 U2 B' U' L D B' D L2 B F R'", "",
1563233713]
]
sessionDataList = [sessionData1, sessionData2]
sessionDict = {"session1": sessionData1, "session2": sessionData2}
json.dump(sessionDict, file)
file.close()
fileManager = FileManager('testing.txt')
for i in range(2):
sessionName = 'session' + str(i + 1)
self.assertEqual(fileManager.getSessionData(sessionName),
sessionDataList[i])
os.remove('testing.txt')
def get_lesson_notation(topic, lesson):
print("Test notation")
topic_path = "topics/"
topic += "/"
file_manager = FileManager(topic_path + topic)
bpm = file_manager.get_tempo_from_file_name(lesson)
lesson_file_path = file_manager.get_lesson_path("/" + lesson)
lesson_analysis = AudioAnalysis(lesson_file_path)
lesson_note_list, lesson_freq_list = lesson_analysis.analyse_notes()
lesson_timing_list = lesson_analysis.analyse_timing()
if int(bpm) < 0:
return "Error: No tempo present in filename"
else:
lesson_notation_creator = Notation(lesson_freq_list, lesson_timing_list, bpm)
lesson_string_list = lesson_notation_creator.get_strings_to_be_played()
lesson_fret_list = lesson_notation_creator.get_frets_to_be_played()
padded_duration_list = lesson_notation_creator.get_padded_duration_list()
total_beats = lesson_notation_creator.calculate_total_beats(padded_duration_list)
d = app_utils.create_dictionary(lesson_string_list=lesson_string_list, lesson_fret_list=lesson_fret_list,
padded_duration_list=padded_duration_list, total_beats=total_beats, bpm=bpm)
return jsonify(d)
def analysis(id, string, file_options_path):
result = None
options = FileManager.read_data_from_json(file_options_path)
if string == "/op":
if options['operators'] and id not in options['operators']:
options['operators'].append(id)
result = "Операция успешно выполнена. Вы оператор"
elif id not in options['operators']:
options['operators'] = [id]
result = "Операция успешно выполнена. Вы оператор"
else:
result = "Операция не выполнена, так как вы уже оператор"
FileManager.write_data_to_json(file_options_path, options)
if string == "/deop":
if options['operators'] and id in options['operators']:
for i in range(0, options['operators'].count(id)):
options['operators'].remove(id)
result = "Операция успешно выполнена. Терерь вы не оператор"
else:
result = "Операция не выполнена, так как вы не были оператором"
FileManager.write_data_to_json(file_options_path, options)
return result
def extract(filename, tmp_dir):
fm = FileManager()
fm.GoInsideDirectory(tmp_dir)
if fm.DirectoryExists(pyserver_path):
fm.DeleteDirectory(pyserver_path)
unpack_archive(filename, path__to_server)
def analyse_user_chords(dirone, dirtwo, lesson):
if request.method == 'POST':
if 'file' not in request.files:
print("no file uploaded")
return "Error: No File uploaded"
# Users attempt
file = request.files['file']
# Path to where the lesson the user attempted is stored
lesson_path = "{}/{}".format(dirone, dirtwo)
file_manager = FileManager(lesson_path)
lesson_file_path = file_manager.get_lesson_path("/" + lesson)
if file and app_utils.allowed_file(file.filename):
filename = secure_filename(file.filename)
# Save user file to be analysed
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
uploaded_file_path = app.config['UPLOAD_FOLDER'] + "/" + filename
user_chord_analyser = ChordAnalyser(uploaded_file_path)
user_chroma_list = user_chord_analyser.compute_chromagram()
user_note_list = user_chord_analyser.get_notes_of_chord(user_chroma_list)
lesson_chord_analyser = ChordAnalyser(lesson_file_path)
lesson_chroma_list = lesson_chord_analyser.compute_chromagram()
lesson_note_list = lesson_chord_analyser.get_notes_of_chord(lesson_chroma_list)
chord_comparision = ChordComparison(lesson, user_note_list, lesson_note_list)
return jsonify(chord_comparision.get_comparision_dict())
else:
return "Wrong File type: Must be wav"
def list_files_in_plan(plan):
plan_path = "plans/"
if plan not in valid_plans:
return "Error: Not a valid plan"
file_manager = FileManager(plan_path + plan)
return jsonify(file_manager.list_files_in_directory())
def HistoryGraph():
readRecord = FileManager(todayWeather)
hmm = readRecord.read()
tempToShow = []
humidToShow = []
timeToShow = []
for temp, humid, time in hmm:
tempToShow.append(temp)
humidToShow.append(humid)
timeToShow.append(time)
print(tempToShow)
# plt.ion()
tempGraphStart = plt.figure()
tempGraph = tempGraphStart.add_subplot(1,1,1)
tempGraph.plot(timeToShow,[float(i) for i in tempToShow])
tempGraph.set_title("temperature")
tempGraph.legend(["temperature"])
humiGraphStart = plt.figure()
humiGraph = humiGraphStart.add_subplot(1,1,1)
humiGraph.plot([float(x) for x in humidToShow])
humiGraph.set_title("humidity")
humiGraph.legend(["humidity"])
# plt.xlabel('temp')
# plt.ylabel('timeElapsed')
#likelihood to rain according to data
averageTemp = (sum([int(i) for i in tempToShow])/len(tempToShow))
averageHumid = (sum([int(i) for i in humidToShow])/len(humidToShow))
title = likelinessToRain(averageHumid, averageTemp)
print(f"title in historical graph {title}")
# plt.legend(["Temperature","Humidity"])
# plt.figure()
plt.show()
def __init__(self):
super().__init__()
self.timeout = 30
self.fetchIncrement = 20
self.height = 600
self.width = 1200
self.tissCataloguesRows = 12
self.tissCataloguesCols = 4
self.personalCatalogueRowsFirst = 4
self.personalCatalogueRowsSecond = 8
self.personalCatalogueCols = 1
self.tissCatalogues = []
self.personalCatalogues = []
self.personalCataloguesTitles = []
self.initUI()
self.setupWorkerThread()
self.loadCatalogues()
settings = FileManager.loadSettings()
if len(settings) > 0:
self.lastFetchDateTime.setText(settings[0])
self.toggleCourseNumbers.setChecked(FileManager.str2bool(settings[1]))
self.toggleCourseHours.setChecked(FileManager.str2bool(settings[2]))
self.exactSemester.setChecked(FileManager.str2bool(settings[3]))
def test9_change_directory_root(self):
"""Checks folder navigation outside root"""
absolutepath = os.path.dirname(
os.path.abspath(inspect.getfile(inspect.currentframe())))
absolutepath += "/User/" + self.username + "/"
fmanager = FileManager(absolutepath)
response = fmanager.changeDirectory("..")
self.assertEqual(response, "You are at root directory")
def test_list_directories(self):
directory = "topics"
file_manager = FileManager(directory)
dir_list = file_manager.list_directories()
expected_output = {'directories': ['fingerIndependence', 'strumming', 'picking']}
assert dir_list == expected_output
def OnSize(self, message):
d = FileManager().CurrentFile().data
w = d.GetWidth()
h = d.GetHeight()
self.SetSize(size=(w * self.scale, h * self.scale))
self.parent.SetScrollbars(1, 1, w * self.scale, h * self.scale)
logging.info("DrawPanel.OnZoom()")
self.Refresh()
class Data:
def __init__(self):
self.file = FileManager()
self._text = self.file.file
def set_data(self, file):
self._text = file
self.file.set_file(self._text)
def OnOK(self, event):
fm = FileManager()
fm.New( 'image',
self.add_w.GetValue(),
self.add_h.GetValue()
)
pub.sendMessage("UpdateBitmap")
self.Destroy()
def test1_create_user_directory(self):
"""Checks if a user directory is created, checking for a user folder called TestUser"""
absolutepath = os.path.dirname(
os.path.abspath(inspect.getfile(inspect.currentframe())))
userRoot = absolutepath + "/User/" + self.username
fmanager = FileManager(userRoot)
fmanager.createUserDirectory()
self.assertTrue(os.path.exists(userRoot))
def catchPics(self, html):
bs = BeautifulSoup(html, 'lxml')
photoNum = 0
for picsboxContent in bs.find_all('div', {"class": "picsbox"})[0]:
imgSrc = picsboxContent.contents[0]['src']
photoNum += 1
self.downloadPic(imgSrc, photoNum)
FileManager.writeToFile('PhotoSrc', imgSrc)
def test_get_tempo_from_file_name_bad_input(self):
directory = "topics"
lesson_name = "A_minor_pentatonic_ascending_quarter_notes95.wav"
file_manager = FileManager(directory)
bpm = file_manager.get_tempo_from_file_name(lesson_name)
assert not bpm
def buildlevel1(data):
seed = 23
modellst = []
filename = "level1Ensemble.pkl"
fObject = FileManager(filename)
if not fObject.isExist():
X, y = data['type1']['x'], data['type1']['y']
###add catboost here
model = CatBoostClassifier(loss_function='Logloss')
model.fit(X, y)
modellst.append(model)
model = CatBoostClassifier(loss_function='CrossEntropy')
model.fit(X, y)
modellst.append(model)
model = CatBoostClassifier(eval_metric=HingelossMetric())
model.fit(X, y)
modellst.append(model)
model = CatBoostClassifier(eval_metric=SquaredlossMetric())
model.fit(X, y)
modellst.append(model)
model = CatBoostClassifier(eval_metric=LogisticMetric())
model.fit(X, y)
modellst.append(model)
model = CatBoostClassifier(eval_metric=AUClossMetric())
model.fit(X, y)
modellst.append(model)
model = CatBoostClassifier(eval_metric=GiniMetric())
model.fit(X, y)
modellst.append(model)
X, y = data['type2']['x'], data['type2']['y']
aucModel = lgbmodel(X, y, metric='auc')
modellst.append(aucModel)
lambdaModel = lgbmodel(X, y, metric='xentlambda')
modellst.append(lambdaModel)
binaryerrModel = lgbmodel(X, y, metric='binary_error')
modellst.append(binaryerrModel)
#save model to disk
fObject.save(modellst)
def __init__(self):
"""Initialize the server manager object.
The parameters are passed on to the init function of server manager
"""
self.user = User("")
self.usermanager = UserManager()
self.absolutePath = os.path.dirname(
os.path.abspath(inspect.getfile(inspect.currentframe())))
self.fileManager = FileManager(self.absolutePath)
super().__init__()
def Monitor(self):
from FileManager import FileManager
FileManager = FileManager()
rules = FileManager.get_rules()
ruledef = FileManager.get_ruledef()
for rule in range(len(rules)):
print rules[rule]
thread = Thread(target=self.manager, args=(rules[rule], ruledef))
thread.start()
def __init__(self, jsonLine):
self.jsonLine = jsonLine
self.fileManager = FileManager()
self.structure = {}
try:
with self.fileManager.readFile("structure.json") as z:
self.structure = json.loads(z.read().replace('\n', ''))
except Exception as e:
self.fileManager.recordError("Couldn't load the structures file ")
self.clear()
def Monitor(self):
from FileManager import FileManager
FileManager = FileManager()
rules = FileManager.get_rules()
ruledef = FileManager.get_ruledef()
for rule in range (len(rules)):
print rules[rule]
thread = Thread( target=self.manager, args=(rules[rule], ruledef))
thread.start()
def negativeFeaturesSingleCat(self,category): ## PREPROCESSING PERCORSI IMMAGINI fm = FileManager() X_negative = [] #for i in range(0,len(listDir)): file_negative = self.root+category+"/"+category+"_" + self.detector + "_" + self.extractor + ".csv" if not os.path.isfile(file_negative): self.creaFileFeatures(category) else: X = fm.csvToArray(file_negative) X_negative = X_negative + X return X_negative
def loadResources(self):
loader = AssetLoader('images')
if BossEnemy.walking_images[Enemy.INDEX_DOWN] is None:
path = os.path.join(
BossEnemy.WALKING_PATH, BossEnemy.WALKING_DOWN_PATH)
prefix_path = os.path.join(
BossEnemy.PREFIX_PATH, BossEnemy.WALKING_DOWN_PATH)
fM = FileManager(path, file_ext='.png', create_dir=False)
BossEnemy.walking_images[Enemy.INDEX_DOWN] = \
loader.load_images(fM.get_files(prefix_path=prefix_path))
if BossEnemy.walking_images[Enemy.INDEX_UP] is None:
path = os.path.join(
BossEnemy.WALKING_PATH, BossEnemy.WALKING_UP_PATH)
prefix_path = os.path.join(
BossEnemy.PREFIX_PATH, BossEnemy.WALKING_UP_PATH)
fM = FileManager(path, file_ext='.png', create_dir=False)
BossEnemy.walking_images[Enemy.INDEX_UP] = \
loader.load_images(fM.get_files(prefix_path=prefix_path))
if BossEnemy.walking_images[Enemy.INDEX_LEFT] is None:
path = os.path.join(
BossEnemy.WALKING_PATH, BossEnemy.WALKING_LEFT_PATH)
prefix_path = os.path.join(
BossEnemy.PREFIX_PATH, BossEnemy.WALKING_LEFT_PATH)
fM = FileManager(path, file_ext='.png', create_dir=False)
BossEnemy.walking_images[Enemy.INDEX_LEFT] = \
loader.load_images(fM.get_files(prefix_path=prefix_path))
if BossEnemy.walking_images[Enemy.INDEX_RIGHT] is None:
path = os.path.join(
BossEnemy.WALKING_PATH, BossEnemy.WALKING_RIGHT_PATH)
prefix_path = os.path.join(
BossEnemy.PREFIX_PATH, BossEnemy.WALKING_RIGHT_PATH)
fM = FileManager(path, file_ext='.png', create_dir=False)
BossEnemy.walking_images[Enemy.INDEX_RIGHT] = \
loader.load_images(fM.get_files(prefix_path=prefix_path))
def main():
captor = AqiCaptor(logger)
file_manager = FileManager()
try:
try:
locations = file_manager.get_locations(source)
except IOError:
raise InitError("File %s is missing"% file_manager.get_locations_path(source))
except ValueError:
raise InitError("The %s file does not contain any correct JSON object"% file_manager.get_locations_path(source))
for city, location in locations.iteritems():
logger.warning("- Capting for %s"% city)
my_date = datetime.now().strftime('%y-%m-%d-%H')
loaded_json = captor.get_data(location)
try:
file_manager.write_json(loaded_json, source, city, my_date)
except IOError:
raise InitError("Folder %s is missing"% file_manager.get_folder_path(source, city))
return 0
except InitError as e:
logger.critical("%s: %s"% (type(e).__name__, e))
return 1
except requests.exceptions.RequestException as e:
logger.critical("%s: %s"% (type(e).__name__, e))
return 2
except Exception as e:
logger.critical(e, exc_info=True)
return 3
def featuresCategories(self): #recupera tutte le categorie, senza distinzione fra positive e negative #usando un numero incrementale per l'assegnazione delle categorie fm = FileManager() X_train = [] y_train = [] assoc = dict() listCategories = fm.listNoHiddenDir(self.root) index = 1 for cat in listCategories: file_positive = self.root+cat+"/"+cat+"_" + self.detector + "_" + self.extractor + ".csv" X_cat = fm.csvToArray(file_positive) X_train = X_train + X_cat y_train = y_train + [index]*len(X_cat) assoc[cat] = index index = index + 1 return X_train,y_train,assoc
def read_all_values_to_rotate(self):
"""
This method read all the data required by the final user to rotate an image
Return:
input_values.- List with all the inputs inserted by the user
[Image path, degrees, New name of the image]
If some value inserted is invalid, the method returns a empty list
"""
file_manager = FileManager()
input_values = []
image_path = self.read_image_path()
if (file_manager.validate_type_of_image(image_path) == True):
degrees = self.read_degrees_to_rotate_image()
if (degrees != 9999):
new_image_name = self.read_name_to_save_image_rotate()
input_values = [image_path, degrees, new_image_name]
return input_values
else:
return input_values
else:
return input_values
def main():
try:
logger.warning("Capting Archdaily...")
now = datetime.now().strftime('%y-%m-%d')
loaded_json = ArchdailyCaptor().get_data()
logger.info("Building the GeoJSON...")
loaded_geojson = ArchdailyGeojsonBuilder().build_geojson(loaded_json)
logger.info("Writing GeoJSON...")
file_manager = FileManager()
try:
file_manager.write_geojson(loaded_geojson, source, None, now)
file_manager.write_js_geojson(loaded_geojson, source, None, now)
except IOError:
raise InitError("The folder %s is missing"% file_manager.get_folder_path(source))
logger.warning("New GeoJSON written for Archdaily: %d locations"% len(loaded_json))
return 0
except InitError as e:
logger.critical("%s: %s"% (type(e).__name__, e))
return 1
except requests.exceptions.RequestException as e:
logger.critical(e, exc_info=True)
return 2
except Exception as e:
logger.critical(e, exc_info=True)
return 3
def test_get_file_path(self):
# Successful cases
root_dir = os.path.join("temp")
try:
f = FileManager(root_dir)
file_path = f.get_file_path()
# TODO: The regex path check is unix specific. Is there
# a way to have a regexp check for os path separator?
path, basename = os.path.split(file_path)
self.assertRegexpMatches(
path, "\d\d\d\d/\d\d/\d\d", "Verify path format is yyyy/mm/dd")
self.assertRegexpMatches(
basename, "\d\d\d\d-\d\d-\d\d_\d\d-\d\d-\d\d.jpg",
"Verify file name format is year-month-day_hour-minute-second.jpg")
finally:
# Clean up - remove directories created just for this test
os.removedirs(os.path.dirname(file_path))
self.assertFalse(
os.path.isdir(root_dir),
"Verify test directory does not exist after clean up")
# Error Cases
# Create a directory that can't be written to
unwritable_dir = "unwritable"
TEST_UMASK = 0o222
orig_umask = os.umask(TEST_UMASK)
os.makedirs(unwritable_dir)
try:
# Make sure we get an exception if creating the directory fails
f = FileManager(unwritable_dir)
self.assertRaises(OSError, f.get_file_path )
finally:
os.umask(orig_umask)
os.removedirs(unwritable_dir)
def read_all_values_to_export_an_image_file_to_another_format(self):
"""
This method read all the data required by the final user to export an image
to another format.
The formats that are supported by the application are: jpg, bmp and png
Return: List with all the inputs inserted by the user
[Image path, new format]
If some value inserted is invalid, the method returns a empty list
"""
file_manager = FileManager()
input_values = []
image_path = self.read_image_path()
if (file_manager.validate_type_of_image(image_path) == True):
new_format = self.read_format_to_export_an_image()
if (new_format != "Incorrect format"):
input_values = [image_path, new_format]
return input_values
else:
return input_values
else:
return input_values
def negativeFeatures(self): ## PREPROCESSING PERCORSI IMMAGINI fm = FileManager() #file_negative = self.root+self.keywords+"/"+self.keywords+"_" + self.detector + "_" + self.extractor + "_negative.csv" # List dir contiene tutte le cartelle della root img listDir = fm.listNoHiddenDir(self.root) # Cerco l'indice della cartella della Keywords indexKeywords = listDir.index(self.keywords) # Vado ad eliminare nella lista cartelle quella della keywords listDir.pop(indexKeywords) X_negative = [] for i in range(0,len(listDir)): file_negative = self.root+listDir[i]+"/"+listDir[i]+"_" + self.detector + "_" + self.extractor + ".csv" if not os.path.isfile(file_negative): self.creaFileFeatures(listDir[i]) else: X = fm.csvToArray(file_negative) X_negative = X_negative + X return X_negative
class FileManagerTest(unittest.TestCase):
def setUp(self):
self.file_manager= FileManager()
self.current_path = os.getcwd()
def test_aget_current_path_return_the_current_path(self):
self.assertEquals(self.current_path, self.file_manager.get_current_path())
def test_blist_image_from_path_return_a_list_with_images(self):
self.assertEquals(['apple.bmp', 'pregoneroOficial.jpg', 'tank.png', 'apple.bmp', 'bmp.bmp', 'linux.png', 'pregoneroOficial.jpg', 'programmer.jpg', 'test.jpg'], self.file_manager.list_image_from_path(self.current_path))
def test_clist_image_from_path_return_a_list_with_images_with_three_matching_files_and_one_different(self):
folder = "/input/moreimages"
path = self.current_path + folder
self.assertEquals(['apple.bmp', 'bmp.bmp', 'linux.png', 'pregoneroOficial.jpg', 'programmer.jpg', 'test.jpg'], self.file_manager.list_image_from_path(path))
def test_dlist_image_from_path_return_a_empty_list_when_no_images_exist(self):
folder="/input/empty"
path = self.current_path + folder
self.assertEquals([], self.file_manager.list_image_from_path(path))
def test_everify_path_directory_exists_when_user_insert_a_valid_path(self):
self.assertEquals(self.current_path, self.file_manager.directory_exists(self.current_path))
def test_fverify_path_directory_exists_when_user_insert_an_invalid_path(self):
self.assertEquals("This is an invalid path", self.file_manager.directory_exists("InvalidPath"))
def test_gverify_image_exist_when_user_insert_an_existing_image(self):
folder = "/input/tank.png"
path_image = self.current_path + folder
self.assertTrue(self.file_manager.validate_type_of_image(path_image))
def test_hverify_image_exist_when_user_insert_an_unexisting_image(self):
image = "/input/92.jpg"
path_image = self.current_path + image
self.assertFalse(self.file_manager.validate_type_of_image(image))
def test_iverify_image_exist_when_user_insert_an_unexisting_image(self):
txt_file = "/input/moreimages/readme.txt"
path_file = self.current_path + txt_file
self.assertFalse(self.file_manager.validate_type_of_image(path_file))
def __init__(self):
self.init_images()
self.file_manager = FileManager(
path=CustomLevelPicker.CUSTOM_MAP_PATH,
file_ext=CustomLevelPicker.MAP_FILE_EXT)
self.file_names = self.file_manager.get_files(strip_ext=True)
self.current_selection = 0
self.text_surf = None
self.text_rect = None
self.highlight_surf = None
self.highlight_rect = None
self.build_text()
self.build_subtitles()
Globals.play_menu_sound()
def action_switchlibrary(self, widget):
""" Load a new library """
library = self.libs[widget.get_active()]
print "loading library '"+library[0]+"' in '"+library[1]+"'"
self.meta = None
self.builder.get_object('notebook').set_current_page(0)
if(self.filemgr != None):
self.filemgr.index.close();
self.filemgr = FileManager(library[1])
self.iconview = self.builder.get_object("iconview")
self.iconview.set_model(self.filemgr.store)
self.iconview.set_text_column(self.filemgr.COL_TITLE)
self.iconview.set_pixbuf_column(self.filemgr.COL_PIXBUF)
self.iconview.set_tooltip_column(self.filemgr.COL_PATH)
self.new_query('')
self.filemgr.index.tagcloud()
def main():
captor = YahooWeatherCaptor()
file_manager = FileManager()
try:
try:
woe_ids = file_manager.get_locations(source)
except IOError:
raise InitError("File %s is missing"% file_manager.get_locations_path(source))
except ValueError:
raise InitError("The %s file does not contain any correct JSON object"% file_manager.get_locations_path(source))
for city, woe_id in woe_ids.iteritems():
logger.warning("Capting for %s" % city)
loaded_json = captor.get_data(woe_id)
last_build_date = dateutil.parser.parse(loaded_json['lastBuildDate'])
date_for_path = last_build_date.strftime('%y-%m-%d-%H-%M')
if os.path.isfile(file_manager.get_path(source, city, date_for_path)):
logger.warning("Same build date for %s (%s)" % (city, last_build_date))
else:
try:
file_manager.write_json(loaded_json, source, city, date_for_path)
except IOError:
raise InitError("Folder %s is missing"% file_manager.get_folder_path(source, city))
logger.warning("New JSON written for %s %s" % (city, last_build_date))
return 0
except InitError as e:
logger.critical("%s: %s"% (type(e).__name__, e))
return 1
except requests.exceptions.RequestException as e:
logger.critical("%s: %s"% (type(e).__name__, e))
return 2
except Exception as e:
logger.critical(e, exc_info=True)
return 3
def creaCsv(self): fm = FileManager() listCategories = fm.listNoHiddenDir(self.root) for cat in listCategories: file_positive = self.root+cat+"/"+cat+"_" + self.detector + "_" + self.extractor + ".csv" if not os.path.isfile(file_positive): #se il file non esiste viene creato print "Nuovo File Features Positive " + self.detector + " + " + self.extractor + " creato." X_positive = [] #elaborazione immagini listArrayPositive = fm.listNoHiddenFiles(self.root+cat,self.estension) for k in range(0,len(listArrayPositive)): # Da eliminare file csv ed altri base_name = self.root+cat+"/"+cat+fm.correggi(k)+ self.estension print "Immagini " + str(k) + " -> " + base_name ret = (self.obj.elabora(base_name)) #[0:cut_features] X_positive.append(ret) fm.arrayToCsv(X_positive,file_positive) else: print "File Features Positive " + self.detector + " + " + self.extractor + " esiste gia."
from FileManager import FileManager
from detectAndExtract import detectAndExtract
n_folds = input("Insert the number of folds: ")
detectors_descriptors = [
["MSER", "SIFT"],
["HARRIS", "SIFT"],
["SIFT", "SIFT"],
["ORB", "ORB"],
["FAST", "SURF"],
["FAST", "BRIEF"],
]
fm = FileManager()
categories = fm.listNoHiddenDir(os.path.dirname(__file__) + os.path.sep + "\\Project_OVA\\imm")
for i in range(0, len(categories)):
currentCategories = categories[i]
print "\n######################################"
print "CURRENT CATEGORY: " + currentCategories
for x in range(0, len(detectors_descriptors)):
print "###########################"
print currentCategories
class TileWindow(Gtk.Window):
def __init__(self):
Gtk.Window.__init__(self, title="TileMapEditor")
self.iconTheme = Gtk.IconTheme.get_default()
self.iconTheme.append_search_path("Ressources/Icons")
self.fileManager = FileManager(self)
self.newContents = CreateMenu(self)
self.tileBox = TileBox()
self.traceManager = TraceManager()
self.objectManager = ObjectManager()
self.sfmlTilePaned = Gtk.Paned()
self.sfmlTilePaned.pack1(self.tileBox)
self.toolNotebook = Gtk.Notebook()
self.toolNotebook.append_page(self.traceManager, Gtk.Label("Trace Manager"))
self.toolNotebook.set_size_request(200,200)
self.miniMap = MiniMap(self.toolNotebook)
self.toolPaned = Gtk.Paned(orientation = Gtk.Orientation.VERTICAL)
self.toolPaned.add1(self.toolNotebook)
self.toolPaned.pack2(self.objectManager)
self.toolPaned.connect('notify::position', self.handleToolPanedMoving)
self.toolPaned.set_property('position-set', True)
self.toolPaned.set_position(300)
self.sfmlBox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.sfmlTilePaned.add2(self.sfmlBox)
self.sfmlTilePaned.set_size_request(500, 300)
globalVar.sfmlArea = None
self.panedSFML_toolPaned = Gtk.Paned()
self.panedSFML_toolPaned.add1(self.sfmlTilePaned)
self.panedSFML_toolPaned.pack2(self.toolPaned, False, False)
self.panedSFML_toolPaned.connect('notify::position', self.handleToolPanedMoving)
self.panedSFML_toolPaned.set_property('position-set', True)
self.panedSFML_toolPaned.set_position(600)
self.set_default_size(800, 600)
self.actionGroup = Gtk.ActionGroup("Actions")
self.makeSFMLMenuAction(self.actionGroup)
self.makeFileMenuAction(self.actionGroup)
self.makeEditionMenuAction(self.actionGroup)
self.makeToolMenuAction(self.actionGroup)
self.tileBox.makeActionMenu(self.actionGroup)
self.uiManager = self.createUIManager()
self.uiManager.insert_action_group(self.actionGroup)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.add(vbox)
vbox.pack_start(self.uiManager.get_widget("/MenuBar"), False, False, 0)
vbox.pack_start(self.uiManager.get_widget("/ToolBar"), False, False, 0)
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
hbox.pack_start(self.panedSFML_toolPaned, True, True, 0)
vbox.pack_start(hbox, True, True, 0)
self.traceManager.connectToolButton(self)
self.tileBox.makePopupMenu(self.uiManager)
self.mode = None
self.show_all()
def buildSFMLArea(self, numberCase, size):
if globalVar.sfmlArea:
self.traceManager.clearAll()
self.tileBox.clearAll()
self.objectManager.clearAll()
for child in self.sfmlBox:
self.sfmlBox.remove(child)
vSlide = Gtk.VScrollbar()
hSlide = Gtk.HScrollbar()
globalVar.sfmlArea = SFMLArea(hSlide, vSlide, \
numberCase, size, self.miniMap)
hBox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
self.eventSFMLBox = Gtk.EventBox()
self.eventSFMLBox.add(globalVar.sfmlArea)
hBox.pack_start(self.eventSFMLBox, True, True, 0)
hBox.pack_start(vSlide, False, False, 0)
self.sfmlBox.pack_start(hBox, True, True, 0)
self.sfmlBox.pack_start(hSlide, False, False, 0)
globalVar.sfmlArea.makePopupAction(self.actionGroup)
globalVar.sfmlArea.makePopup(self.uiManager, self.eventSFMLBox)
self.show_all()
if platform.system() == "Linux":
globalVar.sfmlArea.render.create(globalVar.sfmlArea.get_window().get_xid())
elif platform.system() == "Windows":
globalVar.sfmlArea.render.create(GdkWin32.Win32Window.get_handle(globalVar.sfmlArea.get_window()))
self.zoomPlus.connect("activate", globalVar.sfmlArea.zoom, "in")
self.zoomOut.connect("activate", globalVar.sfmlArea.zoom, "out")
for mode in ["Print", "Eraser"]:
if self.actionGroup.get_action(mode).get_active():
globalVar.sfmlArea.mode = mode
self.mode = mode
break
def makeFileMenuAction(self, actionGroup):
fileMenuAction = Gtk.Action("FileMenu", "_File", None, None)
actionGroup.add_action(fileMenuAction)
newFileAction = Gtk.Action("NewFile", None, None, Gtk.STOCK_NEW)
actionGroup.add_action_with_accel(newFileAction, None)
newFileAction.connect("activate", self.newFile)
openFileAction = Gtk.Action("OpenFile", None, None, Gtk.STOCK_OPEN)
openFileAction.connect("activate", self.manageFile, "open", "xml")
actionGroup.add_action_with_accel(openFileAction, None)
saveAction = Gtk.Action("Save", None, None, Gtk.STOCK_SAVE)
actionGroup.add_action_with_accel(saveAction, None)
saveAction.connect("activate", self.manageFile, "save", "xml")
saveAsAction = Gtk.Action("SaveAs", None, None, Gtk.STOCK_SAVE_AS)
actionGroup.add_action_with_accel(saveAsAction, "<Ctrl><Shift>s")
saveAsAction.connect("activate", self.manageFile, "saveAs", "xml")
def makeEditionMenuAction(self, actionGroup):
editionMenuAction = Gtk.Action("EditionMenu", "_Edition", None, None)
actionGroup.add_action(editionMenuAction)
newTraceAction = Gtk.Action("NewTrace", "New _Trace", None, None)
actionGroup.add_action_with_accel(newTraceAction, "<Ctrl><Shift>t")
newTraceAction.connect("activate", self.newContents.newTrace, self.traceManager)
newImageAction = Gtk.Action("NewImage", "New _Image", None, None)
actionGroup.add_action_with_accel(newImageAction, "<Ctrl><Shift>i")
newImageAction.connect("activate", self.manageFile, "open", "image")
newObjectAction = Gtk.Action("NewObject", "New _Object", None, None)
actionGroup.add_action_with_accel(newObjectAction, "<Ctrl><Shift>o")
newObjectAction.connect("activate", self.objectManager.promptAddObject)
changeSizeAction = Gtk.Action("ChangeSize", "Chan_ge size", None, None)
changeSizeAction.connect("activate", self.promptSetSize)
def makeToolMenuAction(self, actionGroup):
toolsMenuAction = Gtk.Action("ToolsMenu", "_Tools", None, None)
actionGroup.add_action(toolsMenuAction)
changeSizeAction = Gtk.Action("ChangeSize", "Change size", None, None)
actionGroup.add_action(changeSizeAction)
self.zoomPlus = Gtk.Action("Zoom+", None, None, Gtk.STOCK_ZOOM_IN)
actionGroup.add_action_with_accel(self.zoomPlus, None)
self.zoomOut = Gtk.Action("Zoom-", None, None, Gtk.STOCK_ZOOM_OUT)
actionGroup.add_action_with_accel(self.zoomOut, None)
actionGroup.add_radio_actions([("Print", None, None, "p", None, 0), \
("Eraser", None, None, "e", None, 0)], "active", self.radioActionManager)
actionGroup.get_action("Print").set_icon_name("pencil")
actionGroup.get_action("Eraser").set_icon_name("eraser")
def makeSFMLMenuAction(self, actionGroup):
delCase = Gtk.Action("DelCase", "Delete", None, None)
setTileProperties = Gtk.Action("SetTileProperties", "Set tile properties", None, None)
actionGroup.add_action(delCase)
actionGroup.add_action(setTileProperties)
def createUIManager(self):
with open("Ressources/UI_INFO.xml", 'r') as info:
ui = Gtk.UIManager()
ui.add_ui_from_string(info.read())
self.add_accel_group(ui.get_accel_group())
return ui
def manageFile(self, widget, action, mime=""):
if action=="open":
if mime=="image":
self.newContents.createNewImage(self.fileManager, self.tileBox)
elif mime=="xml":
self.fileManager.openFileXML(self.tileBox, self.traceManager, self.objectManager)
elif action=="saveAs":
self.fileManager.saveAsFile(self.tileBox, self.traceManager, self.objectManager)
elif action=="save":
self.fileManager.saveFile(self.tileBox, self.traceManager, self.objectManager)
def handleToolPanedMoving(self, widget, paramSpec):
self.miniMap.scalePixbuf()
def newFile(self, widget):
self.newContents.newFile(self.fileManager)
def promptSetSize(self, widget):
self.newContents.setSize()
def getSaveFileElem(self):
windowElem = ET.Element('Window')
windowElem.set('numberCases', str(globalVar.sfmlArea.numberCases.x)+'x'+str(globalVar.sfmlArea.numberCases.y))
windowElem.set('tileSize', str(globalVar.sfmlArea.sizeCase.x)+'x'+str(globalVar.sfmlArea.sizeCase.y))
windowElem.set('title', str(self.get_title()))
return windowElem
def decodeXML(self, windowElement):
windowValuesElement = dict()
for item in windowElement.items():
windowValuesElement[item[0]]=item[1]
tileSizeSplit = windowValuesElement['tileSize'].split('x')
windowValuesElement['tileSize'] = sf.Vector2(float(tileSizeSplit[0]), float(tileSizeSplit[1]))
numberCasesSplit = windowValuesElement['numberCases'].split('x')
windowValuesElement['numberCases'] = sf.Vector2(float(numberCasesSplit[0]), float(numberCasesSplit[1]))
self.buildSFMLArea(windowValuesElement['numberCases'], windowValuesElement['tileSize'])
self.set_title(windowValuesElement['title'])
def radioActionManager(self, radioAction, current):
if globalVar.sfmlArea:
globalVar.sfmlArea.setMode(current.get_name())
self.mode = current.get_name()
def __init__(self):
Gtk.Window.__init__(self, title="TileMapEditor")
self.iconTheme = Gtk.IconTheme.get_default()
self.iconTheme.append_search_path("Ressources/Icons")
self.fileManager = FileManager(self)
self.newContents = CreateMenu(self)
self.tileBox = TileBox()
self.traceManager = TraceManager()
self.objectManager = ObjectManager()
self.sfmlTilePaned = Gtk.Paned()
self.sfmlTilePaned.pack1(self.tileBox)
self.toolNotebook = Gtk.Notebook()
self.toolNotebook.append_page(self.traceManager, Gtk.Label("Trace Manager"))
self.toolNotebook.set_size_request(200,200)
self.miniMap = MiniMap(self.toolNotebook)
self.toolPaned = Gtk.Paned(orientation = Gtk.Orientation.VERTICAL)
self.toolPaned.add1(self.toolNotebook)
self.toolPaned.pack2(self.objectManager)
self.toolPaned.connect('notify::position', self.handleToolPanedMoving)
self.toolPaned.set_property('position-set', True)
self.toolPaned.set_position(300)
self.sfmlBox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.sfmlTilePaned.add2(self.sfmlBox)
self.sfmlTilePaned.set_size_request(500, 300)
globalVar.sfmlArea = None
self.panedSFML_toolPaned = Gtk.Paned()
self.panedSFML_toolPaned.add1(self.sfmlTilePaned)
self.panedSFML_toolPaned.pack2(self.toolPaned, False, False)
self.panedSFML_toolPaned.connect('notify::position', self.handleToolPanedMoving)
self.panedSFML_toolPaned.set_property('position-set', True)
self.panedSFML_toolPaned.set_position(600)
self.set_default_size(800, 600)
self.actionGroup = Gtk.ActionGroup("Actions")
self.makeSFMLMenuAction(self.actionGroup)
self.makeFileMenuAction(self.actionGroup)
self.makeEditionMenuAction(self.actionGroup)
self.makeToolMenuAction(self.actionGroup)
self.tileBox.makeActionMenu(self.actionGroup)
self.uiManager = self.createUIManager()
self.uiManager.insert_action_group(self.actionGroup)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.add(vbox)
vbox.pack_start(self.uiManager.get_widget("/MenuBar"), False, False, 0)
vbox.pack_start(self.uiManager.get_widget("/ToolBar"), False, False, 0)
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
hbox.pack_start(self.panedSFML_toolPaned, True, True, 0)
vbox.pack_start(hbox, True, True, 0)
self.traceManager.connectToolButton(self)
self.tileBox.makePopupMenu(self.uiManager)
self.mode = None
self.show_all()
def test_create_direcotry(self):
# Successful cases
root_dir = os.path.join("test")
test_dirs = []
# TODO: Test fails if root_dir was not deleted from a previous failing
# test run. I thought I fixed that, but I missed something.
try:
# Pick some specific values to verify the right directories get created
year, month, day = '2001', '09', '11'
year_dir = os.path.join(root_dir, year)
expected_dir = os.path.join(root_dir, year, month, day)
test_dirs.append(expected_dir)
self.assertFalse(
os.path.isdir(root_dir),
"Verify year directory does not exist before creating it")
f = FileManager(root_dir)
f._create_directories(root_dir, year, month, day)
self.assertTrue(
os.path.isdir(expected_dir),
"Verify directories created successfully")
# Make sure the top level directory created has owner, group,
# and world read/write/execute permission. I didn't set up
# proper usernames on different systems, so I want to be able
# to read, write and delete files from different computers
# (including from Windows) as different users.
#
# Assume Linux since the script is designed to run on
# Raspberry Pi
mode = os.stat(year_dir).st_mode & 0o777
self.assertEqual(
mode, 0o777,
"Verity year directory is user, group, world read/write/execute")
f._create_directories(root_dir, year, month, day)
self.assertTrue(
os.path.isdir(expected_dir),
"Verify create_directories works if the directory already exists")
# Try making just a day directory (year and month exist)
day = '12'
expected_dir = os.path.join(root_dir, year, month, day)
test_dirs.append(expected_dir)
self.assertFalse(
os.path.isdir(expected_dir),
"Verify day directory does not exist before creating it")
f._create_directories(root_dir, year, month, day)
self.assertTrue(
os.path.isdir(expected_dir),
"Verify a new day directory was created successfully")
finally:
# Clean up - remove directories created just for this test
for dir in test_dirs:
os.removedirs(dir)
self.assertFalse(
os.path.isdir(dir),
"Verify test directory does not exist after clean up")
self.assertFalse(
os.path.isdir(root_dir),
"Verify root test directory does not exist after clean up")
from DatabaseManager import DatabaseManager
from FileManager import FileManager
from functools import wraps
from shutil import rmtree
import traceback
import re
from urllib import quote
import time
app = Flask("__main__") # This is not used correctly as of now.
# Database Manager
db_man = DatabaseManager(app)
# File Manager
file_man = FileManager(app)
# Base 36 encode/decode used in the subdomains
convert = ['0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
# encode challenge_ids for use in subdomains, just makes them grow a bit slower
def encode(challenge_id):
if challenge_id == 0:
return('0')
challenge_id36 = ''
while challenge_id > 0:
challenge_id36 = convert[challenge_id%36]+challenge_id36
challenge_id = challenge_id / 36
return challenge_id36
def loadResources(self):
if Player.still_images[Player.INDEX_UP] is None:
Player.still_images[Player.INDEX_UP] = \
Player.loader.load_spritesheet_alpha("main_still_up.png", 1, 2)
if Player.still_images[Player.INDEX_DOWN] is None:
Player.still_images[Player.INDEX_DOWN] = \
Player.loader.load_spritesheet_alpha(
"main_still_down.png", 1, 2)
if Player.still_images[Player.INDEX_LEFT] is None:
Player.still_images[Player.INDEX_LEFT] = \
Player.loader.load_spritesheet_alpha(
"main_still_left.png", 2, 1)
if Player.still_images[Player.INDEX_RIGHT] is None:
Player.still_images[Player.INDEX_RIGHT] = \
Player.loader.load_spritesheet_alpha(
"main_still_right.png", 2, 1)
if Player.walking_images[Player.INDEX_DOWN] is None:
path = os.path.join(Player.WALKING_PATH, Player.WALKING_DOWN_PATH)
prefix_path = os.path.join(
Player.PREFIX_PATH, Player.WALKING_DOWN_PATH)
fM = FileManager(path, file_ext='.png', create_dir=False)
Player.walking_images[Player.INDEX_DOWN] = \
Player.loader.load_images(
fM.get_files(prefix_path=prefix_path))
if Player.walking_images[Player.INDEX_UP] is None:
path = os.path.join(Player.WALKING_PATH, Player.WALKING_UP_PATH)
prefix_path = os.path.join(
Player.PREFIX_PATH, Player.WALKING_UP_PATH)
fM = FileManager(path, file_ext='.png', create_dir=False)
Player.walking_images[Player.INDEX_UP] = \
Player.loader.load_images(
fM.get_files(prefix_path=prefix_path))
if Player.walking_images[Player.INDEX_LEFT] is None:
path = os.path.join(Player.WALKING_PATH, Player.WALKING_LEFT_PATH)
prefix_path = os.path.join(
Player.PREFIX_PATH, Player.WALKING_LEFT_PATH)
fM = FileManager(path, file_ext='.png', create_dir=False)
Player.walking_images[Player.INDEX_LEFT] = \
Player.loader.load_images(
fM.get_files(prefix_path=prefix_path))
if Player.walking_images[Player.INDEX_RIGHT] is None:
path = os.path.join(Player.WALKING_PATH, Player.WALKING_RIGHT_PATH)
prefix_path = os.path.join(
Player.PREFIX_PATH, Player.WALKING_RIGHT_PATH)
fM = FileManager(path, file_ext='.png', create_dir=False)
Player.walking_images[Player.INDEX_RIGHT] = \
Player.loader.load_images(
fM.get_files(prefix_path=prefix_path))
if Player.punching_images[Player.INDEX_DOWN] is None:
path = os.path.join(Player.WALKING_PATH, Player.PUNCHING_DOWN_PATH)
prefix_path = os.path.join(
Player.PREFIX_PATH, Player.PUNCHING_DOWN_PATH)
fM = FileManager(path, file_ext='.png', create_dir=False)
Player.punching_images[Player.INDEX_DOWN] = \
Player.loader.load_images(
fM.get_files(prefix_path=prefix_path))
if Player.punching_images[Player.INDEX_UP] is None:
path = os.path.join(Player.WALKING_PATH, Player.PUNCHING_UP_PATH)
prefix_path = os.path.join(
Player.PREFIX_PATH, Player.PUNCHING_UP_PATH)
fM = FileManager(path, file_ext='.png', create_dir=False)
Player.punching_images[Player.INDEX_UP] = \
Player.loader.load_images(
fM.get_files(prefix_path=prefix_path))
if Player.punching_images[Player.INDEX_LEFT] is None:
path = os.path.join(Player.WALKING_PATH, Player.PUNCHING_LEFT_PATH)
prefix_path = os.path.join(
Player.PREFIX_PATH, Player.PUNCHING_LEFT_PATH)
fM = FileManager(path, file_ext='.png', create_dir=False)
Player.punching_images[Player.INDEX_LEFT] = \
Player.loader.load_images(
fM.get_files(prefix_path=prefix_path))
if Player.punching_images[Player.INDEX_RIGHT] is None:
path = os.path.join(
Player.WALKING_PATH, Player.PUNCHING_RIGHT_PATH)
prefix_path = os.path.join(
Player.PREFIX_PATH, Player.PUNCHING_RIGHT_PATH)
fM = FileManager(path, file_ext='.png', create_dir=False)
Player.punching_images[Player.INDEX_RIGHT] = \
Player.loader.load_images(
fM.get_files(prefix_path=prefix_path))
if Player.hitSound is None:
Player.hitSound = Player.loader.load_sound(Player.SOUND_PATH)
if Player.attackSound is None:
Player.attackSound = Player.loader.load_sound(
Player.ATTACK_SOUND_PATH)
def setUp(self):
self.file_manager= FileManager()
self.current_path = os.getcwd()
from kivy.uix.button import Button
from kivy.uix.togglebutton import ToggleButton
from kivy.uix.scrollview import ScrollView
from kivy.base import runTouchApp
from kivy.uix.textinput import TextInput
from kivy.uix.screenmanager import ScreenManager, Screen, WipeTransition
from kivy.clock import Clock
from FileManager import FileManager
from Course_Item import Course_Item
from kivy.uix.dropdown import DropDown
from Proto3_5 import DragTab
#from dashNoKv import Dashboard
fm = FileManager()
catalog = fm.load_courses()
user = fm.load_user('ihill','crashcourse')
favorite_courses = []
search_temp_list = []
class TabTextInput(TextInput):
def __init__(self, *args, **kwargs):
self.next = kwargs.pop('next', None)
super(TabTextInput, self).__init__(*args, **kwargs)
def set_next(self, next):
#"必要な要素のインデックス取得"
id_num = attr.index('_N')
title_num = attr.index('TI')
abst_num = attr.index('AB')
doc = []
#"各行での結合"
for line in input_data[1:]:
tmp = line[id_num] + '\t' + line[title_num] + '\t' + line[abst_num]
doc.append(tmp)
return doc
#"メイン関数"
if __name__ == "__main__":
tsvfile = TSVDIR + "mission.facet.2.tsv"
fm = FileManager()
f = fm.readFile(tsvfile, '\t')
#"関数の呼び出し、結合した情報の取得"
texts = merge_doc(f)
#"作成したtextsの中身確認"
print texts[0]
print texts[1]
