def next(): reader = Directory().reader("club") entry = reader.search()[0].entry_writable() result = entry.neatNextUidNumber.value entry.neatNextUidNumber = result + 1 entry.entry_commit_changes() return result
def getInfoDir(dirPath): out = subprocess.Popen(['stat', dirPath], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) stdout, stderr = out.communicate() res = stdout.decode("utf-8") attrs = res.split() permission = attrs[2] dirNode = int(attrs[3]) dirOwner = attrs[4] groupOwner = attrs[5] dirSize = int(attrs[7]) dirName = attrs[-1].split("/")[-1] date = formatDate(res) dir = Directory(dirPath, dirName, permission, dirOwner, groupOwner, dirSize, dirNode, date) subout = subprocess.Popen(['ls', '-lh', dirPath], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) substdout, substderr = subout.communicate() if len(substdout) == 0: return dir subres = substdout.decode("utf-8").splitlines(True) for sub in subres: subAttrs = sub.split() if subAttrs[0].startswith('d'): dir.addDirSub(subAttrs[-1]) return dir
def _list_inventory(self): d = Directory(self.nodes_uri) entities = {} def register_fn(dirpath, filenames): for f in filter(lambda f: f.endswith(FILE_EXTENSION), filenames): name = f[:-len(FILE_EXTENSION)] nodeinfo = self.nodeinfo(name) entities[name] = nodeinfo d.walk(register_fn) applications = {} classes = {} for f, nodeinfo in entities.iteritems(): for a in nodeinfo['applications']: if a in applications: applications[a].append(f) else: applications[a] = [f] for c in nodeinfo['classes']: if c in classes: classes[c].append(f) else: classes[c] = [f] return entities, applications, classes
def backup_directories(directories_to_backup): """ Backs up all the directories which have been selected for backup. """ count = 1 for d in config.DIRECTORIES: directory = Directory(d) if directory.name in directories_to_backup: print_header("Backing up directory %s of %s: %s" % (str(count), len(directories_to_backup), directory.name)) if device.has_space: directory.backup() else: print "Not enough space on %s to update %s." % (device.name, directory.name) log(" %s:" % directory.name) log(" copied: False") count += 1 else: log(" %s:" % directory.name) log(" copied: False") # Add a blank line below this backup event's log event to seperate it # from the next one. log("")
def sync(fp_source, fp_target, create_copy): bk = BookKeeper() lst_synced = bk.read() lst_source = Directory(fp_source) lst_target = Directory(fp_target) count = 0 what = 'copied' if create_copy else 'moved' for source in lst_source: if source not in lst_synced and source not in lst_target: full_source = os.path.join(lst_source.path, source) full_target = os.path.join(lst_target.path, source) if create_copy: shutil.copy(full_source, full_target) else: shutil.move(full_source, full_target) bk.write(source) count += 1 logging.debug('{}: {} {}'.format(lst_source.path, what, source)) else: if source in lst_synced: logging.debug('{}: {} already synced'.format( lst_source.path, source)) if source in lst_target: logging.debug('{}: {} at target location'.format( lst_source.path, source)) logging.info('{} {} of {} files from {} to {}.'.format( what, count, len(lst_source), lst_source.path, lst_target.path))
def get_entries(self, rel_path=None): root = Directory(self.directory.join(rel_path)) entries = {} for song in self.songs: if song.directory.name.startswith(root.name): rel_depth = song.directory.get_depth() - \ root.get_depth() rel_path = song.directory.get_layer(root.name, 0) if rel_depth > 1:# and not rel_path in entries: if rel_path not in entries: entries[rel_path] = DirectoryEntry(\ parent=self.parent_widget, name=rel_path, \ start_screen=self.sing_screen, \ player=self.player, song_manager=self ) if isinstance(entries[rel_path], DirectoryEntry): entries[rel_path].entries.append(song) elif rel_depth == 1: entries[rel_path] = SongEntry(\ parent = self.parent_widget, song = song, \ start_screen = self.sing_screen, \ player = self.player, song_manager=self, start_button_text=self.parent_widget.song_start_text ) return entries
class Protocol: def __init__(self): self.directory = Directory() def proses(self, json_to_process): obj = json.loads(json_to_process) pkt = {} try: command = obj['cmd'] if command == 'list': pkt['list'] = self.directory.get_list() res = 'OK' elif command == 'get': filename = obj['filename'] ret, binary = self.directory.get_file(filename) content = binary.decode() pkt['content'] = content res = 'OK' if ret else 'ERRNF' elif command == 'put': filename = obj['filename'] raw_content = obj['content'] content = raw_content.encode() ret = self.directory.put_file(filename, content) res = 'OK' if ret else 'ERRDUP' else: res = 'ERRCMD' except: res = 'ERROR' finally: pkt['res'] = res return json.dumps(pkt)
def test_load(self): self.dir.add_contact("pepe", "*****@*****.**", "27", "Mexico") self.dir.add_contact("juan", "*****@*****.**", "27", "Mexico") self.dir.add_contact("oscar", "*****@*****.**", "29", "Mexico") self.dir.save() dir2 = Directory(self.file) self.assertEqual(self.dir.search_by_email("*****@*****.**"), dir2.search_by_email("*****@*****.**"))
def __init__(self, input_=None, output_=None): if input_ is None: input_ = Directory(path_="../resource/wakachi/", default_extension_=".meishi.wakachi") if output_ is None: output_ = Directory(path_="../resource/imporwords/", default_extension_=".uniq.csv") super().__init__(input_.path, output_.path, input_.default_extension, output_.default_extension)
def setResolvedUrl(handle, succeeded, listitem): log.debug('setResolvedUrl: {}'.format(listitem._path)) directory = Directory() directory.path = Route.current_explored_route.path item = Item() item.url = listitem._path item.listitem = listitem item.is_folder = False directory.items[1] = item Directory.current_directory = directory
def create_directory(self, directory, name, attrib=0x10): if name in [e.name() for e in directory.entries]: print(name, " already exists in directory") return None cluster = self.next_free_cluster() filename, extension = short_filename(name, directory) if name == filename.strip() + ('.' + extension.strip()) if len( extension.strip()) != 0 else '': name = '' today = datetime.datetime.today() milliseconds = today.microsecond // 10000 + (today.second % 2) * 100 entry = Entry(filename, extension, Attrib(attrib), 0x00, milliseconds, today.time(), today.date(), today.date(), today.time(), today.date(), cluster, 0, name) directory.write(entry) self.current_directory.read_from_disk() self.write_to_fat(cluster, 0x0FFFFFFF) new_directory = Directory(self, cluster) self_entry = Entry(". ", " ", Attrib(0x10), 0x00, milliseconds, today.time(), today.date(), today.date(), today.time(), today.date(), cluster, 0, '') new_directory.write(self_entry) new_directory.read_from_disk() up_entry = Entry(".. ", " ", Attrib(0x10), 0x00, milliseconds, today.time(), today.date(), today.date(), today.time(), today.date(), directory.first_cluster, 0, '') new_directory.write(up_entry)
def testcase1(self): rootFolder = Directory() folderNames = '/home/gcj/finals' rootFolder.addDirectory(folderNames.split('/')[1:]) self.assertEqual(3, rootFolder.size()) folderNames = '/home/gcj/quals' rootFolder.addDirectory(folderNames.split('/')[1:]) self.assertEqual(4, rootFolder.size())
def _enumerate_inventory(self, basedir, duplicate_handler=None): ret = {} def register_fn(dirpath, filenames): filenames = fnmatch.filter(filenames, '*{0}'.format(self._file_extension)) vvv('REGISTER {0} in path {1}'.format(filenames, dirpath)) for f in filenames: name = os.path.splitext(f)[0] uri = os.path.join(dirpath, f) if name in ret and callable(duplicate_handler): duplicate_handler(name, os.path.join(basedir, ret[name]), uri) ret[name] = os.path.relpath(uri, basedir) d = Directory(basedir) d.walk(register_fn) return ret
def _download(self, content): cwd = os.getcwd() os.chdir(self._working_dir) for multihash in content.keys(): self._ipfs_client.get(multihash) for multihash in os.listdir(self._working_dir): name = base64.b64decode(content[multihash]).decode() os.rename(multihash, name) full_path = os.path.join(self._working_dir, name) self._content.add(full_path, multihash) if os.path.isfile(full_path): File(full_path).decrypt_content(cipher=self._cipher, dst_dir=self._root_dir) time.sleep(0.1) os.remove(full_path) elif os.path.isdir(full_path): Directory(full_path).decrypt_content(cipher=self._cipher, dst_dir=self._root_dir) time.sleep(0.1) shutil.rmtree(full_path) os.chdir(cwd)
def start_server(ip, port): server = SimpleXMLRPCServer((ip, port)) PYTHON_LOGGER.info("Server listen at adresse {} port {}".format(ip, port)) server.register_function(Directory(), "directory_class") server.serve_forever() PYTHON_LOGGER.info("Server stop")
def __init__(self, name): self.lock = threading.Lock() self.name = name self.config = None self.cache_layer = {} self.c_nodes = 0 self.links = {} self.env = None self.compute_nodes = 0 self.mapper_list = {} self.cpu = 0 self.placement = None self.logger = None self.blk_dir = Directory('blk_dir') #block directory self.jobStat = JobStat() self.hash_ring = None self.nic_count = 0 self.scheduler = None self.repType = 'rep' self.repCount = 3 self.ec = [] self.rep_size = 4 self.chunk_size = 4 self.osdMap = None self.dl_access = 0 self.outstanding_req = {}
def _parse_entry_table(self) -> (List[Firmware], List[Directory]): entries = chunker(self.firmware_entry_table[4:], 4) for index, entry in enumerate(entries): firmware_type = self._FIRMWARE_ENTRY_TYPES[index] if index < len( self._FIRMWARE_ENTRY_TYPES) else 'unknown' address = struct.unpack('<I', entry)[0] & 0x00FFFFFF # assumption: offset == 0 is an invalid entry if address not in [0x0, 0xfffffe]: directory = self[address:address + 16 * 8] magic = directory[:4] # either this entry points to a PSP directory directly if magic in [b'$PSP', b'$BHD']: directory = Directory(self, address, firmware_type) self.directories.append(directory) # if this Directory points to a secondary directory: add it, too if directory.secondary_directory_address is not None: secondary_directory = Directory( self, directory.secondary_directory_address, 'secondary') self.directories.append(secondary_directory) # or this entry points to a combo-directory (i.e. two directories) elif magic == b'2PSP': psp_dir_one_addr = struct.unpack( '<I', directory[10 * 4:10 * 4 + 4])[0] & 0x00FFFFFF psp_dir_two_addr = struct.unpack( '<I', directory[14 * 4:14 * 4 + 4])[0] & 0x00FFFFFF for address in [psp_dir_one_addr, psp_dir_two_addr]: directory = Directory(self, address, firmware_type) self.directories.append(directory) # if this Directory points to a secondary directory: add it, too if directory.secondary_directory_address is not None: secondary_directory = Directory( self, directory.secondary_directory_address, 'secondary') self.directories.append(secondary_directory) # or this entry is unparsable and thus a firmware else: firmware = Firmware(self, address, firmware_type, magic) self.firmwares.append(firmware)
class IOManager(ABC): """ファイルを生成するクラスの抽象クラス""" def __init__(self, input_dir_path_, output_dir_path_, input_extension_, output_extension_): self.input = Directory(input_dir_path_, input_extension_) self.output = Directory(output_dir_path_, output_extension_) self.import_io_files() @abstractmethod def generate(self): """何かを生成する為の抽象メソッド""" pass def import_io_files(self): """ディレクトリにファイルを登録する""" self.input.import_files() self.output.import_files()
def __init__(self, path, rootdirectory=None, flags=None): assert type(path) is list self.__path = path if rootdirectory is None: self.__rootdirectory = Directory() else: self.__rootdirectory = rootdirectory pass self.__rootdirectory.set_filesystem(self) if flags is None: self.__flags = set() else: self.__flags = flags pass pass
def _enumerate_inventory(self, basedir, duplicate_handler=None): ret = {} def register_fn(dirpath, filenames): filenames = fnmatch.filter(filenames, '*{0}'.format(FILE_EXTENSION)) vvv('REGISTER {0} in path {1}'.format(filenames, dirpath)) for f in filenames: name = os.path.splitext(f)[0] uri = os.path.join(dirpath, f) if name in ret and callable(duplicate_handler): duplicate_handler(name, os.path.join(basedir, ret[name]), uri) ret[name] = os.path.relpath(uri, basedir) d = Directory(basedir) d.walk(register_fn) return ret
def addDirectoryItems(handle, items_qd, totalItems=0): log.debug('addDirectoryItems of {} items'.format(totalItems)) directory = Directory() directory.path = Route.current_explored_route.path cnt = 0 for item_cq in items_qd: item = Item() cnt += 1 item.url = item_cq[0] item.listitem = item_cq[1] item.is_folder = item_cq[2] item.key = cnt directory.items[cnt] = item Directory.current_directory = directory return True
def __init__(self, input_path="./resource/", output_path="./resource/testsuite/", learn_result_=None, units_=None): """初期化""" super().__init__(input_path, output_path, ".txt", ".testsuite.csv") self.vocab = {} self.vocab_n = 0 self.vocab_i = {} self.units = units_ self.learn_model = None self.learn_result = learn_result_ self.length = 30 self.imporwords = Directory(self.input.path + "imporwords/", ".imporword.csv") self.imporwords.import_files() np.random.seed(np.random.randint(1, 1000)) chainer.config.train = False # 学習中ではないことを明示
def getPaths(self): dirs = [] with open(self.__file_path, 'r') as json_file: data = json.load(json_file) if data['directories'] is not None and len( data['directories']) > 0: for data_dir in data['directories']: directory = Directory(dictionary=data_dir) dirs.append(directory) return dirs
def getFolderSizeHelper(folder, dirList, currDir, nested): for item in os.scandir(folder): if item.is_file(): currDir.size+=item.stat().st_size elif item.is_dir(): subDir = Directory(item.path[(item.path).rfind('/'):], (nested + 1)) currDir.size += getFolderSizeHelper(item.path, dirList, subDir, subDir.size) dirList.append(currDir) return currDir.size
def get_last_backup(self): dirs = (x for x in sorted((Directory(date=x, path=self.mount_point) for x in os.listdir(self.mount_point) if is_date(date=x, time_format=TIME_FORMAT)), reverse=True)) try: return next(dirs) except StopIteration: return None
def addRoot(my_user): directory_id = my_user.key.id() + '/' directory = Directory(id=directory_id) directory.name = 'root' directory.parent = None directory.path = '/' directory.put() my_user.root = directory.key my_user.put()
def main(): # Get configuration config = Config( (ConfigOption('LDAP_URL', '--ldap-host'), ConfigOption('LDAP_DN', '--ldap-dn'), ConfigOption('LDAP_PASSWORD', '--ldap-password'), ConfigOption('LDAP_USERS', '--ldap-users'), ConfigOption('LDAP_GROUPS', '--ldap-groups'), ConfigOption('LDAP_USER_FILTER', '--ldap-user-filter'), ConfigOption('GITLAB_URL', '--gitlab-url'), ConfigOption('GITLAB_TOKEN', '--gitlab-token'), ConfigOption('GITLAB_PARENT', '--gitlab-parent'))).get() # Initialize Gitlab and LDAP objects directory = Directory(config['LDAP_URL'], config['LDAP_DN'], config['LDAP_PASSWORD']) gitlab = Gitlab(config['GITLAB_URL'], private_token=config['GITLAB_TOKEN']) users_by_group = {} # Create missing groups ldap_groups = directory.get_groups(config['LDAP_GROUPS']) for dn, attrs in ldap_groups: group_name = attrs['cn'][0].decode() if group_name.startswith('gitlab-') and group_name != 'gitlab-users': create_group_if_missing(gitlab, dn, attrs, config['GITLAB_PARENT']) users_by_group[group_name] = directory.get_member_uids( config['LDAP_USERS'], dn) # Create missing users ldap_users = directory.get_users(config['LDAP_USERS'], config['LDAP_USER_FILTER']) for dn, attrs in ldap_users: uid = attrs['uid'][0].decode() gitlab_user = gitlab.users.list(username=uid) if not gitlab_user: create_user(gitlab, dn, attrs) sync_group_membership(gitlab, users_by_group)
def free_space(self, force_clean=False): if LOGLEVEL > 0: if force_clean is False and not self.has_space(): print( "Disk at {} has no space left:{}deleting some old backups..." .format(self.mount_point, os.linesep)) elif force_clean is True: print("Force clean on disk {}:{}deleting all old backups...". format(self.mount_point, os.linesep)) dirs = (x for x in sorted( Directory(date=x, path=self.mount_point) for x in os.listdir(self.mount_point) if is_date(date=x, time_format=TIME_FORMAT))) try: previous_backup = next(dirs) for tmp_dir in dirs: if not force_clean and self.has_space(): break else: if tmp_dir.is_deletable(previous_dir=previous_backup): tmp_dir.remove() else: previous_backup = tmp_dir except StopIteration: pass if not self.has_space(): if LOGLEVEL > 0: print("No more useless backup: deleting from the oldest") dirs = (x for x in sorted((Directory(date=x, path=self.mount_point) for x in os.listdir(self.mount_point) if is_date(date=x, time_format=TIME_FORMAT)))) while not self.has_space(): try: next(dirs).remove() except StopIteration: print( "All backup removed but still not enough space. Aborting.") exit(1) if LOGLEVEL > 0: print("Cleanup finished.")
def _add_file(self, file_path, add_file=True): """A helper function to add a file or directory""" paths = file_path.split('/') curr = self._root for i, path in enumerate(paths): next = curr._children.get(path) if next is None: if i == len(path) - 1 and add_file: next = curr._children[path] = File(path) else: next = curr._children[path] = Directory(path) curr = next
def sync(fp_target, remove_synced=False): bk = BookKeeper() lst_synced = bk.read() target = Directory(fp_target) ad = AndroidDevice(lst_synced) ad.connect() ad.get_files_to_sync() lst_new = ad.sync(target=target, remove_synced=remove_synced) ad.disconnect() bk.write(lst_new)
def main(): d = Directory() folder = d.get_folder_from_user() folder_contents = d.get_folder_contents(folder) table_name = d.get_table_name() df = d.merge_all_tables(folder_contents, table_name) df.to_csv('../merged_tables.csv')
def add_root_dir(self, start_time): for path in os.listdir(self._root_dir_path): full_path = os.path.join(self._root_dir_path, path).replace(os.sep, '/') if os.path.getctime(full_path) >= start_time: continue if os.path.isfile(full_path): file = File(full_path) hash = self._ipfs_client.add_file(file) self._content.add(file.path, hash) elif os.path.isdir(full_path): content_list = self._ipfs_client.add_dir(Directory(full_path)) self._content.add_list(content_list) self._ipfs_cluster.pin(self._content[full_path])
def main(): directory = Directory() add_persons(directory) show_directory(directory) find_user(directory, "*****@*****.**", 62) find_user(directory, "*****@*****.**", 42) delete_user(directory, 2) show_directory(directory) save_directory(directory)
def _enumerate_inventory(self, basedir, name_mangler): ret = {} def register_fn(dirpath, filenames): filenames = fnmatch.filter(filenames, "*{0}".format(FILE_EXTENSION)) vvv("REGISTER {0} in path {1}".format(filenames, dirpath)) for f in filenames: name = os.path.splitext(f)[0] relpath = os.path.relpath(dirpath, basedir) if callable(name_mangler): relpath, name = name_mangler(relpath, name) uri = os.path.join(dirpath, f) if name in ret: E = reclass.errors.DuplicateNodeNameError raise E(self.name, name, os.path.join(basedir, ret[name]), uri) if relpath: f = os.path.join(relpath, f) ret[name] = f d = Directory(basedir) d.walk(register_fn) return ret
def _generate_topology(self, width=7, depth=7): if depth > 0: topology = list() for i in range(0, width): isFile = random.choice([True, False]) print(isFile) user_name = random.choice(self._users.keys()) print(user_name) name = ''.join(random.choice(string.lowercase) for _ in range(random.randint(7, 14))) print(name) if isFile: topology.append(File(user_name, name)) else: directory = Directory(user_name, name) directory_data = self._generate_topology(width=width, depth=depth-1) if directory_data: for accessible_object in directory_data: directory.write(accessible_object) topology.append(directory) return topology return None
def add_root_directory(my_user): directory_id = my_user.key.id() + '/' directory = Directory(id=directory_id) directory.parent_directory = None directory.name = 'root' directory.path = '/' directory.put() my_user.root_directory = directory.key my_user.put()
def addDirectory(self, path, recursively = True, followSymLinks = False, forceUpdate = False): if path[-1] != u'/': path += u'/' dirObj = self.store.find(Directory, Directory.path == path).any() if dirObj is None: dirObj = Directory() dirObj.path = path dirObj.recursively = recursively dirObj.followSymLinks = followSymLinks self.store.add(dirObj) return dirObj, True else: dirObj.recursively = recursively dirObj.followSymLinks = followSymLinks if forceUpdate: dirObj.lastScan = 0 return dirObj, False
def add_directory(name, parent_directory_key): my_user = get_my_user() parent_directory_object = parent_directory_key.get() path = get_path(name, parent_directory_object) directory_id = my_user.key.id() + path directory = Directory(id=directory_id) # check if directory already exists in this path if exists(directory.key, parent_directory_object.directories): # Add key to parent directory parent_directory_object.directories.append(directory.key) parent_directory_object.put() # Set all attributes of the directory and save it to datastore directory.parent_directory = parent_directory_key directory.name = name directory.path = path directory.put()
def buildLevel(self): """ KEY FOR LEVELS P = Platform C = player starting position A = Spike (Up) - 1 V = Spike (Down) - 2 > = Spike (Right) - 3 < = Spike (Left) - 4 K = Key X = Trophy T = Door Top B = Door Bottom O = Coin """ level = open(Directory.getDirectory() + '/levels/level' + str(self.level) + '.txt', 'r') for row in level: for col in row: if col.isdigit() and self.loadedCoins == False: if int(col) > 0: self.loadedCoins = True self.levelCoins = int(col) else: self.loadedCoins = True self.levelCoins = 1 if col == "P": p = Platform(self.x, self.y) # Place a platform at the given x,y self.platforms.insert(0, p) # Insert it into the platforms list self.entities.add(p) # Add to entities so it appears on screen if col == "C": self.charX = self.x # The character x found from file loading self.charY = self.y # The character y found from file loading self.player = Player(self.charX, self.charY) # Set the player along with the x,y of the starting position if col == "A": spike = Spike(self.x, self.y, 1) # Load a spike at the x,y found self.entities.add(spike) # Add the spike to the entities self.spikes.add(spike) # Add the spike to the spike sprite group for collison purposes if col == "V": spike = Spike(self.x, self.y, 2) # Load a spike at the x,y found self.entities.add(spike) # Add the spike to the entities self.spikes.add(spike) # Add the spike to the spike sprite group for collison purposes if col == ">": spike = Spike(self.x, self.y, 3) # Load a spike at the x,y found self.entities.add(spike) # Add the spike to the entities self.spikes.add(spike) # Add the spike to the spike sprite group for collison purposes if col == "<": spike = Spike(self.x, self.y, 4) # Load a spike at the x,y found self.entities.add(spike) # Add the spike to the entities self.spikes.add(spike) # Add the spike to the spike sprite group for collison purposes if col == "O": coin = Coins(self.x, self.y) # Load a coin image at the given x,y self.entities.add(coin) # Coin 1 to the entities self.coin.add(coin) # add coin 1 to the coinA sprite group if col == "X": try: win_object = Trophy(self.x, self.y, self.level) # Load the proper trophy by passing the level to the trophy class and load at the given x,y from file loading self.entities.add(win_object) # Add the trophy to the entities so it appears self.trophies.add(win_object) # Also make it a trophy sprite for collision detection purposes except: win_object = Trophy(self.x, self.y, 0) self.entities.add(win_object) # Add the trophy to the entities so it appears self.trophies.add(win_object) # Also make it a trophy sprite for collision detection purposes if col == "T": self.doorA = Door(self.x, self.y) self.platforms.append(self.doorA) # Make the door top a platform so the player cannot walk through it self.entities.add(self.doorA) # Add the door bottom to the entities if col == "B": self.doorB = Door(self.x, self.y) self.platforms.append(self.doorB) # Make the door bottom a platform so the player cannot walk through it self.entities.add(self.doorB) # Add the door bottom to entities self.x += 32 self.y += 32 self.x = 0 # Try loading in the level image and theme; if it fails, use level 0 theme and background try: self.background = pygame.image.load(Directory.getDirectory() + '/images/backgrounds/background' + str(self.level) + '.png').convert_alpha() self.background_rect = self.background.get_rect() except: self.background = pygame.image.load(Directory.getDirectory() + '/images/backgrounds/background0.png').convert_alpha() self.background_rect = self.background.get_rect()
from directory import Directory main = Directory(0) Directory.start_the_story(main)
def main(): try: print('Making root entries...') rootdir = Directory('root') bindir = Directory('bin') tmpdir = Directory('tmp') usrdir = Directory('usr') rootdir.add(bindir) rootdir.add(tmpdir) rootdir.add(usrdir) bindir.add(MyFile('vi', 10000)) bindir.add(MyFile('latex', 20000)) rootdir.accept(ListVisitor()) print('') print('Making user entries...') yuki = Directory('yuki') hanako = Directory('hanako') tomura = Directory('tomura') usrdir.add(yuki) usrdir.add(hanako) usrdir.add(tomura) yuki.add(MyFile('diary.html', 100)) yuki.add(MyFile('Composite.py', 200)) hanako.add(MyFile('memo.txt', 300)) tomura.add(MyFile('game.doc', 400)) tomura.add(MyFile('junk.mail', 500)) rootdir.accept(ListVisitor()) except FileTreatmentException as e: logging.exception('FileTreatmentException: {0}'.format(e))
class Viewer: def __init__(self,dir): self.dir = dir pygame.init() modes = pygame.display.list_modes() self.screen = pygame.display.set_mode(modes[0],pygame.FULLSCREEN) self.loc = Directory(dir) self.myfont = pygame.font.Font(join(dirname(realpath(__file__)),"verdana.ttf"),32) self.index = 0 self.list = [".."]+self.loc.listdir() self.collen = int((self.screen.get_size()[1]*1.0)/self.myfont.size(self.list[1])[1]) print "collen",self.collen,self.myfont.size(self.list[1])[1],self.screen.get_size()[1] self.draw_list() clock = pygame.time.Clock() while 1: clock.tick(5) for event in pygame.event.get(): if event.type is QUIT: return elif event.type is KEYDOWN: oldindex = self.index olddir = self.loc.path if event.key == K_ESCAPE: return elif event.key == K_DOWN or event.key == K_UP or event.key == K_LEFT or event.key == K_RIGHT: if event.key == K_DOWN or event.key == K_RIGHT: if event.key == K_DOWN: self.index +=1 else: # K_RIGHT self.index += self.collen if self.index>=len(self.list): while self.index>=self.collen: self.index -= self.collen if self.index>=len(self.list): self.index -= len(self.list) else: # K_UP or K_LEFT if event.key == K_UP: self.index = self.index - 1 else: self.index = self.index - self.collen if self.index<0: self.index = len(self.list)+self.index elif event.key == K_RETURN or event.key == K_BACKSPACE: if event.key == K_BACKSPACE: self.index = 0 if self.loc.isfile(self.list[self.index]): if self.list[self.index][-4:]=='.cbz' or self.list[self.index][-4:]=='.zip' or self.list[self.index][-4:]=='.cbr' or self.list[self.index][-4:] == ".rar": if self.list[self.index]!="..": self.loc.chdir(self.list[self.index]) self.list = [".."]+self.loc.listdir() self.index = 0 else: place = self.loc.path[-1] self.loc.chdir("..") self.list = [".."]+self.loc.listdir() self.index=0 for l in range(len(self.list)): if self.list[l]==place: self.index = l break else: self.index -=1 self.browser() self.list = [".."]+self.loc.listdir() self.index +=1 self.draw_list() else: if self.list[self.index]!="..": self.loc.chdir(self.list[self.index]) self.list = [".."]+self.loc.listdir() self.index = 0 else: place = [x for x in self.loc.path.split(os.sep) if x!=""][-1] print "dir",self.loc.path#,Directory.sep.findall(self.loc.path) self.loc.chdir("..") self.list = [".."]+self.loc.listdir() self.index=0 print "looking for",place for l in range(len(self.list)): print self.list[l] if self.list[l]==place: self.index = l break elif event.key == K_END: self.index = len(self.list)-1 elif event.key == K_HOME: self.index = 0 elif event.key == K_DELETE: self.loc.delete(self.list[self.index]) self.loc.clear_dir() self.list = [".."]+self.loc.listdir() if self.index == len(self.list): self.index -=1 self.draw_list() elif event.key == K_r: self.list = [".."]+self.loc.listdir() self.draw_list() else: print "No binding for "+str(pygame.key.name(event.key)) if oldindex!=self.index or self.loc.path!=olddir: self.draw_list() def draw_list(self): self.screen.fill((0,0,0)) try: height = self.myfont.size(self.list[1])[1] except IndexError: height=20 except: print "list",self.list raise y = 0 min_x = 20 x = min_x max_x = 0 for f in self.list: if self.myfont.size(f)[0]>max_x: max_x = self.myfont.size(f)[0] firstdraw = 0 width = self.screen.get_size()[0] while self.index-firstdraw>self.collen*int(width/(max_x*1.0)): if firstdraw+self.collen>self.index: break firstdraw += self.collen for i in range(firstdraw, len(self.list)): f = self.list[i] if not self.loc.isfile(f): f = "["+f+"]" if y == self.collen: y = 0 x += max_x+min_x if x > width: break if self.index == i: self.screen.blit(self.myfont.render(f,True,(255,255,255),(255,0,0)),(x,y*height)) else: self.screen.blit(self.myfont.render(f,True,(255,255,255)),(x,y*height)) y += 1 pygame.display.flip() def browser(self): image = self.get_image(self.loc.listdir()[self.index]) pygame.display.flip() while 1: for event in pygame.event.get(): if event.type is QUIT: return elif event.type is KEYDOWN: if event.key == K_ESCAPE or event.key == K_BACKSPACE: return elif event.key in [K_PAGEDOWN, K_RIGHT, K_DOWN, K_PAGEUP, K_LEFT, K_UP]: if event.key in [K_PAGEDOWN, K_RIGHT, K_DOWN]: self.index = self.index + 1 if self.index>len(self.loc.listdir())-1: self.index = len(self.loc.listdir())-1 else: self.index = self.index - 1 if self.index<0: self.index = 0 image = self.get_image(self.loc.listdir()[self.index]) pygame.display.flip() else: print "No binding for "+str(pygame.key.name(event.key)) def get_image(self,filename): try: print filename f = self.loc.open(filename) print f image = pygame.image.load(f,filename).convert() r=[0,0] for i in range(2): r[i] = self.screen.get_size()[i]/(image.get_size()[i]*1.0) if r[0]>r[1]: ratio = r[1] else: ratio = r[0] scr = (self.screen.get_size()[0]/(self.screen.get_size()[1]*1.0)) imr = (image.get_size()[0]/(image.get_size()[1]*1.0)) print "imr",scr,imr if imr<1.0: print "small ratio",ratio image = pygame.transform.rotate(image,90) for i in range(2): r[i] = self.screen.get_size()[i]/(image.get_size()[i]*1.0) if r[0]>r[1]: ratio = r[1] else: ratio = r[0] print ratio,scr,image.get_size(),(image.get_size()[0]*ratio,image.get_size()[1]*ratio),self.screen.get_size() image = pygame.transform.smoothscale(image,(image.get_size()[0]*ratio,image.get_size()[1]*ratio)) self.screen.fill((0,0,0)) self.screen.blit(image, ((self.screen.get_size()[0]-image.get_size()[0])/2, (self.screen.get_size()[1]-image.get_size()[1])/2)) return image except pygame.error, message: if str(message) == "Unsupported image format": return None else: print "\""+str(message)+"\"" raise
def __init__(self,dir): self.dir = dir pygame.init() modes = pygame.display.list_modes() self.screen = pygame.display.set_mode(modes[0],pygame.FULLSCREEN) self.loc = Directory(dir) self.myfont = pygame.font.Font(join(dirname(realpath(__file__)),"verdana.ttf"),32) self.index = 0 self.list = [".."]+self.loc.listdir() self.collen = int((self.screen.get_size()[1]*1.0)/self.myfont.size(self.list[1])[1]) print "collen",self.collen,self.myfont.size(self.list[1])[1],self.screen.get_size()[1] self.draw_list() clock = pygame.time.Clock() while 1: clock.tick(5) for event in pygame.event.get(): if event.type is QUIT: return elif event.type is KEYDOWN: oldindex = self.index olddir = self.loc.path if event.key == K_ESCAPE: return elif event.key == K_DOWN or event.key == K_UP or event.key == K_LEFT or event.key == K_RIGHT: if event.key == K_DOWN or event.key == K_RIGHT: if event.key == K_DOWN: self.index +=1 else: # K_RIGHT self.index += self.collen if self.index>=len(self.list): while self.index>=self.collen: self.index -= self.collen if self.index>=len(self.list): self.index -= len(self.list) else: # K_UP or K_LEFT if event.key == K_UP: self.index = self.index - 1 else: self.index = self.index - self.collen if self.index<0: self.index = len(self.list)+self.index elif event.key == K_RETURN or event.key == K_BACKSPACE: if event.key == K_BACKSPACE: self.index = 0 if self.loc.isfile(self.list[self.index]): if self.list[self.index][-4:]=='.cbz' or self.list[self.index][-4:]=='.zip' or self.list[self.index][-4:]=='.cbr' or self.list[self.index][-4:] == ".rar": if self.list[self.index]!="..": self.loc.chdir(self.list[self.index]) self.list = [".."]+self.loc.listdir() self.index = 0 else: place = self.loc.path[-1] self.loc.chdir("..") self.list = [".."]+self.loc.listdir() self.index=0 for l in range(len(self.list)): if self.list[l]==place: self.index = l break else: self.index -=1 self.browser() self.list = [".."]+self.loc.listdir() self.index +=1 self.draw_list() else: if self.list[self.index]!="..": self.loc.chdir(self.list[self.index]) self.list = [".."]+self.loc.listdir() self.index = 0 else: place = [x for x in self.loc.path.split(os.sep) if x!=""][-1] print "dir",self.loc.path#,Directory.sep.findall(self.loc.path) self.loc.chdir("..") self.list = [".."]+self.loc.listdir() self.index=0 print "looking for",place for l in range(len(self.list)): print self.list[l] if self.list[l]==place: self.index = l break elif event.key == K_END: self.index = len(self.list)-1 elif event.key == K_HOME: self.index = 0 elif event.key == K_DELETE: self.loc.delete(self.list[self.index]) self.loc.clear_dir() self.list = [".."]+self.loc.listdir() if self.index == len(self.list): self.index -=1 self.draw_list() elif event.key == K_r: self.list = [".."]+self.loc.listdir() self.draw_list() else: print "No binding for "+str(pygame.key.name(event.key)) if oldindex!=self.index or self.loc.path!=olddir: self.draw_list()