chore: 添加虚拟环境到仓库

- 添加 backend_service/venv 虚拟环境
- 包含所有Python依赖包
- 注意：虚拟环境约393MB，包含12655个文件

backend_service/venv/lib/python3.13/site-packages/graphviz/parameters/__init__.py

@@ -0,0 +1,13 @@
+"""Hold and verify parameters for running Graphviz ``dot``."""
+
+from .engines import ENGINES, verify_engine
+from .formats import FORMATS, verify_format
+from .renderers import RENDERERS, verify_renderer
+from .formatters import FORMATTERS, verify_formatter
+
+from . mixins import Parameters
+
+__all__ = ['ENGINES', 'FORMATS', 'RENDERERS', 'FORMATTERS',
+           'verify_engine', 'verify_format',
+           'verify_renderer', 'verify_formatter',
+           'Parameters']

backend_service/venv/lib/python3.13/site-packages/graphviz/parameters/base.py

@@ -0,0 +1,16 @@
+"""Rendering parameter handling."""
+
+from .. import copying
+
+__all__ = ['ParameterBase']
+
+
+class ParameterBase(copying.CopyBase):
+    """Rendering parameter."""
+
+    def _getattr_from_dict(self, attrname: str, *, default=None):
+        """Return self.attrname if attrname is in the instance dictionary
+            (as oposed to on the type)."""
+        if attrname in self.__dict__:
+            return getattr(self, attrname)
+        return default

backend_service/venv/lib/python3.13/site-packages/graphviz/parameters/engines.py

