doc2dict 0.2.0__tar.gz → 0.2.2__tar.gz

{doc2dict-0.2.0 → doc2dict-0.2.2}/PKG-INFO

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

doc2dict-0.2.2/doc2dict/__init__.py

@@ -0,0 +1,7 @@
+from .html.html_parser import html_reduction
+from .html.visualizer import format_list_html
+from .xml.parser import xml2dict
+from .txt.parser import txt2dict
+from .dict2dict import dict2dict
+
+__all__ = ['html_reduction', 'format_list_html', 'xml2dict', 'txt2dict','dict2dict']

doc2dict-0.2.2/doc2dict/dict2dict.py

@@ -0,0 +1,50 @@
+def dict2dict(data):
+    result = {}
+    
+    def process_item(item):
+        # If item is a string, return it directly
+        if isinstance(item, str):
+            return item.strip()
+            
+        # If item is not a dict, return string version
+        if not isinstance(item, dict):
+            return str(item).strip()
+            
+        # Base case: if there's no further content, return the item itself
+        if 'content' not in item:
+            return item
+        
+        # If there's a text key, use it as the dict key, otherwise use the type
+        key = item.get('text', item.get('type', ''))
+        
+        # Process the content
+        if isinstance(item['content'], list):
+            # Check if content contains dictionaries with type/text
+            if any(isinstance(x, dict) and ('type' in x or 'text' in x) for x in item['content']):
+                nested_result = {}
+                for content_item in item['content']:
+                    if isinstance(content_item, dict):
+                        nested_key = content_item.get('text', content_item.get('type', ''))
+                        nested_result[nested_key] = process_item(content_item)
+                return nested_result
+            # If content items are simple values (strings/numbers), join with newlines and strip
+            else:
+                return '\n'.join(str(x) for x in item['content']).strip()
+        else:
+            return str(item['content']).strip()
+
+    # Handle case where data itself might be a string
+    if isinstance(data, str):
+        return data.strip()
+        
+    # Handle case where content is a list directly
+    if isinstance(data.get('content', []), list):
+        for item in data['content']:
+            if isinstance(item, dict):
+                key = item.get('text', item.get('type', ''))
+                result[key] = process_item(item)
+            else:
+                # If we have a string in content, use it as both key and value
+                result[str(item).strip()] = str(item).strip()
+                
+    return result

doc2dict-0.2.2/doc2dict/html/html_parser.py

