Final deployment: working server with model download fix

app.py.bak

@@ -0,0 +1,262 @@
+import os
+import json
+import tempfile
+import time
+import subprocess
+import ssl
+import threading
+import functools
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from werkzeug.utils import secure_filename
+from allosaurus.app import read_recognizer
+
+app = Flask(__name__)
+CORS(app)
+
+CACHE_DIR = "/tmp/cache"
+UPLOAD_FOLDER = 'uploads'
+ALLOWED_EXTENSIONS = {'wav', 'ogg', 'mp3', 'm4a'}
+
+os.makedirs("/tmp/uploads", exist_ok=True)
+os.makedirs("/tmp/cache", exist_ok=True)
+
+# Disable SSL verification for model download
+ssl._create_default_https_context = ssl._create_unverified_context
+os.environ['PYTHONHTTPSVERIFY'] = '0'
+
+import torch
+
+# Preload the model at server startup
+print("Preloading Allosaurus model...")
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+print(f"Using device: {device}")
+MODEL = read_recognizer(alt_model_path="/tmp/allosaurus_models", skip_download=True, model_dir="/tmp/allosaurus_models")
+if device == 'cuda':
+    MODEL.model.to(device)
+
+# Create a phoneme to viseme mapping dictionary for faster lookups
+PHONEME_MAP = {}
+vowels = ['a', 'e', 'i', 'o', 'u', 'æ', 'ɑ', 'ɒ', 'ɔ', 'ɛ', 'ɜ', 'ɪ', 'ʊ', 'ʌ', 'ə', 'ɐ']
+bilabials = ['b', 'p', 'm']
+labiodentals = ['f', 'v']
+dentals = ['θ', 'ð']
+alveolars = ['t', 'd', 'n', 's', 'z', 'l', 'r']
+palatals = ['ʃ', 'ʒ', 'j', 'tʃ', 'dʒ']
+velars = ['k', 'g', 'ŋ', 'x']
+
+# Build the mapping dictionary
+for p in bilabials:
+    PHONEME_MAP[p] = 'A'  # MBP
+
+for p in labiodentals + dentals:
+    PHONEME_MAP[p] = 'G'  # FV
+
+for p in alveolars:
+    if p == 'l':
+        PHONEME_MAP[p] = 'H'  # L
+    else:
+        PHONEME_MAP[p] = 'B'  # etc
+
+for p in palatals + velars:
+    PHONEME_MAP[p] = 'B'  # etc
+
+for p in vowels:
+    if p in ['a', 'æ', 'ɑ', 'ɒ']:
+        PHONEME_MAP[p] = 'D'  # AI
+    elif p in ['e', 'ɛ', 'ɪ', 'i']:
+        PHONEME_MAP[p] = 'C'  # E
+    elif p in ['o', 'ɔ', 'ʌ', 'ə', 'ɐ', 'ɜ']:
+        PHONEME_MAP[p] = 'E'  # O
+    elif p in ['u', 'ʊ']:
+        PHONEME_MAP[p] = 'F'  # U
+    else:
+        PHONEME_MAP[p] = 'C'  # Default vowel
+
+# Cache for processed results
+RESULT_CACHE = {}
+
+def allowed_file(filename):
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+def convert_to_wav(input_file):
+    output_file = os.path.splitext(input_file)[0] + '.wav'
+    try:
+        subprocess.run(['ffmpeg', '-i', input_file, '-acodec', 'pcm_s16le', '-ar', '16000', output_file], 
+                      check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        return output_file
+    except subprocess.CalledProcessError:
+        return None
+
+def map_phoneme_to_viseme(phoneme):
+    # Fast lookup using the precomputed dictionary
+    return PHONEME_MAP.get(phoneme, 'X')  # Default to 'X' if not found
+
+def get_file_hash(filepath):
+    # Simple file hash based on file size and modification time
+    stat = os.stat(filepath)
+    return f"{stat.st_size}_{stat.st_mtime}"
+
+def process_audio_with_allosaurus(audio_file):
+    # Optimized cache check with LRU eviction
+    file_hash = get_file_hash(audio_file)
+    cache_key = f"{os.path.basename(audio_file)}_{file_hash}"
+    
+    if cache_key in RESULT_CACHE:
+        # Move to front of cache for LRU
+        result = RESULT_CACHE.pop(cache_key)
+        RESULT_CACHE[cache_key] = result
+        return result
+    
+    start_time = time.time()
+    
+    # Convert to WAV if not already in WAV format
+    if not audio_file.lower().endswith('.wav'):
+        wav_file = convert_to_wav(audio_file)
+        if not wav_file:
+            return None
+        audio_file = wav_file
+    
+    # Recognize phonemes using the preloaded model
+    if device == 'cuda':
+        with torch.no_grad():
+            phonemes = MODEL.recognize(audio_file, timestamp=True)
+    else:
+        phonemes = MODEL.recognize(audio_file, timestamp=True)
+    
+    # Process the phonemes into visemes
+    mouth_cues = []
+    
+    # Parse the phoneme output
+    lines = phonemes.strip().split('\n')
+    
+    for line in lines:
+        parts = line.split()
+        if len(parts) >= 3:
+            start_time_val = float(parts[0])
+            duration = float(parts[1])
+            phoneme = parts[2]
+            
+            # Map phoneme to viseme using the fast lookup
+            viseme = map_phoneme_to_viseme(phoneme)
+            
+            # Calculate end time
+            end_time_val = start_time_val + duration
+            
+            # Add to mouth cues
+            mouth_cues.append({
+                "start": round(start_time_val, 2),
+                "end": round(end_time_val, 2),
+                "value": viseme
+            })
+    
+    # Add rest position at the beginning if needed
+    if mouth_cues and mouth_cues[0]["start"] > 0:
+        mouth_cues.insert(0, {
+            "start": 0,
+            "end": mouth_cues[0]["start"],
+            "value": "X"
+        })
+    
+    # Get audio duration
+    try:
+        result = subprocess.run(['ffprobe', '-v', 'error', '-show_entries', 'format=duration', '-of', 
+                               'default=noprint_wrappers=1:nokey=1', audio_file], 
+                              stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=True)
+        duration = float(result.stdout.strip())
+    except:
+        # If ffprobe fails, estimate duration from the last phoneme
+        duration = mouth_cues[-1]["end"] if mouth_cues else 0
+    
+    # Add rest position at the end if needed
+    if mouth_cues and mouth_cues[-1]["end"] < duration:
+        mouth_cues.append({
+            "start": mouth_cues[-1]["end"],
+            "end": duration,
+            "value": "X"
+        })
+    
+    # Create result in the same format as Rhubarb for compatibility
+    result = {
+        "metadata": {
+            "soundFile": audio_file,
+            "duration": duration
+        },
+        "mouthCues": mouth_cues
+    }
+    
+    # Cache with size limit (100 items)
+    if len(RESULT_CACHE) >= 100:
+        RESULT_CACHE.pop(next(iter(RESULT_CACHE)))
+    RESULT_CACHE[cache_key] = result
+    
+    processing_time = time.time() - start_time
+    print(f"Processing completed in {processing_time:.2f} seconds")
+    
+    return result
+
+@app.route('/api/viseme', methods=['POST'])
+def generate_viseme():
+    if 'file' not in request.files:
+        return jsonify({'error': 'No file part'}), 400
+    
+    file = request.files['file']
+    
+    if file.filename == '':
+        return jsonify({'error': 'No selected file'}), 400
+    
+    if file and allowed_file(file.filename):
+        filename = secure_filename(file.filename)
+        filepath = os.path.join(UPLOAD_FOLDER, filename)
+        file.save(filepath)
+        
+        result = process_audio_with_allosaurus(filepath)
+        
+        # Don't delete the file immediately to allow caching to work
+        # We'll clean up old files periodically
+        
+        if result:
+            return jsonify(result)
+        else:
+            return jsonify({'error': 'Failed to process audio file'}), 500
+    
+    return jsonify({'error': 'File type not allowed'}), 400
+
+@app.route('/api/status', methods=['GET'])
+def status():
+    return jsonify({
+        'status': 'ok', 
+        'model_loaded': MODEL is not None,
+        'cache_size': len(RESULT_CACHE),
+        'supported_formats': list(ALLOWED_EXTENSIONS)
+    })
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    return jsonify({'status': 'ok'})
+
+def cleanup_old_files():
+    # Clean up files older than 1 hour
+    now = time.time()
+    for filename in os.listdir(UPLOAD_FOLDER):
+        filepath = os.path.join(UPLOAD_FOLDER, filename)
+        if os.path.isfile(filepath) and now - os.path.getmtime(filepath) > 3600:
+            os.unlink(filepath)
+
+if __name__ == '__main__':
+    # Start a background thread to clean up old files
+    cleanup_thread = threading.Thread(target=lambda: (
+        time.sleep(3600),  # Run every hour
+        cleanup_old_files()
+    ))
+    cleanup_thread.daemon = True
+    cleanup_thread.start()
+
+    # Configure hot reload with increased watcher sensitivity
+    app.run(host='0.0.0.0',
+            port=7860,
+            debug=True,
+            use_reloader=True,
+            reloader_type='stat',
+            extra_files=['./requirements.txt'],
+            reloader_interval=1)

requirements.txt

@@ -5,5 +5,5 @@ python-dotenv==0.19.0
 werkzeug==2.0.1
 allosaurus>=1.0.2
 numpy<2.0.0
-torch==1.13.1
-torchaudio==0.13.1
+torch==2.2.0
+torchaudio==2.2.0

venv/bin/Activate.ps1

@@ -0,0 +1,247 @@
+<#
+.Synopsis
+Activate a Python virtual environment for the current PowerShell session.
+
+.Description
+Pushes the python executable for a virtual environment to the front of the
+$Env:PATH environment variable and sets the prompt to signify that you are
+in a Python virtual environment. Makes use of the command line switches as
+well as the `pyvenv.cfg` file values present in the virtual environment.
+
+.Parameter VenvDir
+Path to the directory that contains the virtual environment to activate. The
+default value for this is the parent of the directory that the Activate.ps1
+script is located within.
+
+.Parameter Prompt
+The prompt prefix to display when this virtual environment is activated. By
+default, this prompt is the name of the virtual environment folder (VenvDir)
+surrounded by parentheses and followed by a single space (ie. '(.venv) ').
+
+.Example
+Activate.ps1
+Activates the Python virtual environment that contains the Activate.ps1 script.
+
+.Example
+Activate.ps1 -Verbose
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and shows extra information about the activation as it executes.
+
+.Example
+Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
+Activates the Python virtual environment located in the specified location.
+
+.Example
+Activate.ps1 -Prompt "MyPython"
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and prefixes the current prompt with the specified string (surrounded in
+parentheses) while the virtual environment is active.
+
+.Notes
+On Windows, it may be required to enable this Activate.ps1 script by setting the
+execution policy for the user. You can do this by issuing the following PowerShell
+command:
+
+PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+For more information on Execution Policies: 
+https://go.microsoft.com/fwlink/?LinkID=135170
+
+#>
+Param(
+    [Parameter(Mandatory = $false)]
+    [String]
+    $VenvDir,
+    [Parameter(Mandatory = $false)]
+    [String]
+    $Prompt
+)
+
+<# Function declarations --------------------------------------------------- #>
+
+<#
+.Synopsis
+Remove all shell session elements added by the Activate script, including the
+addition of the virtual environment's Python executable from the beginning of
+the PATH variable.
+
+.Parameter NonDestructive
+If present, do not remove this function from the global namespace for the
+session.
+
+#>
+function global:deactivate ([switch]$NonDestructive) {
+    # Revert to original values
+
+    # The prior prompt:
+    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
+        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
+        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
+    }
+
+    # The prior PYTHONHOME:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
+        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
+    }
+
+    # The prior PATH:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
+        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
+    }
+
+    # Just remove the VIRTUAL_ENV altogether:
+    if (Test-Path -Path Env:VIRTUAL_ENV) {
+        Remove-Item -Path env:VIRTUAL_ENV
+    }
+
+    # Just remove VIRTUAL_ENV_PROMPT altogether.
+    if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) {
+        Remove-Item -Path env:VIRTUAL_ENV_PROMPT
+    }
+
+    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
+    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
+        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
+    }
+
+    # Leave deactivate function in the global namespace if requested:
+    if (-not $NonDestructive) {
+        Remove-Item -Path function:deactivate
+    }
+}
+
+<#
+.Description
+Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
+given folder, and returns them in a map.
+
+For each line in the pyvenv.cfg file, if that line can be parsed into exactly
+two strings separated by `=` (with any amount of whitespace surrounding the =)
+then it is considered a `key = value` line. The left hand string is the key,
+the right hand is the value.
+
+If the value starts with a `'` or a `"` then the first and last character is
+stripped from the value before being captured.
+
+.Parameter ConfigDir
+Path to the directory that contains the `pyvenv.cfg` file.
+#>
+function Get-PyVenvConfig(
+    [String]
+    $ConfigDir
+) {
+    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
+
+    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
+    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
+
+    # An empty map will be returned if no config file is found.
+    $pyvenvConfig = @{ }
+
+    if ($pyvenvConfigPath) {
+
+        Write-Verbose "File exists, parse `key = value` lines"
+        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
+
+        $pyvenvConfigContent | ForEach-Object {
+            $keyval = $PSItem -split "\s*=\s*", 2
+            if ($keyval[0] -and $keyval[1]) {
+                $val = $keyval[1]
+
+                # Remove extraneous quotations around a string value.
+                if ("'""".Contains($val.Substring(0, 1))) {
+                    $val = $val.Substring(1, $val.Length - 2)
+                }
+
+                $pyvenvConfig[$keyval[0]] = $val
+                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
+            }
+        }
+    }
+    return $pyvenvConfig
+}
+
+
+<# Begin Activate script --------------------------------------------------- #>
+
+# Determine the containing directory of this script
+$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$VenvExecDir = Get-Item -Path $VenvExecPath
+
+Write-Verbose "Activation script is located in path: '$VenvExecPath'"
+Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
+Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
+
+# Set values required in priority: CmdLine, ConfigFile, Default
+# First, get the location of the virtual environment, it might not be
+# VenvExecDir if specified on the command line.
+if ($VenvDir) {
+    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
+}
+else {
+    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
+    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
+    Write-Verbose "VenvDir=$VenvDir"
+}
+
+# Next, read the `pyvenv.cfg` file to determine any required value such
+# as `prompt`.
+$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
+
+# Next, set the prompt from the command line, or the config file, or
+# just use the name of the virtual environment folder.
+if ($Prompt) {
+    Write-Verbose "Prompt specified as argument, using '$Prompt'"
+}
+else {
+    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
+    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
+        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
+        $Prompt = $pyvenvCfg['prompt'];
+    }
+    else {
+        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)"
+        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
+        $Prompt = Split-Path -Path $venvDir -Leaf
+    }
+}
+
+Write-Verbose "Prompt = '$Prompt'"
+Write-Verbose "VenvDir='$VenvDir'"
+
+# Deactivate any currently active virtual environment, but leave the
+# deactivate function in place.
+deactivate -nondestructive
+
+# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
+# that there is an activated venv.
+$env:VIRTUAL_ENV = $VenvDir
+
+if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
+
+    Write-Verbose "Setting prompt to '$Prompt'"
+
+    # Set the prompt to include the env name
+    # Make sure _OLD_VIRTUAL_PROMPT is global
+    function global:_OLD_VIRTUAL_PROMPT { "" }
+    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
+    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
+
+    function global:prompt {
+        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
+        _OLD_VIRTUAL_PROMPT
+    }
+    $env:VIRTUAL_ENV_PROMPT = $Prompt
+}
+
+# Clear PYTHONHOME
+if (Test-Path -Path Env:PYTHONHOME) {
+    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
+    Remove-Item -Path Env:PYTHONHOME
+}
+
+# Add the venv to the PATH
+Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
+$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"

