# encoding: utf-8 # module littlefs.lfs # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\littlefs\lfs.cp311-win_amd64.pyd # by generator 1.147 # no doc # imports import builtins as __builtins__ # import logging as logging # C:\Programs\Python\Python311\Lib\logging\__init__.py import enum as enum # C:\Programs\Python\Python311\Lib\enum.py import littlefs.errors as errors # C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\littlefs\errors.py import enum as __enum # Variables with simple values FILENAME_ENCODING = 'ascii' # functions def dir_close(LFSFilesystem_fs, LFSDirectory_dh): # real signature unknown; restored from __doc__ """ dir_close(LFSFilesystem fs, LFSDirectory dh) """ pass def dir_open(LFSFilesystem_fs, path): # real signature unknown; restored from __doc__ """ dir_open(LFSFilesystem fs, path) """ pass def dir_read(LFSFilesystem_fs, LFSDirectory_dh): # real signature unknown; restored from __doc__ """ dir_read(LFSFilesystem fs, LFSDirectory dh) """ pass def dir_rewind(LFSFilesystem_fs, LFSDirectory_dh): # real signature unknown; restored from __doc__ """ dir_rewind(LFSFilesystem fs, LFSDirectory dh) """ pass def dir_tell(LFSFilesystem_fs, LFSDirectory_dh): # real signature unknown; restored from __doc__ """ dir_tell(LFSFilesystem fs, LFSDirectory dh) """ pass def file_close(LFSFilesystem_fs, LFSFile_fh): # real signature unknown; restored from __doc__ """ file_close(LFSFilesystem fs, LFSFile fh) """ pass def file_open(LFSFilesystem_fs, path, flags): # real signature unknown; restored from __doc__ """ file_open(LFSFilesystem fs, path, flags) """ pass def file_open_cfg(self, path, flags, config): # real signature unknown; restored from __doc__ """ file_open_cfg(self, path, flags, config) """ pass def file_read(LFSFilesystem_fs, LFSFile_fh, size): # real signature unknown; restored from __doc__ """ file_read(LFSFilesystem fs, LFSFile fh, size) """ pass def file_rewind(LFSFilesystem_fs, LFSFile_fh): # real signature unknown; restored from __doc__ """ file_rewind(LFSFilesystem fs, LFSFile fh) """ pass def file_seek(LFSFilesystem_fs, LFSFile_fh, off, whence): # real signature unknown; restored from __doc__ """ file_seek(LFSFilesystem fs, LFSFile fh, off, whence) """ pass def file_size(LFSFilesystem_fs, LFSFile_fh): # real signature unknown; restored from __doc__ """ file_size(LFSFilesystem fs, LFSFile fh) """ pass def file_sync(LFSFilesystem_fs, LFSFile_fh): # real signature unknown; restored from __doc__ """ file_sync(LFSFilesystem fs, LFSFile fh) """ pass def file_tell(LFSFilesystem_fs, LFSFile_fh): # real signature unknown; restored from __doc__ """ file_tell(LFSFilesystem fs, LFSFile fh) """ pass def file_truncate(LFSFilesystem_fs, LFSFile_fh, size): # real signature unknown; restored from __doc__ """ file_truncate(LFSFilesystem fs, LFSFile fh, size) """ pass def file_write(LFSFilesystem_fs, LFSFile_fh, data): # real signature unknown; restored from __doc__ """ file_write(LFSFilesystem fs, LFSFile fh, data) """ pass def format(LFSFilesystem_fs, LFSConfig_cfg): # real signature unknown; restored from __doc__ """ format(LFSFilesystem fs, LFSConfig cfg) Format the filesystem """ pass def fs_size(LFSFilesystem_fs): # real signature unknown; restored from __doc__ """ fs_size(LFSFilesystem fs) """ pass def getattr(LFSFilesystem_fs, path, type, buffer, size): # real signature unknown; restored from __doc__ """ getattr(LFSFilesystem fs, path, type, buffer, size) """ pass def mkdir(LFSFilesystem_fs, path): # real signature unknown; restored from __doc__ """ mkdir(LFSFilesystem fs, path) """ pass def mount(LFSFilesystem_fs, LFSConfig_cfg): # real signature unknown; restored from __doc__ """ mount(LFSFilesystem fs, LFSConfig cfg) Mount the filesystem """ pass def namedtuple(typename, field_names, *, rename=False, defaults=None, module=None): # reliably restored by inspect """ Returns a new subclass of tuple with named fields. >>> Point = namedtuple('Point', ['x', 'y']) >>> Point.__doc__ # docstring for the new class 'Point(x, y)' >>> p = Point(11, y=22) # instantiate with positional args or keywords >>> p[0] + p[1] # indexable like a plain tuple 33 >>> x, y = p # unpack like a regular tuple >>> x, y (11, 22) >>> p.x + p.y # fields also accessible by name 33 >>> d = p._asdict() # convert to a dictionary >>> d['x'] 11 >>> Point(**d) # convert from a dictionary Point(x=11, y=22) >>> p._replace(x=100) # _replace() is like str.replace() but targets named fields Point(x=100, y=22) """ pass def remove(LFSFilesystem_fs, path): # real signature unknown; restored from __doc__ """ remove(LFSFilesystem fs, path) Remove a file or directory If removing a direcotry, the directory must be empty. """ pass def removeattr(LFSFilesystem_fs, path, type): # real signature unknown; restored from __doc__ """ removeattr(LFSFilesystem fs, path, type) """ pass def rename(LFSFilesystem_fs, oldpath, newpath): # real signature unknown; restored from __doc__ """ rename(LFSFilesystem fs, oldpath, newpath) Rename or move a file or directory If the destination exists, it must match the source in type. If the destination is a directory, the directory must be empty. """ pass def setattr(LFSFilesystem_fs, path, type, buffer, size): # real signature unknown; restored from __doc__ """ setattr(LFSFilesystem fs, path, type, buffer, size) """ pass def stat(LFSFilesystem_fs, path): # real signature unknown; restored from __doc__ """ stat(LFSFilesystem fs, path) Find info about a file or directory """ pass def unmount(LFSFilesystem_fs): # real signature unknown; restored from __doc__ """ unmount(LFSFilesystem fs) Unmount the filesystem This does nothing beside releasing any allocated resources """ pass # classes class LFSConfig(object): """ LFSConfig(context=None, **kwargs) """ def __init__(self, context=None, **kwargs): # real signature unknown; restored from __doc__ pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __reduce__(self, *args, **kwargs): # real signature unknown """ LFSConfig.__reduce_cython__(self) """ pass def __setstate__(self, *args, **kwargs): # real signature unknown """ LFSConfig.__setstate_cython__(self, __pyx_state) """ pass attr_max = property(lambda self: object(), lambda self, v: None, lambda self: None) # default block_count = property(lambda self: object(), lambda self, v: None, lambda self: None) # default block_size = property(lambda self: object(), lambda self, v: None, lambda self: None) # default cache_size = property(lambda self: object(), lambda self, v: None, lambda self: None) # default file_max = property(lambda self: object(), lambda self, v: None, lambda self: None) # default lookahead_size = property(lambda self: object(), lambda self, v: None, lambda self: None) # default name_max = property(lambda self: object(), lambda self, v: None, lambda self: None) # default prog_size = property(lambda self: object(), lambda self, v: None, lambda self: None) # default read_size = property(lambda self: object(), lambda self, v: None, lambda self: None) # default __dict__ = None # (!) real value is "mappingproxy({'__new__': , '__init__': , 'read_size': , 'prog_size': , 'block_size': , 'block_count': , 'cache_size': , 'lookahead_size': , 'name_max': , 'file_max': , 'attr_max': , '__dict__': , '__doc__': 'LFSConfig(context=None, **kwargs)', '__reduce__': , '__setstate__': })" class LFSDirectory(object): # no doc def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __reduce__(self, *args, **kwargs): # real signature unknown """ LFSDirectory.__reduce_cython__(self) """ pass def __setstate__(self, *args, **kwargs): # real signature unknown """ LFSDirectory.__setstate_cython__(self, __pyx_state) """ pass class LFSFile(object): # no doc def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __reduce__(self, *args, **kwargs): # real signature unknown """ LFSFile.__reduce_cython__(self) """ pass def __setstate__(self, *args, **kwargs): # real signature unknown """ LFSFile.__setstate_cython__(self, __pyx_state) """ pass flags = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Mode flags of an open file""" class LFSFileFlag(__enum.IntFlag): """ Littlefs file mode flags """ def _generate_next_value_(name, start, count, last_values): # reliably restored by inspect """ Generate the next value when not given. name: the name of the member start: the initial start value or None count: the number of existing members last_values: the last value assigned or None """ pass def _new_member_(self, *args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def _value_repr_(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __and__(self, other): # reliably restored by inspect # no doc pass def __format__(self, *args, **kwargs): # real signature unknown pass def __init__(self, *args, **kwds): # reliably restored by inspect # no doc pass def __invert__(self): # reliably restored by inspect # no doc pass @staticmethod # known case of __new__ def __new__(cls, value): # reliably restored by inspect # no doc pass def __or__(self, other): # reliably restored by inspect # no doc pass def __rand__(self, other): # reliably restored by inspect # no doc pass def __ror__(self, other): # reliably restored by inspect # no doc pass def __rxor__(self, other): # reliably restored by inspect # no doc pass def __xor__(self, other): # reliably restored by inspect # no doc pass append = 2048 creat = 256 excl = 512 rdonly = 1 rdwr = 3 trunc = 1024 wronly = 2 _all_bits_ = 4095 _boundary_ = _flag_mask_ = 3843 _inverted_ = None _member_map_ = { 'append': 2048, 'creat': 256, 'excl': 512, 'rdonly': 1, 'rdwr': 3, 'trunc': 1024, 'wronly': 2, } _member_names_ = [ 'rdonly', 'wronly', 'creat', 'excl', 'trunc', 'append', ] _member_type_ = int _unhashable_values_ = [] _use_args_ = True _value2member_map_ = { 1: 1, 2: 2, 3: 3, 256: 256, 512: 512, 1024: 1024, 2048: 2048, } class LFSFilesystem(object): # no doc def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __reduce__(self, *args, **kwargs): # real signature unknown """ LFSFilesystem.__reduce_cython__(self) """ pass def __setstate__(self, *args, **kwargs): # real signature unknown """ LFSFilesystem.__setstate_cython__(self, __pyx_state) """ pass class LFSStat(tuple): """ Littlefs File / Directory status """ def _asdict(self): # reliably restored by inspect """ Return a new dict which maps field names to their values. """ pass @classmethod def _make(cls, *args, **kwargs): # real signature unknown """ Make a new LFSStat object from a sequence or iterable """ pass def _replace(self, **kwds): # reliably restored by inspect """ Return a new LFSStat object replacing specified fields with new values """ pass def __getnewargs__(self): # reliably restored by inspect """ Return self as a plain tuple. Used by copy and pickle. """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(_cls, type, size, name): # reliably restored by inspect """ Create new instance of LFSStat(type, size, name) """ pass def __repr__(self): # reliably restored by inspect """ Return a nicely formatted representation string """ pass name = _tuplegetter(2, 'Alias for field number 2') size = _tuplegetter(1, 'Alias for field number 1') type = _tuplegetter(0, 'Alias for field number 0') _fields = ( 'type', 'size', 'name', ) _field_defaults = {} __match_args__ = ( 'type', 'size', 'name', ) __slots__ = () class UserContext(object): """ Basic User Context Implementation """ def erase(self, cfg, block): # reliably restored by inspect """ Erase a block Parameters ---------- cfg : ~littlefs.lfs.LFSConfig Filesystem configuration object block : int Block number to read """ pass def prog(self, cfg, block, off, data): # reliably restored by inspect """ program data Parameters ---------- cfg : ~littlefs.lfs.LFSConfig Filesystem configuration object block : int Block number to program off : int Offset from start of block data : bytes Data to write """ pass def read(self, cfg, block, off, size): # reliably restored by inspect """ read data Parameters ---------- cfg : ~littlefs.lfs.LFSConfig Filesystem configuration object block : int Block number to read off : int Offset from start of block size : int Number of bytes to read. """ pass def sync(self, cfg): # reliably restored by inspect """ Sync cached data Parameters ---------- cfg : ~littlefs.lfs.LFSConfig Filesystem configuration object """ pass def __init__(self, buffsize): # reliably restored by inspect # no doc pass __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """list of weak references to the object (if defined)""" __dict__ = None # (!) real value is "mappingproxy({'__module__': 'littlefs.context', '__doc__': 'Basic User Context Implementation', '__init__': , 'read': , 'prog': , 'erase': , 'sync': , '__dict__': , '__weakref__': })" # variables with complex values __LFS_DISK_VERSION__ = ( 2, 0, ) __LFS_VERSION__ = ( 2, 4, ) __loader__ = None # (!) real value is '<_frozen_importlib_external.ExtensionFileLoader object at 0x00000187FCD42910>' __spec__ = None # (!) real value is "ModuleSpec(name='littlefs.lfs', loader=<_frozen_importlib_external.ExtensionFileLoader object at 0x00000187FCD42910>, origin='C:\\\\Users\\\\xukai\\\\Downloads\\\\??2\\\\venv\\\\Lib\\\\site-packages\\\\littlefs\\\\lfs.cp311-win_amd64.pyd')" __test__ = {}