@@ -0,0 +1,294 @@
+import re
+
+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)
+
+class Ctx:
+    def __init__(self, base=16.0):
+        self.base = base  # base font size
+        self.vh = 900    # viewport height
+        self.vw = 1600   # viewport width
+
+class Box:
+    def __init__(self):
+        self.mt = self.mb = self.pt = self.pb = self.bt = self.bb = 0  # margins, padding, borders
+        self.ch = 0  # content height
+    
+    @property
+    def height(self):
+        return self.mt + self.pt + self.bt + self.ch + self.mb + self.pb + self.bb
+
+def parse_val(val, ctx, parent):
+    """Parse CSS values with unit support"""
+    if not val or val == 'auto' or val == 'none': return 0
+    
+    try:
+        m = re.match(r'^(-?\d*\.?\d+)(\D*)$', val.strip())
+        if not m: return 0
+        
+        n, u = float(m.group(1)), m.group(2)
+        
+        units = {
+            '': n,
+            'px': n,
+            'em': n * parent,
+            'rem': n * ctx.base,
+            '%': (n/100) * parent,
+            'vh': (n/100) * ctx.vh,
+            'vw': (n/100) * ctx.vw,
+            'pt': n * 1.333333,
+            'pc': n * 16,
+            'in': n * 96,
+            'cm': n * 37.795276,
+            'mm': n * 3.779528
+        }
+        
+        return units.get(u, 0)
+    except:
+        return 0
+
+def parse_border(val, ctx, parent):
+    """Parse border values"""
+    if not val: return 0
+    return next((parse_val(p, ctx, parent) for p in val.split() if re.match(r'^\d', p)), 0)
+
+def calc_line_height(fs, lh):
+    """Calculate line height"""
+    if not lh: return fs  # Default to font size
+    
+    try:
+        if isinstance(lh, (int, float)):
+            return fs * float(lh)  # multiplier
+        elif lh.endswith('px'):
+            return float(lh[:-2])
+        elif lh.endswith('%'):
+            return fs * (float(lh[:-1])/100)
+        return fs  # Default to font size for any other value
+    except:
+        return fs
+
+class StyleChain:
+    def __init__(self, ctx):
+        self.ctx = ctx
+        self.chain = []
+    
+    def push(self, s): self.chain.append(s)
+    def pop(self): self.chain.pop() if self.chain else None
+    
+    def get(self, prop, default=''):
+        """Get computed style"""
+        for s in reversed(self.chain):
+            if prop in s: return s[prop][0]
+        return default
+    
+    def font_size(self):
+        """Calculate font size through chain"""
+        size = self.ctx.base
+        for s in self.chain:
+            if 'font-size' in s:
+                size = parse_val(s['font-size'][0], self.ctx, size)
+        return size
+
+def get_box_metrics(styles, chain):
+    """Calculate box model metrics"""
+    ctx = chain.ctx
+    fs = chain.font_size()
+    box = Box()
+    
+    # Get box properties
+    props = {
+        'margin-top': 'mt', 'margin-bottom': 'mb',
+        'padding-top': 'pt', 'padding-bottom': 'pb'
+    }
+    
+    for css_prop, box_prop in props.items():
+        if css_prop in styles:
+            setattr(box, box_prop, parse_val(styles[css_prop][0], ctx, fs))
+    
+    # Borders
+    if 'border-top' in styles: box.bt = parse_border(styles['border-top'][0], ctx, fs)
+    if 'border-bottom' in styles: box.bb = parse_border(styles['border-bottom'][0], ctx, fs)
+    
+    # Content height
+    box.ch = calc_line_height(fs, chain.get('line-height'))
+    
+    # Handle border-box
+    if chain.get('box-sizing') == 'border-box':
+        extra = box.pt + box.pb + box.bt + box.bb
+        box.ch = max(0, box.ch - extra)
+    
+    return box
+
+def process_height(node, chain):
+    """Process element height"""
+    styles = get_node_styles(node)
+    chain.push(styles)
+    
+    try:
+        box = get_box_metrics(styles, chain)
+        fs = chain.font_size()
+        
+        return {
+            'font_size': round(fs, 2),
+            'content_height': round(box.ch, 2),
+            'total_height': round(box.ch, 2),  # Only use content height
+            'box': {
+                'mt': 0, 'mb': 0,
+                'pt': 0, 'pb': 0,
+                'bt': 0, 'bb': 0
+            }
+        }
+    finally:
+        chain.pop()
+
+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
+    }
+    
+    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
+        
+    font_weight = styles.get('font-weight', [''])[0]
+    if font_weight in {'bold', '700', '800', '900'}:
+        text_style['bold'] = True
+        
+    if styles.get('font-style', [''])[0] == 'italic':
+        text_style['italic'] = True
+        
+    if 'underline' in styles.get('text-decoration', [''])[0]:
+        text_style['underline'] = True
+        
+    return text_style
+
+def is_inline(node, styles):
+    if node.tag in {'span', 'a', 'strong', 'em', 'b', 'i', 'u'}:
+        return True
+    return styles.get('display', [''])[0] == 'inline'
+
+def html_reduction(tree):
+    """Main processing function"""
+    ctx = Ctx()
+    chain = StyleChain(ctx)
+    blocks = {'p', 'div', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'article', 'section', 'li'}
+    skip = {'script', 'style', 'noscript'}
+    lines = []
+    cur_line = []
+    row_items = []
+    in_row = False
+    
+    def flush():
+        if cur_line:
+            items = []
+            for text, style, node in cur_line:
+                if text.strip():
+                    metrics = process_height(node, chain)
+                    items.append({
+                        "text": text.strip(),
+                        "bold": style.get('bold', False),
+                        "italic": style.get('italic', False),
+                        "underline": style.get('underline', False),
+                        "height": metrics['total_height'],
+                        "font_size": metrics['font_size']
+                    })
+            if items: lines.append(items)
+            cur_line.clear()
+
+    for event, node, styles, text, style in iterwalk(tree.body, include_text=True):
+        if node.tag in skip: continue
+        
+        if event == "start": chain.push(styles)
+        
+        if node.tag == 'tr':
+            if event == "start":
+                in_row = True
+                row_items = []
+            elif event == "end":
+                if row_items:
+                    lines.append([{
+                        "text": t,
+                        "bold": s['bold'],
+                        "italic": s['italic'],
+                        "underline": s['underline'],
+                        "height": process_height(n, chain)['total_height'],
+                        "font_size": process_height(n, chain)['font_size']
+                    } for t, s, n in row_items])
+                in_row = False
+                row_items = []
+                
+        if in_row and event == "start" and text:
+            t = text.strip()
+            if t: row_items.append((t, style, node))
+            continue
+            
+        if (node.tag in blocks or styles.get('display', [''])[0] == 'flex') and not is_inline(node, styles):
+            if event == "start":
+                flush()
+                if text:
+                    t = text.strip()
+                    if t:
+                        metrics = process_height(node, chain)
+                        lines.append([{
+                            "text": t,
+                            "bold": style['bold'],
+                            "italic": style['italic'],
+                            "underline": style['underline'],
+                            "height": metrics['total_height'],
+                            "font_size": metrics['font_size']
+                        }])
+            elif event == "end":
+                flush()
+        elif event == "start" and text:
+            t = text.strip()
+            if t: cur_line.append((t, style, node))
+                
+        if event == "end": chain.pop()
+    
+    flush()
+    return lines

