uiml 0.1.0__tar.gz

uiml-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 xystudiocode
+
+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.

uiml-0.1.0/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: uiml
+Version: 0.1.0
+Home-page: https://github.com/xystudio889/
+Author: xystudio
+Author-email: xystudio <173288240@qq.com>
+License: MIT
+Project-URL: Homepage, https://github.com/xystudio889/
+Keywords: uiml,PySide6,Qt,ui,xml,design
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PySide6>=6.10.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+<div align="center">
+<img src="./imgs/readme/logo.png" width="400" alt="logo" />
+<h1>uiml</h1>
+一个使用特殊的xml格式，用于绘制PySide6的ui界面
+</div>
+
+--- 
+
+## 介绍
+uiml是一个用于绘制PySide6的ui界面的工具，它使用特殊的xml格式来定义界面的布局，样式和信号。uiml的语法非常简单，易于学习和使用。你可以使用uiml来创建复杂的界面，而不需要编写大量的代码。
+
+uiml的语法在xml的基础上，增加支持的python对象，所以它既有xml的轻便性，又有python对象的灵活性。
+
+## 安装
+要使用uiml，你需要先安装它。你可以使用pip来安装uiml：
+
+```bash
+pip install uiml
+```
+
+## 使用
+要使用uiml，你需要创建一个uiml文件，并在其中定义界面的布局，样式和信号。以下是一个简单的示例：
+
+```xml
+<layout name="central_layout" direction="v">
+    <QLabel name="text" arg=["This is a label"] />
+    <layout name="bottom_layout" direction="h" stretch="true">
+        <QPushButton name="ok_button" arg=["Close the window"] style="selected" signals={"clicked": self.close} />
+    </layout>
+</layout>
+```
+
+## 属性
+### layout
+这是布局对象，可以在子项添加布局对象，或者添加控件对象。
+参数：
+- name：布局对象的名称，用于在代码中引用。
+- direction：布局的方向，可以是“v”（垂直）或“h”（水平），可以自己扩展。
+- stretch：布局对象的拉伸因子，可以是“true”或“false”。
+
+### Widget
+这是组件对象，对象的tag名是控件的名称，例如“QLabel”、“QPushButton”等。
+参数：
+- name：控件对象的名称，用于在代码中引用。
+= arg：控件对象的参数，使用列表存储，可以是字符串、列表、字典等。
+- kwarg：控件对象的属性，带有关键字，使用字典存储，可以是字符串、列表、字典等。
+- style：控件对象的样式，可以是字符串、列表、字典等。
+- signals：控件对象的信号，使用字典存储，键是信号名称，值是信号处理函数。
+- init_steps：控件对象的初始化步骤，使用列表存储，子项使用字典。

uiml-0.1.0/README.md

@@ -0,0 +1,49 @@
+<div align="center">
+<img src="./imgs/readme/logo.png" width="400" alt="logo" />
+<h1>uiml</h1>
+一个使用特殊的xml格式，用于绘制PySide6的ui界面
+</div>
+
+--- 
+
+## 介绍
+uiml是一个用于绘制PySide6的ui界面的工具，它使用特殊的xml格式来定义界面的布局，样式和信号。uiml的语法非常简单，易于学习和使用。你可以使用uiml来创建复杂的界面，而不需要编写大量的代码。
+
+uiml的语法在xml的基础上，增加支持的python对象，所以它既有xml的轻便性，又有python对象的灵活性。
+
+## 安装
+要使用uiml，你需要先安装它。你可以使用pip来安装uiml：
+
+```bash
+pip install uiml
+```
+
+## 使用
+要使用uiml，你需要创建一个uiml文件，并在其中定义界面的布局，样式和信号。以下是一个简单的示例：
+
+```xml
+<layout name="central_layout" direction="v">
+    <QLabel name="text" arg=["This is a label"] />
+    <layout name="bottom_layout" direction="h" stretch="true">
+        <QPushButton name="ok_button" arg=["Close the window"] style="selected" signals={"clicked": self.close} />
+    </layout>
+</layout>
+```
+
+## 属性
+### layout
+这是布局对象，可以在子项添加布局对象，或者添加控件对象。
+参数：
+- name：布局对象的名称，用于在代码中引用。
+- direction：布局的方向，可以是“v”（垂直）或“h”（水平），可以自己扩展。
+- stretch：布局对象的拉伸因子，可以是“true”或“false”。
+
+### Widget
+这是组件对象，对象的tag名是控件的名称，例如“QLabel”、“QPushButton”等。
+参数：
+- name：控件对象的名称，用于在代码中引用。
+= arg：控件对象的参数，使用列表存储，可以是字符串、列表、字典等。
+- kwarg：控件对象的属性，带有关键字，使用字典存储，可以是字符串、列表、字典等。
+- style：控件对象的样式，可以是字符串、列表、字典等。
+- signals：控件对象的信号，使用字典存储，键是信号名称，值是信号处理函数。
+- init_steps：控件对象的初始化步骤，使用列表存储，子项使用字典。

