feat: Deprecate custom NotFoundError in favor of built-in FileNotFoundError

[kylebarron]

Custom exceptions with multiple inheritance are not currently possible in pyo3 (at least to define on the Rust side). See PyO3/pyo3#4979

You could have a custom exception with multiple inheritance if you defined it on the Python side and then imported it into Rust... but then that would leak into pyo3-object_store and I want that to be self contained and not require other users of pyo3-object_store to have a dependency on some Python package where the exception is defined.

So I think the best way forward for now is to choose one or the other. Since we're already using FileNotFoundError, let's just use that one.

The primary downside is that obstore.exceptions.BaseError is not universally the base of everything we raise.

Closes#197, closes#199

[lukasbindreiter]

The only small downside with fully using builtins.FileNotFoundError I think is it's name - since no files are necessarily involved.

fromobstore.storeimportMemoryStoreMemoryStore().get("non-existent") # FileNotFoundError# no files involved anywhere

I guess that's why the exception in obstore was just named NotFoundError?
For the above example KeyError would probably be the more appropriate, but then for other stores not really.

[kylebarron]

All stores will raise the same exceptions, that's for sure. Having different stores raise different exceptions would be so confusing IMO

[lukasbindreiter]

Having different stores raise different exceptions would be so confusing IMO

yeah for sure, totally agree with that. Just wanted to mention that FileNotFoundError itself may also be confusing in certain scenarios - but for now it is the best approach for sure.

[kylebarron]

Custom exceptions with multiple inheritance are not currently possible in pyo3 (at least to define on the Rust side). See PyO3/pyo3#4979

You could have a custom exception with multiple inheritance if you defined it on the Python side and then imported it into Rust... but then that would leak into pyo3-object_store and I want that to be self contained and not require other users of pyo3-object_store to have a dependency on some Python package where the exception is defined.

So I think the best way forward for now is to choose one or the other. Since we're already using FileNotFoundError, let's just use that one.

The primary downside is that obstore.exceptions.BaseError is not universally the base of everything we raise.

Closes#197, closes#199

[lukasbindreiter]

The only small downside with fully using builtins.FileNotFoundError I think is it's name - since no files are necessarily involved.

fromobstore.storeimportMemoryStoreMemoryStore().get("non-existent") # FileNotFoundError# no files involved anywhere

I guess that's why the exception in obstore was just named NotFoundError?
For the above example KeyError would probably be the more appropriate, but then for other stores not really.

[kylebarron]

All stores will raise the same exceptions, that's for sure. Having different stores raise different exceptions would be so confusing IMO

[lukasbindreiter]

Having different stores raise different exceptions would be so confusing IMO

yeah for sure, totally agree with that. Just wanted to mention that FileNotFoundError itself may also be confusing in certain scenarios - but for now it is the best approach for sure.

[kylebarron]

Custom exceptions with multiple inheritance are not currently possible in pyo3 (at least to define on the Rust side). See PyO3/pyo3#4979

You could have a custom exception with multiple inheritance if you defined it on the Python side and then imported it into Rust... but then that would leak into pyo3-object_store and I want that to be self contained and not require other users of pyo3-object_store to have a dependency on some Python package where the exception is defined.

So I think the best way forward for now is to choose one or the other. Since we're already using FileNotFoundError, let's just use that one.

The primary downside is that obstore.exceptions.BaseError is not universally the base of everything we raise.

Closes#197, closes#199

[lukasbindreiter]

The only small downside with fully using builtins.FileNotFoundError I think is it's name - since no files are necessarily involved.

fromobstore.storeimportMemoryStoreMemoryStore().get("non-existent") # FileNotFoundError# no files involved anywhere

I guess that's why the exception in obstore was just named NotFoundError?
For the above example KeyError would probably be the more appropriate, but then for other stores not really.

[kylebarron]

All stores will raise the same exceptions, that's for sure. Having different stores raise different exceptions would be so confusing IMO

[lukasbindreiter]

Having different stores raise different exceptions would be so confusing IMO

yeah for sure, totally agree with that. Just wanted to mention that FileNotFoundError itself may also be confusing in certain scenarios - but for now it is the best approach for sure.

[kylebarron]

Custom exceptions with multiple inheritance are not currently possible in pyo3 (at least to define on the Rust side). See PyO3/pyo3#4979

You could have a custom exception with multiple inheritance if you defined it on the Python side and then imported it into Rust... but then that would leak into pyo3-object_store and I want that to be self contained and not require other users of pyo3-object_store to have a dependency on some Python package where the exception is defined.

So I think the best way forward for now is to choose one or the other. Since we're already using FileNotFoundError, let's just use that one.

The primary downside is that obstore.exceptions.BaseError is not universally the base of everything we raise.

Closes#197, closes#199

[lukasbindreiter]

The only small downside with fully using builtins.FileNotFoundError I think is it's name - since no files are necessarily involved.

fromobstore.storeimportMemoryStoreMemoryStore().get("non-existent") # FileNotFoundError# no files involved anywhere

I guess that's why the exception in obstore was just named NotFoundError?
For the above example KeyError would probably be the more appropriate, but then for other stores not really.

[kylebarron]

All stores will raise the same exceptions, that's for sure. Having different stores raise different exceptions would be so confusing IMO

[lukasbindreiter]

Having different stores raise different exceptions would be so confusing IMO

yeah for sure, totally agree with that. Just wanted to mention that FileNotFoundError itself may also be confusing in certain scenarios - but for now it is the best approach for sure.

