tessl/pypi-fs

Python's filesystem abstraction layer providing a unified interface for working with different types of filesystems

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview

Eval results

Files

Path Operations

Name: tessl/pypi-fs
Author: tessl

Platform-agnostic path manipulation utilities that work consistently across different operating systems and filesystem types. PyFileSystem2 uses forward slashes as path separators internally, ensuring compatibility across platforms.

Capabilities

Path Joining and Splitting

Combine and separate path components in a platform-independent way.

def join(*paths: str) -> str:
    """
    Join path components with forward slashes.

    Parameters:
    - *paths: str, path components to join

    Returns:
    str: Joined path

    Example:
    join('home', 'user', 'documents') -> 'home/user/documents'
    """

def split(path: str) -> Tuple[str, str]:
    """
    Split path into directory and filename.

    Parameters:
    - path: str, path to split

    Returns:
    Tuple[str, str]: (directory, filename)

    Example:
    split('home/user/file.txt') -> ('home/user', 'file.txt')
    """

def splitext(path: str) -> Tuple[str, str]:
    """
    Split path into base and extension.

    Parameters:
    - path: str, path to split

    Returns:
    Tuple[str, str]: (base, extension)

    Example:
    splitext('file.txt') -> ('file', '.txt')
    """

def parts(path: str) -> List[str]:
    """
    Split path into individual components.

    Parameters:
    - path: str, path to split

    Returns:
    List[str]: Path components

    Example:
    parts('home/user/documents') -> ['home', 'user', 'documents']
    """

Path Components

Extract directory and filename components from paths.

def dirname(path: str) -> str:
    """
    Get directory portion of path.

    Parameters:
    - path: str, input path

    Returns:
    str: Directory portion

    Example:
    dirname('home/user/file.txt') -> 'home/user'
    """

def basename(path: str) -> str:
    """
    Get filename portion of path.

    Parameters:
    - path: str, input path

    Returns:
    str: Filename portion

    Example:
    basename('home/user/file.txt') -> 'file.txt'
    """

Path Normalization

Clean and standardize path format for consistent handling.

def abspath(path: str) -> str:
    """
    Convert path to absolute form.

    Parameters:
    - path: str, input path

    Returns:
    str: Absolute path

    Example:
    abspath('./file.txt') -> '/current/dir/file.txt'
    """

def normpath(path: str) -> str:
    """
    Normalize path by removing redundant separators and references.

    Parameters:
    - path: str, input path

    Returns:
    str: Normalized path

    Example:
    normpath('home//user/../user/file.txt') -> 'home/user/file.txt'
    """

def relpath(path: str, start: str = '/') -> str:
    """
    Get relative path from start directory.

    Parameters:
    - path: str, target path
    - start: str, starting directory

    Returns:
    str: Relative path

    Example:
    relpath('/home/user/file.txt', '/home') -> 'user/file.txt'
    """

Path Analysis

Analyze path properties and relationships.

def isabs(path: str) -> bool:
    """
    Check if path is absolute.

    Parameters:
    - path: str, path to check

    Returns:
    bool: True if path is absolute

    Example:
    isabs('/home/user') -> True
    isabs('user/file') -> False
    """

def isroot(path: str) -> bool:
    """
    Check if path is root directory.

    Parameters:
    - path: str, path to check

    Returns:
    bool: True if path is root

    Example:
    isroot('/') -> True
    isroot('/home') -> False
    """

def isdotfile(path: str) -> bool:
    """
    Check if path is a dot file (hidden file).

    Parameters:
    - path: str, path to check

    Returns:
    bool: True if filename starts with dot

    Example:
    isdotfile('.hidden') -> True
    isdotfile('visible.txt') -> False
    """

def commonpath(paths: List[str]) -> str:
    """
    Get common path prefix for multiple paths.

    Parameters:
    - paths: List[str], paths to compare

    Returns:
    str: Common path prefix

    Example:
    commonpath(['/home/user/a', '/home/user/b']) -> '/home/user'
    """

Path Traversal

Iterate through path components and directory hierarchies.

def iteratepath(path: str, reverse: bool = False) -> Iterator[str]:
    """
    Iterate over path components.

    Parameters:
    - path: str, path to iterate
    - reverse: bool, iterate from leaf to root

    Returns:
    Iterator[str]: Path components

    Example:
    list(iteratepath('home/user/file')) -> ['home', 'home/user', 'home/user/file']
    """

def recursepath(path: str, reverse: bool = False) -> Iterator[str]:
    """
    Recursively iterate through directory path components.

    Parameters:
    - path: str, directory path
    - reverse: bool, iterate from deepest to shallowest

    Returns:
    Iterator[str]: Directory paths

    Example:
    list(recursepath('a/b/c')) -> ['a', 'a/b', 'a/b/c']
    """

Path Utilities

Additional utilities for path manipulation and formatting.

def forcedir(path: str) -> str:
    """
    Ensure path ends with directory separator.

    Parameters:
    - path: str, input path

    Returns:
    str: Path ending with separator

    Example:
    forcedir('home/user') -> 'home/user/'
    """

def frombase(path: str, base: str) -> str:
    """
    Convert path relative to base directory.

    Parameters:
    - path: str, full path
    - base: str, base directory

    Returns:
    str: Path relative to base

    Example:
    frombase('/home/user/file.txt', '/home') -> 'user/file.txt'
    """

def iswildcard(path: str) -> bool:
    """
    Check if path contains wildcard characters.

    Parameters:
    - path: str, path to check

    Returns:
    bool: True if path contains wildcards (* or ?)

    Example:
    iswildcard('*.txt') -> True
    iswildcard('file.txt') -> False
    """

Usage Examples

Basic path operations:

from fs import path

# Join path components
file_path = path.join('home', 'user', 'documents', 'file.txt')
# Result: 'home/user/documents/file.txt'

# Split path
directory, filename = path.split(file_path)
# Result: ('home/user/documents', 'file.txt')

# Get components
base, ext = path.splitext(filename)
# Result: ('file', '.txt')

# Normalize paths
clean_path = path.normpath('home//user/../user/./file.txt')
# Result: 'home/user/file.txt'

Working with path hierarchies:

from fs import path

# Iterate through path components
for component in path.iteratepath('home/user/documents'):
    print(component)
# Output: 'home', 'home/user', 'home/user/documents'

# Get common path
common = path.commonpath([
    'home/user/docs/file1.txt',
    'home/user/docs/file2.txt',
    'home/user/pics/image.jpg'
])
# Result: 'home/user'

Path analysis:

from fs import path

# Check path properties  
print(path.isabs('/home/user'))        # True
print(path.isabs('user/file'))         # False
print(path.isdotfile('.bashrc'))       # True
print(path.iswildcard('*.txt'))        # True

Types

from typing import List, Tuple, Iterator

# Path types are generally strings, but some functions return tuples or lists
PathComponents = List[str]
PathTuple = Tuple[str, str]

Install with Tessl CLI