mirror of https://github.com/deadc0de6/catcli
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
340 lines
9.0 KiB
Python
340 lines
9.0 KiB
Python
"""
|
|
author: deadc0de6 (https://github.com/deadc0de6)
|
|
Copyright (c) 2023, deadc0de6
|
|
|
|
Class that represents a node in the catalog tree
|
|
"""
|
|
# pylint: disable=W0622
|
|
|
|
import os
|
|
from typing import Dict, Any, cast
|
|
from anytree import NodeMixin
|
|
|
|
from catcli.exceptions import CatcliException
|
|
from catcli.utils import fix_badchars
|
|
|
|
|
|
TYPE_TOP = 'top'
|
|
TYPE_FILE = 'file'
|
|
TYPE_DIR = 'dir'
|
|
TYPE_ARCHIVED = 'arc'
|
|
TYPE_STORAGE = 'storage'
|
|
TYPE_META = 'meta'
|
|
|
|
NAME_TOP = 'top'
|
|
NAME_META = 'meta'
|
|
|
|
|
|
def typcast_node(node: Any) -> None:
|
|
"""typecast node to its sub type"""
|
|
if node.type == TYPE_TOP:
|
|
node.__class__ = NodeTop
|
|
elif node.type == TYPE_FILE:
|
|
node.__class__ = NodeFile
|
|
elif node.type == TYPE_DIR:
|
|
node.__class__ = NodeDir
|
|
elif node.type == TYPE_ARCHIVED:
|
|
node.__class__ = NodeArchived
|
|
elif node.type == TYPE_STORAGE:
|
|
node.__class__ = NodeStorage
|
|
elif node.type == TYPE_META:
|
|
node.__class__ = NodeMeta
|
|
else:
|
|
raise CatcliException(f"bad node: {node}")
|
|
|
|
|
|
class NodeAny(NodeMixin): # type: ignore
|
|
"""generic node"""
|
|
|
|
def __init__(self, # type: ignore[no-untyped-def]
|
|
name=None,
|
|
size=0,
|
|
parent=None,
|
|
children=None):
|
|
"""build generic node"""
|
|
super().__init__()
|
|
self.name = name
|
|
self.nodesize = size
|
|
self.parent = parent
|
|
if children:
|
|
self.children = children
|
|
|
|
def get_name(self) -> str:
|
|
"""get node name"""
|
|
return fix_badchars(self.name)
|
|
|
|
def set_name(self, name: str) -> None:
|
|
"""set node name"""
|
|
self.name = fix_badchars(name)
|
|
|
|
def has_attr(self, attr: str) -> bool:
|
|
"""return True if node has attr as attribute"""
|
|
return attr in self.__dict__
|
|
|
|
def may_have_children(self) -> bool:
|
|
"""can node contains sub"""
|
|
raise NotImplementedError
|
|
|
|
def _to_str(self) -> str:
|
|
ret = str(self.__class__) + ": " + str(self.__dict__)
|
|
if self.children:
|
|
ret += '\n'
|
|
for child in self.children:
|
|
ret += f' child => {child}\n'
|
|
return ret
|
|
|
|
def __str__(self) -> str:
|
|
return self._to_str()
|
|
|
|
def get_fullpath(self) -> str:
|
|
"""return full path to this node"""
|
|
path = self.get_name()
|
|
if self.parent:
|
|
typcast_node(self.parent)
|
|
ppath = self.parent.get_fullpath()
|
|
path = os.path.join(ppath, path)
|
|
return fix_badchars(path)
|
|
|
|
def get_rec_size(self) -> int:
|
|
"""recursively traverse tree and return size"""
|
|
totsize: int = self.nodesize
|
|
for node in self.children:
|
|
typcast_node(node)
|
|
totsize += node.get_rec_size()
|
|
return totsize
|
|
|
|
def get_storage_node(self) -> NodeMixin:
|
|
"""recursively traverse up to find storage"""
|
|
return None
|
|
|
|
def flagged(self) -> bool:
|
|
"""is flagged"""
|
|
if not hasattr(self, '_flagged'):
|
|
return False
|
|
return self._flagged
|
|
|
|
def flag(self) -> None:
|
|
"""flag a node"""
|
|
self._flagged = True # pylint: disable=W0201
|
|
|
|
def unflag(self) -> None:
|
|
"""unflag node"""
|
|
self._flagged = False # pylint: disable=W0201
|
|
delattr(self, '_flagged')
|
|
|
|
|
|
class NodeTop(NodeAny):
|
|
"""a top node"""
|
|
|
|
def __init__(self, # type: ignore[no-untyped-def]
|
|
name: str,
|
|
children=None):
|
|
"""build a top node"""
|
|
super().__init__() # type: ignore[no-untyped-call]
|
|
self.name = name
|
|
self.type = TYPE_TOP
|
|
self.parent = None
|
|
if children:
|
|
self.children = children
|
|
|
|
def get_fullpath(self) -> str:
|
|
"""return full path to this node"""
|
|
return ''
|
|
|
|
def may_have_children(self) -> bool:
|
|
"""can node contains sub"""
|
|
return True
|
|
|
|
def get_rec_size(self) -> int:
|
|
"""
|
|
recursively traverse tree and return size
|
|
also ensure to update the size on the way
|
|
"""
|
|
size = super().get_rec_size()
|
|
self.nodesize = size
|
|
return size
|
|
|
|
def __str__(self) -> str:
|
|
return self._to_str()
|
|
|
|
|
|
class NodeFile(NodeAny):
|
|
"""a file node"""
|
|
|
|
def __init__(self, # type: ignore[no-untyped-def]
|
|
name: str,
|
|
nodesize: int,
|
|
md5: str,
|
|
maccess: float,
|
|
parent=None,
|
|
children=None):
|
|
"""build a file node"""
|
|
super().__init__() # type: ignore[no-untyped-call]
|
|
self.name = name
|
|
self.type = TYPE_FILE
|
|
self.nodesize = nodesize
|
|
self.md5 = md5
|
|
self.maccess = maccess
|
|
self.parent = parent
|
|
if children:
|
|
self.children = children
|
|
|
|
def may_have_children(self) -> bool:
|
|
"""can node contains sub"""
|
|
return False
|
|
|
|
def get_storage_node(self) -> NodeAny:
|
|
"""recursively traverse up to find storage"""
|
|
return cast(NodeStorage, self.ancestors[1])
|
|
|
|
def __str__(self) -> str:
|
|
return self._to_str()
|
|
|
|
|
|
class NodeDir(NodeAny):
|
|
"""a directory node"""
|
|
|
|
def __init__(self, # type: ignore[no-untyped-def]
|
|
name: str,
|
|
nodesize: int,
|
|
maccess: float,
|
|
parent=None,
|
|
children=None):
|
|
"""build a directory node"""
|
|
super().__init__() # type: ignore[no-untyped-call]
|
|
self.name = name
|
|
self.type = TYPE_DIR
|
|
self.nodesize = nodesize
|
|
self.maccess = maccess
|
|
self.parent = parent
|
|
if children:
|
|
self.children = children
|
|
|
|
def may_have_children(self) -> bool:
|
|
"""can node contains sub"""
|
|
return True
|
|
|
|
def get_rec_size(self) -> int:
|
|
"""
|
|
recursively traverse tree and return size
|
|
also ensure to update the size on the way
|
|
"""
|
|
size = super().get_rec_size()
|
|
self.nodesize = size
|
|
return size
|
|
|
|
def get_storage_node(self) -> NodeAny:
|
|
"""recursively traverse up to find storage"""
|
|
return cast(NodeStorage, self.ancestors[1])
|
|
|
|
def __str__(self) -> str:
|
|
return self._to_str()
|
|
|
|
|
|
class NodeArchived(NodeAny):
|
|
"""an archived node"""
|
|
|
|
def __init__(self, # type: ignore[no-untyped-def]
|
|
name: str,
|
|
nodesize: int,
|
|
md5: str,
|
|
archive: str,
|
|
parent=None,
|
|
children=None):
|
|
"""build an archived node"""
|
|
super().__init__() # type: ignore[no-untyped-call]
|
|
self.name = name
|
|
self.type = TYPE_ARCHIVED
|
|
self.nodesize = nodesize
|
|
self.md5 = md5
|
|
self.archive = archive
|
|
self.parent = parent
|
|
if children:
|
|
self.children = children
|
|
|
|
def may_have_children(self) -> bool:
|
|
"""can node contains sub"""
|
|
return False
|
|
|
|
def get_storage_node(self) -> NodeAny:
|
|
"""recursively traverse up to find storage"""
|
|
return cast(NodeStorage, self.ancestors[1])
|
|
|
|
def __str__(self) -> str:
|
|
return self._to_str()
|
|
|
|
|
|
class NodeStorage(NodeAny):
|
|
"""a storage node"""
|
|
|
|
def __init__(self, # type: ignore[no-untyped-def]
|
|
name: str,
|
|
free: int,
|
|
total: int,
|
|
nodesize: int,
|
|
ts: float,
|
|
attr: str,
|
|
parent=None,
|
|
children=None):
|
|
"""build a storage node"""
|
|
super().__init__() # type: ignore[no-untyped-call]
|
|
self.name = name
|
|
self.type = TYPE_STORAGE
|
|
self.free = free
|
|
self.total = total
|
|
self.attr = attr
|
|
self.nodesize = nodesize
|
|
self.ts = ts # pylint: disable=C0103
|
|
self.parent = parent
|
|
if children:
|
|
self.children = children
|
|
|
|
def may_have_children(self) -> bool:
|
|
"""can node contains sub"""
|
|
return True
|
|
|
|
def get_rec_size(self) -> int:
|
|
"""
|
|
recursively traverse tree and return size
|
|
also ensure to update the size on the way
|
|
"""
|
|
size = super().get_rec_size()
|
|
self.nodesize = size
|
|
return size
|
|
|
|
def get_storage_node(self) -> NodeAny:
|
|
"""recursively traverse up to find storage"""
|
|
return self
|
|
|
|
def __str__(self) -> str:
|
|
return self._to_str()
|
|
|
|
|
|
class NodeMeta(NodeAny):
|
|
"""a meta node"""
|
|
|
|
def __init__(self, # type: ignore[no-untyped-def]
|
|
name: str,
|
|
attr: Dict[str, Any],
|
|
parent=None,
|
|
children=None):
|
|
"""build a meta node"""
|
|
super().__init__() # type: ignore[no-untyped-call]
|
|
self.name = name
|
|
self.type = TYPE_META
|
|
self.attr = attr
|
|
self.parent = parent
|
|
if children:
|
|
self.children = children
|
|
|
|
def may_have_children(self) -> bool:
|
|
"""can node contains sub"""
|
|
return False
|
|
|
|
def get_rec_size(self) -> int:
|
|
"""recursively traverse tree and return size"""
|
|
return 0
|
|
|
|
def __str__(self) -> str:
|
|
return self._to_str()
|