Return correct path if windows or linux

I think you can lean on a class-variable to create your base paths, and then define the functions to use that variable:

import os
from sys import platform

class GetAllPaths:
    """
    Return file and paths directions
    """

    if platform == "win32":
        root = 'C:\Users'
    elif platform == 'linux':
        root = '/home'
    else:
        # Probably raise an exception here
        raise Exception(f"Platform {platform} not supported")

    def test(self):
        return os.path.join(self.root, "test.py")

    def test2(self):
        return os.path.join(self.root, "test2.py")

    def test_flag(self):
        # new_manual_url.flag
        return os.path.join(self.root, "*test.flag")

    def kill_flag(self):
        # kill_*.txt
        return os.path.join(self.root, "*kill_*.flag")

    def restart(self):
        # start_*.txt
        return os.path.join(self.root, "*start_*.flag")

Furthermore, you'll notice that I'm using os.path.join, this way you don't have to worry about hard-coding the path separators.

Even more DRY would be to use a decorator on each of these functions which cuts down on repeated code:

import os
from functools import wraps
from sys import platform


class GetAllPaths:
    if platform == "win32":
        root = 'C:\Users'
    elif platform == 'linux':
        root = '/home'
    else:
        # Probably raise an exception here
        raise Exception(f"Platform {platform} not supported")

    def _add_platform(f):
        @wraps(f)
        def wrapper(self):
            path = f(self)
            return os.path.join(self.root, path)
        return wrapper

    
    @_add_platform
    def test(self):
        return "test.py"

    
    @_add_platform
    def test2(self):
        return "test2.py"


    @_add_platform
    def test_flag(self):
        # new_manual_url.flag
        return "*test.flag"


    @_add_platform
    def kill_flag(self):
        # kill_*.txt
        return "*kill_*.flag"


    @_add_platform
    def restart(self):
        # start_*.txt
        return "*start_*.flag"

Ditch the class

Realistically, you don't need the class here. You can identify this by looking at how your functions are utilized. There's not any class or instance specific information being passed to your functions (decorator notwithstanding). This means that your class and a module are fairly indistinguishable. To see this without a class, you might put all of this code into a new file, say get_all_paths.py:

# get_all_paths.py
import os
from functools import wraps
from sys import platform


if platform == "win32":
    root = 'C:\Users'
elif platform == 'linux':
    root = '/home'
else:
    # Probably raise an exception here
    raise Exception(f"Platform {platform} not supported")


def add_platform(f):
    @wraps(f)
    def wrapper(*args, **kwargs):
        path = f(*args, **kwargs)
        return os.path.join(root, path)
    return wrapper


@add_platform
def test():
    return "test.py"


@add_platform
def test2():
    return "test2.py"


@add_platform
def test_flag():
    # new_manual_url.flag
    return "*test.flag"


@add_platform
def kill_flag():
    # kill_*.txt
    return "*kill_*.flag"


@add_platform
def restart():
    # start_*.txt
    return "*start_*.flag"

Where now, you can use your functions through a global import:

import get_all_paths as g

g.test()
'/home/test.py'
```