I have a couple reservations here. In the provided example, CustomError is used as a snap-in replacement for ValueError. The error message already makes it clear where the error comes from, because it is set by the programmer. So the exception handler does not provide a lot of additional insight.

Should you even raise an exception in this case? I find that debatable, because you can easily prevent the error in the first place by checking the value. In a real scenario, you might want to perform even more checks.

That being said, raising an exception is useful when you want to add an entry to the error logs, or when you want some corrective action to take place, like a cleanup routine (even though a context manager or a Finally clause can take care of that).

Minor points

Some statements can be simplified just a little:

self.source_line = linecache.getline(self.file_name,self.line).strip()
        if not self.source_line:
            self.source_line = "<unavailable

Slightly more succinct:

self.source_line = linecache.getline(self.file_name,self.line).strip() or "<unavailable source>"

However, there is a possible flaw here. If linecache.getline returns None, then the .strip you are applying could fail and raise an exception. But wait, let's look at the docs, because I admit I am not familiar with this lib. Sounds like you are in the clear here:

Get line lineno from file named filename. This function will never raise an exception — it will return '' on errors (the terminating newline character will be included for lines that are found).

I believe the frame object properties eg f_lineno etc should all be present, so hopefully no surprises here.

Instead of:

self.file_name = "<unknown file>"
self.func_name = "<unknown func>"

I would use None as a value. That simplifies parsing, and makes it clear that the value is not initialized or not yet known. The programmer retrieving these values from the exception can still reformat the error message as desired.

In __repr__ you use self.__class__.__name__ to identify your class, good idea. You can do the same in the __str__ method.

Stack trace

In more complex situations, the full stack trace is really helpful to have the context of the error, so that the programmer can dig hard into the logs and fix the issue. Perhaps you should consider making it available as an option. The idea should be to add more context and insight, not suppress useful information.

If the intention is really to generalize usage of this class, as an all-purpose exception handler, this could be problematic because we may want to handle exceptions differently, depending on their type. Some exceptions are recoverable, like transient network errors, whereas other exceptions are more fatal and point to a flaw in the program that cannot be easily managed.

This appears to be a very useful class. As per my comment to your post, I think one would prefer to create the CustomError instance and "raise it" on the same line so that you are reporting where the exception is being raised rather than where the instance was created.

Method CustomError.__init__

Although this method "works", I do think it can be improved so that the logic is a bit clearer and unnecessary initializations are removed. You unconditionally execute the statement ...

self.source_line = linecache.getline(self.file_name,self.line).strip()

... even when there is no current frame and the arguments to linecache.getline would be "<unknown file>" and "<unknown func>". There is not much value in that.

You initialize self.file_name to "<unknown file>" and self.func_name to "<unknown func>" up front, which is an unnecessary initialization when the current frame can be found and these values will be replaced with new assignments. Using an "if-then-else" can improve clarity and efficiency.

If for some reason frame_error = frame_current.f_back raises an exception, then in your finally block, you will be attempting to delete frame_error, which will be None. So you need to check its value before deleting it. And you should move the initialization statement frame_error = None to a position where it makes more sense, i.e. within the if frame_current: block.

Putting it all together:

class CustomError(Exception):
    ...

    def __init__(self, msg:str, info:bool = False):
        super().__init__(msg)
        self.info = info
        frame_current = inspect.currentframe()
        if frame_current:
            frame_error = None
            try:
                frame_error = frame_current.f_back
                code = frame_error.f_code
                self.line = frame_error.f_lineno
                self.file_name = code.co_filename
                self.func_name = code.co_name
                self.source_line = linecache.getline(self.file_name,self.line).strip()
                if not self.source_line:
                    self.source_line = "<unavailable source>"
            finally:
                if frame_error:
                    del frame_error
                del frame_current
        else:
            self.line = "<unavailable source>"
            self.source_line = self.line
            self.file_name = "<unknown file>"
            self.func_name = "<unknown func>"