PDASC 0.1.0__py3-none-any.whl

pdasc/main.py

@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+
+# Suppress resource_tracker semaphore warnings from sounddevice
+# Must be done before any other imports
+import os
+os.environ['PYTHONWARNINGS'] = 'ignore'
+
+import warnings
+warnings.filterwarnings(
+    "ignore",
+    message=".*resource_tracker.*semaphore.*"
+)
+
+from core import AsciiConverter, AsciiDisplayer, AsciiEncoder, generate_color_ramp, get_charmap, render_charmap, VideoAsciiConverter, process_video
+from web import create_video_server, ImageServer
+from PIL import Image
+import argparse
+import sys
+from importlib.resources import files
+
+def add_common_args(parser):
+    """Add arguments common to both play and encode"""
+    parser.add_argument(
+        "-b", "--block-size",
+        type=int,
+        default=8,
+        help="Size of character blocks (default: 8)"
+    )
+    
+    parser.add_argument(
+        "-n", "--num-ascii",
+        type=int,
+        default=8,
+        help="Number of ASCII characters to use (default: 8)"
+    )
+    
+    parser.add_argument(
+        "-f", "--font",
+        type=str,
+        default=os.path.join(os.path.dirname(__file__), "fonts", "CascadiaMono.ttf"),
+        help="Path to font file to create the ASCII character set from and to display on the website"
+    )
+    
+    parser.add_argument(
+        "--no-color",
+        action="store_true",
+        help="Disable color output"
+    )
+    
+    parser.add_argument(
+        "--no-audio",
+        action="store_true",
+        help="Disable audio playback for videos"
+    )
+
+def cmd_play(args):
+    """Play command - display images/videos/camera"""
+    # Validate font
+    if not os.path.exists(args.font):
+        print(f"Error: Font file '{args.font}' not found", file=sys.stderr)
+        sys.exit(1)
+    
+    converter = AsciiConverter(num_ascii=args.num_ascii, chunk_size=args.block_size, font_path=args.font)
+    displayer = AsciiDisplayer(converter, args.debug)
+    
+    try:
+        if args.input == "camera":
+            print(f"Starting camera {args.camera} (press Ctrl+C to stop)")
+            displayer.display_camera(camera_index=args.camera, color=not args.no_color)
+        else:
+            # Validate input file
+            if not os.path.exists(args.input):
+                print(f"Error: File '{args.input}' not found", file=sys.stderr)
+                sys.exit(1)
+            
+            # Determine file type
+            video_extensions = {'.mp4', '.avi', '.mov', '.mkv', '.webm', '.flv', '.wmv', '.m4v'}
+            image_extensions = {'.png', '.jpg', '.jpeg', '.gif', '.bmp', '.tiff', '.webp'}
+            special_extensions = {'.asc'}
+            
+            ext = os.path.splitext(args.input)[-1].lower()
+            
+            if ext not in video_extensions and ext not in image_extensions and ext not in special_extensions:
+                print(f"Error: Unsupported file extension '{ext}'", file=sys.stderr)
+                print(f"Supported: .asc, {', '.join(sorted(video_extensions | image_extensions))}", file=sys.stderr)
+                sys.exit(1)
+            
+            if ext == '.asc':
+                print(f"Playing .asc file: {args.input}")
+                displayer.display_asc_file(args.input, not args.no_audio)
+            elif ext in video_extensions:
+                print(f"Playing video: {args.input}")
+                displayer.display_video(
+                    video_path=args.input,
+                    play_audio=not args.no_audio,
+                    color=not args.no_color
+                )
+            else:
+                print(f"Displaying image: {args.input}")
+                displayer.display_image(image=Image.open(args.input), color=not args.no_color)
+                
+    except KeyboardInterrupt:
+        print("\nInterrupted by user", file=sys.stderr)
+        sys.exit(0)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+def cmd_encode(args):
+    """Encode command - save encoded ASCII to file"""
+    # Validate font
+    if not os.path.exists(args.font):
+        print(f"Error: Font file '{args.font}' not found", file=sys.stderr)
+        sys.exit(1)
+    
+    print(f"Encoding {args.input} to {args.output}")
+    # Validate input file
+    if not os.path.exists(args.input):
+        print(f"Error: File '{args.input}' not found", file=sys.stderr)
+        sys.exit(1)
+    
+    # Determine file type
+    video_extensions = {'.mp4', '.avi', '.mov', '.mkv', '.webm', '.flv', '.wmv', '.m4v'}
+    image_extensions = {'.png', '.jpg', '.jpeg', '.gif', '.bmp', '.tiff', '.webp'}
+    
+    ext = os.path.splitext(args.input)[-1].lower()
+    
+    if ext not in video_extensions and ext not in image_extensions:
+        print(f"Error: Unsupported file extension '{ext}'", file=sys.stderr)
+        print(f"Supported: {', '.join(sorted(video_extensions | image_extensions))}", file=sys.stderr)
+        sys.exit(1)
+    
+    encoder = AsciiEncoder()
+    converter = AsciiConverter(num_ascii=args.num_ascii, chunk_size=args.block_size, font_path=args.font)
+    
+    if ext in video_extensions:
+        encoder.encode_video_to_asc(args.input, args.output, not args.no_audio, not args.no_color, converter)
+    else:
+        encoder.encode_image_to_asc(args.input, args.output, not args.no_color, converter)
+
+def cmd_website(args):
+    if args.input:
+        video_extensions = {'.mp4', '.avi', '.mov', '.mkv', '.webm', '.flv', '.wmv', '.m4v'}
+        ext = os.path.splitext(args.input)[-1].lower()
+        if os.path.splitext(os.path.splitext(args.input)[0])[-1].lower() == '.asc':
+            app = create_video_server(args.input)
+            app.run()
+        elif ext in video_extensions:
+            with open("shaders/ascii.frag") as file:
+                frac_src = file.read()
+            font_path = str(files("pdasc.fonts").joinpath("font8x8.ttf"))
+            charmap_img = render_charmap(get_charmap(generate_color_ramp(font_path=font_path), levels=16), font_path=font_path)
+            converter = VideoAsciiConverter(frac_src, charmap_img, not args.no_color)
+            out_path = process_video(converter, args.input, args.output, not args.no_audio)
+            app = create_video_server(out_path)
+            app.run()
+        else:
+            print("Invalid input for website. Must be a valid video file or not specified")
+    else:
+        app = ImageServer(font_path=str(files("pdasc.fonts").joinpath("CascadiaMono.ttf")))
+        app.run(port=args.port)
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Convert images and videos to ASCII art",
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    
+    subparsers = parser.add_subparsers(dest='command', help='Available commands')
+    
+    # Play subcommand
+    play_parser = subparsers.add_parser(
+        'play',
+        help='Display images/videos/camera as ASCII art',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s image.png
+  %(prog)s video.mp4 --no-audio
+  %(prog)s camera -c 0
+  %(prog)s image.jpg -b 16 -n 70
+        """
+    )
+    
+    add_common_args(play_parser)
+    
+    play_parser.add_argument(
+        "input",
+        type=str,
+        help='Path to input file or "camera" for camera input'
+    )
+    
+    play_parser.add_argument(
+        "-c", "--camera",
+        type=int,
+        default=0,
+        help="Camera index when using camera input (default: 0)"
+    )
+    
+    play_parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug mode to show FPS and other debug info"
+    )
+    
+    play_parser.set_defaults(func=cmd_play)
+    
+    # Encode subcommand
+    encode_parser = subparsers.add_parser(
+        'encode',
+        help='Encode video/image to compressed ASCII file',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s video.mp4 -o output.asc
+  %(prog)s image.png -o output.asc --no-color
+        """
+    )
+    
+    encode_parser.add_argument(
+        "input",
+        type=str,
+        help="Path to input video or image file"
+    )
+    
+    encode_parser.add_argument(
+        "-o", "--output",
+        type=str,
+        default="ascii_out.asc",
+        help="Output file path"
+    )
+    
+    add_common_args(encode_parser)
+    
+    encode_parser.set_defaults(func=cmd_encode)
+    
+    website_parser = subparsers.add_parser(
+        'website',
+        help='Open image demo website or website to display ASCII shaded video',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Usage:
+  %(prog)s
+  %(prog)s video.mp4
+  %(prog)s ascii_video.asc.mp4
+        """
+    )
+    
+    website_parser.add_argument(
+        "input",
+        nargs='?',
+        type=str,
+        default=None,
+        help='Path to video to display on website (optional)'
+    )
+    
+    website_parser.add_argument(
+        "-o", "--output",
+        type=str,
+        default="",
+        help="Output file path"
+    )
+    
+    website_parser.add_argument(
+        "-p", "--port",
+        type=int,
+        default=5000,
+        help="Port to run website on"
+    )
+    
+    website_parser.add_argument(
+        "--no-color",
+        action="store_true",
+        help="Disable color output"
+    )
+    
+    website_parser.add_argument(
+        "--no-audio",
+        action="store_true",
+        help="Disable audio playback for videos"
+    )
+    
+    website_parser.set_defaults(func=cmd_website)
+    
+    args = parser.parse_args()
+    
+    # Show help if no command specified
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+    
+    # Call correct sub-command
+    args.func(args)
+
+if __name__ == "__main__":
+    main()

pdasc-0.1.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: PDASC
+Version: 0.1.0
+Summary: Made for Intersession 2026
+Author-email: Colin Politi <urboycolinthepanda@gmail.com>
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: Pillow>=9.0.0
+Requires-Dist: numba>=0.56.0
+Requires-Dist: pyaudio>=0.2.11
+Requires-Dist: opencv-python>=4.5.0
+Requires-Dist: zstandard>=0.18.0
+Requires-Dist: flask>=2.0.0
+Requires-Dist: moderngl>=5.6.0
+Dynamic: license-file

pdasc-0.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+core/__init__.py,sha256=YuZURZG4sVzajPjDD4infnkBunphk2n1vOPEbrhGa3M,785
+core/ascii_converter.py,sha256=Jh4Rl-40jckmcoSixpEEs7NuQplL60LYqjSPkfEck_0,3969
+core/ascii_displayer.py,sha256=Dp1JmCFJW0BfY-8MqeGifqMEvLH7Xw703p5ImE54cpA,11891
+core/ascii_file_encoding.py,sha256=qHrlZwGV058hjbVBaPmVAeL-_dIKe88x3PveVod_5H0,9695
+core/audio_player.py,sha256=a0IQBft4h2fGMTVRm8EapZJhL3lVMW3hn8lj2N0obB8,5594
+core/generate_color_ramp.py,sha256=UBnrOmjG0G8mFXVWehG1wKfIM8dDllnBuwopia9DZho,2336
+core/utils.py,sha256=aL3lmt7uX6NZB6EqqNLt4SiJfBFlfhhqXwKuJnhuQTs,868
+core/video_ascii_video.py,sha256=8EIaBc96oT0FYMKSIRsKlreSPVRq2hkRwrRkAREdsGs,7490
+core/video_extractor.py,sha256=Gqyrj53qbHeRR7WDD70qvia2OowCbmxq8LIMwaox3Pg,4206
+pdasc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pdasc/main.py,sha256=hoeR6oHvddnAjsK1pCLFk6mGWCTzu29Nml5rAl3Krn8,9937
+pdasc/fonts/CascadiaMono.ttf,sha256=CAJvYX7qMVyspZiYeE6Zn2zbLQw00gQN7rBCvNw1n6I,714804
+pdasc/fonts/font8x8.ttf,sha256=YQF0gD089-zxbgsLg_hklnec42cSvjfsOOehDZVSuRg,66484
+pdasc-0.1.0.dist-info/licenses/LICENSE,sha256=1ss2MifclFKIfzZXjfcFh-LuQuHvNLhKG8fAnKWy7SM,1090
+web/__init__.py,sha256=4-_vwOO6HfcyeKPs4oU2lACf8lWZb3GijVu-wM1l4Qc,140
+web/image_controller/__init__.py,sha256=Q72s3s3C_5iYRHScILKs7DD2dBw1_E2NFOt4ab51poc,28
+web/image_controller/app.py,sha256=V2DFsvroQ4_aT8mdmhSWCjnM_kGu6fxfNwE-dwupOQY,3914
+web/image_controller/templates/index.html,sha256=2pjUlsN9jfNOxubnApiYnSj1IYl4uMqqIBgr9NUNYpA,10669
+web/video_player/__init__.py,sha256=g3L-NXzSsLTh3w40QSzU5U4rqxVmZgI0cAmiyiU4czQ,36
+web/video_player/app.py,sha256=K8I87xLMlRAOGSaSa7DU8SbjCFZpX27aMOnf5UchADE,1296
+web/video_player/templates/index.html,sha256=f6qpVInwXAushhHwZIwLunJgTa1ixSu1LoNFKkqzMkk,8208
+pdasc-0.1.0.dist-info/METADATA,sha256=n-AFMuMVOurWh1Kw9x_YODeTymL-UH0Q77FTlmctOFU,473
+pdasc-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pdasc-0.1.0.dist-info/entry_points.txt,sha256=DjIudun90vxvj4UvWXM07l07CvevQrPHn9LGwRyTjHQ,42
+pdasc-0.1.0.dist-info/top_level.txt,sha256=swqiWpl30iX2Jy2LDoWFkBD7mIHD_cPgzOVd5mT833A,15
+pdasc-0.1.0.dist-info/RECORD,,

pdasc-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pdasc-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pdasc = pdasc.main:main

pdasc-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ColinThePanda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pdasc-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+core
+pdasc
+web

web/__init__.py

@@ -0,0 +1,4 @@
+from .video_player import create_video_server
+from .image_controller import ImageServer
+
+__all__ = ["create_video_server", "ImageServer"]

web/image_controller/__init__.py

@@ -0,0 +1 @@
+from .app import ImageServer

web/image_controller/app.py

@@ -0,0 +1,99 @@
+import sys
+import os
+# add root to path to import from core
+sys.path.insert(0, os.path.join(__file__, "../../../"))
+
+from flask import Flask, render_template, request
+from PIL import Image
+from core import AsciiConverter, AsciiDisplayer
+from typing import Any
+
+class ImageServer:
+    def __init__(self, font_path: str | None = None) -> None:
+        self.app = Flask(__name__)
+        self._setup_app()
+        self.converter = AsciiConverter(font_path=font_path) if font_path else AsciiConverter()
+        self.displayer = AsciiDisplayer(self.converter)
+        self.colored = True
+
+    def _html_from_ansi(self, ansi: str) -> str:
+        if not self.colored:
+            # Escape HTML characters and replace newlines with <br> for plain ASCII
+            import html
+            escaped = html.escape(ansi)
+            return f'<span>{escaped.replace("\n", "<br>")}</span>'
+        
+        import re
+        
+        html_parts = []
+        current_color = None
+        
+        # Pattern to match ANSI escape codes
+        ansi_pattern = re.compile(r'\x1b\[([0-9;]+)m')
+        
+        last_end = 0
+        for match in ansi_pattern.finditer(ansi):
+            # Add any text before this escape code
+            text = ansi[last_end:match.start()]
+            if text:
+                if current_color:
+                    html_parts.append(f'<span style="color:{current_color}">{text}</span>')
+                else:
+                    html_parts.append(text)
+            
+            # Parse the escape code
+            codes = match.group(1).split(';')
+            i = 0
+            while i < len(codes):
+                code = codes[i]
+                
+                if code == '0' or code == '':  # Reset
+                    current_color = None
+                elif code == '38' and i + 2 < len(codes) and codes[i + 1] == '2':  # RGB foreground
+                    r, g, b = codes[i + 2], codes[i + 3], codes[i + 4]
+                    current_color = f'rgb({r},{g},{b})'
+                    i += 4
+                
+                i += 1
+            
+            last_end = match.end()
+        
+        # Add any remaining text
+        text = ansi[last_end:]
+        if text:
+            if current_color:
+                html_parts.append(f'<span style="color:{current_color}">{text}</span>')
+            else:
+                html_parts.append(text)
+        
+        return ''.join(html_parts).replace('\n', '<br>')
+    
+    def _setup_app(self):
+        self.app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024 
+        @self.app.route('/')
+        def index():
+            return render_template(
+                "index.html"
+            )
+        
+        @self.app.route('/ascii', methods=['POST'])
+        def ascii():
+            num_ascii = request.form.get('num_ascii')
+            block_size = request.form.get('block_size')
+            colored = request.form.get('colored')
+            image_file  = request.files.get('image')  # This is base64 encoded
+            
+            if not num_ascii or not block_size or not colored or not image_file:
+                return "Error one of the inputs is not defined"
+            
+            self.converter.num_ascii = int(num_ascii)
+            self.converter.chunk_size = int(block_size)
+            self.colored = bool(int(colored))
+            image = Image.open(image_file.stream)
+            self.converter.regen_charmap()
+            ascii = self.converter.get_ascii(image, self.colored)
+            frame = self.displayer.render_ascii(ascii, self.colored)
+            return self._html_from_ansi(frame)
+    
+    def run(self, host: str | None = None, port: int | None = None, debug: bool | None = None, load_dotenv: bool = True, **options: Any):
+        self.app.run(host=host, port=port, debug=debug, load_dotenv=load_dotenv, **options)