ai-pack-cli 0.1.2__tar.gz → 0.1.7__tar.gz

{ai_pack_cli-0.1.2/ai_pack_cli.egg-info → ai_pack_cli-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ai-pack-cli
-Version: 0.1.2
+Version: 0.1.7
 Home-page: https://github.com/iamraydoan/ai-pack
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
@@ -8,6 +8,8 @@ Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
 Requires-Dist: pyperclip>=1.8.2
 Requires-Dist: questionary>=1.10.0
+Requires-Dist: codesigs>=0.0.1; python_version >= "3.9"
+Requires-Dist: ast-grep-py<=0.39.7; python_version == "3.9"
 
 # 📦 ai-pack
 
@@ -72,6 +74,14 @@ curl -o ~/.local/bin/aip https://raw.githubusercontent.com/iamraydoan/ai-pack/ma
 ```
 *(Note: If you run it standalone, you will need to manually run `pip3 install pyperclip questionary` to enable all optional interactive and clipboard features).*
 
+> [!TIP]
+> **Optional backend for Skeleton Mode (`--skeleton`)**:
+> If you plan to use skeleton extraction for non-Python languages (such as JavaScript, TypeScript, Go, Rust, Java, C#, C++, PHP, Lua, CSS, Swift, and Kotlin), you must install `ast-grep` globally:
+> ```bash
+> npm install -g @ast-grep/cli
+> # or: cargo install ast-grep
+> ```
+
 
 ### Usage Examples
 
@@ -123,7 +133,12 @@ def fibonacci(n):
     ...
 ```
 
-*Supports Python and all brace-delimited languages (JS, TS, Go, Rust, C++, Java, Swift, etc.)*
+*Supports Python, JavaScript, TypeScript, Go, Rust, Java, C#, C++, PHP, Lua, CSS, Swift, and Kotlin via codesigs and ast-grep.*
+
+> [!IMPORTANT]
+> **Skeleton Mode Dependencies**:
+> * **Python >= 3.9**: Required to run the `--skeleton` feature.
+> * **ast-grep**: For non-Python languages, the `ast-grep` command-line tool must be installed globally (e.g. via npm: `npm install -g @ast-grep/cli` or cargo: `cargo install ast-grep`).
 
 ---
 

ai_pack_cli-0.1.2/PKG-INFO → ai_pack_cli-0.1.7/README.md

@@ -1,14 +1,3 @@
-Metadata-Version: 2.1
-Name: ai-pack-cli
-Version: 0.1.2
-Home-page: https://github.com/iamraydoan/ai-pack
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Description-Content-Type: text/markdown
-Requires-Dist: pyperclip>=1.8.2
-Requires-Dist: questionary>=1.10.0
-
 # 📦 ai-pack
 
 [![Python Version](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/)
@@ -72,6 +61,14 @@ curl -o ~/.local/bin/aip https://raw.githubusercontent.com/iamraydoan/ai-pack/ma
 ```
 *(Note: If you run it standalone, you will need to manually run `pip3 install pyperclip questionary` to enable all optional interactive and clipboard features).*
 
+> [!TIP]
+> **Optional backend for Skeleton Mode (`--skeleton`)**:
+> If you plan to use skeleton extraction for non-Python languages (such as JavaScript, TypeScript, Go, Rust, Java, C#, C++, PHP, Lua, CSS, Swift, and Kotlin), you must install `ast-grep` globally:
+> ```bash
+> npm install -g @ast-grep/cli
+> # or: cargo install ast-grep
+> ```
+
 
 ### Usage Examples
 
@@ -123,7 +120,12 @@ def fibonacci(n):
     ...
 ```
 
-*Supports Python and all brace-delimited languages (JS, TS, Go, Rust, C++, Java, Swift, etc.)*
+*Supports Python, JavaScript, TypeScript, Go, Rust, Java, C#, C++, PHP, Lua, CSS, Swift, and Kotlin via codesigs and ast-grep.*
+
+> [!IMPORTANT]
+> **Skeleton Mode Dependencies**:
+> * **Python >= 3.9**: Required to run the `--skeleton` feature.
+> * **ast-grep**: For non-Python languages, the `ast-grep` command-line tool must be installed globally (e.g. via npm: `npm install -g @ast-grep/cli` or cargo: `cargo install ast-grep`).
 
 ---
 

{ai_pack_cli-0.1.2 → ai_pack_cli-0.1.7}/ai_pack.py

@@ -195,211 +195,31 @@ class SkeletonExtractor:
 
     @staticmethod
     def get_skeleton(file_path: str, content: str) -> str:
-        ext = os.path.splitext(file_path)[1].lower()
-        if ext == ".py":
-            return SkeletonExtractor.extract_python_skeleton(content)
-        elif ext in (".js", ".ts", ".jsx", ".tsx", ".go", ".rs", ".cpp", ".c", ".h", ".hpp", ".java", ".cs", ".php", ".swift"):
-            return SkeletonExtractor.extract_brace_skeleton(content)
-        else:
-            # Fallback: keep full content for configuration, text, markdown, or unrecognized files
-            return content
+        try:
+            from codesigs import file_sigs
+            sigs = file_sigs(file_path)
+            if sigs is not None:
+                return "\n".join(sigs)
+        except ImportError:
+            print("⚠️ Error: 'codesigs' package is required for --skeleton mode.", file=sys.stderr)
+            print("💡 Please install it using: pip install ai-pack-cli (requires Python >= 3.9)", file=sys.stderr)
+        except Exception as e:
+            print(f"⚠️ codesigs failed for {file_path}: {e}", file=sys.stderr)
+        return content
 
-    @staticmethod
-    def extract_python_skeleton(content: str) -> str:
-        lines = content.splitlines()
-        skeleton_lines = []
-        i = 0
-        n = len(lines)
-        decorator_buffer = []
-        
-        while i < n:
-            line = lines[i]
-            stripped = line.strip()
-            
-            # Keep track of decorators
-            if stripped.startswith("@"):
-                decorator_buffer.append(line)
-                i += 1
-                continue
-                
-            # If function signature
-            if stripped.startswith("def ") or stripped.startswith("async def "):
-                if decorator_buffer:
-                    skeleton_lines.extend(decorator_buffer)
-                    decorator_buffer = []
-                    
-                indent = len(line) - len(line.lstrip())
-                sig_lines = []
-                
-                # Consume multi-line signatures by tracking open parentheses/brackets
-                open_braces = 0
-                while i < n:
-                    line_to_add = lines[i]
-                    sig_lines.append(line_to_add)
-                    open_braces += line_to_add.count('(') - line_to_add.count(')')
-                    open_braces += line_to_add.count('[') - line_to_add.count(']')
-                    open_braces += line_to_add.count('{') - line_to_add.count('}')
-                    
-                    if open_braces <= 0 and ":" in line_to_add:
-                        break
-                    i += 1
-                    
-                skeleton_lines.extend(sig_lines)
-                
-                # Skip the function body (all lines indented further than indent)
-                i += 1
-                body_skipped = False
-                while i < n:
-                    next_line = lines[i]
-                    next_stripped = next_line.strip()
-                    if not next_stripped:
-                        i += 1
-                        continue
-                    next_indent = len(next_line) - len(next_line.lstrip())
-                    if next_indent <= indent:
-                        break
-                    body_skipped = True
-                    i += 1
-                    
-                if body_skipped:
-                    skeleton_lines.append(" " * (indent + 4) + "...")
-                decorator_buffer = []
-            else:
-                if decorator_buffer:
-                    skeleton_lines.extend(decorator_buffer)
-                    decorator_buffer = []
-                skeleton_lines.append(line)
-                i += 1
-                
-        return "\n".join(skeleton_lines)
 
-    @staticmethod
-    def extract_brace_skeleton(content: str) -> str:
-        """Parses brace-delimited languages to extract function definitions and omit bodies."""
-        result = []
-        i = 0
-        n = len(content)
-        
-        in_string = None
-        in_comment = None
-        brace_depth = 0
-        skip_until_brace_depth = None
-        prefix_buffer = []
-        
-        while i < n:
-            c = content[i]
-            
-            # --- 1. Handle Comments ---
-            if in_comment == 'single':
-                if c == '\n':
-                    in_comment = None
-                    if skip_until_brace_depth is None:
-                        result.append(c)
-                i += 1
-                continue
-            elif in_comment == 'multi':
-                if c == '/' and i > 0 and content[i-1] == '*':
-                    in_comment = None
-                i += 1
-                continue
-                
-            # --- 2. Handle Strings ---
-            if in_string:
-                if c == '\\' and i + 1 < n:
-                    escaped_char = content[i:i+2]
-                    if skip_until_brace_depth is None:
-                        result.append(escaped_char)
-                        prefix_buffer.append(escaped_char)
-                    i += 2
-                    continue
-                if skip_until_brace_depth is None:
-                    result.append(c)
-                    prefix_buffer.append(c)
-                if c == in_string:
-                    in_string = None
-                i += 1
-                continue
-                
-            # --- 3. Detect Comment Start (when not in string/comment) ---
-            if c == '/' and i + 1 < n:
-                next_c = content[i+1]
-                if next_c == '/':
-                    in_comment = 'single'
-                    i += 2
-                    continue
-                elif next_c == '*':
-                    in_comment = 'multi'
-                    i += 2
-                    continue
-                    
-            # --- 4. Detect String Start (when not in string/comment) ---
-            if c in ('"', "'", "`"):
-                in_string = c
-                if skip_until_brace_depth is None:
-                    result.append(c)
-                    prefix_buffer.append(c)
-                i += 1
-                continue
-                
-            # --- 5. Brace & Skipping Logic ---
-            if skip_until_brace_depth is not None:
-                if c == '{':
-                    brace_depth += 1
-                elif c == '}':
-                    brace_depth -= 1
-                    if brace_depth == skip_until_brace_depth:
-                        result.append(' { /* ... */ }')
-                        skip_until_brace_depth = None
-                i += 1
-                continue
-                
-            # Normal code processing
-            if c == '{':
-                prefix_str = "".join(prefix_buffer).strip()
-                is_func = False
-                
-                if '=>' in prefix_str:
-                    is_func = True
-                elif 'function' in prefix_str:
-                    is_func = True
-                elif 'constructor' in prefix_str:
-                    is_func = True
-                elif any(x in prefix_str for x in ('fn ', 'func ')):
-                    is_func = True
-                elif '(' in prefix_str and ')' in prefix_str:
-                    first_paren = prefix_str.find('(')
-                    name_part = prefix_str[:first_paren].strip()
-                    words = name_part.split()
-                    if words:
-                        clean_words = [w for w in words if w not in (
-                            'export', 'async', 'default', 'public', 'private', 'protected', 'static', 'readonly'
-                        )]
-                        if clean_words:
-                            first_word = clean_words[0].strip()
-                            if first_word not in ('if', 'for', 'while', 'switch', 'catch'):
-                                is_func = True
-                            
-                if is_func:
-                    skip_until_brace_depth = brace_depth
-                    brace_depth += 1
-                    prefix_buffer = []
-                else:
-                    brace_depth += 1
-                    result.append(c)
-                    prefix_buffer = []
-            elif c == '}':
-                brace_depth -= 1
-                result.append(c)
-                prefix_buffer = []
-            else:
-                result.append(c)
-                if c == '\n':
-                    prefix_buffer = []
-                else:
-                    prefix_buffer.append(c)
-            i += 1
-            
-        return "".join(result)
+def copy_via_osc52(payload: str) -> bool:
+    """Attempts to copy text to the client system clipboard using OSC 52 escape sequence."""
+    try:
+        import base64
+        # Base64 encode the payload
+        b64_data = base64.b64encode(payload.encode("utf-8")).decode("ascii")
+        # Write to stdout using the OSC 52 escape sequence: \x1b]52;c;[base64]\x07
+        sys.stdout.write(f"\x1b]52;c;{b64_data}\x07")
+        sys.stdout.flush()
+        return True
+    except Exception:
+        return False
 
 
 def walk_dir(directory: str, git_files: Set[str] = None, gitignore: GitignoreMatcher = None) -> List[str]:
@@ -656,12 +476,20 @@ def main():
             print(f"❌ Error saving to file {args.output}: {e}", file=sys.stderr)
             sys.exit(1)
     else:
+        copied = False
         try:
             import pyperclip
             pyperclip.copy(payload)
+            copied = True
             print("🚀 Successfully copied to clipboard!")
-        except Exception as e:
-            print(f"❌ Error copying to clipboard: {e}", file=sys.stderr)
+        except Exception:
+            # Fallback to OSC 52 (works seamlessly over SSH / remote terminal sessions)
+            if copy_via_osc52(payload):
+                copied = True
+                print("🚀 Successfully copied to clipboard (via OSC 52 remote sequence)!")
+                
+        if not copied:
+            print("❌ Error copying to clipboard: Pyperclip could not find a copy/paste mechanism.", file=sys.stderr)
             print("💡 In headless Linux systems, you must install 'xclip' or 'xsel', or direct output to a file using the '-o' flag.", file=sys.stderr)
             sys.exit(1)
 

ai_pack_cli-0.1.2/README.md → ai_pack_cli-0.1.7/ai_pack_cli.egg-info/PKG-INFO

@@ -1,3 +1,16 @@
+Metadata-Version: 2.1
+Name: ai-pack-cli
+Version: 0.1.7
+Home-page: https://github.com/iamraydoan/ai-pack
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+Requires-Dist: pyperclip>=1.8.2
+Requires-Dist: questionary>=1.10.0
+Requires-Dist: codesigs>=0.0.1; python_version >= "3.9"
+Requires-Dist: ast-grep-py<=0.39.7; python_version == "3.9"
+
 # 📦 ai-pack
 
 [![Python Version](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/)
@@ -61,6 +74,14 @@ curl -o ~/.local/bin/aip https://raw.githubusercontent.com/iamraydoan/ai-pack/ma
 ```
 *(Note: If you run it standalone, you will need to manually run `pip3 install pyperclip questionary` to enable all optional interactive and clipboard features).*
 
+> [!TIP]
+> **Optional backend for Skeleton Mode (`--skeleton`)**:
+> If you plan to use skeleton extraction for non-Python languages (such as JavaScript, TypeScript, Go, Rust, Java, C#, C++, PHP, Lua, CSS, Swift, and Kotlin), you must install `ast-grep` globally:
+> ```bash
+> npm install -g @ast-grep/cli
+> # or: cargo install ast-grep
+> ```
+
 
 ### Usage Examples
 
@@ -112,7 +133,12 @@ def fibonacci(n):
     ...
 ```
 
-*Supports Python and all brace-delimited languages (JS, TS, Go, Rust, C++, Java, Swift, etc.)*
+*Supports Python, JavaScript, TypeScript, Go, Rust, Java, C#, C++, PHP, Lua, CSS, Swift, and Kotlin via codesigs and ast-grep.*
+
+> [!IMPORTANT]
+> **Skeleton Mode Dependencies**:
+> * **Python >= 3.9**: Required to run the `--skeleton` feature.
+> * **ast-grep**: For non-Python languages, the `ast-grep` command-line tool must be installed globally (e.g. via npm: `npm install -g @ast-grep/cli` or cargo: `cargo install ast-grep`).
 
 ---
 

{ai_pack_cli-0.1.2 → ai_pack_cli-0.1.7}/ai_pack_cli.egg-info/SOURCES.txt

@@ -9,5 +9,4 @@ ai_pack_cli.egg-info/requires.txt
 ai_pack_cli.egg-info/top_level.txt
 tests/test_binary.py
 tests/test_gitignore.py
-tests/test_skeleton_braces.py
-tests/test_skeleton_python.py
+tests/test_skeleton.py

ai_pack_cli-0.1.7/ai_pack_cli.egg-info/requires.txt

@@ -0,0 +1,8 @@
+pyperclip>=1.8.2
+questionary>=1.10.0
+
+[:python_version == "3.9"]
+ast-grep-py<=0.39.7
+
+[:python_version >= "3.9"]
+codesigs>=0.0.1

{ai_pack_cli-0.1.2 → ai_pack_cli-0.1.7}/setup.py

@@ -6,11 +6,13 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="ai-pack-cli",
-    version="0.1.2",
+    version="0.1.7",
     py_modules=["ai_pack"],
     install_requires=[
         "pyperclip>=1.8.2",
         "questionary>=1.10.0",
+        'codesigs>=0.0.1; python_version >= "3.9"',
+        'ast-grep-py<=0.39.7; python_version == "3.9"',
     ],
     entry_points={
         "console_scripts": [

ai_pack_cli-0.1.7/tests/test_skeleton.py

@@ -0,0 +1,41 @@
+import unittest
+from unittest.mock import patch, MagicMock
+import sys
+from io import StringIO
+from ai_pack import SkeletonExtractor
+
+class TestSkeletonExtractor(unittest.TestCase):
+    @patch('ai_pack.sys.stderr', new_callable=StringIO)
+    def test_get_skeleton_success(self, mock_stderr):
+        # Mock codesigs module in sys.modules
+        mock_codesigs = MagicMock()
+        mock_codesigs.file_sigs.return_value = ["def foo():", "    ..."]
+        
+        with patch.dict(sys.modules, {'codesigs': mock_codesigs}):
+            result = SkeletonExtractor.get_skeleton("test.py", "def foo():\n    pass")
+            self.assertEqual(result, "def foo():\n    ...")
+            mock_codesigs.file_sigs.assert_called_once_with("test.py")
+
+    @patch('ai_pack.sys.stderr', new_callable=StringIO)
+    def test_get_skeleton_import_error(self, mock_stderr):
+        # Clear sys.modules of any real codesigs import to trigger ImportError
+        original_modules = sys.modules.copy()
+        if 'codesigs' in sys.modules:
+            del sys.modules['codesigs']
+        try:
+            with patch.dict(sys.modules, {'codesigs': None}):
+                result = SkeletonExtractor.get_skeleton("test.py", "def foo():\n    pass")
+                self.assertEqual(result, "def foo():\n    pass")
+                self.assertIn("package is required", mock_stderr.getvalue())
+        finally:
+            sys.modules = original_modules
+
+    @patch('ai_pack.sys.stderr', new_callable=StringIO)
+    def test_get_skeleton_runtime_error(self, mock_stderr):
+        mock_codesigs = MagicMock()
+        mock_codesigs.file_sigs.side_effect = Exception("ast-grep not found")
+        
+        with patch.dict(sys.modules, {'codesigs': mock_codesigs}):
+            result = SkeletonExtractor.get_skeleton("test.py", "def foo():\n    pass")
+            self.assertEqual(result, "def foo():\n    pass")
+            self.assertIn("codesigs failed", mock_stderr.getvalue())

ai_pack_cli-0.1.2/ai_pack_cli.egg-info/requires.txt

@@ -1,2 +0,0 @@
-pyperclip>=1.8.2
-questionary>=1.10.0

ai_pack_cli-0.1.2/tests/test_skeleton_braces.py

@@ -1,139 +0,0 @@
-import unittest
-from ai_pack import SkeletonExtractor
-
-class TestBraceSkeletonExtractor(unittest.TestCase):
-    def test_javascript_typescript(self):
-        js_code = """import { component } from 'framework';
-const PORT = 8080;
-
-export default class Widget extends Base {
-    constructor(config) {
-        super(config);
-        this.init();
-    }
-
-    render() {
-        return `<div>${this.config.title}</div>`;
-    }
-}
-
-const add = (a, b) => {
-    return a + b;
-};
-"""
-        expected = """import { component } from 'framework';
-const PORT = 8080;
-
-export default class Widget extends Base {
-    constructor(config)  { /* ... */ }
-
-    render()  { /* ... */ }
-}
-
-const add = (a, b) =>  { /* ... */ };"""
-        self.assertEqual(SkeletonExtractor.extract_brace_skeleton(js_code).strip(), expected.strip())
-
-    def test_js_template_literals_with_braces(self):
-        js_code = """const render = (name) => {
-    return `Hello, ${name}! Your age is ${getAge({birth: 1990})}.`;
-};
-"""
-        expected = """const render = (name) =>  { /* ... */ };"""
-        self.assertEqual(SkeletonExtractor.extract_brace_skeleton(js_code).strip(), expected.strip())
-
-    def test_golang_parser(self):
-        go_code = """package main
-import "fmt"
-
-type Server struct {
-    Port int
-}
-
-func NewServer(port int) *Server {
-    return &Server{Port: port}
-}
-
-func (s *Server) Start() error {
-    fmt.Println("Starting...")
-    return nil
-}
-"""
-        expected = """package main
-import "fmt"
-
-type Server struct {
-    Port int
-}
-
-func NewServer(port int) *Server  { /* ... */ }
-
-func (s *Server) Start() error  { /* ... */ }"""
-        self.assertEqual(SkeletonExtractor.extract_brace_skeleton(go_code).strip(), expected.strip())
-
-    def test_rust_parser(self):
-        rust_code = """use std::io;
-
-pub struct Robot {
-    name: String,
-}
-
-impl Robot {
-    pub fn new(name: &str) -> Self {
-        Robot {
-            name: name.to_string(),
-        }
-    }
-
-    fn speak(&self) {
-        println!("Hello, my name is {}", self.name);
-    }
-}
-"""
-        expected = """use std::io;
-
-pub struct Robot {
-    name: String,
-}
-
-impl Robot {
-    pub fn new(name: &str) -> Self  { /* ... */ }
-
-    fn speak(&self)  { /* ... */ }
-}"""
-        self.assertEqual(SkeletonExtractor.extract_brace_skeleton(rust_code).strip(), expected.strip())
-
-    def test_cpp_java_parser(self):
-        java_code = """public class App {
-    public static void main(String[] args) {
-        System.out.println("Hello World!");
-    }
-    
-    private int calc(int a) {
-        return a * 2;
-    }
-}
-"""
-        expected = """public class App {
-    public static void main(String[] args)  { /* ... */ }
-    
-    private int calc(int a)  { /* ... */ }
-}"""
-        self.assertEqual(SkeletonExtractor.extract_brace_skeleton(java_code).strip(), expected.strip())
-
-    def test_typescript_return_types(self):
-        ts_code = """class Manager {
-    async getItems(req: Request): Promise<Item[]> {
-        return this.client.get();
-    }
-    
-    add(a: number, b: number): number {
-        return a + b;
-    }
-}
-"""
-        expected = """class Manager {
-    async getItems(req: Request): Promise<Item[]>  { /* ... */ }
-    
-    add(a: number, b: number): number  { /* ... */ }
-}"""
-        self.assertEqual(SkeletonExtractor.extract_brace_skeleton(ts_code).strip(), expected.strip())

ai_pack_cli-0.1.2/tests/test_skeleton_python.py

@@ -1,63 +0,0 @@
-import unittest
-from ai_pack import SkeletonExtractor
-
-class TestPythonSkeletonExtractor(unittest.TestCase):
-    def test_basic_functions_and_classes(self):
-        code = """class User:
-    def __init__(self, name):
-        self.name = name
-    def greet(self):
-        print("Hello " + self.name)
-"""
-        expected = """class User:
-    def __init__(self, name):
-        ...
-    def greet(self):
-        ..."""
-        self.assertEqual(SkeletonExtractor.extract_python_skeleton(code).strip(), expected.strip())
-
-    def test_decorators_and_async(self):
-        code = """@property
-@cache
-def value(self):
-    return self._val
-
-async def fetch_data(url):
-    res = await client.get(url)
-    return res.json()
-"""
-        expected = """@property
-@cache
-def value(self):
-    ...
-async def fetch_data(url):
-    ..."""
-        self.assertEqual(SkeletonExtractor.extract_python_skeleton(code).strip(), expected.strip())
-
-    def test_multiline_signatures(self):
-        code = """def complex_function(
-    a: int,
-    b: str,
-    c: float = 1.0
-) -> bool:
-    print(a, b, c)
-    return True
-"""
-        expected = """def complex_function(
-    a: int,
-    b: str,
-    c: float = 1.0
-) -> bool:
-    ..."""
-        self.assertEqual(SkeletonExtractor.extract_python_skeleton(code).strip(), expected.strip())
-
-    def test_single_line_and_comments(self):
-        code = """def simple_get(self): return self.x
-
-def comment_sig(a, b): # basic add
-    return a + b
-"""
-        expected = """def simple_get(self): return self.x
-def comment_sig(a, b): # basic add
-    ..."""
-        self.assertEqual(SkeletonExtractor.extract_python_skeleton(code).strip(), expected.strip())