doc2dict-0.2.2/doc2dict/html/visualizer.py

@@ -0,0 +1,100 @@
+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;
+    }
+    .row {
+        margin-bottom: 20px;
+        display: flex;
+        flex-wrap: wrap;
+    }
+    .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:  # Change height to font-size
+            style_properties.append(f'font-size: {height}')
+                
+        if style_properties:
+            return f"<span style='{'; '.join(style_properties)}'>{text}</span>"
+        return text
+    
+    for items in nested_list:
+        if isinstance(items, list):
+            first_indent = items[0].get('indent', 0) if isinstance(items[0], dict) else 0
+            html_content += f"<div class='row' style='padding-left: {first_indent}em'>\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"
+        else:
+            if isinstance(items, dict):
+                indent = items.get('indent', 0)
+                styled_text = get_styled_text(items)
+                height = items.get('height', '')
+                height_style = f'height: {height};' if height else ''
+                html_content += f"<div class='row' style='padding-left: {indent}em'><span class='item' style='background-color: {single_line_color}; {height_style}'>{styled_text}</span></div>\n"
+            else:
+                styled_text = str(items)
+                indent = 0
+                html_content += f"<div class='row' style='padding-left: {indent}em'><span class='item' style='background-color: {single_line_color}'>{styled_text}</span></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.2.2/doc2dict/txt/parser.py

@@ -0,0 +1,21 @@
+from doc2dict.mapping import DocumentProcessor
+
+def txt2dict(content,mapping_dict):
+    # Split by double newlines to get paragraphs
+    paragraphs = content.split('\n\n')
+    
+    # Process each paragraph
+    lines = []
+    for paragraph in paragraphs:
+        if paragraph.strip():  # Skip empty paragraphs
+            processed = paragraph.strip()
+            processed = processed.split('\n')
+            # Add double newlines at start of each paragraph
+            processed[0] = '\n\n' + processed[0]
+            # Add single newline to other lines
+            processed[1:] = ['\n' + line for line in processed[1:]]
+            lines.extend(processed)
+            
+    processor = DocumentProcessor(mapping_dict)
+    result = processor.process(lines)
+    return result

doc2dict-0.2.2/doc2dict/xml/parser.py

@@ -0,0 +1,12 @@
+import xmltodict
+from ..mapping import JSONTransformer
+
+def xml2dict(content, mapping_dict=None):
+    data = xmltodict.parse(content)
+    
+    if mapping_dict is None:
+        return data
+     
+    transformer = JSONTransformer(mapping_dict)
+    transformed_data = transformer.transform(data)
+    return transformed_data

{doc2dict-0.2.0 → doc2dict-0.2.2}/doc2dict.egg-info/PKG-INFO

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

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

@@ -0,0 +1,16 @@
+setup.py
+doc2dict/__init__.py
+doc2dict/dict2dict.py
+doc2dict/mapping.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/html/__init__.py
+doc2dict/html/html_parser.py
+doc2dict/html/visualizer.py
+doc2dict/txt/__init__.py
+doc2dict/txt/parser.py
+doc2dict/xml/__init__.py
+doc2dict/xml/parser.py

{doc2dict-0.2.0 → doc2dict-0.2.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="doc2dict",
-    version="0.2.0",
+    version="0.2.2",
     packages=find_packages(),
     install_requires=['selectolax','xmltodict'
     ],

doc2dict-0.2.0/doc2dict/__init__.py

@@ -1,4 +0,0 @@
-from .html.html_parser import html_reduction
-from .html.visualizer import format_list_html
-from .xml.parser import xml2dict
-from .txt.parser import txt2dict

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

@@ -1,8 +0,0 @@
-setup.py
-doc2dict/__init__.py
-doc2dict/mapping.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