doc2dict 0.1__tar.gz

doc2dict-0.1/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.1
+Name: doc2dict
+Version: 0.1
+Requires-Python: >=3.8

doc2dict-0.1/doc2dict/__init__.py

@@ -0,0 +1,3 @@
+from .html_parser import html_reduction
+from .visualizer import format_list_html
+from .xml_parser import xml_parser

doc2dict-0.1/doc2dict/html_parser.py

@@ -0,0 +1,302 @@
+# Core functionality (original)
+def standardize_css(style):
+    if not style: 
+        return {}
+    return {
+        k.strip(): v.strip().split() 
+        for k, v in (pair.split(':') for pair in style.split(';') if ':' in pair)
+        if k.strip() and v.strip()
+    }
+
+def get_node_styles(node):
+    style = node.attributes.get('style')
+    if not style:
+        return {}
+    return standardize_css(style)
+
+def get_text_style(node, styles, inherited_style=None):
+    text_style = inherited_style.copy() if inherited_style else {
+        'bold': False,
+        'italic': False,
+        'underline': False
+    }
+    
+    # Check HTML tags
+    if node.tag in {'b', 'strong'}:
+        text_style['bold'] = True
+    if node.tag in {'i', 'em'}:
+        text_style['italic'] = True
+    if node.tag == 'u':
+        text_style['underline'] = True
+        
+    # Check CSS styles
+    font_weight = styles.get('font-weight', [''])[0]
+    if font_weight in {'bold', '700', '800', '900'}:
+        text_style['bold'] = True
+        
+    font_style = styles.get('font-style', [''])[0]
+    if font_style == 'italic':
+        text_style['italic'] = True
+        
+    text_decoration = styles.get('text-decoration', [''])[0]
+    if 'underline' in text_decoration:
+        text_style['underline'] = True
+        
+    return text_style
+
+def get_indent(styles):
+    # Handle direct indentation
+    margin_left = styles.get('margin-left', ['0'])[0]
+    text_indent = styles.get('text-indent', ['0'])[0]
+    text_align = styles.get('text-align', ['left'])[0]  # default to left
+
+    def convert_to_pixels(value):
+        try:
+            if value.endswith('in'):
+                return float(value.rstrip('in')) * 96
+            elif value.endswith('cm'):
+                return float(value.rstrip('cm')) * 37.8
+            elif value.endswith('mm'):
+                return float(value.rstrip('mm')) * 3.78
+            elif value.endswith('pt'):
+                return float(value.rstrip('pt')) * 1.333
+            elif value.endswith('px'):
+                return float(value.rstrip('px'))
+            elif value.endswith('%'):
+                return float(value.rstrip('%'))
+            else:
+                return float(value)
+        except ValueError:
+            return 0
+
+    # Calculate physical indentation in pixels
+    margin = convert_to_pixels(margin_left)
+    indent = convert_to_pixels(text_indent)
+    
+    # Convert alignment to positions on 0-100 scale
+    # left = 0, center = 50, right = 100
+    if text_align == 'center':
+        return 50
+    elif text_align == 'right':
+        return 100
+    else:  # left or justify
+        # Convert physical indent to percentage (assuming standard page width of ~700px)
+        # This is approximate - might need to adjust the scaling factor
+        page_width = 700  # assumed page width in pixels
+        position = ((margin + indent) / page_width) * 100
+        return min(100, position)  # cap at 100
+    
+def is_inline(node, styles):
+    if node.tag in {'span', 'a', 'strong', 'em', 'b', 'i', 'u'}:
+        return True
+    display = styles.get('display', [''])[0]
+    return display == 'inline'
+
+def iterwalk(root, include_text):
+    def walk(node, inherited_styles=None, inherited_text_style=None):
+        current_styles = dict(inherited_styles or {})
+        node_styles = get_node_styles(node)
+        current_styles.update(node_styles)
+        
+        if current_styles.get('display', [''])[0] == 'none':
+            return
+            
+        text_content = node.text_content
+        if text_content:
+            text_transform = current_styles.get('text-transform', [''])[0]
+            if text_transform == 'uppercase':
+                text_content = text_content.upper()
+            elif text_transform == 'lowercase':
+                text_content = text_content.lower()
+            elif text_transform == 'capitalize':
+                text_content = text_content.capitalize()
+
+        text_style = get_text_style(node, current_styles, inherited_text_style)
+        
+        yield ("start", node, current_styles, text_content, text_style)
+        for child in node.iter(include_text=include_text):
+            if child is not node:
+                yield from walk(child, current_styles, text_style)
+        yield ("end", node, current_styles, text_content, text_style)
+    
+    for node in root.iter(include_text=include_text):
+        if node is not root:
+            yield from walk(node)
+
+# New height calculation functionality (add/modify these sections)
+def parse_font_size(size_str, base_size):
+    """Parse font size with precise point-to-pixel conversion"""
+    try:
+        if size_str.endswith('pt'):
+            # Convert points to pixels (1pt = 1.333px)
+            return float(size_str[:-2]) * 1.333
+        elif size_str.endswith('px'):
+            return float(size_str[:-2])
+        elif size_str.endswith('%'):
+            return base_size * float(size_str[:-1]) / 100
+        elif size_str.endswith('em'):
+            return base_size * float(size_str[:-2])
+        elif size_str.endswith('rem'):
+            return 16 * float(size_str[:-3])  # rem is relative to root (usually 16px)
+        return float(size_str)  # Assume pixels if no unit
+    except ValueError:
+        return base_size  # Return base size if parsing fails
+
+def get_effective_style(node, parent_styles=None):
+    """Get combined styles considering element and parent context"""
+    styles = {}
+    
+    # Start with parent styles
+    if parent_styles:
+        styles.update(parent_styles)
+    
+    # Add element's own styles
+    element_styles = get_node_styles(node)
+    for key, value in element_styles.items():
+        if key in {'font-size', 'line-height', 'margin-top', 'margin-bottom',
+                  'padding-top', 'padding-bottom', 'border-top', 'border-bottom'}:
+            styles[key] = value
+            
+    return styles
+
+def calculate_compound_height(node, inherited_size=None):
+    """Calculate exact height based on all style factors"""
+    base_size = inherited_size or 16
+    styles = get_effective_style(node)
+    
+    # Get font size
+    if 'font-size' in styles:
+        font_size = parse_font_size(styles['font-size'][0], base_size)
+    else:
+        font_size = base_size
+        
+    # Calculate line height (default 1.2 if not specified)
+    line_height_mult = 1.2
+    if 'line-height' in styles:
+        try:
+            line_height_mult = float(styles['line-height'][0])
+        except ValueError:
+            pass
+            
+    content_height = font_size * line_height_mult
+    
+    # Add margins, padding, borders
+    spacing = 0
+    for prop in ['margin-top', 'margin-bottom', 'padding-top', 'padding-bottom']:
+        if prop in styles:
+            spacing += parse_font_size(styles[prop][0], base_size)
+            
+    # Handle borders
+    if 'border-top' in styles:
+        border_value = styles['border-top'][0].split()[0]
+        spacing += parse_font_size(border_value, base_size)
+    if 'border-bottom' in styles:
+        border_value = styles['border-bottom'][0].split()[0]
+        spacing += parse_font_size(border_value, base_size)
+
+    # round to 2 decimal places
+    font_size = round(font_size, 2)
+    content_height = round(content_height, 2)
+    spacing = round(spacing, 2)
+        
+    return {
+        'font_size': font_size,
+        'content_height': content_height,
+        'total_height': content_height + spacing
+    }
+
+def html_reduction(tree):
+    """Main processing function"""
+    blocks = {'p', 'div', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'article', 'section', 'li'}
+    skip_elements = {'script', 'style', 'noscript'}
+    lines = []
+    current_line = []
+    row_content = []
+    in_row = False
+    inherited_size = 16  # Base font size
+    
+    def flush_line():
+        if current_line:
+            items = []
+            for text, style in current_line:
+                if text.strip():
+                    height_metrics = calculate_compound_height(current_node, inherited_size)
+                    items.append({
+                        "text": text.strip(),
+                        "indent": get_indent(current_styles),
+                        "bold": style.get('bold', False),
+                        "italic": style.get('italic', False),
+                        "underline": style.get('underline', False),
+                        "height": height_metrics['total_height'],
+                        "font_size": height_metrics['font_size']
+                    })
+            if items:
+                lines.append(items)
+            current_line.clear()
+
+    for event, node, styles, text_content, text_style in iterwalk(tree.body, include_text=True):
+        if node.tag in skip_elements:
+            continue
+
+        current_node = node
+        current_styles = styles
+        current_text_style = text_style
+        
+        if event == "start":
+            # Update inherited size based on parent styles
+            if 'font-size' in styles:
+                inherited_size = parse_font_size(styles['font-size'][0], inherited_size)
+
+        # Process content based on node type
+        if node.tag == 'tr':
+            if event == "start":
+                in_row = True
+                row_content = []
+            elif event == "end":
+                if row_content:
+                    height_metrics = calculate_compound_height(node, inherited_size)
+                    lines.append([{
+                        "text": text,
+                        "indent": 0,
+                        "bold": style['bold'],  # Use captured style
+                        "italic": style['italic'],  # Use captured style
+                        "underline": style['underline'],  # Use captured style
+                        "height": height_metrics['total_height'],
+                        "font_size": height_metrics['font_size']
+                    } for text, style in row_content])  # Unpack both text and style
+                in_row = False
+                row_content = []
+                continue
+
+        if in_row and event == "start" and text_content:
+            text = text_content.strip()
+            if text:
+                # Store both text and style
+                row_content.append((text, text_style))
+            continue
+            
+        if (node.tag in blocks or styles.get('display', [''])[0] == 'flex') and not is_inline(node, styles):
+            if event == "start":
+                flush_line()
+                if text_content:
+                    text = text_content.strip()
+                    if text:
+                        height_metrics = calculate_compound_height(node, inherited_size)
+                        lines.append([{
+                            "text": text,
+                            "indent": get_indent(styles),
+                            "bold": text_style['bold'],
+                            "italic": text_style['italic'],
+                            "underline": text_style['underline'],
+                            "height": height_metrics['total_height'],
+                            "font_size": height_metrics['font_size']
+                        }])
+            elif event == "end":
+                flush_line()
+        elif event == "start" and text_content:
+            text = text_content.strip()
+            if text:
+                current_line.append((text, text_style))  # Store tuple of (text, style)
+    
+    flush_line()
+    return lines

