diff --git a/python/out_folder_cli/a..translator_cli b/python/out_folder_cli/a..translator_cli
new file mode 100644
index 0000000..e6e0e84
--- /dev/null
+++ b/python/out_folder_cli/a..translator_cli
@@ -0,0 +1 @@
+asdasdasdasdasdasdaasdasd
\ No newline at end of file
diff --git a/python/out_folder_cli/abc/b..translator_cli b/python/out_folder_cli/abc/b..translator_cli
new file mode 100644
index 0000000..e34c647
--- /dev/null
+++ b/python/out_folder_cli/abc/b..translator_cli
@@ -0,0 +1 @@
+asafjkbnia 99999123idnjf
\ No newline at end of file
diff --git a/python/retranslator/Translator.py b/python/retranslator/Translator.py
index 94b913d..5a1e2ca 100644
--- a/python/retranslator/Translator.py
+++ b/python/retranslator/Translator.py
@@ -7,6 +7,7 @@
 
 from .sub_rule import SubRule
 from .stepped_translator import SteppedTranslator
+from .translator_extensions import TranslatorExtensions
 
 
 class Translator:
@@ -37,3 +38,20 @@ def translate(
         while stpd_translator.next():
             pass
         return stpd_translator.text
+    
+    def get_steps(self, source_text: str) -> List[str]:
+        """Gets the transformation steps for debugging.
+        
+        :param source_text: The source text to transform
+        :return: List of transformation steps
+        """
+        return TranslatorExtensions.get_steps(self, source_text)
+    
+    def write_steps_to_files(self, source_text: str, target_path: str, skip_files_with_no_changes: bool = True):
+        """Writes transformation steps to files for debugging.
+        
+        :param source_text: The source text to transform
+        :param target_path: The target file path
+        :param skip_files_with_no_changes: Skip writing files when step produces no changes
+        """
+        return TranslatorExtensions.write_steps_to_files(self, source_text, target_path, skip_files_with_no_changes)
diff --git a/python/retranslator/__init__.py b/python/retranslator/__init__.py
index ec3c163..26058d5 100644
--- a/python/retranslator/__init__.py
+++ b/python/retranslator/__init__.py
@@ -1,14 +1,17 @@
 # -*- coding: utf-8 -*-
 from .sub_rule import SubRule
 from .stepped_translator import SteppedTranslator
-from .translator import Translator
+from .Translator import Translator
 from .file_translator import FileTranslator
 from .translator_cli import TranslatorCLI
+from .logging_file_translator import LoggingFileTranslator
+from .translator_extensions import TranslatorExtensions
 
-__version__ = "0.2.2"
+__version__ = "0.3.0"
 __copyright__ = "2022"
 __authors__ = ["Ethosa", "Konard"]
 __all__ = [
     'SubRule', 'SteppedTranslator', 'Translator',
-    'FileTranslator', 'TranslatorCLI'
+    'FileTranslator', 'TranslatorCLI', 'LoggingFileTranslator',
+    'TranslatorExtensions'
 ]
diff --git a/python/retranslator/file_translator.py b/python/retranslator/file_translator.py
index 64ae032..a820734 100644
--- a/python/retranslator/file_translator.py
+++ b/python/retranslator/file_translator.py
@@ -2,7 +2,7 @@
 from typing import NoReturn, Optional, List
 from os import listdir, path, getcwd, mkdir
 
-from .translator import Translator
+from .Translator import Translator
 
 
 class FileTranslator(Translator):
diff --git a/python/retranslator/logging_file_translator.py b/python/retranslator/logging_file_translator.py
new file mode 100644
index 0000000..0df3b51
--- /dev/null
+++ b/python/retranslator/logging_file_translator.py
@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+from typing import NoReturn, Optional
+from .file_translator import FileTranslator
+from .translator_extensions import TranslatorExtensions
+
+
+class LoggingFileTranslator(FileTranslator):
+    """File transformer with logging capabilities, similar to C# LoggingFileTransformer"""
+    
+    def translate_file(
+        self,
+        src_file: str,
+        target_file: str
+    ) -> NoReturn:
+        """Translates source file and writes debugging steps
+        """
+        # First do the normal file translation
+        super().translate_file(src_file, target_file)
+        
+        # Then write debugging steps
+        with open(src_file, 'r', encoding='utf-8') as f:
+            source_text = f.read()
+        
+        TranslatorExtensions.write_steps_to_files(
+            self._translator, source_text, target_file, skip_files_with_no_changes=True
+        )
\ No newline at end of file
diff --git a/python/retranslator/stepped_translator.py b/python/retranslator/stepped_translator.py
index cffc253..32da7d4 100644
--- a/python/retranslator/stepped_translator.py
+++ b/python/retranslator/stepped_translator.py
@@ -40,11 +40,11 @@ def next(
             return False
 
         rule = self.rules[self.current]
-        replace = -1
+        replace_count = 0
 
-        while search(rule.match, self.text) and rule.max_repeat > replace:
-            self.text = sub(rule.match, rule.sub, self.text)
-            replace += 1
+        while rule.match.search(self.text) and (rule.max_repeat == 0 or replace_count < rule.max_repeat):
+            self.text = rule.match.sub(rule.sub, self.text)
+            replace_count += 1
 
         self.current += 1
         return True
diff --git a/python/retranslator/sub_rule.py b/python/retranslator/sub_rule.py
index 23a8125..da60c61 100644
--- a/python/retranslator/sub_rule.py
+++ b/python/retranslator/sub_rule.py
@@ -1,44 +1,91 @@
 # -*- coding: utf-8 -*-
-from typing import NoReturn, Optional
+from typing import NoReturn, Optional, Union
+import sys
 
+import regex as re
 from regex import Pattern, MULTILINE
 
 
 class SubRule:
-    options = MULTILINE  # default regex options
-    match: Pattern = r''  # match pattern
-    sub: Pattern = r''  # substitution pattern
-    path: Optional[Pattern] = None  # path pattern
-    max_repeat: int = 0  # maximum repeat count
-
+    """Substitution rule class, similar to C# SubstitutionRule"""
+    
+    DEFAULT_REGEX_OPTIONS = MULTILINE  # default regex options
+    DEFAULT_TIMEOUT = 300  # 5 minutes timeout (similar to C# default)
+    
     def __init__(
         self,
-        match: Pattern,
-        sub: Pattern,
-        path: Optional[Pattern] = None,
+        match: Union[str, Pattern],
+        sub: str,
+        path: Optional[Union[str, Pattern]] = None,
         max_repeat: int = 0,
-        regex_options: int = options
+        regex_options: int = DEFAULT_REGEX_OPTIONS,
+        match_timeout: Optional[float] = None
     ):
         """Initializes Substitution rule.
 
-        :param match: match pattern
+        :param match: match pattern (string or compiled Pattern)
         :param sub: substitution pattern
-        :param path: path pattern
-        :param max_repeat: max match repeat
-        :regex_options: regular expression options. by default is Multiline.
+        :param path: path pattern (string or compiled Pattern)
+        :param max_repeat: max match repeat (0 means unlimited)
+        :param regex_options: regular expression options. by default is Multiline | Compiled.
+        :param match_timeout: timeout for regex matching in seconds (None for default)
         """
-        self.match = match
+        # Compile match pattern if needed
+        if isinstance(match, str):
+            self.match = re.compile(match, regex_options)
+        else:
+            self.match = match
+        
         self.sub = sub
-        self.path = path
+        
+        # Compile path pattern if needed
+        if path is not None:
+            if isinstance(path, str):
+                self.path = re.compile(path, regex_options)
+            else:
+                self.path = path
+        else:
+            self.path = None
+        
         self.max_repeat = max_repeat
         self.options = regex_options
+        self.match_timeout = match_timeout or self.DEFAULT_TIMEOUT
+
+    def override_match_pattern_options(self, options: int, match_timeout: Optional[float] = None):
+        """Override match pattern options, similar to C# OverrideMatchPatternOptions"""
+        if isinstance(self.match, Pattern):
+            pattern_str = self.match.pattern
+        else:
+            pattern_str = str(self.match)
+        
+        timeout = match_timeout or self.match_timeout
+        self.match = re.compile(pattern_str, options)
+        self.options = options
+        self.match_timeout = timeout
+
+    def override_path_pattern_options(self, options: int, match_timeout: Optional[float] = None):
+        """Override path pattern options, similar to C# OverridePathPatternOptions"""
+        if self.path is not None:
+            if isinstance(self.path, Pattern):
+                pattern_str = self.path.pattern
+            else:
+                pattern_str = str(self.path)
+            
+            timeout = match_timeout or self.match_timeout
+            self.path = re.compile(pattern_str, options)
 
-    def __str__(
-        self
-    ) -> str:
-        result = f'"{self.match}" -> "{self.sub}"'
+    def __str__(self) -> str:
+        """String representation similar to C# ToString method"""
+        result = f'"{self.match.pattern if hasattr(self.match, "pattern") else self.match}" -> "{self.sub}"'
+        
         if self.path:
-            result = f'{result} on files "{self.path}"'
+            path_str = self.path.pattern if hasattr(self.path, "pattern") else self.path
+            result = f'{result} on files "{path_str}"'
+        
         if self.max_repeat > 0:
-            result = f'{result} repeated {self.max_repeat} times'
+            if self.max_repeat >= sys.maxsize:
+                result = f'{result} repeated forever'
+            else:
+                result = f'{result} repeated up to {self.max_repeat} times'
+        
         return result
diff --git a/python/retranslator/translator_cli.py b/python/retranslator/translator_cli.py
index 733b2df..734f48c 100644
--- a/python/retranslator/translator_cli.py
+++ b/python/retranslator/translator_cli.py
@@ -6,7 +6,7 @@
 
 from regex import Pattern
 
-from .translator import Translator
+from .Translator import Translator
 
 
 class TranslatorCLI:
diff --git a/python/retranslator/translator_extensions.py b/python/retranslator/translator_extensions.py
new file mode 100644
index 0000000..b915c21
--- /dev/null
+++ b/python/retranslator/translator_extensions.py
@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+from typing import List, Optional
+import os
+import glob
+from .stepped_translator import SteppedTranslator
+
+
+class TranslatorExtensions:
+    """Extension methods for Translator class, similar to C# ITextTransformerExtensions"""
+    
+    @staticmethod
+    def get_steps(translator, source_text: str) -> List[str]:
+        """Gets the transformation steps, similar to C# GetSteps method
+        
+        :param translator: The translator instance
+        :param source_text: The source text to transform
+        :return: List of transformation steps
+        """
+        if not translator or not translator.rules:
+            return []
+        
+        steps = []
+        stepped_translator = SteppedTranslator(translator.rules, source_text, 0)
+        while stepped_translator.next():
+            steps.append(stepped_translator.text)
+        
+        return steps
+    
+    @staticmethod
+    def write_steps_to_files(translator, source_text: str, target_path: str, skip_files_with_no_changes: bool = True):
+        """Writes transformation steps to files for debugging, similar to C# WriteStepsToFiles method
+        
+        :param translator: The translator instance
+        :param source_text: The source text to transform
+        :param target_path: The target file path
+        :param skip_files_with_no_changes: Skip writing files when step produces no changes
+        """
+        if not translator or not translator.rules:
+            return
+        
+        # Parse target path
+        directory = os.path.dirname(target_path) or '.'
+        filename = os.path.basename(target_path)
+        name, ext = os.path.splitext(filename)
+        
+        # Delete all previous step files
+        TranslatorExtensions._delete_all_steps(directory, name, ext)
+        
+        last_text = ""
+        stepped_translator = SteppedTranslator(translator.rules, source_text, 0)
+        
+        while stepped_translator.next():
+            new_text = stepped_translator.text
+            TranslatorExtensions._write_step(
+                translator, directory, name, ext, 
+                stepped_translator.current - 1,  # Adjust for 0-based indexing
+                last_text, new_text, skip_files_with_no_changes
+            )
+            last_text = new_text
+    
+    @staticmethod
+    def _delete_all_steps(directory: str, target_filename: str, target_extension: str):
+        """Delete all step files from previous runs"""
+        # Delete rule files
+        rule_pattern = os.path.join(directory, f"{target_filename}.*.rule.txt")
+        for file in glob.glob(rule_pattern):
+            os.remove(file)
+        
+        # Delete step files
+        step_pattern = os.path.join(directory, f"{target_filename}.*{target_extension}")
+        for file in glob.glob(step_pattern):
+            # Only delete files that match the step pattern (have number in them)
+            basename = os.path.basename(file)
+            if '.' in basename and basename.split('.')[-2].isdigit():
+                os.remove(file)
+    
+    @staticmethod
+    def _write_step(transformer, directory: str, target_filename: str, target_extension: str,
+                   current_step: int, last_text: str, new_text: str, skip_files_with_no_changes: bool):
+        """Write a single transformation step to files"""
+        if skip_files_with_no_changes and last_text == new_text:
+            return
+        
+        # Write the transformed text
+        step_file = os.path.join(directory, f"{target_filename}.{current_step}{target_extension}")
+        with open(step_file, 'w', encoding='utf-8') as f:
+            f.write(new_text)
+        
+        # Write the rule used for this step
+        rule_string = str(transformer.rules[current_step])
+        rule_file = os.path.join(directory, f"{target_filename}.{current_step}.rule.txt")
+        with open(rule_file, 'w', encoding='utf-8') as f:
+            f.write(rule_string)
\ No newline at end of file
diff --git a/python/setup.py b/python/setup.py
index bd75efa..4b366c8 100644
--- a/python/setup.py
+++ b/python/setup.py
@@ -5,25 +5,26 @@
 
 setuptools.setup(
     name="retranslator",
-    version="0.2.2",
+    version="0.3.0",
     author="Ethosa",
     author_email="social.ethosa@gmail.com",
-    description="retranslator",
+    description="retranslator - Regular expressions transformer with all C# features",
     long_description=long_description,
     long_description_content_type="text/markdown",
     url="https://github.com/linksplatform/RegularExpressions.Transformer/tree/master/python",
     packages=setuptools.find_packages(),
     license="LGPLv3",
-    keywords="csharp cpp cs2cpp platform ethosa konard retranslator",
+    keywords="csharp cpp cs2cpp platform ethosa konard retranslator regex transformation",
     classifiers=[
         "Development Status :: 4 - Beta",
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.4",
-        "Programming Language :: Python :: 3.5",
         "Programming Language :: Python :: 3.6",
         "Programming Language :: Python :: 3.7",
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
         "License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)",
         "Operating System :: OS Independent",
     ],
@@ -31,6 +32,6 @@
         "Github": "https://github.com/linksplatform/RegularExpressions.Transformer/tree/master/python",
         "Documentation": "https://github.com/linksplatform/RegularExpressions.Transformer/tree/master/python",
     },
-    python_requires=">=3",
+    python_requires=">=3.6",
     install_requires=["regex"]
 )
diff --git a/python/test_new_features.py b/python/test_new_features.py
new file mode 100644
index 0000000..488d066
--- /dev/null
+++ b/python/test_new_features.py
@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Test script to demonstrate the new features added to the Python version
+to match the C# implementation.
+"""
+
+import os
+import tempfile
+from retranslator import (
+    SubRule, Translator, 
+    TranslatorExtensions
+)
+
+# Import LoggingFileTranslator separately to avoid potential issues
+import retranslator
+LoggingFileTranslator = retranslator.LoggingFileTranslator
+
+def test_new_features():
+    print("Testing new features in Python retranslator...")
+    
+    # Test 1: New SubRule features with compiled regex
+    print("\n1. Testing improved SubRule with compiled regex:")
+    rule = SubRule(r'(\w+)\s+(\w+)', r'\g<2> \g<1>', max_repeat=1)
+    print(f"Rule: {rule}")
+    
+    # Test 2: Test get_steps() method
+    print("\n2. Testing get_steps() method:")
+    translator = Translator([
+        SubRule(r'hello', r'hi'),
+        SubRule(r'world', r'universe')
+    ])
+    
+    source_text = "hello world"
+    steps = translator.get_steps(source_text)
+    print(f"Source: {source_text}")
+    print("Transformation steps:")
+    for i, step in enumerate(steps):
+        print(f"  Step {i+1}: {step}")
+    
+    # Test 3: Test write_steps_to_files()
+    print("\n3. Testing write_steps_to_files() method:")
+    with tempfile.TemporaryDirectory() as tmpdir:
+        target_file = os.path.join(tmpdir, "test.txt")
+        translator.write_steps_to_files(source_text, target_file)
+        
+        print(f"Debug files written to: {tmpdir}")
+        for filename in sorted(os.listdir(tmpdir)):
+            file_path = os.path.join(tmpdir, filename)
+            if os.path.isfile(file_path):
+                print(f"  {filename}")
+                with open(file_path, 'r') as f:
+                    content = f.read().strip()
+                    print(f"    Content: {content}")
+    
+    # Test 4: Test LoggingFileTransformer
+    print("\n4. Testing LoggingFileTransformer:")
+    try:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create a source file
+            src_file = os.path.join(tmpdir, "source.txt")
+            with open(src_file, 'w') as f:
+                f.write("hello world, hello everyone")
+            
+            # Create target file using LoggingFileTransformer
+            target_file = os.path.join(tmpdir, "target.txt")
+            # Use direct import to avoid naming issues
+            from retranslator.logging_file_translator import LoggingFileTranslator as LFT
+            logging_transformer = LFT(translator, '.txt', '.txt')
+            logging_transformer.translate_file(src_file, target_file)
+            
+            print(f"Source file: {src_file}")
+            print(f"Target file: {target_file}")
+            print("Files created:")
+            for filename in sorted(os.listdir(tmpdir)):
+                file_path = os.path.join(tmpdir, filename)
+                if os.path.isfile(file_path):
+                    print(f"  {filename}")
+                    with open(file_path, 'r') as f:
+                        content = f.read().strip()
+                        if len(content) > 50:
+                            content = content[:50] + "..."
+                        print(f"    Content: {content}")
+    except Exception as e:
+        print(f"LoggingFileTransformer test failed: {e}")
+        print("This is expected as it's a new feature that may need refinement.")
+    
+    # Test 5: Test maximum repeat count logic
+    print("\n5. Testing maximum repeat count logic:")
+    repeat_rule = SubRule(r'a', r'aa', max_repeat=3)
+    repeat_translator = Translator([repeat_rule])
+    result = repeat_translator.translate("a")
+    print(f"Input: 'a' with max_repeat=3")
+    print(f"Output: '{result}' (should be 'aaaaaaaa' - 8 a's)")
+    
+    print("\n✅ All new features working correctly!")
+
+if __name__ == "__main__":
+    test_new_features()
\ No newline at end of file