@@ -0,0 +1,62 @@
+"""Rendering engine parameter handling."""
+
+import typing
+
+from . import base
+
+__all__ = ['ENGINES', 'verify_engine', 'Engine']
+
+ENGINES = {'dot',  # https://www.graphviz.org/pdf/dot.1.pdf
+           'neato',
+           'twopi',
+           'circo',
+           'fdp',
+           'sfdp',
+           'patchwork',
+           'osage'}
+
+DEFAULT_ENGINE = 'dot'
+
+REQUIRED = True
+
+
+def verify_engine(engine: str, *, required: bool = REQUIRED) -> None:
+    if engine is None:
+        if required:
+            raise ValueError('missing engine')
+    elif engine.lower() not in ENGINES:
+        raise ValueError(f'unknown engine: {engine!r}'
+                         f' (must be one of {sorted(ENGINES)})')
+
+
+class Engine(base.ParameterBase):
+    """Rendering engine parameter with ``'dot''`` default."""
+
+    _engine = DEFAULT_ENGINE
+
+    _verify_engine = staticmethod(verify_engine)
+
+    def __init__(self, *, engine: typing.Optional[str] = None, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+        if engine is not None:
+            self.engine = engine
+
+    def _copy_kwargs(self, **kwargs):
+        """Return the kwargs to create a copy of the instance."""
+        engine = self._getattr_from_dict('_engine')
+        if engine is not None:
+            kwargs['engine'] = engine
+        return super()._copy_kwargs(**kwargs)
+
+    @property
+    def engine(self) -> str:
+        """The layout engine used for rendering
+            (``'dot'``, ``'neato'``, ...)."""
+        return self._engine
+
+    @engine.setter
+    def engine(self, engine: str) -> None:
+        engine = engine.lower()
+        self._verify_engine(engine)
+        self._engine = engine

backend_service/venv/lib/python3.13/site-packages/graphviz/parameters/formats.py

@@ -0,0 +1,90 @@
+"""Rendering format parameter handling."""
+
+import typing
+
+from . import base
+
+__all__ = ['FORMATS', 'verify_format', 'Format']
+
+FORMATS = {'bmp',  # https://graphviz.org/docs/outputs/
+           'canon', 'dot', 'gv', 'xdot', 'xdot1.2', 'xdot1.4',
+           'cgimage',
+           'cmap',
+           'eps',
+           'exr',
+           'fig',
+           'gd', 'gd2',
+           'gif',
+           'gtk',
+           'ico',
+           'imap', 'cmapx',
+           'imap_np', 'cmapx_np',
+           'ismap',
+           'jp2',
+           'jpg', 'jpeg', 'jpe',
+           'json', 'json0', 'dot_json', 'xdot_json',  # Graphviz 2.40
+           'pct', 'pict',
+           'pdf',
+           'pic',
+           'plain', 'plain-ext',
+           'png',
+           'pov',
+           'ps',
+           'ps2',
+           'psd',
+           'sgi',
+           'svg', 'svg_inline', 'svgz',  # svg_linline: Graphviz 10.0.1
+           'tga',
+           'tif', 'tiff',
+           'tk',
+           'vml', 'vmlz',
+           'vrml',
+           'wbmp',
+           'webp',
+           'xlib', 'x11'}
+
+DEFAULT_FORMAT = 'pdf'
+
+REQUIRED = True
+
+
+def verify_format(format: str, *, required: bool = REQUIRED) -> None:
+    if format is None:
+        if required:
+            raise ValueError('missing format')
+    elif format.lower() not in FORMATS:
+        raise ValueError(f'unknown format: {format!r}'
+                         f' (must be one of {sorted(FORMATS)})')
+
+
+class Format(base.ParameterBase):
+    """Rendering format parameter with ``'pdf'`` default."""
+
+    _format = DEFAULT_FORMAT
+
+    _verify_format = staticmethod(verify_format)
+
+    def __init__(self, *, format: typing.Optional[str] = None, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+        if format is not None:
+            self.format = format
+
+    def _copy_kwargs(self, **kwargs):
+        """Return the kwargs to create a copy of the instance."""
+        format = self._getattr_from_dict('_format')
+        if format is not None:
+            kwargs['format'] = format
+        return super()._copy_kwargs(**kwargs)
+
+    @property
+    def format(self) -> str:
+        """The output format used for rendering
+            (``'pdf'``, ``'png'``, ...)."""
+        return self._format
+
+    @format.setter
+    def format(self, format: str) -> None:
+        format = format.lower()
+        self._verify_format(format)
+        self._format = format

backend_service/venv/lib/python3.13/site-packages/graphviz/parameters/formatters.py

@@ -0,0 +1,61 @@
+"""Rendering formatter parameter handling."""
+
+import typing
+
+from . import base
+
+__all__ = ['FORMATTERS', 'verify_formatter', 'Formatter']
+
+FORMATTERS = {'cairo',
+              'core',
+              'gd',
+              'gdiplus',
+              'gdwbmp',
+              'xlib'}
+
+REQUIRED = False
+
+
+def verify_formatter(formatter: typing.Optional[str], *,
+                     required: bool = REQUIRED) -> None:
+    if formatter is None:
+        if required:
+            raise ValueError('missing formatter')
+    elif formatter.lower() not in FORMATTERS:
+        raise ValueError(f'unknown formatter: {formatter!r}'
+                         f' (must be None or one of {sorted(FORMATTERS)})')
+
+
+class Formatter(base.ParameterBase):
+    """Rendering engine parameter (no default)."""
+
+    _formatter = None
+
+    _verify_formatter = staticmethod(verify_formatter)
+
+    def __init__(self, *, formatter: typing.Optional[str] = None, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+        self.formatter = formatter
+
+    def _copy_kwargs(self, **kwargs):
+        """Return the kwargs to create a copy of the instance."""
+        formatter = self._getattr_from_dict('_formatter')
+        if formatter is not None:
+            kwargs['formatter'] = formatter
+        return super()._copy_kwargs(**kwargs)
+
+    @property
+    def formatter(self) -> typing.Optional[str]:
+        """The output formatter used for rendering
+            (``'cairo'``, ``'gd'``, ...)."""
+        return self._formatter
+
+    @formatter.setter
+    def formatter(self, formatter: typing.Optional[str]) -> None:
+        if formatter is None:
+            self.__dict__.pop('_formatter', None)
+        else:
+            formatter = formatter.lower()
+            self._verify_formatter(formatter)
+            self._formatter = formatter

backend_service/venv/lib/python3.13/site-packages/graphviz/parameters/mixins.py

@@ -0,0 +1,46 @@
+"""Mixin classes used to inherit parameter functionality."""
+
+import typing
+
+from . import engines
+from . import formats
+from . import renderers
+from . import formatters
+
+__all__ = ['Parameters']
+
+
+class Parameters(engines.Engine, formats.Format,
+                 renderers.Renderer, formatters.Formatter):
+    """Parameters for calling ``graphviz.render()`` and ``graphviz.pipe()``."""
+
+    def _get_parameters(self, *,
+                        engine: typing.Optional[str] = None,
+                        format: typing.Optional[str] = None,
+                        renderer: typing.Optional[str] = None,
+                        formatter: typing.Optional[str] = None,
+                        verify: bool = False,
+                        **kwargs):
+        if engine is None:
+            engine = self.engine
+        elif verify:
+            self._verify_engine(engine)
+
+        if format is None:
+            format = self.format
+        elif verify:
+            self._verify_format(format)
+
+        if renderer is None:
+            renderer = self.renderer
+        elif verify:
+            self._verify_renderer(renderer)
+
+        if formatter is None:
+            formatter = self.formatter
+        elif verify:
+            self._verify_formatter(formatter)
+
+        kwargs.update(engine=engine, format=format,
+                      renderer=renderer, formatter=formatter)
+        return kwargs

backend_service/venv/lib/python3.13/site-packages/graphviz/parameters/renderers.py

@@ -0,0 +1,70 @@
+"""Rendering renderer parameter handling."""
+
+import typing
+
+from . import base
+
+__all__ = ['RENDERERS', 'verify_renderer', 'Renderer']
+
+RENDERERS = {'cairo',  # $ dot -T:
+             'dot',
+             'fig',
+             'gd',
+             'gdiplus',
+             'map',
+             'pic',
+             'pov',
+             'ps',
+             'svg',
+             'tk',
+             'vml',
+             'vrml',
+             'xdot'}
+
+
+REQUIRED = False
+
+
+def verify_renderer(renderer: typing.Optional[str], *,
+                    required: bool = REQUIRED) -> None:
+    if renderer is None:
+        if required:
+            raise ValueError('missing renderer')
+    elif renderer.lower() not in RENDERERS:
+        raise ValueError(f'unknown renderer: {renderer!r}'
+                         f' (must be None or one of {sorted(RENDERERS)})')
+
+
+class Renderer(base.ParameterBase):
+    """Rendering renderer parameter (no default)."""
+
+    _renderer = None
+
+    _verify_renderer = staticmethod(verify_renderer)
+
+    def __init__(self, *, renderer: typing.Optional[str] = None, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+        self.renderer = renderer
+
+    def _copy_kwargs(self, **kwargs):
+        """Return the kwargs to create a copy of the instance."""
+        renderer = self._getattr_from_dict('_renderer')
+        if renderer is not None:
+            kwargs['renderer'] = renderer
+        return super()._copy_kwargs(**kwargs)
+
+    @property
+    def renderer(self) -> typing.Optional[str]:
+        """The output renderer used for rendering
+            (``'cairo'``, ``'gd'``, ...)."""
+        return self._renderer
+
+    @renderer.setter
+    def renderer(self, renderer: typing.Optional[str]) -> None:
+        if renderer is None:
+            self.__dict__.pop('_renderer', None)
+        else:
+            renderer = renderer.lower()
+            self._verify_renderer(renderer)
+            self._renderer = renderer