ngpt 3.6.0__py3-none-any.whl → 3.7.0__py3-none-any.whl

ngpt/cli/modes/shell.py

@@ -1,6 +1,6 @@
 from ..formatters import COLORS
 from ..ui import spinner, copy_to_clipboard
-from ..renderers import prettify_markdown, has_markdown_renderer
+from ..renderers import prettify_markdown, has_markdown_renderer, prettify_streaming_markdown, show_available_renderers
 from ...utils import enhance_prompt_with_web_search
 import subprocess
 import sys
@@ -9,6 +9,7 @@ import platform
 import os
 import shutil
 import re
+import time
 
 # System prompt for shell command generation
 SHELL_SYSTEM_PROMPT = """Your role: Provide only plain text without Markdown formatting. Do not show any warnings or information regarding your capabilities. Do not provide any description. If you need to store any data, assume it will be stored in the chat. Provide only {shell_name} command for {operating_system} without any description. If there is a lack of details, provide most logical solution. Ensure the output is a valid shell command. If multiple steps required try to combine them together.
@@ -131,6 +132,251 @@ def detect_shell():
         else:
             return "bash", "bash", operating_system
 
+def setup_streaming(args, logger=None):
+    """Set up streaming configuration based on command-line arguments.
+    
+    Args:
+        args: The parsed command-line arguments
+        logger: Optional logger instance for logging
+        
+    Returns:
+        tuple: (should_stream, use_stream_prettify, use_regular_prettify, 
+                stream_setup) - Configuration settings and streaming components
+    """
+    # Default values - initialize all at once
+    stream_callback = live_display = stop_spinner_func = None
+    stop_spinner = spinner_thread = stop_spinner_event = None
+    should_stream = True  # Default to streaming
+    use_stream_prettify = use_regular_prettify = False
+    first_content_received = False
+    
+    # Determine final behavior based on flag priority
+    if args.stream_prettify:
+        # Highest priority: stream-prettify
+        if has_markdown_renderer('rich'):
+            should_stream = True
+            use_stream_prettify = True
+            live_display, stream_callback, setup_spinner = prettify_streaming_markdown(args.renderer)
+            if not live_display:
+                # Fallback if live display fails
+                use_stream_prettify = False
+                use_regular_prettify = True
+                should_stream = False 
+                print(f"{COLORS['yellow']}Live display setup failed. Falling back to regular prettify mode.{COLORS['reset']}")
+        else:
+            # Rich not available for stream-prettify
+            print(f"{COLORS['yellow']}Warning: Rich is not available for --stream-prettify. Install with: pip install \"ngpt[full]\".{COLORS['reset']}")
+            print(f"{COLORS['yellow']}Falling back to default streaming without prettify.{COLORS['reset']}")
+            should_stream = True
+            use_stream_prettify = False
+    elif args.no_stream:
+        # Second priority: no-stream
+        should_stream = False
+        use_regular_prettify = False # No prettify if no streaming
+    elif args.prettify:
+        # Third priority: prettify (requires disabling stream)
+        if has_markdown_renderer(args.renderer):
+            should_stream = False
+            use_regular_prettify = True
+            print(f"{COLORS['yellow']}Note: Using standard markdown rendering (--prettify). For streaming markdown rendering, use --stream-prettify instead.{COLORS['reset']}")
+        else:
+            # Renderer not available for prettify
+            print(f"{COLORS['yellow']}Warning: Renderer '{args.renderer}' not available for --prettify.{COLORS['reset']}")
+            show_available_renderers()
+            print(f"{COLORS['yellow']}Falling back to default streaming without prettify.{COLORS['reset']}")
+            should_stream = True 
+            use_regular_prettify = False
+    
+    # Create a wrapper for the stream callback that will stop the spinner on first content
+    if stream_callback:
+        original_callback = stream_callback
+        
+        def spinner_handling_callback(content, **kwargs):
+            nonlocal first_content_received
+            
+            # On first content, stop the spinner 
+            if not first_content_received and stop_spinner_func:
+                first_content_received = True
+                # Stop the spinner
+                stop_spinner_func()
+                # Ensure spinner message is cleared with an extra blank line
+                sys.stdout.write("\r" + " " * 100 + "\r")
+                sys.stdout.flush()
+            
+            # Call the original callback to update the display
+            if original_callback:
+                original_callback(content, **kwargs)
+        
+        # Use our wrapper callback
+        if use_stream_prettify and live_display:
+            stream_callback = spinner_handling_callback
+            
+            # Set up the spinner if we have a live display
+            stop_spinner_event = threading.Event()
+            stop_spinner_func = setup_spinner(stop_spinner_event, color=COLORS['cyan'])
+    
+    # Create spinner for non-stream-prettify modes EXCEPT no-stream
+    if not use_stream_prettify and not args.no_stream:
+        # Prepare spinner (but don't start it yet - will be started in generate_with_model)
+        stop_spinner = threading.Event()
+        spinner_thread = threading.Thread(
+            target=spinner, 
+            args=("Generating...",), 
+            kwargs={"stop_event": stop_spinner, "color": COLORS['cyan']}
+        )
+        spinner_thread.daemon = True
+    
+    # Create a stream_setup dict to hold all the variables - use a dict comprehension
+    stream_setup = {
+        'stream_callback': stream_callback,
+        'live_display': live_display,
+        'stop_spinner_func': stop_spinner_func,
+        'stop_spinner': stop_spinner,
+        'spinner_thread': spinner_thread,
+        'stop_spinner_event': stop_spinner_event,
+        'first_content_received': first_content_received
+    }
+    
+    return (should_stream, use_stream_prettify, use_regular_prettify, stream_setup)
+
+def generate_with_model(client, prompt, messages, args, stream_setup, 
+                       use_stream_prettify, should_stream, spinner_message="Generating...", 
+                       temp_override=None, logger=None):
+    """Generate content using the model with proper streaming and spinner handling.
+    
+    Args:
+        client: The NGPTClient instance
+        prompt: The prompt to send to the model
+        messages: The formatted messages to send
+        args: The parsed command-line arguments
+        stream_setup: The streaming setup from setup_streaming
+        use_stream_prettify: Whether to use stream prettify
+        should_stream: Whether to stream the response
+        spinner_message: Message to show in the spinner
+        temp_override: Optional temperature override
+        logger: Optional logger instance
+        
+    Returns:
+        str: The generated content
+    """
+    # Extract variables from stream_setup - only unpack what we need
+    stream_callback = stream_setup['stream_callback']
+    stop_spinner = stream_setup['stop_spinner']
+    spinner_thread = stream_setup['spinner_thread']
+    stop_spinner_event = stream_setup['stop_spinner_event']
+    stop_spinner_func = stream_setup['stop_spinner_func']
+    
+    # Show spinner for all modes except no-stream
+    if not args.no_stream:
+        # Two possible spinner types:
+        # 1. Rich spinner for stream_prettify
+        # 2. Regular spinner for all other modes (including --prettify)
+        
+        if use_stream_prettify and stop_spinner_func:
+            # Rich spinner is handled by callbacks
+            pass
+        elif spinner_thread and stop_spinner:
+            # Start the regular spinner thread
+            spinner_thread._args = (spinner_message,)
+            if not spinner_thread.is_alive():
+                spinner_thread.start()
+    else:
+        # No-stream mode just gets a status message
+        print(spinner_message)
+    
+    # Set temperature
+    temp = args.temperature if temp_override is None else temp_override
+    
+    try:
+        # Make the API call
+        return client.chat(
+            prompt=prompt,
+            stream=should_stream,
+            messages=messages,
+            temperature=temp,
+            top_p=args.top_p,
+            max_tokens=args.max_tokens,
+            stream_callback=stream_callback
+        )
+    except KeyboardInterrupt:
+        print("\nRequest cancelled by user.")
+        return ""
+    except Exception as e:
+        print(f"Error generating content: {e}")
+        return ""
+    finally:
+        # Stop the spinner
+        if use_stream_prettify and stop_spinner_event:
+            # Stop rich spinner
+            if not stream_setup['first_content_received']:
+                stop_spinner_event.set()
+        elif stop_spinner:
+            # Stop regular spinner
+            stop_spinner.set()
+            if spinner_thread and spinner_thread.is_alive():
+                spinner_thread.join()
+            
+            # Clear the spinner line completely
+            sys.stdout.write("\r" + " " * 100 + "\r")
+            sys.stdout.flush()
+
+def display_content(content, content_type, highlight_lang, args, use_stream_prettify, use_regular_prettify):
+    """Display generated content with appropriate formatting.
+    
+    Args:
+        content: The content to display
+        content_type: Type of content ('command' or 'description')
+        highlight_lang: Language for syntax highlighting
+        args: The parsed command-line arguments
+        use_stream_prettify: Whether stream prettify is enabled
+        use_regular_prettify: Whether regular prettify is enabled
+    """
+    if not content:
+        return
+    
+    # Define title based on content type - use a lookup instead of if-else
+    titles = {
+        'command': "Generated Command",
+        'description': "Command Description"
+    }
+    title = titles.get(content_type, "Generated Content")
+        
+    # Format content appropriately - create formatted content only when needed
+    if use_regular_prettify and has_markdown_renderer(args.renderer):
+        if content_type == 'command':
+            formatted_content = f"### {title}\n\n```{highlight_lang}\n{content}\n```"
+        else:  # description
+            formatted_content = f"### {title}\n\n{content}"
+    
+    # Only show formatted content if not already shown by stream-prettify
+    if not use_stream_prettify:
+        if use_regular_prettify and has_markdown_renderer(args.renderer):
+            # Use rich renderer for pretty output
+            prettify_markdown(formatted_content, args.renderer)
+        elif args.no_stream:
+            # Simple output for no-stream mode (no box)
+            if content_type == 'command':
+                print(f"\n{title}:\n{COLORS['green']}{content}{COLORS['reset']}\n")
+            else:
+                print(f"\n{title}:\n{content}\n")
+        else:
+            # Regular display or fallback
+            if content_type == 'command':
+                # Box formatting for commands in regular mode - calculate once
+                term_width = shutil.get_terminal_size().columns
+                box_width = min(term_width - 4, len(content) + 8)
+                horizontal_line = "─" * box_width
+                spacing = box_width - len(title) - 11
+                content_spacing = box_width - len(content) - 2
+                
+                print(f"\n┌{horizontal_line}┐")
+                print(f"│ {COLORS['bold']}{title}:{COLORS['reset']}  {' ' * spacing}│")
+                print(f"│ {COLORS['green']}{content}{COLORS['reset']}{' ' * content_spacing}│")
+                print(f"└{horizontal_line}┘\n")
+            else:
+                # Simple display for descriptions
+                print(f"\n{content}\n")
+
 def shell_mode(client, args, logger=None):
     """Handle the shell command generation mode.
     