doc2dict-0.1/doc2dict/visualizer.py

@@ -0,0 +1,125 @@
+import webbrowser
+import os
+
+def format_list_html(nested_list):
+    # Simplified color scheme
+    single_line_color = '#E6F3FF'  # Blue hue
+    multi_first_color = '#E6FFE6'  # Green hue
+    multi_rest_color = '#FFE6E6'   # Red hue
+    
+    html_content = """
+<html>
+<head>
+<style>
+    body {
+        font-family: Arial, sans-serif;
+        line-height: 1.6;
+        margin: 20px;
+        max-width: 1200px;  /* Set a max-width for consistent scaling */
+    }
+    .row {
+        margin-bottom: 20px;
+        width: 100%;
+        position: relative;  /* For absolute positioning of items */
+    }
+    .item-container {
+        display: inline-block;
+        position: relative;  /* For proper indent positioning */
+    }
+    .item {
+        padding: 10px 15px;
+        border-radius: 5px;
+        margin-right: 15px;
+        margin-bottom: 10px;
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+"""
+    
+    def get_styled_text(item):
+        """Helper function to apply text styling"""
+        if not isinstance(item, dict):
+            return str(item)
+            
+        height = str(item.get('height', ''))
+        text = item.get('text', '')
+        style_properties = []
+        
+        if item.get('bold', False):
+            style_properties.append('font-weight: bold')
+        if item.get('italic', False):
+            style_properties.append('font-style: italic')
+        if item.get('underline', False):
+            style_properties.append('text-decoration: underline')
+        if height:
+            style_properties.append(f'font-size: {height}')
+                
+        if style_properties:
+            return f"<span style='{'; '.join(style_properties)}'>{text}</span>"
+        return text
+    
+    def calculate_position(indent):
+        """Convert normalized indent (0-100) to percentage position"""
+        if indent is None:
+            return 0
+        # Ensure indent is within 0-100 range
+        indent = max(0, min(100, indent))
+        # Convert to percentage for positioning
+        return indent
+            
+    for items in nested_list:
+        if isinstance(items, list):
+            # Get indent from first item if it's a dictionary
+            first_indent = items[0].get('indent', 0) if isinstance(items[0], dict) else 0
+            position = calculate_position(first_indent)
+            
+            html_content += f"<div class='row'>\n"
+            html_content += f"  <div class='item-container' style='margin-left: {position}%'>\n"
+            
+            for i, item in enumerate(items):
+                # Single item -> blue
+                if len(items) == 1:
+                    color = single_line_color
+                # Multiple items: first -> green, rest -> red
+                else:
+                    color = multi_first_color if i == 0 else multi_rest_color
+                    
+                styled_text = get_styled_text(item)
+                html_content += f"    <span class='item' style='background-color: {color}'>{styled_text}</span>\n"
+            
+            html_content += "  </div>\n</div>\n"
+        else:
+            # Handle single items
+            indent = items.get('indent', 0) if isinstance(items, dict) else 0
+            position = calculate_position(indent)
+            
+            html_content += f"<div class='row'>\n"
+            html_content += f"  <div class='item-container' style='margin-left: {position}%'>\n"
+            
+            if isinstance(items, dict):
+                styled_text = get_styled_text(items)
+                height = items.get('height', '')
+                height_style = f'height: {height};' if height else ''
+                html_content += f"    <span class='item' style='background-color: {single_line_color}; {height_style}'>{styled_text}</span>\n"
+            else:
+                styled_text = str(items)
+                html_content += f"    <span class='item' style='background-color: {single_line_color}'>{styled_text}</span>\n"
+            
+            html_content += "  </div>\n</div>\n"
+    
+    html_content += """
+</body>
+</html>
+"""
+    
+    # Write HTML content to a temporary file
+    with open('temp.html', 'w', encoding='utf-8') as f:
+        f.write(html_content)
+    
+    # Get the absolute path of the file
+    file_path = os.path.abspath('temp.html')
+    
+    # Open the HTML file in the default web browser
+    webbrowser.open('file://' + file_path)