[kylebarron]

Custom exceptions with multiple inheritance are not currently possible in pyo3 (at least to define on the Rust side). See PyO3/pyo3#4979

You could have a custom exception with multiple inheritance if you defined it on the Python side and then imported it into Rust... but then that would leak into pyo3-object_store and I want that to be self contained and not require other users of pyo3-object_store to have a dependency on some Python package where the exception is defined.

So I think the best way forward for now is to choose one or the other. Since we're already using FileNotFoundError, let's just use that one.

The primary downside is that obstore.exceptions.BaseError is not universally the base of everything we raise.

Closes#197, closes#199

[lukasbindreiter]

The only small downside with fully using builtins.FileNotFoundError I think is it's name - since no files are necessarily involved.

fromobstore.storeimportMemoryStoreMemoryStore().get("non-existent") # FileNotFoundError# no files involved anywhere

I guess that's why the exception in obstore was just named NotFoundError?
For the above example KeyError would probably be the more appropriate, but then for other stores not really.

[kylebarron]

All stores will raise the same exceptions, that's for sure. Having different stores raise different exceptions would be so confusing IMO

[lukasbindreiter]

Having different stores raise different exceptions would be so confusing IMO

yeah for sure, totally agree with that. Just wanted to mention that FileNotFoundError itself may also be confusing in certain scenarios - but for now it is the best approach for sure.

[kylebarron]

Custom exceptions with multiple inheritance are not currently possible in pyo3 (at least to define on the Rust side). See PyO3/pyo3#4979

You could have a custom exception with multiple inheritance if you defined it on the Python side and then imported it into Rust... but then that would leak into pyo3-object_store and I want that to be self contained and not require other users of pyo3-object_store to have a dependency on some Python package where the exception is defined.

So I think the best way forward for now is to choose one or the other. Since we're already using FileNotFoundError, let's just use that one.

The primary downside is that obstore.exceptions.BaseError is not universally the base of everything we raise.

Closes#197, closes#199

[lukasbindreiter]

The only small downside with fully using builtins.FileNotFoundError I think is it's name - since no files are necessarily involved.

fromobstore.storeimportMemoryStoreMemoryStore().get("non-existent") # FileNotFoundError# no files involved anywhere

I guess that's why the exception in obstore was just named NotFoundError?
For the above example KeyError would probably be the more appropriate, but then for other stores not really.

[kylebarron]

All stores will raise the same exceptions, that's for sure. Having different stores raise different exceptions would be so confusing IMO

[lukasbindreiter]

Having different stores raise different exceptions would be so confusing IMO

yeah for sure, totally agree with that. Just wanted to mention that FileNotFoundError itself may also be confusing in certain scenarios - but for now it is the best approach for sure.

[kylebarron]

Custom exceptions with multiple inheritance are not currently possible in pyo3 (at least to define on the Rust side). See PyO3/pyo3#4979

You could have a custom exception with multiple inheritance if you defined it on the Python side and then imported it into Rust... but then that would leak into pyo3-object_store and I want that to be self contained and not require other users of pyo3-object_store to have a dependency on some Python package where the exception is defined.

So I think the best way forward for now is to choose one or the other. Since we're already using FileNotFoundError, let's just use that one.

The primary downside is that obstore.exceptions.BaseError is not universally the base of everything we raise.

Closes#197, closes#199

[lukasbindreiter]

The only small downside with fully using builtins.FileNotFoundError I think is it's name - since no files are necessarily involved.

fromobstore.storeimportMemoryStoreMemoryStore().get("non-existent") # FileNotFoundError# no files involved anywhere

I guess that's why the exception in obstore was just named NotFoundError?
For the above example KeyError would probably be the more appropriate, but then for other stores not really.

[kylebarron]

All stores will raise the same exceptions, that's for sure. Having different stores raise different exceptions would be so confusing IMO

[lukasbindreiter]

Having different stores raise different exceptions would be so confusing IMO

yeah for sure, totally agree with that. Just wanted to mention that FileNotFoundError itself may also be confusing in certain scenarios - but for now it is the best approach for sure.

[kylebarron]

Custom exceptions with multiple inheritance are not currently possible in pyo3 (at least to define on the Rust side). See PyO3/pyo3#4979

You could have a custom exception with multiple inheritance if you defined it on the Python side and then imported it into Rust... but then that would leak into pyo3-object_store and I want that to be self contained and not require other users of pyo3-object_store to have a dependency on some Python package where the exception is defined.

So I think the best way forward for now is to choose one or the other. Since we're already using FileNotFoundError, let's just use that one.

The primary downside is that obstore.exceptions.BaseError is not universally the base of everything we raise.

Closes#197, closes#199

[lukasbindreiter]

The only small downside with fully using builtins.FileNotFoundError I think is it's name - since no files are necessarily involved.

fromobstore.storeimportMemoryStoreMemoryStore().get("non-existent") # FileNotFoundError# no files involved anywhere

I guess that's why the exception in obstore was just named NotFoundError?
For the above example KeyError would probably be the more appropriate, but then for other stores not really.

[kylebarron]

All stores will raise the same exceptions, that's for sure. Having different stores raise different exceptions would be so confusing IMO

[lukasbindreiter]

Having different stores raise different exceptions would be so confusing IMO

yeah for sure, totally agree with that. Just wanted to mention that FileNotFoundError itself may also be confusing in certain scenarios - but for now it is the best approach for sure.