uiml-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "uiml"
+version = "0.1.0"
+description = ""
+readme = { file = "README.md", content-type = "text/markdown" }
+authors = [
+    { name = "xystudio", email = "173288240@qq.com" }
+]
+license = { text = "MIT" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+keywords = ["uiml", "PySide6", "Qt", "ui", "xml", "design"]
+requires-python = ">=3"
+dependencies = [
+    "PySide6>=6.10.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/xystudio889/"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]

uiml-0.1.0/setup.cfg

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

uiml-0.1.0/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup, find_packages
+
+setup(
+    name = "uiml",
+    version = "0.1.0",
+    package_dir={"": "src"},
+    packages=find_packages(where="src"),
+    install_requires = ["PySide6>=6.10.0"],
+    python_requires = ">=3.10",
+    author = "xystudio",
+    author_email = "173288240@qq.com",
+    description = "",
+    long_description = open("README.md",encoding="utf-8").read(),
+    long_description_content_type="text/markdown",
+    license = "MIT",
+    url = "https://github.com/xystudio889/",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    keywords = ['uiml', 'PySide6', 'Qt', 'ui', 'xml', 'design'],
+)

uiml-0.1.0/src/uiml/__init__.py

@@ -0,0 +1,452 @@
+from typing import Any, Dict, Optional
+from uiml.uilib import *
+import inspect
+import re
+
+_CURRENT_MODULE_NAME = __name__
+
+def xml_parse(xml_str: str, namespace: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    '''
+    将扩展 XML 字符串转换为 Python 字典。
+
+    参数:
+        xml_str: XML 字符串，支持属性值不带引号、Python 字面量（列表、字典、集合）、
+                 变量/函数引用、表达式以及 true/false/null 字面量（任意嵌套）。
+        namespace: 解析函数/变量时使用的命名空间（默认为调用方的全局+局部变量合并）。
+
+    返回:
+        解析后的字典，包含 'name' 键（标签名）、'content' 键（子元素或文本）以及所有属性。
+    '''
+    if namespace is None:
+        # 获取当前帧
+        frame = inspect.currentframe().f_back
+        # 向上查找，跳过所有属于 uiml 模块的帧
+        while frame and frame.f_globals.get('__name__') == _CURRENT_MODULE_NAME:
+            frame = frame.f_back
+        if frame is None:
+            # 如果没有找到非 uiml 的帧，则回退到直接调用者的上一级（兼容性）
+            frame = inspect.currentframe().f_back
+        # 合并全局和局部变量（局部优先）
+        namespace = {}
+        namespace.update(frame.f_globals)
+        namespace.update(frame.f_locals)
+
+    idx = 0
+    n = len(xml_str)
+
+    def skip_whitespace():
+        nonlocal idx
+        while idx < n and xml_str[idx].isspace():
+            idx += 1
+
+    def peek_char() -> str:
+        return xml_str[idx] if idx < n else ''
+
+    def parse_comment():
+        nonlocal idx
+        if xml_str.startswith('<!--', idx):
+            idx += 4
+            end = xml_str.find('-->', idx)
+            if end == -1:
+                raise ValueError("未找到注释结束标记 '-->'")
+            idx = end + 3
+            return None
+        return False
+
+    def parse_text() -> str:
+        nonlocal idx
+        start = idx
+        while idx < n and xml_str[idx] != '<':
+            idx += 1
+        return xml_str[start:idx]
+
+    def parse_tag_name_with_lt() -> str:
+        nonlocal idx
+        if xml_str[idx] != '<':
+            raise ValueError(f"期望 '<'，实际 '{xml_str[idx]}'")
+        idx += 1
+        start = idx
+        while idx < n and (xml_str[idx].isalnum() or xml_str[idx] == '_'):
+            idx += 1
+        if start == idx:
+            raise ValueError('无效的标签名')
+        return xml_str[start:idx]
+
+    def parse_tag_name_only() -> str:
+        nonlocal idx
+        start = idx
+        while idx < n and (xml_str[idx].isalnum() or xml_str[idx] == '_'):
+            idx += 1
+        if start == idx:
+            raise ValueError('无效的标签名')
+        return xml_str[start:idx]
+
+    def preprocess_expr(expr: str) -> str:
+        # 将表达式中的独立 true/false/null 替换为 Python 字面量
+        expr = re.sub(r'\btrue\b', 'True', expr)
+        expr = re.sub(r'\bfalse\b', 'False', expr)
+        expr = re.sub(r'\bnull\b', 'None', expr)
+        return expr
+
+    def parse_attribute_value() -> Any:
+        nonlocal idx
+        if idx >= n:
+            raise ValueError('属性值意外结束')
+
+        ch = xml_str[idx]
+        if ch in ('"', "'"):
+            quote = ch
+            idx += 1
+            start = idx
+            while idx < n and xml_str[idx] != quote:
+                if xml_str[idx] == '\\' and idx + 1 < n:
+                    idx += 2
+                else:
+                    idx += 1
+            if idx >= n or xml_str[idx] != quote:
+                raise ValueError(f'未找到匹配的引号 {quote}')
+            value_str = xml_str[start:idx]
+            idx += 1
+            return value_str
+
+        start = idx
+        depth = 0
+        while idx < n:
+            c = xml_str[idx]
+            if c in '[{':
+                depth += 1
+            elif c in ']}':
+                depth -= 1
+            elif depth == 0 and (c.isspace() or c == '>' or (c == '/' and idx + 1 < n and xml_str[idx + 1] == '>')):
+                break
+            idx += 1
+        expr = xml_str[start:idx].strip()
+        if not expr:
+            raise ValueError('空的属性值')
+
+        expr_processed = preprocess_expr(expr)
+        try:
+            return eval(expr_processed, namespace)
+        except NameError as e:
+            raise NameError(f"未定义的标识符 '{expr}'，请检查命名空间或拼写") from e
+        except Exception as e:
+            raise ValueError(f"无法解析属性值 '{expr}': {e}")
+
+    def parse_attributes() -> Dict[str, Any]:
+        nonlocal idx
+        attrs = {}
+        while idx < n and xml_str[idx] != '>' and not (xml_str[idx] == '/' and idx + 1 < n and xml_str[idx + 1] == '>'):
+            skip_whitespace()
+            if xml_str[idx] == '>' or (xml_str[idx] == '/' and idx + 1 < n and xml_str[idx + 1] == '>'):
+                break
+
+            start = idx
+            while idx < n and (xml_str[idx].isalnum() or xml_str[idx] == '_'):
+                idx += 1
+            if start == idx:
+                raise ValueError('无效的属性名')
+            attr_name = xml_str[start:idx]
+
+            skip_whitespace()
+            if xml_str[idx] != '=':
+                raise ValueError(f"属性 '{attr_name}' 后缺少 '='")
+            idx += 1
+
+            skip_whitespace()
+            attr_value = parse_attribute_value()
+            attrs[attr_name] = attr_value
+
+        return attrs
+
+    def parse_element() -> Dict[str, Any]:
+        nonlocal idx
+
+        while True:
+            skip_whitespace()
+            if xml_str.startswith('<!--', idx):
+                if parse_comment() is None:
+                    continue
+            break
+
+        if peek_char() != '<':
+            text = parse_text()
+            if text.strip():
+                return {"content": text.strip()}
+            return {}
+
+        tag_name = parse_tag_name_with_lt()
+        skip_whitespace()
+        attrs = parse_attributes()
+
+        if xml_str[idx] == '/' and idx + 1 < n and xml_str[idx + 1] == '>':
+            idx += 2
+            return {"type": tag_name, **attrs}
+
+        if xml_str[idx] != '>':
+            raise ValueError(f"期望 '>'，实际 '{xml_str[idx]}'")
+        idx += 1
+
+        children = []
+        text_content = None
+
+        while idx < n:
+            skip_whitespace()
+            if idx >= n:
+                break
+
+            if xml_str.startswith('<!--', idx):
+                parse_comment()
+                continue
+
+            if xml_str.startswith('</', idx):
+                idx += 2
+                end_tag_name = parse_tag_name_only()
+                skip_whitespace()
+                if xml_str[idx] != '>':
+                    raise ValueError(f"期望 '>'，实际 '{xml_str[idx]}'")
+                idx += 1
+                if end_tag_name != tag_name:
+                    raise ValueError(f"结束标签不匹配: 期望 '{tag_name}'，实际 '{end_tag_name}'")
+                break
+
+            if xml_str[idx] == '<':
+                child = parse_element()
+                if child:
+                    children.append(child)
+                continue
+
+            text = parse_text()
+            if text:
+                if children:
+                    pass
+                else:
+                    text_content = text.strip()
+
+        result = {"type": tag_name, **attrs}
+        if text_content is not None:
+            result["content"] = text_content
+        elif children:
+            result["content"] = children
+        return result
+
+    skip_whitespace()
+    root = parse_element()
+    return root
+
+def xml_parse_file(file_path: str, namespace: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    '''
+    从文件中读取扩展 XML 字符串并解析为 Python 字典。
+
+    参数:
+        file_path: 文件路径，支持属性值不带引号、Python 字面量（列表、字典、集合）、
+                变量/函数引用、表达式等。
+        namespace: 解析函数/变量时使用的命名空间（默认为调用方的全局命名空间）。
+    '''
+    with open(file_path, 'r', encoding='utf-8') as file:
+        xml_str = file.read()  # 读取文件内容
+    return xml_parse(xml_str, namespace)  # 解析 XML 字符串
+
+def set_style(widget, class_name: str):
+    '''
+    设置按钮的class属性并刷新样式
+    '''
+    # 1. 设置class属性
+    widget.setProperty('class', class_name)
+
+    # 2. 强制样式刷新
+    widget.style().unpolish(widget)
+    widget.style().polish(widget)
+
+    # 3. 触发重绘
+    widget.update()
+
+def set_namespace(value_replace_func=None, layout_parser_func=None, widget_parser_func=None):
+    '''
+    设置解析函数/变量时使用的操作。
+    '''
+    global replacer, layout_parser, widget_parser
+    if value_replace_func is not None:replacer = value_replace_func
+    if layout_parser_func is not None:layout_parser = layout_parser_func
+    if widget_parser_func is not None:widget_parser = widget_parser_func
+    
+def default_replacer(value: str):
+    '''默认替换函数，返回原值，可以自定义添加函数，如替换变量、函数调用等。'''
+    return value
+
+def default_layout_parser(ui_data: Dict[str, Any]):
+    '''默认布局解析函数，进行递归解析返回'''
+    compiled_list = []
+    for item in ui_data.get('content', []):
+        compiled_list.append(compile_ui(item)) # 递归解析
+    return {'name': ui_data.get('name'), 'direction': ui_data.get('direction'), 'content': compiled_list, 'stretch': ui_data.get('stretch', False)}
+
+def default_widget_parser(widget_data: Dict[str, Any], namespace: Dict[str, Any]):
+    '''默认控件解析函数，进行解析返回'''
+    argv = [] # 参数
+    kwargv = {} # 关键字参数
+    style = widget_data.get('style', '') # 样式
+    
+    for arg in widget_data.get('arg', []):
+        if type(arg) == str:
+            argv.append(replacer(arg))
+        else:
+            argv.append(arg)
+            
+    for k, arg in widget_data.get('kwarg', {}).items():
+        if type(arg) == str:
+            kwargv[k] = replacer(arg)
+        else:
+            kwargv[k] = arg
+                
+    widget = eval(f'{widget_data.get('type')}(*{argv}, **{kwargv})') # 获取函数
+    set_style(widget, style) # 设置样式
+
+    for func in widget_data.get('init_steps', []):
+        name = func['name']
+        args = func.get('args', [])
+        kwargs = func.get('kwargs', {})
+        getattr(widget, name)(*args, **kwargs) # 执行初始化步骤
+        
+    for sign, func in widget_data.get('signals', {}).items():
+        getattr(widget, sign).connect(func) # 连接信号
+    
+    return {'name': widget_data.get('name'), 'content': widget}
+
+def compile_ui(ui_data, namespace=None):
+    if namespace is None: 
+        namespace = inspect.currentframe().f_back.f_globals
+    if ui_data.get('direction'): # 这是layout类型
+        return layout_parser(ui_data)
+    else: # 这是widget类型
+        return widget_parser(ui_data, namespace)
+    
+def compile_ui_file(file_path: str, namespace=None):
+    '''
+    从文件中读取扩展 XML 字符串并解析为 Python 字典，然后编译为布局或控件对象。
+
+    参数:
+        file_path: 文件路径，支持属性值不带引号、Python 字面量（列表、字典、集合）、变量/函数引用、表达式等。
+        namespace: 解析函数/变量时使用的命名空间（默认为调用方的全局命名空间）。
+    '''
+    with open(file_path, 'r', encoding='utf-8') as file:
+        xml_str = file.read()  # 读取文件内容
+    return compile_ui(xml_parse(xml_str, namespace), namespace)  # 解析 XML 字符串并编译
+    
+class UIMLLayout:
+    def __init__(self, list):
+        self.list = list
+        
+    def find_widget(self, path: str, data=None):
+        '''
+        在嵌套字典结构中按点分隔路径查找元素。
+
+        规则：
+        - 路径中的每一段对应字典中的 'name' 字段。
+        - 若当前节点是布局（含有 'direction' 键），且不是最后一段，则自动进入其子元素继续查找。
+        - 布局的子元素在 'content' 列表中。
+        - 最后一段如果是普通布局，返回其 'content' 列表；如果是 'u' 布局，返回 {'texts':..., 'inputs':..., 'combos':...}；如果是控件，返回其 'content'。
+        - 路径必须完整且精确，找不到时抛出 KeyError。
+
+        参数:
+            path: 点分隔的路径字符串，如 "layout.vlayout.checkbox2"
+            data: 根字典（例如 {'name': 'layout', 'direction': 'h', 'content': [...]}）
+
+        返回:
+            根据路径找到的控件对象、布局的 content 列表，或 'u' 布局的 texts/inputs/combos 字典。
+        '''
+        data = self.list if data is None else data
+        parts = path.split('.')
+        if not parts:
+            raise ValueError("Empty path")
+
+        # 根节点名称必须匹配第一段
+        if data.get('name') != parts[0]:
+            raise KeyError(f"Root name mismatch: expected '{parts[0]}', got '{data.get('name')}'")
+
+        current = data
+
+        for i, part in enumerate(parts):
+            # 检查当前节点名称是否匹配
+            if current.get('name') != part:
+                raise KeyError(f"Name mismatch: expected '{part}', got '{current.get('name')}'")
+
+            # 最后一段
+            if i == len(parts) - 1:
+                if 'direction' in current:
+                    # 普通布局：返回 content 列表
+                    content = current.get('content')
+                    if content is None:
+                        raise ValueError(f"Layout '{part}' has no content")
+                    if not isinstance(content, list):
+                        raise TypeError(f"Layout '{part}' content is not a list")
+                    return content
+                else:
+                    # 控件：返回 content 属性
+                    content = current.get('content')
+                    if content is None:
+                        raise ValueError(f"Widget '{part}' has no content")
+                    return content
+
+            # 不是最后一段，当前节点必须是布局
+            if 'direction' not in current:
+                raise KeyError(f"'{part}' is not a layout, cannot traverse further")
+
+            next_name = parts[i + 1]
+            found = None
+
+            # 普通布局从 content 中查找
+            for child in current.get('content', []):
+                if child.get('name') == next_name:
+                    found = child
+                    break
+
+            if found is None:
+                raise KeyError(f"Child '{next_name}' not found in layout '{part}'")
+            current = found
+
+        # 正常流程不会执行到这里
+        return None
+
+    def show(self):   
+        '''显示布局，返回布局对象和类型字符串'''
+        return self.draw_layout()[0]
+        
+    def draw_layout(self, list_content=None):
+        '''绘制布局，返回布局对象和类型字符串'''
+        list_content = self.list if list_content is None else list_content
+        if list_content.get('direction') is not None: # 这是layout类型
+            if list_content['direction'].lower() == 'h':
+                layout = QHBoxLayout()
+            elif list_content['direction'].lower() == 'v':
+                layout = QVBoxLayout()
+            else:
+                return self.extend_layout(list_content)
+            if list_content.get('stretch', False):
+                layout.addStretch(1)
+            for item in list_content['content']:
+                widget = self.draw_layout(item)
+                if widget[1] == 'widget':
+                    layout.addWidget(widget[0])
+                elif widget[1] == 'layout':
+                    layout.addLayout(widget[0])
+                else:
+                    raise ValueError('Content must be a widget or a layout')
+            return layout, 'layout'
+        else: # 这是widget类型
+            return list_content['content'], 'widget'
+    
+    def extend_layout(self, list_info):
+        '''扩展布局，可以在不复制draw_layout()函数的情况下，直接在原布局上添加加载时代码'''
+        WidgetError.direction_error() # 默认这里抛出错误，因为widget类型没有direction属性
+        
+    def extend_widget(self, widget_info):
+        '''扩展控件，可以在不复制draw_layout()函数的情况下，直接在原控件上添加加载时代码'''
+        return widget_info['content'], 'widget'
+            
+class WidgetError:
+    @staticmethod
+    def direction_error():
+        '''错误方案：在widget类型中找不到direction属性时，抛出错误。可以自定义添加函数，如替换变量、函数调用等。'''
+        raise ValueError('Direction error: cannot find direction attribute in widget type')
+    
+set_namespace(default_replacer, default_layout_parser, default_widget_parser) # 设置默认解析函数和布局解析函数

uiml-0.1.0/src/uiml/uilib.py

@@ -0,0 +1,4 @@
+from PySide6.QtCore import *
+from PySide6.QtWidgets import *
+from PySide6.QtGui import *
+import sys

uiml-0.1.0/src/uiml.egg-info/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: uiml
+Version: 0.1.0
+Home-page: https://github.com/xystudio889/
+Author: xystudio
+Author-email: xystudio <173288240@qq.com>
+License: MIT
+Project-URL: Homepage, https://github.com/xystudio889/
+Keywords: uiml,PySide6,Qt,ui,xml,design
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PySide6>=6.10.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+<div align="center">
+<img src="./imgs/readme/logo.png" width="400" alt="logo" />
+<h1>uiml</h1>
+一个使用特殊的xml格式，用于绘制PySide6的ui界面
+</div>
+
+--- 
+
+## 介绍
+uiml是一个用于绘制PySide6的ui界面的工具，它使用特殊的xml格式来定义界面的布局，样式和信号。uiml的语法非常简单，易于学习和使用。你可以使用uiml来创建复杂的界面，而不需要编写大量的代码。
+
+uiml的语法在xml的基础上，增加支持的python对象，所以它既有xml的轻便性，又有python对象的灵活性。
+
+## 安装
+要使用uiml，你需要先安装它。你可以使用pip来安装uiml：
+
+```bash
+pip install uiml
+```
+
+## 使用
+要使用uiml，你需要创建一个uiml文件，并在其中定义界面的布局，样式和信号。以下是一个简单的示例：
+
+```xml
+<layout name="central_layout" direction="v">
+    <QLabel name="text" arg=["This is a label"] />
+    <layout name="bottom_layout" direction="h" stretch="true">
+        <QPushButton name="ok_button" arg=["Close the window"] style="selected" signals={"clicked": self.close} />
+    </layout>
+</layout>
+```
+
+## 属性
+### layout
+这是布局对象，可以在子项添加布局对象，或者添加控件对象。
+参数：
+- name：布局对象的名称，用于在代码中引用。
+- direction：布局的方向，可以是“v”（垂直）或“h”（水平），可以自己扩展。
+- stretch：布局对象的拉伸因子，可以是“true”或“false”。
+
+### Widget
+这是组件对象，对象的tag名是控件的名称，例如“QLabel”、“QPushButton”等。
+参数：
+- name：控件对象的名称，用于在代码中引用。
+= arg：控件对象的参数，使用列表存储，可以是字符串、列表、字典等。
+- kwarg：控件对象的属性，带有关键字，使用字典存储，可以是字符串、列表、字典等。
+- style：控件对象的样式，可以是字符串、列表、字典等。
+- signals：控件对象的信号，使用字典存储，键是信号名称，值是信号处理函数。
+- init_steps：控件对象的初始化步骤，使用列表存储，子项使用字典。

uiml-0.1.0/src/uiml.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+src/uiml/__init__.py
+src/uiml/uilib.py
+src/uiml.egg-info/PKG-INFO
+src/uiml.egg-info/SOURCES.txt
+src/uiml.egg-info/dependency_links.txt
+src/uiml.egg-info/requires.txt
+src/uiml.egg-info/top_level.txt
+tests/test_data.py

uiml-0.1.0/src/uiml.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

uiml-0.1.0/src/uiml.egg-info/requires.txt

@@ -0,0 +1 @@
+PySide6>=6.10.0

uiml-0.1.0/src/uiml.egg-info/top_level.txt

@@ -0,0 +1 @@
+uiml

uiml-0.1.0/tests/test_data.py

@@ -0,0 +1,20 @@
+import uiml
+
+def function_a(a, b):
+    return a, b
+
+def test_data():
+    with open('tests/test-data.gui', 'r') as f:
+        data = f.read()
+    data = uiml.xml_parse(data)  # This will raise an exception if the XML is not valid or if there are any errors in the data.
+    
+    app = uiml.QApplication()
+    ui = uiml.compile_ui(data)
+    widget = uiml.QWidget()
+    layout = uiml.UIWindow(ui).show()
+    widget.setLayout(layout)
+    widget.show()
+    app.exec()  # This will start the Qt event loop and display the widget.
+        
+if __name__ == '__main__':
+    test_data()