Lines Matching full:self
29 def __init__(self, data: bytes): argument
31 self.partition_table = []
34 self.partition_table.append(
51 def __str__(self): argument
55 for i, partition in enumerate(self.partition_table)
62 def __init__(self, data: bytes): argument
64 self.bytes_per_sector = int.from_bytes(data[11:13], "little")
65 self.sectors_per_cluster = data[13]
66 self.reserved_sectors = int.from_bytes(data[14:16], "little")
67 self.fat_count = data[16]
68 self.root_entries = int.from_bytes(data[17:19], "little")
70 self.media_descriptor = data[21]
71 self.sectors_per_fat = int.from_bytes(data[22:24], "little")
72 self.sectors_per_track = int.from_bytes(data[24:26], "little")
73 self.heads = int.from_bytes(data[26:28], "little")
74 self.hidden_sectors = int.from_bytes(data[28:32], "little")
79 self.total_sectors = total_sectors_16 or total_sectors_32
80 self.drive_number = data[36]
81 self.volume_id = int.from_bytes(data[39:43], "little")
82 self.volume_label = data[43:54].decode("ascii").strip()
83 self.fs_type = data[54:62].decode("ascii").strip()
85 def root_dir_start(self): argument
89 return self.reserved_sectors + self.fat_count * self.sectors_per_fat
91 def root_dir_size(self): argument
96 self.root_entries * DIRENTRY_SIZE + self.bytes_per_sector - 1
97 ) // self.bytes_per_sector
99 def data_sector_start(self): argument
103 return self.root_dir_start() + self.root_dir_size()
105 def first_sector_of_cluster(self, cluster: int) -> int: argument
110 self.data_sector_start() + (cluster - 2) * self.sectors_per_cluster
113 def cluster_bytes(self): argument
117 return self.bytes_per_sector * self.sectors_per_cluster
119 def __str__(self): argument
121 f"Bytes per sector: {self.bytes_per_sector}\n"
122 f"Sectors per cluster: {self.sectors_per_cluster}\n"
123 f"Reserved sectors: {self.reserved_sectors}\n"
124 f"FAT count: {self.fat_count}\n"
125 f"Root entries: {self.root_entries}\n"
126 f"Total sectors: {self.total_sectors}\n"
127 f"Media descriptor: {self.media_descriptor}\n"
128 f"Sectors per FAT: {self.sectors_per_fat}\n"
129 f"Sectors per track: {self.sectors_per_track}\n"
130 f"Heads: {self.heads}\n"
131 f"Hidden sectors: {self.hidden_sectors}\n"
132 f"Drive number: {self.drive_number}\n"
133 f"Volume ID: {self.volume_id}\n"
134 f"Volume label: {self.volume_label}\n"
135 f"FS type: {self.fs_type}\n"
141 def __init__(self, data: bytes, sector: int, offset: int): argument
142 self.name = data[0:8].decode("ascii").strip()
143 self.ext = data[8:11].decode("ascii").strip()
144 self.attributes = data[11]
145 self.reserved = data[12]
146 self.create_time_tenth = data[13]
147 self.create_time = int.from_bytes(data[14:16], "little")
148 self.create_date = int.from_bytes(data[16:18], "little")
149 self.last_access_date = int.from_bytes(data[18:20], "little")
151 self.last_mod_time = int.from_bytes(data[22:24], "little")
152 self.last_mod_date = int.from_bytes(data[24:26], "little")
154 self.cluster = (high_cluster << 16) | low_cluster
155 self.size_bytes = int.from_bytes(data[28:32], "little")
158 self.sector = sector
159 self.offset = offset
161 def as_bytes(self) -> bytes: argument
163 self.name.ljust(8, " ").encode("ascii")
164 + self.ext.ljust(3, " ").encode("ascii")
165 + self.attributes.to_bytes(1, "little")
166 + self.reserved.to_bytes(1, "little")
167 + self.create_time_tenth.to_bytes(1, "little")
168 + self.create_time.to_bytes(2, "little")
169 + self.create_date.to_bytes(2, "little")
170 + self.last_access_date.to_bytes(2, "little")
171 + (self.cluster >> 16).to_bytes(2, "little")
172 + self.last_mod_time.to_bytes(2, "little")
173 + self.last_mod_date.to_bytes(2, "little")
174 + (self.cluster & 0xFFFF).to_bytes(2, "little")
175 + self.size_bytes.to_bytes(4, "little")
178 def whole_name(self): argument
179 if self.ext:
180 return f"{self.name}.{self.ext}"
182 return self.name
184 def __str__(self): argument
186 f"Name: {self.name}\n"
187 f"Ext: {self.ext}\n"
188 f"Attributes: {self.attributes}\n"
189 f"Reserved: {self.reserved}\n"
190 f"Create time tenth: {self.create_time_tenth}\n"
191 f"Create time: {self.create_time}\n"
192 f"Create date: {self.create_date}\n"
193 f"Last access date: {self.last_access_date}\n"
194 f"Last mod time: {self.last_mod_time}\n"
195 f"Last mod date: {self.last_mod_date}\n"
196 f"Cluster: {self.cluster}\n"
197 f"Size: {self.size_bytes}\n"
200 def __repr__(self): argument
202 return str(vars(self))
206 def __call__(self, start_sector: int, num_sectors: int = 1) -> bytes: ... argument
211 self, argument
217 self.start_sector = start_sector
218 self.size_in_sectors = size
219 self.sector_reader = sector_reader
220 self.sector_writer = sector_writer
222 self.boot_sector = FatBootSector(self.sector_reader(start_sector, 1))
225 self.boot_sector.sectors_per_fat * self.boot_sector.fat_count
227 self.fats = self.read_sectors(
228 self.boot_sector.reserved_sectors, fat_size_in_sectors
230 self.fats_dirty_sectors: Set[int] = set()
232 def read_sectors(self, start_sector: int, num_sectors: int) -> bytes: argument
233 return self.sector_reader(start_sector + self.start_sector,
236 def write_sectors(self, start_sector: int, data: bytes) -> None: argument
237 return self.sector_writer(start_sector + self.start_sector, data)
240 self, data: bytes, start_sector: int argument
271 def read_root_directory(self) -> List[FatDirectoryEntry]: argument
272 root_dir = self.read_sectors(
273 self.boot_sector.root_dir_start(), self.boot_sector.root_dir_size()
275 return self.directory_from_bytes(
276 root_dir, self.boot_sector.root_dir_start()
279 def read_fat_entry(self, cluster: int) -> int: argument
284 return int.from_bytes(self.fats[fat_offset : fat_offset + 2], "little")
286 def write_fat_entry(self, cluster: int, value: int) -> None: argument
291 self.fats = (
292 self.fats[:fat_offset]
294 + self.fats[fat_offset + 2 :]
296 self.fats_dirty_sectors.add(fat_offset // SECTOR_SIZE)
298 def flush_fats(self) -> None: argument
302 for sector in self.fats_dirty_sectors:
303 data = self.fats[sector * SECTOR_SIZE : (sector + 1) * SECTOR_SIZE]
304 sector = self.boot_sector.reserved_sectors + sector
305 self.write_sectors(sector, data)
306 self.fats_dirty_sectors = set()
308 def next_cluster(self, cluster: int) -> Optional[int]: argument
315 fat_entry = self.read_fat_entry(cluster)
327 def next_free_cluster(self) -> int: argument
333 if self.read_fat_entry(i) == 0:
337 def next_free_cluster_non_continuous(self) -> int: argument
345 if self.read_fat_entry(i) == 0:
346 if before and self.read_fat_entry(i + 1) == 0:
355 def read_cluster(self, cluster: int) -> bytes: argument
359 return self.read_sectors(
360 self.boot_sector.first_sector_of_cluster(cluster),
361 self.boot_sector.sectors_per_cluster,
364 def write_cluster(self, cluster: int, data: bytes) -> None: argument
368 assert len(data) == self.boot_sector.cluster_bytes()
369 self.write_sectors(
370 self.boot_sector.first_sector_of_cluster(cluster),
375 self, cluster: Optional[int] argument
382 data = self.read_cluster(cluster)
384 self.directory_from_bytes(
385 data, self.boot_sector.first_sector_of_cluster(cluster)
388 cluster = self.next_cluster(cluster)
392 self, cluster: Optional[int], name: str, ext: str, attributes: int argument
422 new_entry.cluster = self.next_free_cluster()
426 self.write_fat_entry(new_entry.cluster, 0xFFFF)
429 for i in range(self.boot_sector.root_dir_size()):
430 sector_data = self.read_sectors(
431 self.boot_sector.root_dir_start() + i, 1
435 new_entry.sector = self.boot_sector.root_dir_start() + i
437 self.update_direntry(new_entry)
441 data = self.read_cluster(cluster)
445 self.boot_sector.first_sector_of_cluster(cluster)
448 self.update_direntry(new_entry)
450 cluster = self.next_cluster(cluster)
454 def update_direntry(self, entry: FatDirectoryEntry) -> None: argument
458 sector = self.read_sectors(entry.sector, 1)
464 self.write_sectors(entry.sector, sector)
466 def find_direntry(self, path: str) -> Optional[FatDirectoryEntry]: argument
474 directory = self.read_root_directory()
496 directory = self.read_directory(current_entry.cluster)
500 def read_file(self, entry: Optional[FatDirectoryEntry]) -> Optional[bytes]: argument
512 data += self.read_cluster(cluster)
513 cluster = self.next_cluster(cluster)
517 self, argument
532 size + self.boot_sector.cluster_bytes() - 1
533 ) // self.boot_sector.cluster_bytes()
557 cluster = self.next_cluster(cluster)
561 self.next_cluster(cluster) is None
567 new_cluster = self.next_free_cluster_non_continuous()
569 new_cluster = self.next_free_cluster()
570 self.write_fat_entry(cluster, new_cluster)
571 self.write_fat_entry(new_cluster, 0xFFFF)
579 cluster = self.next_cluster(cluster)
582 next_cluster = self.next_cluster(cluster)
584 self.write_fat_entry(cluster, 0xFFFF)
588 next_cluster = self.next_cluster(next_cluster)
589 self.write_fat_entry(cluster, 0)
591 self.flush_fats()
599 cluster = self.next_cluster(cluster)
606 self.update_direntry(entry)
610 first_sector = self.boot_sector.first_sector_of_cluster(cluster)
611 first_sector_data = self.read_sectors(first_sector, 1)
612 self.write_sectors(first_sector, first_sector_data)
614 def write_file(self, entry: FatDirectoryEntry, data: bytes) -> None: argument
625 self.truncate_file(entry, data_len)
629 data_to_write = data[: self.boot_sector.cluster_bytes()]
630 if len(data_to_write) < self.boot_sector.cluster_bytes():
631 old_data = self.read_cluster(cluster)
634 self.write_cluster(cluster, data_to_write)
635 data = data[self.boot_sector.cluster_bytes() :]
638 cluster = self.next_cluster(cluster)
644 def create_file(self, path: str) -> Optional[FatDirectoryEntry]: argument
655 directory = self.read_root_directory()
673 directory = self.read_directory(current_entry.cluster)
690 return self.add_direntry(directory_cluster, filename, ext, 0)