@@ -139,6 +385,7 @@ def shell_mode(client, args, logger=None):
         args: The parsed command-line arguments
         logger: Optional logger instance
     """
+    # Get the user prompt more efficiently
     if args.prompt is None:
         try:
             print("Enter shell command description: ", end='')
@@ -153,11 +400,12 @@ def shell_mode(client, args, logger=None):
     if logger:
         logger.log("user", prompt)
     
-    # Enhance prompt with web search if enabled
+    # Enhance prompt with web search if enabled - reuse variables
     if args.web_search:
+        original_prompt = prompt
+        web_search_succeeded = False
+        
         try:
-            original_prompt = prompt
-            
             # Start spinner for web search
             stop_spinner = threading.Event()
             spinner_thread = threading.Thread(
@@ -170,23 +418,23 @@ def shell_mode(client, args, logger=None):
             
             try:
                 prompt = enhance_prompt_with_web_search(prompt, logger=logger, disable_citations=True)
-                # Stop the spinner
+                web_search_succeeded = True
+            finally:
+                # Always stop the spinner
                 stop_spinner.set()
                 spinner_thread.join()
+                
                 # Clear the spinner line completely
                 sys.stdout.write("\r" + " " * 100 + "\r")
                 sys.stdout.flush()
-                print("Enhanced input with web search results.")
-            except Exception as e:
-                # Stop the spinner before re-raising
-                stop_spinner.set()
-                spinner_thread.join()
-                raise e
             
-            # Log the enhanced prompt if logging is enabled
-            if logger:
-                # Use "web_search" role instead of "system" for clearer logs
-                logger.log("web_search", prompt.replace(original_prompt, "").strip())
+            if web_search_succeeded:
+                print("Enhanced input with web search results.")
+                
+                # Log the enhanced prompt if logging is enabled
+                if logger:
+                    # Use "web_search" role instead of "system" for clearer logs
+                    logger.log("web_search", prompt.replace(original_prompt, "").strip())
         except Exception as e:
             print(f"{COLORS['yellow']}Warning: Failed to enhance prompt with web search: {str(e)}{COLORS['reset']}")
             # Continue with the original prompt if web search fails
@@ -224,36 +472,21 @@ def shell_mode(client, args, logger=None):
     if logger:
         logger.log("system", system_prompt)
     
-    # Start spinner while waiting for command generation
-    stop_spinner = threading.Event()
-    spinner_thread = threading.Thread(
-        target=spinner, 
-        args=("Generating command...",), 
-        kwargs={"stop_event": stop_spinner, "color": COLORS['cyan']}
-    )
-    spinner_thread.daemon = True
-    spinner_thread.start()
+    # Set up streaming once and reuse for both command and description
+    should_stream, use_stream_prettify, use_regular_prettify, stream_setup = setup_streaming(args)
     
-    try:
-        command = client.chat(
-            prompt=prompt,
-            stream=False,
-            messages=messages,
-            temperature=args.temperature,
-            top_p=args.top_p,
-            max_tokens=args.max_tokens
-        )
-    except Exception as e:
-        print(f"Error generating shell command: {e}")
-        command = ""
-    finally:
-        # Stop the spinner
-        stop_spinner.set()
-        spinner_thread.join()
-        
-        # Clear the spinner line completely
-        sys.stdout.write("\r" + " " * 100 + "\r")
-        sys.stdout.flush()
+    # Generate the command
+    command = generate_with_model(
+        client=client, 
+        prompt=prompt, 
+        messages=messages, 
+        args=args, 
+        stream_setup=stream_setup, 
+        use_stream_prettify=use_stream_prettify, 
+        should_stream=should_stream,
+        spinner_message="Generating command...",
+        logger=logger
+    )
     
     if not command:
         return  # Error already printed by client
@@ -265,30 +498,45 @@ def shell_mode(client, args, logger=None):
     # Get the most up-to-date shell type at command generation time
     _, highlight_lang, _ = detect_shell()
     
-    # Create a markdown-formatted display of the command with appropriate syntax highlighting
-    formatted_command = f"### Generated Command\n\n```{highlight_lang}\n{command}\n```"
+    # Format with proper syntax highlighting for streaming prettify - only if needed
+    if use_stream_prettify and stream_setup['stream_callback'] and command:
+        # Create properly formatted markdown for streaming display
+        formatted_command = f"```{highlight_lang}\n{command}\n```"
+        # Update the live display with the formatted command
+        stream_setup['stream_callback'](formatted_command, complete=True)
     
-    # Check if we can use rich rendering
-    if has_markdown_renderer('rich'):
-        # Use rich renderer for pretty output
-        prettify_markdown(formatted_command, 'rich')
-    else:
-        # Fallback to simpler formatting
-        term_width = shutil.get_terminal_size().columns
-        box_width = min(term_width - 4, len(command) + 8)
-        horizontal_line = "─" * box_width
-        
-        print(f"\n┌{horizontal_line}┐")
-        print(f"│ {COLORS['bold']}Generated Command:{COLORS['reset']}  {' ' * (box_width - 20)}│")
-        print(f"│ {COLORS['green']}{command}{COLORS['reset']}{' ' * (box_width - len(command) - 2)}│")
-        print(f"└{horizontal_line}┘\n")
-    
-    # Display options with better formatting
-    print(f"{COLORS['bold']}Options:{COLORS['reset']}")
-    print(f"  {COLORS['cyan']}c{COLORS['reset']} - Copy to clipboard")
-    print(f"  {COLORS['cyan']}e{COLORS['reset']} - Execute command")
-    print(f"  {COLORS['cyan']}n{COLORS['reset']} - Cancel (default)")
-    print(f"\nWhat would you like to do? [{COLORS['cyan']}c{COLORS['reset']}/{COLORS['cyan']}e{COLORS['reset']}/N] ", end='')
+    # Display the command
+    display_content(
+        content=command,
+        content_type='command',
+        highlight_lang=highlight_lang,
+        args=args,
+        use_stream_prettify=use_stream_prettify,
+        use_regular_prettify=use_regular_prettify
+    )
+    
+    # Display options with better formatting - prepare strings once
+    options_text = f"{COLORS['bold']}Options:{COLORS['reset']}"
+    options = [
+        f"  {COLORS['cyan']}C{COLORS['reset']} - Copy       - Copy the command to clipboard",
+        f"  {COLORS['cyan']}E{COLORS['reset']} - Execute    - Run the command in your shell",
+        f"  {COLORS['cyan']}D{COLORS['reset']} - Describe   - Explain what this command does",
+        f"  {COLORS['cyan']}A{COLORS['reset']} - Abort      - Cancel and return to prompt"
+    ]
+    prompt_text = f"\nWhat would you like to do? [{COLORS['cyan']}C{COLORS['reset']}/{COLORS['cyan']}E{COLORS['reset']}/{COLORS['cyan']}D{COLORS['reset']}/{COLORS['cyan']}A{COLORS['reset']}] "
+
+    # Print options with proper flushing to ensure display
+    print(options_text, flush=True)
+    for option in options:
+        print(option, flush=True)
+
+    # Add a small delay to ensure terminal rendering is complete,
+    # especially important for stream-prettify mode
+    if use_stream_prettify:
+        time.sleep(0.2)
+
+    # Print prompt and flush to ensure it appears
+    print(prompt_text, end='', flush=True)
     
     try:
         response = input().lower()
@@ -296,7 +544,7 @@ def shell_mode(client, args, logger=None):
         print("\nCommand execution cancelled by user.")
         return
         
-    if response == 'e' or response == 'execute':
+    if response == 'e':
         # Log the execution if logging is enabled
         if logger:
             logger.log("system", f"Executing command: {command}")
@@ -326,7 +574,7 @@ def shell_mode(client, args, logger=None):
                 logger.log("system", f"Command error: {error}")
                 
             print(f"\nError:\n{error}")
-    elif response == 'c' or response == 'copy':
+    elif response == 'c':
         # Copy command to clipboard without confirmation prompt
         copied = copy_to_clipboard(command, skip_confirmation=True)
         if not copied:
@@ -334,4 +582,93 @@ def shell_mode(client, args, logger=None):
         
         # Log the copy if logging is enabled
         if logger:
-            logger.log("system", "Command copied to clipboard") 
+            logger.log("system", "Command copied to clipboard") 
+    elif response == 'd':
+        # Ask LLM to describe what the command does
+        describe_prompt = f"Please explain this command: {command}"
+        
+        # Create system prompt for description that includes OS and shell info
+        describe_system_prompt = f"You are a helpful assistant explaining shell commands. The user is running {shell_name} on {operating_system}. Explain what the following shell command does in detail, considering this specific environment. Include any potential risks, side effects, or compatibility issues with this OS/shell combination."
+        
+        # Prepare messages for the chat API
+        describe_messages = [
+            {"role": "system", "content": describe_system_prompt},
+            {"role": "user", "content": describe_prompt}
+        ]
+        
+        # Log the system prompt if logging is enabled
+        if logger:
+            logger.log("system", f"Command description requested for {operating_system}/{shell_name}")
+        
+        # Set up fresh streaming for description - reuse existing setup when possible
+        # We only need to refresh the streaming setup if we're using stream_prettify
+        if use_stream_prettify:
+            _, use_stream_prettify_desc, use_regular_prettify_desc, stream_setup_desc = setup_streaming(args)
+        else:
+            # Reuse the existing setup for non-prettify streaming
+            use_stream_prettify_desc = use_stream_prettify
+            use_regular_prettify_desc = use_regular_prettify
+            
+            # Always create a fresh spinner for description
+            stop_spinner = threading.Event()
+            spinner_thread = threading.Thread(
+                target=spinner, 
+                args=("Generating command description...",), 
+                kwargs={"stop_event": stop_spinner, "color": COLORS['cyan']}
+            )
+            spinner_thread.daemon = True
+            
+            # Create a new stream setup with the fresh spinner
+            stream_setup_desc = {
+                'stream_callback': stream_setup.get('stream_callback'),
+                'live_display': stream_setup.get('live_display'),
+                'stop_spinner_func': stream_setup.get('stop_spinner_func'),
+                'stop_spinner': stop_spinner,
+                'spinner_thread': spinner_thread,
+                'stop_spinner_event': stream_setup.get('stop_spinner_event'),
+                'first_content_received': False
+            }
+        
+        # Generate the description
+        description = generate_with_model(
+            client=client, 
+            prompt=describe_prompt, 
+            messages=describe_messages, 
+            args=args, 
+            stream_setup=stream_setup_desc, 
+            use_stream_prettify=use_stream_prettify_desc, 
+            should_stream=should_stream,
+            spinner_message="Generating command description...",
+            temp_override=0.3,
+            logger=logger
+        )
+        
+        if not description:
+            return  # Error already printed
+        
+        # Log the generated description if logging is enabled
+        if logger:
+            logger.log("assistant", description)
+        
+        # Format with proper markdown for streaming prettify - only if needed
+        if use_stream_prettify_desc and stream_setup_desc['stream_callback'] and description:
+            # Format description as markdown for prettier display
+            md_description = f"### Command Description\n\n{description}"
+            # Update the live display with the formatted description
+            stream_setup_desc['stream_callback'](md_description, complete=True)
+        
+        # Display the description
+        display_content(
+            content=description,
+            content_type='description',
+            highlight_lang=highlight_lang,
+            args=args,
+            use_stream_prettify=use_stream_prettify_desc,
+            use_regular_prettify=use_regular_prettify_desc
+        )
+    elif response == 'a' or response == '':
+        print("\nCommand aborted.")
+        
+        # Log the abort if logging is enabled
+        if logger:
+            logger.log("system", "Command aborted by user") 

{ngpt-3.6.0.dist-info → ngpt-3.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ngpt
-Version: 3.6.0
+Version: 3.7.0
 Summary: Swiss army knife for LLMs: powerful CLI and interactive chatbot in one package. Seamlessly work with OpenAI, Ollama, Groq, Claude, Gemini, or any OpenAI-compatible API to generate code, craft git commits, rewrite text, and execute shell commands.
 Project-URL: Homepage, https://github.com/nazdridoy/ngpt
 Project-URL: Repository, https://github.com/nazdridoy/ngpt

{ngpt-3.6.0.dist-info → ngpt-3.7.0.dist-info}/RECORD

@@ -14,15 +14,15 @@ ngpt/cli/modes/code.py,sha256=3avR9OM-D3r4HHfVm2bTfCOlsYQoqgtvU49zGzYfUqw,12513
 ngpt/cli/modes/gitcommsg.py,sha256=Alm1OLxXkuteiDSnDxjmnPvlSggGG2sTlUBAqJaYaN4,46739
 ngpt/cli/modes/interactive.py,sha256=TtBrZUX45CVfKOPvkb1ya7dIQhXLILtn7ajmfM9ohso,17419
 ngpt/cli/modes/rewrite.py,sha256=EKCPZwvu0MTDpD-nj_oty8vjVQpaF4ucwmTG99LJT6M,10736
-ngpt/cli/modes/shell.py,sha256=kOfOi7uREd98FLHCcON3UuyeUcbQmk8ylOgsELoD810,14168
+ngpt/cli/modes/shell.py,sha256=VT5Lc2pDOs7C7RY53mxg0soaxIfFYmdN7HNC_cEKJZ4,29335
 ngpt/cli/modes/text.py,sha256=7t5WWXMFxGkBM5HMP4irbN9aQwxE2YgywjiVPep710k,6417
 ngpt/utils/__init__.py,sha256=qu_66I1Vtav2f1LDiPn5J3DUsbK7o1CSScMcTkYqxoM,1179
 ngpt/utils/cli_config.py,sha256=Ug8cECBTIuzOwkBWidLTfs-OAdOsCMJ2bNa70pOADfw,11195
 ngpt/utils/config.py,sha256=wsArA4osnh8fKqOvtsPqqBxAz3DpdjtaWUFaRtnUdyc,10452
 ngpt/utils/log.py,sha256=f1jg2iFo35PAmsarH8FVL_62plq4VXH0Mu2QiP6RJGw,15934
 ngpt/utils/web_search.py,sha256=w5ke4KJMRxq7r5jtbUXvspja6XhjoPZloVkZ0IvBXIE,30731
-ngpt-3.6.0.dist-info/METADATA,sha256=cUXBG4wlN36T0SsClQPpfT-SfeLYFdg2iy_n3Krrpx4,23912
-ngpt-3.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ngpt-3.6.0.dist-info/entry_points.txt,sha256=SqAAvLhMrsEpkIr4YFRdUeyuXQ9o0IBCeYgE6AVojoI,44
-ngpt-3.6.0.dist-info/licenses/LICENSE,sha256=mQkpWoADxbHqE0HRefYLJdm7OpdrXBr3vNv5bZ8w72M,1065
-ngpt-3.6.0.dist-info/RECORD,,
+ngpt-3.7.0.dist-info/METADATA,sha256=nnaAlOrIabLAvTq6nbbJ9F_-Y8JEzcWO4NCGlMYWYTE,23912
+ngpt-3.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ngpt-3.7.0.dist-info/entry_points.txt,sha256=SqAAvLhMrsEpkIr4YFRdUeyuXQ9o0IBCeYgE6AVojoI,44
+ngpt-3.7.0.dist-info/licenses/LICENSE,sha256=mQkpWoADxbHqE0HRefYLJdm7OpdrXBr3vNv5bZ8w72M,1065
+ngpt-3.7.0.dist-info/RECORD,,