File I/O Operations

def open(
    fp,
    mode="r",
    driver=None,
    schema=None,
    crs=None,
    encoding=None,
    layer=None,
    vfs=None,
    enabled_drivers=None,
    crs_wkt=None,
    ignore_fields=None,
    ignore_geometry=False,
    include_fields=None,
    wkt_version=None,
    allow_unsupported_drivers=False,
    opener=None,
    **kwargs
):
    """
    Open a collection for read, append, or write.

    Parameters:
    - fp: str or Path, dataset resource identifier or file object
    - mode: str, one of 'r' (read), 'a' (append), or 'w' (write)
    - driver: str, format driver name (required for write mode)
    - schema: dict, required in write mode, defines geometry and properties
    - crs: str or dict, coordinate reference system (required for write mode)
    - encoding: str, name of encoding used to encode/decode dataset
    - layer: int or str, integer index or name of layer in multi-layer dataset
    - vfs: str, deprecated, use URI scheme instead
    - enabled_drivers: list, optional list of driver names to use
    - crs_wkt: str, optional WKT representation of CRS
    - ignore_fields: list[str], field names to ignore on load
    - include_fields: list[str], subset of field names to include on load
    - ignore_geometry: bool, ignore geometry on load
    - wkt_version: WktVersion or str, version for CRS WKT
    - allow_unsupported_drivers: bool, don't limit to known working drivers
    - opener: callable or obj, custom dataset opener for virtual filesystem
    - kwargs: dict, other driver-specific parameters

    Returns:
    Collection object

    Raises:
    DriverError: When selected driver cannot provide requested capabilities
    """

# Reading a shapefile
with fiona.open('data.shp', 'r') as collection:
    for feature in collection:
        print(feature['properties'])

# Writing GeoJSON with specific schema
schema = {
    'geometry': 'Point',
    'properties': {'name': 'str:50', 'population': 'int'}
}

with fiona.open('cities.geojson', 'w', driver='GeoJSON',
                schema=schema, crs='EPSG:4326') as collection:
    feature = {
        'geometry': {'type': 'Point', 'coordinates': [-122.5, 37.5]},
        'properties': {'name': 'San Francisco', 'population': 875000}
    }
    collection.write(feature)

# Reading specific layer from multi-layer file
with fiona.open('data.gpkg', 'r', layer='roads') as collection:
    print(f"Layer CRS: {collection.crs}")
    print(f"Feature count: {len(collection)}")

# Using custom field filtering
with fiona.open('large_dataset.shp', 'r', 
                include_fields=['name', 'category']) as collection:
    for feature in collection:
        # Only 'name' and 'category' fields are loaded
        print(feature['properties'])

def listlayers(fp, opener=None, vfs=None, **kwargs):
    """
    Lists the layers in a dataset.

    Parameters:
    - fp: str, Path, or file-like object, dataset identifier
    - opener: callable or obj, custom dataset opener
    - vfs: str, deprecated parameter
    - kwargs: dict, dataset opening options

    Returns:
    list[str]: List of layer name strings

    Raises:
    TypeError: If input is not str, Path, or file object
    """

# List layers in a GeoPackage
layers = fiona.listlayers('database.gpkg')
print(f"Available layers: {layers}")

# List layers in a PostGIS database
layers = fiona.listlayers('PG:host=localhost dbname=gis user=postgres')
for layer in layers:
    print(f"Layer: {layer}")

# List layers in a zip archive
layers = fiona.listlayers('zip://data.zip')

def listdir(fp, opener=None):
    """
    Lists datasets in a directory or archive file.

    Parameters:
    - fp: str or Path, directory or archive path
    - opener: callable or obj, custom dataset opener

    Returns:
    list[str]: List of dataset paths

    Raises:
    TypeError: If input is not str or Path
    """

# List datasets in a directory
datasets = fiona.listdir('/path/to/gis/data')
for dataset in datasets:
    print(f"Found dataset: {dataset}")

# List datasets in a zip archive
datasets = fiona.listdir('zip://archive.zip')

# List datasets in a tar archive
datasets = fiona.listdir('tar://archive.tar.gz')

def remove(path_or_collection, driver=None, layer=None, opener=None):
    """
    Delete an OGR data source or layer.

    Parameters:
    - path_or_collection: str, Path, or Collection, target to delete
    - driver: str, name of driver for deletion (usually auto-detected)
    - layer: str or int, name or index of specific layer to delete
    - opener: callable or obj, custom dataset opener

    Returns:
    None

    Raises:
    DatasetDeleteError: If data source cannot be deleted
    """

# Remove entire dataset
fiona.remove('unwanted_data.shp')

# Remove specific layer from multi-layer dataset
fiona.remove('database.gpkg', layer='temporary_layer')

# Remove using Collection object
with fiona.open('data.shp', 'r') as collection:
    # Process data...
    pass
# Remove the dataset after processing
fiona.remove(collection)

class MemoryFile:
    def __init__(self, file_or_bytes=None, filename=None, ext=""):
        """
        BytesIO-like object backed by in-memory file.

        Parameters:
        - file_or_bytes: bytes or file-like object, initial content
        - filename: str, optional filename for format detection
        - ext: str, file extension for format detection
        """
    
    def open(self, mode=None, driver=None, schema=None, crs=None, **kwargs):
        """
        Open and return Collection for the memory file.

        Returns:
        Collection object
        """

from fiona.io import MemoryFile

# Create in-memory GeoJSON
schema = {'geometry': 'Point', 'properties': {'name': 'str'}}

with MemoryFile() as memfile:
    with memfile.open(driver='GeoJSON', mode='w', 
                      schema=schema, crs='EPSG:4326') as collection:
        feature = {
            'geometry': {'type': 'Point', 'coordinates': [0, 0]},
            'properties': {'name': 'Origin'}
        }
        collection.write(feature)
    
    # Read back from memory
    memfile.seek(0)
    with memfile.open('r') as collection:
        for feature in collection:
            print(feature)

# Work with existing bytes data
geojson_bytes = b'{"type": "FeatureCollection", "features": []}'
with MemoryFile(geojson_bytes) as memfile:
    with memfile.open('r') as collection:
        print(f"Driver: {collection.driver}")