Mount flags as a set of mutually exclusive enums

[lavafroth]

I've been trying to create a better fix for the compress / nodatacow flags for btrfs. I've come up with the idea of separating the flags into enums, each enum containing a set of mutually exclusive variants.

from enum import Enum
from typing import TYPE_CHECKING, Set

class MountFlag(Enum):
    def __init__(self, *args, **kwargs):
        super().__init__(self, *args, **kwargs)

    def __hash__(self):
        return hash(self.__class__)

    def __eq__(self, o):
        return self.__class__ == o.__class__

# One cannot use compress and nodatacow together
class CompressFlag(MountFlag):
    Compress = 'compress'
    Nodatacow = 'nodatacow'

# This is a joke
class SomeOtherMountFlag(MountFlag):
    SpookyScary = 'spookyscary'
    Skeletons = 'skeletons'

def mount_options(flags: Set[MountFlag]):
    for flag in flags:
        if isinstance(flag, CompressFlag):
            print("Hi, I'm a compress flag:", flag.value)
        elif isinstance(flag, SomeOtherMountFlag):
            print("Hi, I'm a spooky flag:", flag.value)
        else:
            print("oh I don't recognize this")

mount_options({CompressFlag.Compress, SomeOtherMountFlag.SpookyScary})

print("\ntrying two CompressFlag\n")

flags: Set[MountFlag] = {CompressFlag.Compress, SomeOtherMountFlag.Skeletons, CompressFlag.Nodatacow}

mount_options(flags)

When we run this, we get

Hi, I'm a compress flag: compress
Hi, I'm a spooky flag: spookyscary

trying two CompressFlag

Hi, I'm a compress flag: compress
Hi, I'm a spooky flag: skeletons

Notice how the last flag variant is automatically removed from the set.

I want to hear everyone's opinion about this, whether this is a good enough design. Thanks!

[Torxed]

I've thought about it, and perhaps a dataclass would be more suitable here that can do post-init validation?

from dataclasses import dataclass

class validator_hook:
	def __post_init__(self):
		for name, field in self.__dataclass_fields__.items():
			if (method := getattr(self, f"validate_{name}", None)):
				setattr(self, name, method(getattr(self, name)))
				
@dataclass
class MountFlags(validator_hook):
	compress :bool | None = None
	nodatacow :bool | None = None
	compress_level :int | None = None

	def __post_init__(self):
		validator_hook.__post_init__(self)

		if self.compress and self.nodatacow:
			raise ValueError("Cannot have compression and nodatacow at the same time.")

	def validate_compress_level(self, val):
		if val and (not isinstance(int, val) or 19 < val < 0):
			raise ValueError("Compression level must be a positive int between 0 - 19")

MountFlags(compress=True)
MountFlags(nodatacow=True)
MountFlags(compress=True, nodatacow=True)

[Torxed]

More specifically we should probably call it BtrfsMountFlags as it's some what unique to BTRFS.
(And I know the class inheritance is not needed, but it showed in a meaningful way the connection to the validator class. And we could/should probably replace that with pydantic once we feel comfortable migrating to it)

[svartkanin]

I do prefer dataclasses over inheritance, IMHO inheritance is difficult to maintain in a sane way if things grow.

To @Torxed example the post init will work but it doesn't prevent setting one of the attributes manually after the objective was created.

We could move those two under an enum fir now and just have them as a single attribute in the Btrfs class

[Torxed]

Could work, an alternative would be to have __set__ and __get__ functions and enable validation there. That could be generalized just like the validator class, so that it calls the validation after each __set__.

But at this point, it starts to sound like I'm implementing pydantic validation xD

[lavafroth]

We can use dataclasses as both of you suggested, along with union types to create BtrfsMountFlag like the following:

@dataclass(frozen=True)
class Compress:
    level: int

    def __post_init__(self):
        if not 0 < self.level < 19:
            raise ValueError("Compression level must be a positive int between 0 - 19")

@dataclass
class Nodatacow:
    pass

BtrfsMountFlag = Compress | Nodatacow

def describe_flag(flag: BtrfsMountFlag):
    match flag:
        case Compress(level):
            print(f"compress with level {level}")
        case Nodatacow:
            print("nodatacow")

describe_flag(Compress(2))
describe_flag(Nodatacow())
describe_flag(Compress(20)) # ValueError

Edit: We can also pass frozen=True for the dataclass to prevent further modification.

[Torxed]

I think it's the additional function that bothers me a bit.

[lavafroth]

In that case inheritance can actually help since Python does not have the ability to implement a method directly on a union type unlike Rust's enums.