venv/bin/activate

@@ -0,0 +1,71 @@
+# This file must be used with "source bin/activate" *from bash*
+# You cannot run it directly
+
+deactivate () {
+    # reset old environment variables
+    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
+        PATH="${_OLD_VIRTUAL_PATH:-}"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
+        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # Call hash to forget past locations. Without forgetting
+    # past locations the $PATH changes we made may not be respected.
+    # See "man bash" for more details. hash is usually a builtin of your shell
+    hash -r 2> /dev/null
+
+    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
+        PS1="${_OLD_VIRTUAL_PS1:-}"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    unset VIRTUAL_ENV_PROMPT
+    if [ ! "${1:-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+# on Windows, a path can contain colons and backslashes and has to be converted:
+if [ "${OSTYPE:-}" = "cygwin" ] || [ "${OSTYPE:-}" = "msys" ] ; then
+    # transform D:\path\to\venv to /d/path/to/venv on MSYS
+    # and to /cygdrive/d/path/to/venv on Cygwin
+    export VIRTUAL_ENV=$(cygpath /Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv)
+else
+    # use the path as-is
+    export VIRTUAL_ENV=/Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv
+fi
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/"bin":$PATH"
+export PATH
+
+# unset PYTHONHOME if set
+# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
+# could use `if (set -u; : $PYTHONHOME) ;` in bash
+if [ -n "${PYTHONHOME:-}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1:-}"
+    PS1='(venv) '"${PS1:-}"
+    export PS1
+    VIRTUAL_ENV_PROMPT='(venv) '
+    export VIRTUAL_ENV_PROMPT
+fi
+
+# Call hash to forget past commands. Without forgetting
+# past commands the $PATH changes we made may not be respected
+hash -r 2> /dev/null

venv/bin/activate.csh

@@ -0,0 +1,27 @@
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV /Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv
+
+set _OLD_VIRTUAL_PATH="$PATH"
+setenv PATH "$VIRTUAL_ENV/"bin":$PATH"
+
+
+set _OLD_VIRTUAL_PROMPT="$prompt"
+
+if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
+    set prompt = '(venv) '"$prompt"
+    setenv VIRTUAL_ENV_PROMPT '(venv) '
+endif
+
+alias pydoc python -m pydoc
+
+rehash

venv/bin/activate.fish

@@ -0,0 +1,69 @@
+# This file must be used with "source <venv>/bin/activate.fish" *from fish*
+# (https://fishshell.com/). You cannot run it directly.
+
+function deactivate  -d "Exit virtual environment and return to normal shell environment"
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        set -gx PATH $_OLD_VIRTUAL_PATH
+        set -e _OLD_VIRTUAL_PATH
+    end
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+        # prevents error when using nested fish instances (Issue #93858)
+        if functions -q _old_fish_prompt
+            functions -e fish_prompt
+            functions -c _old_fish_prompt fish_prompt
+            functions -e _old_fish_prompt
+        end
+    end
+
+    set -e VIRTUAL_ENV
+    set -e VIRTUAL_ENV_PROMPT
+    if test "$argv[1]" != "nondestructive"
+        # Self-destruct!
+        functions -e deactivate
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV /Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv
+
+set -gx _OLD_VIRTUAL_PATH $PATH
+set -gx PATH "$VIRTUAL_ENV/"bin $PATH
+
+# Unset PYTHONHOME if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # fish uses a function instead of an env var to generate the prompt.
+
+    # Save the current fish_prompt function as the function _old_fish_prompt.
+    functions -c fish_prompt _old_fish_prompt
+
+    # With the original prompt function renamed, we can override with our own.
+    function fish_prompt
+        # Save the return status of the last command.
+        set -l old_status $status
+
+        # Output the venv prompt; color taken from the blue of the Python logo.
+        printf "%s%s%s" (set_color 4B8BBE) '(venv) ' (set_color normal)
+
+        # Restore the return status of the previous command.
+        echo "exit $old_status" | .
+        # Output the original/"old" prompt.
+        _old_fish_prompt
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+    set -gx VIRTUAL_ENV_PROMPT '(venv) '
+end

venv/bin/align_wordlists.py

@@ -0,0 +1,73 @@
+#!/Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv/bin/python3.12
+from __future__ import print_function
+
+import unicodecsv as csv
+import argparse
+import panphon
+import Levenshtein
+import munkres
+import panphon.distance
+from functools import partial
+
+
+def levenshtein_dist(_, a, b):
+    return Levenshtein.distance(a, b)
+
+
+def dogol_leven_dist(_, a, b):
+    return Levenshtein.distance(dist.map_to_dogol_prime(a),
+                                dist.map_to_dogol_prime(b))
+
+
+def feature_hamming_dist(dist, a, b):
+    return dist.feature_edit_distance(a, b)
+
+
+def feature_weighted_dist(dist, a, b):
+    return dist.weighted_feature_edit_distance(a, b)
+
+
+def construct_cost_matrix(words_a, words_b, dist):
+    def matrix_row(word_a, words_b):
+        return [dist(word_a, word_b) for (word_b, _) in words_b]
+    return [matrix_row(word_a, words_b) for (word_a, _) in words_a]
+
+
+def score(indices):
+    pairs, errors = 0, 0
+    for row, column in indices:
+        pairs += 1
+        if row != column:
+            errors += 1
+    return pairs, errors
+
+
+def main(wordlist1, wordlist2, dist_funcs):
+    with open(wordlist1, 'rb') as file_a, open(wordlist2, 'rb') as file_b:
+        reader_a = csv.reader(file_a, encoding='utf-8')
+        reader_b = csv.reader(file_b, encoding='utf-8')
+        print('Reading word lists...')
+        words = zip([(w, g) for (g, w) in reader_a],
+                    [(w, g) for (g, w) in reader_b])
+        words_a, words_b = zip(*[(a, b) for (a, b) in words if a and b])
+        print('Constructing cost matrix...')
+        matrix = construct_cost_matrix(words_a, words_b, dist_funcs)
+        m = munkres.Munkres()
+        print('Computing matrix using Hungarian Algorithm...')
+        indices = m.compute(matrix)
+        print(score(indices))
+        print('Done.')
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(usage='Align two lists of "cognates" using a specified distance metric.')
+    parser.add_argument('wordlists', nargs=2, help='Filenames of two wordlists in corresponding order.')
+    parser.add_argument('-d', '--dist', default='hamming', help='Distance metric (e.g. Hamming).')
+    args = parser.parse_args()
+    dists = {'levenshtein': levenshtein_dist,
+             'dogol-leven': dogol_leven_dist,
+             'hamming': feature_hamming_dist,
+             'weighted': feature_weighted_dist}
+    dist = panphon.distance.Distance()
+    dist_funcs = partial(dists[args.dist], dist)
+    main(args.wordlists[0], args.wordlists[1], dist_funcs)

venv/bin/convert-caffe2-to-onnx

@@ -0,0 +1,8 @@
+#!/Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv/bin/python3.12
+# -*- coding: utf-8 -*-
+import re
+import sys
+from caffe2.python.onnx.bin.conversion import caffe2_to_onnx
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(caffe2_to_onnx())

venv/bin/convert-onnx-to-caffe2

@@ -0,0 +1,8 @@
+#!/Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv/bin/python3.12
+# -*- coding: utf-8 -*-
+import re
+import sys
+from caffe2.python.onnx.bin.conversion import onnx_to_caffe2
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(onnx_to_caffe2())

venv/bin/dotenv

@@ -0,0 +1,8 @@
+#!/Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv/bin/python3.12
+# -*- coding: utf-8 -*-
+import re
+import sys
+from dotenv.cli import cli
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(cli())

venv/bin/f2py

@@ -0,0 +1,8 @@
+#!/Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv/bin/python3.12
+# -*- coding: utf-8 -*-
+import re
+import sys
+from numpy.f2py.f2py2e import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/flask

@@ -0,0 +1,8 @@
+#!/Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv/bin/python3.12
+# -*- coding: utf-8 -*-
+import re
+import sys
+from flask.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/generate_ipa_all.py

@@ -0,0 +1,182 @@
+#!/Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv/bin/python3.12
+from __future__ import print_function, unicode_literals
+
+import argparse
+import codecs
+import copy
+
+import yaml
+
+import unicodecsv as csv
+
+
+class Segment(object):
+    """Class modeling phonological segment."""
+
+    def __init__(self, form, features):
+        """Construct Segment objectself.
+
+        Args:
+            form (string): the segment as ipa
+            features (list): the segment as feature_names
+        """
+        self.form = form
+        self.features = features
+
+    def __repr__(self):
+        """Output string representation of Segment."""
+        return 'Segment("{}", {})'.format(self.form,
+                                          repr(self.features)).encode('utf-8')
+
+    def feature_vector(self, feature_names):
+        """Return feature vector for segment.
+
+        Args:
+            feature_names (list): ordered names of features
+
+        Returns:
+            list: feature values
+        """
+        return [self.features[ft] for ft in feature_names]
+
+
+class Diacritic(object):
+    """An object encapsulating a diacritics properties."""
+
+    def __init__(self, marker, position, conditions, exclude, content):
+        """Construct a diacritic object.
+
+        Args:
+            marker (unicode): the string form of the diacritic
+            position (str): 'pre' or 'post', determining whether the diacritic
+                            attaches before or after the base
+            conditions (list): feature specification on which application of
+                               diacritic is conditional
+            exclude (list): conditions under which the diacritic will not be
+                            applied]
+            content (list): feature specification that will override
+                            existing feature specifications when diacritics
+                            is applied
+        """
+        self.marker = marker
+        assert position in ['pre', 'post']
+        self.position = position
+        self.exclude = exclude
+        self.conditions = conditions
+        self.content = content
+
+    def match(self, segment):
+        if segment.form not in self.exclude:
+            for condition in self.conditions:
+                if set(condition.items()) <= set(segment.features.items()):
+                    return True
+            return False
+        else:
+            return False
+
+    def apply(self, segment):
+        if self.match(segment):
+            new_seg = copy.deepcopy(segment)
+            for k, v in self.content.items():
+                new_seg.features[k] = v
+            if self.position == 'post':
+                new_seg.form = '{}{}'.format(new_seg.form, self.marker)
+            else:
+                new_seg.form = '{}{}'.format(self.marker, new_seg.form)
+            return new_seg
+        else:
+            return None
+
+
+class Combination(object):
+    def __init__(self, diacritics, name, sequence):
+        self.name = name
+        self.sequence = [diacritics[d] for d in sequence]
+
+    def apply(self, segment):
+        new_seg = copy.deepcopy(segment)
+        for dia in self.sequence:
+            if dia.match(new_seg):
+                new_seg = dia.apply(new_seg)
+            else:
+                return None
+        return new_seg
+
+
+def read_ipa_bases(ipa_bases):
+    segments = []
+    with open(ipa_bases, 'rb') as f:
+        dictreader = csv.DictReader(f, encoding='utf=8')
+        for record in dictreader:
+            form = record['ipa']
+            features = {k: v for k, v in record.items() if k != 'ipa'}
+            segments.append(Segment(form, features))
+    return segments
+
+
+def parse_dia_defs(dia_defs):
+    defs = yaml.load(codecs.open(dia_defs, "r", "utf-8").read(), Loader=yaml.FullLoader)
+    diacritics = {}
+    for dia in defs['diacritics']:
+        if 'exclude' in dia:
+            exclude = dia['exclude']
+        else:
+            exclude = []
+        diacritics[dia['name']] = Diacritic(dia['marker'], dia['position'],
+                                            dia['conditions'], exclude,
+                                            dia['content'])
+    combinations = []
+    for comb in defs['combinations']:
+        combinations.append(Combination(diacritics, comb['name'],
+                                        comb['combines']))
+    return diacritics, combinations
+
+
+def sort_all_segments(sort_order, all_segments):
+    all_segments_list = list(all_segments)
+    field_order = reversed(yaml.load(open(sort_order, 'r').read(), Loader=yaml.FullLoader))
+    for field in field_order:
+        all_segments_list.sort(key=lambda seg: seg.features[field['name']],
+                               reverse=field['reverse'])
+    return all_segments_list
+
+
+def write_ipa_all(ipa_bases, ipa_all, all_segments, sort_order):
+    with open(ipa_bases, 'rb') as f:
+        reader = csv.reader(f, encoding='utf-8')
+        fieldnames = next(reader)
+    with open(ipa_all, 'wb') as f:
+        writer = csv.DictWriter(f, encoding='utf-8', fieldnames=fieldnames)
+        writer.writerow({k: k for k in fieldnames})
+        all_segments_list = sort_all_segments(sort_order, all_segments)
+        for segment in all_segments_list:
+            fields = copy.copy(segment.features)
+            fields['ipa'] = segment.form
+            writer.writerow(fields)
+
+
+def main(ipa_bases, ipa_all, dia_defs, sort_order):
+    segments = read_ipa_bases(ipa_bases)
+    diacritics, combinations = parse_dia_defs(dia_defs)
+    all_segments = set(segments)
+    for diacritic in diacritics.values():
+        for segment in segments:
+            new_seg = diacritic.apply(segment)
+            if new_seg is not None:
+                all_segments.add(new_seg)
+    for combination in combinations:
+        for segment in segments:
+            new_seg = combination.apply(segment)
+            if new_seg is not None:
+                all_segments.add(new_seg)
+    write_ipa_all(ipa_bases, ipa_all, all_segments, sort_order)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('bases', help='File containing IPA bases (ipa_bases.csv)')
+    parser.add_argument('all', help='File to which all IPA segments is to be written (ipa_all.csv)')
+    parser.add_argument('-d', '--dia', required=True, help='Diacritic definition file (default=diacritic_definitions.yml)')
+    parser.add_argument('-s', '--sort-order', required=True, help='File definiting sort order.')
+    args = parser.parse_args()
+    main(args.bases, args.all, args.dia, args.sort_order)

venv/bin/isympy

@@ -0,0 +1,8 @@
+#!/Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv/bin/python3.12
+# -*- coding: utf-8 -*-
+import re
+import sys
+from isympy import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/normalizer

@@ -0,0 +1,8 @@
+#!/Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv/bin/python3.12
+# -*- coding: utf-8 -*-
+import re
+import sys
+from charset_normalizer.cli.normalizer import cli_detect
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(cli_detect())

venv/bin/numba

@@ -0,0 +1,8 @@
+#!/Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv/bin/python3.12
+# -*- coding: UTF-8 -*-
+from __future__ import print_function, division, absolute_import
+
+from numba.misc.numba_entry import main
+
+if __name__ == "__main__":
+    main()

venv/bin/pip

@@ -0,0 +1,8 @@
+#!/Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv/bin/python3.12
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/pip3

@@ -0,0 +1,8 @@
+#!/Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv/bin/python3.12
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/pip3.12

@@ -0,0 +1,8 @@
+#!/Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv/bin/python3.12
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/python

@@ -0,0 +1 @@
+python3.12

venv/bin/python3

@@ -0,0 +1 @@
+python3.12

venv/bin/python3.12

@@ -0,0 +1 @@
+/Library/Frameworks/Python.framework/Versions/3.12/bin/python3.12

venv/bin/torchrun

@@ -0,0 +1,8 @@
+#!/Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv/bin/python3.12
+# -*- coding: utf-8 -*-
+import re
+import sys
+from torch.distributed.run import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/validate_ipa.py

@@ -0,0 +1,54 @@
+#!/Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv/bin/python3.12
+# -*- coding: utf-8 -*-
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import panphon
+import regex as re
+import sys
+
+
+class Validator(object):
+    def __init__(self, infile=sys.stdin):
+        """Validate Unicode IPA from file relative to panphon database.
+
+        infile -- File from which input is taken; by default, STDIN.
+        """
+        self.ws_punc_regex = re.compile(r'[," \t\n]', re.V1 | re.U)
+        self.ft = panphon.FeatureTable()
+        self._validate_file(infile)
+
+    def _validate_file(self, infile):
+        for line in infile:
+            line = unicode(line, 'utf-8')
+            self.validate_line(line)
+
+    def validate_line(self, line):
+        """Validate Unicode IPA string relative to panphon.
+
+        line -- String of IPA characters. Can contain whitespace and limited
+        punctuation.
+        """
+        line0 = line
+        pos = 0
+        while line:
+            seg_m = self.ft.seg_regex.match(line)
+            wsp_m = self.ws_punc_regex.match(line)
+            if seg_m:
+                length = len(seg_m.group(0))
+                line = line[length:]
+                pos += length
+            elif wsp_m:
+                length = len(wsp_m.group(0))
+                line = line[length:]
+                pos += length
+            else:
+                msg = 'IPA not valid at position {} in "{}".'.format(pos, line0.strip())
+                # msg = msg.decode('utf-8')
+                print(msg, file=sys.stderr)
+                line = line[1:]
+                pos += 1
+
+
+if __name__ == '__main__':
+    validator = Validator(sys.stdin)

venv/pyvenv.cfg

@@ -0,0 +1,5 @@
+home = /Library/Frameworks/Python.framework/Versions/3.12/bin
+include-system-site-packages = false
+version = 3.12.8
+executable = /Library/Frameworks/Python.framework/Versions/3.12/bin/python3.12
+command = /Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv/bin/python3 -m venv /Users/marcos/Documents/projects/parle/avataronly/avatar_v10/avatar2b/backend/servers/allosaurus/lipsync/venv

venv/share/man/man1/isympy.1

@@ -0,0 +1,188 @@
+'\" -*- coding: us-ascii -*-
+.if \n(.g .ds T< \\FC
+.if \n(.g .ds T> \\F[\n[.fam]]
+.de URL
+\\$2 \(la\\$1\(ra\\$3
+..
+.if \n(.g .mso www.tmac
+.TH isympy 1 2007-10-8 "" ""
+.SH NAME
+isympy \- interactive shell for SymPy
+.SH SYNOPSIS
+'nh
+.fi
+.ad l
+\fBisympy\fR \kx
+.if (\nx>(\n(.l/2)) .nr x (\n(.l/5)
+'in \n(.iu+\nxu
+[\fB-c\fR | \fB--console\fR] [\fB-p\fR ENCODING | \fB--pretty\fR ENCODING] [\fB-t\fR TYPE | \fB--types\fR TYPE] [\fB-o\fR ORDER | \fB--order\fR ORDER] [\fB-q\fR | \fB--quiet\fR] [\fB-d\fR | \fB--doctest\fR] [\fB-C\fR | \fB--no-cache\fR] [\fB-a\fR | \fB--auto\fR] [\fB-D\fR | \fB--debug\fR] [
+-- | PYTHONOPTIONS]
+'in \n(.iu-\nxu
+.ad b
+'hy
+'nh
+.fi
+.ad l
+\fBisympy\fR \kx
+.if (\nx>(\n(.l/2)) .nr x (\n(.l/5)
+'in \n(.iu+\nxu
+[
+{\fB-h\fR | \fB--help\fR}
+|
+{\fB-v\fR | \fB--version\fR}
+]
+'in \n(.iu-\nxu
+.ad b
+'hy
+.SH DESCRIPTION
+isympy is a Python shell for SymPy. It is just a normal python shell
+(ipython shell if you have the ipython package installed) that executes
+the following commands so that you don't have to:
+.PP
+.nf
+\*(T<
+>>> from __future__ import division
+>>> from sympy import *
+>>> x, y, z = symbols("x,y,z")
+>>> k, m, n = symbols("k,m,n", integer=True)
+    \*(T>
+.fi
+.PP
+So starting isympy is equivalent to starting python (or ipython) and
+executing the above commands by hand. It is intended for easy and quick
+experimentation with SymPy. For more complicated programs, it is recommended
+to write a script and import things explicitly (using the "from sympy
+import sin, log, Symbol, ..." idiom).
+.SH OPTIONS
+.TP
+\*(T<\fB\-c \fR\*(T>\fISHELL\fR, \*(T<\fB\-\-console=\fR\*(T>\fISHELL\fR
+Use the specified shell (python or ipython) as
+console backend instead of the default one (ipython
+if present or python otherwise).
+
+Example: isympy -c python
+
+\fISHELL\fR could be either
+\&'ipython' or 'python'
+.TP
+\*(T<\fB\-p \fR\*(T>\fIENCODING\fR, \*(T<\fB\-\-pretty=\fR\*(T>\fIENCODING\fR
+Setup pretty printing in SymPy. By default, the most pretty, unicode
+printing is enabled (if the terminal supports it). You can use less
+pretty ASCII printing instead or no pretty printing at all.
+
+Example: isympy -p no
+
+\fIENCODING\fR must be one of 'unicode',
+\&'ascii' or 'no'.
+.TP
+\*(T<\fB\-t \fR\*(T>\fITYPE\fR, \*(T<\fB\-\-types=\fR\*(T>\fITYPE\fR
+Setup the ground types for the polys. By default, gmpy ground types
+are used if gmpy2 or gmpy is installed, otherwise it falls back to python
+ground types, which are a little bit slower. You can manually
+choose python ground types even if gmpy is installed (e.g., for testing purposes).
+
+Note that sympy ground types are not supported, and should be used
+only for experimental purposes.
+
+Note that the gmpy1 ground type is primarily intended for testing; it the
+use of gmpy even if gmpy2 is available.
+
+This is the same as setting the environment variable
+SYMPY_GROUND_TYPES to the given ground type (e.g.,
+SYMPY_GROUND_TYPES='gmpy')
+
+The ground types can be determined interactively from the variable
+sympy.polys.domains.GROUND_TYPES inside the isympy shell itself.
+
+Example: isympy -t python
+
+\fITYPE\fR must be one of 'gmpy',
+\&'gmpy1' or 'python'.
+.TP
+\*(T<\fB\-o \fR\*(T>\fIORDER\fR, \*(T<\fB\-\-order=\fR\*(T>\fIORDER\fR
+Setup the ordering of terms for printing. The default is lex, which
+orders terms lexicographically (e.g., x**2 + x + 1). You can choose
+other orderings, such as rev-lex, which will use reverse
+lexicographic ordering (e.g., 1 + x + x**2).
+
+Note that for very large expressions, ORDER='none' may speed up
+printing considerably, with the tradeoff that the order of the terms
+in the printed expression will have no canonical order
+
+Example: isympy -o rev-lax
+
+\fIORDER\fR must be one of 'lex', 'rev-lex', 'grlex',
+\&'rev-grlex', 'grevlex', 'rev-grevlex', 'old', or 'none'.
+.TP
+\*(T<\fB\-q\fR\*(T>, \*(T<\fB\-\-quiet\fR\*(T>
+Print only Python's and SymPy's versions to stdout at startup, and nothing else.
+.TP
+\*(T<\fB\-d\fR\*(T>, \*(T<\fB\-\-doctest\fR\*(T>
+Use the same format that should be used for doctests. This is
+equivalent to '\fIisympy -c python -p no\fR'.
+.TP
+\*(T<\fB\-C\fR\*(T>, \*(T<\fB\-\-no\-cache\fR\*(T>
+Disable the caching mechanism. Disabling the cache may slow certain
+operations down considerably. This is useful for testing the cache,
+or for benchmarking, as the cache can result in deceptive benchmark timings.
+
+This is the same as setting the environment variable SYMPY_USE_CACHE
+to 'no'.
+.TP
+\*(T<\fB\-a\fR\*(T>, \*(T<\fB\-\-auto\fR\*(T>
+Automatically create missing symbols. Normally, typing a name of a
+Symbol that has not been instantiated first would raise NameError,
+but with this option enabled, any undefined name will be
+automatically created as a Symbol. This only works in IPython 0.11.
+
+Note that this is intended only for interactive, calculator style
+usage. In a script that uses SymPy, Symbols should be instantiated
+at the top, so that it's clear what they are.
+
+This will not override any names that are already defined, which
+includes the single character letters represented by the mnemonic
+QCOSINE (see the "Gotchas and Pitfalls" document in the
+documentation). You can delete existing names by executing "del
+name" in the shell itself. You can see if a name is defined by typing
+"'name' in globals()".
+
+The Symbols that are created using this have default assumptions.
+If you want to place assumptions on symbols, you should create them
+using symbols() or var().
+
+Finally, this only works in the top level namespace. So, for
+example, if you define a function in isympy with an undefined
+Symbol, it will not work.
+.TP
+\*(T<\fB\-D\fR\*(T>, \*(T<\fB\-\-debug\fR\*(T>
+Enable debugging output. This is the same as setting the
+environment variable SYMPY_DEBUG to 'True'. The debug status is set
+in the variable SYMPY_DEBUG within isympy.
+.TP
+-- \fIPYTHONOPTIONS\fR
+These options will be passed on to \fIipython (1)\fR shell.
+Only supported when ipython is being used (standard python shell not supported).
+
+Two dashes (--) are required to separate \fIPYTHONOPTIONS\fR
+from the other isympy options.
+
+For example, to run iSymPy without startup banner and colors:
+
+isympy -q -c ipython -- --colors=NoColor
+.TP
+\*(T<\fB\-h\fR\*(T>, \*(T<\fB\-\-help\fR\*(T>
+Print help output and exit.
+.TP
+\*(T<\fB\-v\fR\*(T>, \*(T<\fB\-\-version\fR\*(T>
+Print isympy version information and exit.
+.SH FILES
+.TP
+\*(T<\fI${HOME}/.sympy\-history\fR\*(T>
+Saves the history of commands when using the python
+shell as backend.
+.SH BUGS
+The upstreams BTS can be found at \(lahttps://github.com/sympy/sympy/issues\(ra
+Please report all bugs that you find in there, this will help improve
+the overall quality of SymPy.
+.SH "SEE ALSO"
+\fBipython\fR(1), \fBpython\fR(1)