doc2dict-0.1/doc2dict/xml_parser.py

@@ -0,0 +1,6 @@
+import xmltodict
+import json
+
+# Modify to add mapping dict
+def parse_xml(content):
+    return xmltodict.parse(content) 

doc2dict-0.1/doc2dict.egg-info/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.1
+Name: doc2dict
+Version: 0.1
+Requires-Python: >=3.8

doc2dict-0.1/doc2dict.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+setup.py
+doc2dict/__init__.py
+doc2dict/html_parser.py
+doc2dict/visualizer.py
+doc2dict/xml_parser.py
+doc2dict.egg-info/PKG-INFO
+doc2dict.egg-info/SOURCES.txt
+doc2dict.egg-info/dependency_links.txt
+doc2dict.egg-info/requires.txt
+doc2dict.egg-info/top_level.txt

doc2dict-0.1/doc2dict.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

doc2dict-0.1/doc2dict.egg-info/requires.txt

@@ -0,0 +1 @@
+selectolax

doc2dict-0.1/doc2dict.egg-info/top_level.txt

@@ -0,0 +1 @@
+doc2dict

doc2dict-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

doc2dict-0.1/setup.py

@@ -0,0 +1,10 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="doc2dict",
+    version="0.01",
+    packages=find_packages(),
+    install_requires=['selectolax'
+    ],
+    python_requires=">=3.8"
+)