data-flow-diagram 1.12.1.post3__tar.gz → 1.13.1__tar.gz

{data_flow_diagram-1.12.1.post3 → data_flow_diagram-1.13.1}/CHANGES.md

@@ -1,3 +1,7 @@
+## Version 1.13.1:
+
+- Supports style rotated (and unrotated).
+
 ## Version 1.12.1.post3:
 
 - CHANGES.md is read by setup.py to deduce the version.

{data_flow_diagram-1.12.1.post3/src/data_flow_diagram.egg-info → data_flow_diagram-1.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: data-flow-diagram
-Version: 1.12.1.post3
+Version: 1.13.1
 Summary: Commandline tool to generate data flow diagrams from text
 Home-page: https://github.com/pbauermeister/dfd
 Author: Pascal Bauermeister

{data_flow_diagram-1.12.1.post3 → data_flow_diagram-1.13.1}/src/data_flow_diagram/__init__.py

@@ -27,96 +27,96 @@ from .error import print_error
 try:
     VERSION = pkg_resources.require("data-flow-diagram")[0].version
 except pkg_resources.DistributionNotFound:
-    VERSION = 'undefined'
+    VERSION = "undefined"
 
 
 def parse_args() -> argparse.Namespace:
-    description, epilog = [each.strip() for each in __doc__.split('-----')[:2]]
+    description, epilog = [each.strip() for each in __doc__.split("-----")[:2]]
 
     parser = argparse.ArgumentParser(description=description, epilog=epilog)
 
     parser.add_argument(
-        'INPUT_FILE',
-        action='store',
+        "INPUT_FILE",
+        action="store",
         default=None,
-        nargs='?',
-        help='UML sequence input file; ' 'if omitted, stdin is used',
+        nargs="?",
+        help="UML sequence input file; " "if omitted, stdin is used",
     )
 
     parser.add_argument(
-        '--output-file',
-        '-o',
+        "--output-file",
+        "-o",
         required=False,
-        help='output file name; pass \'-\' to use stdout; '
-        'if omitted, use INPUT_FILE base name with \'.svg\' '
-        'extension, or stdout',
+        help="output file name; pass '-' to use stdout; "
+        "if omitted, use INPUT_FILE base name with '.svg' "
+        "extension, or stdout",
     )
 
     parser.add_argument(
-        '--markdown',
-        '-m',
-        action='store_true',
-        help='consider snippets between opening marker: '
-        '```data-flow-diagram OUTFILE, and closing marker: ``` '
-        'allowing to generate all diagrams contained in an '
-        'INPUT_FILE that is a markdown file',
+        "--markdown",
+        "-m",
+        action="store_true",
+        help="consider snippets between opening marker: "
+        "```data-flow-diagram OUTFILE, and closing marker: ``` "
+        "allowing to generate all diagrams contained in an "
+        "INPUT_FILE that is a markdown file",
     )
 
     parser.add_argument(
-        '--format',
-        '-f',
+        "--format",
+        "-f",
         required=False,
-        default='svg',
-        help='output format: gif, jpg, tiff, bmp, pnm, eps, '
-        'pdf, svg (any supported by Graphviz); default is svg',
+        default="svg",
+        help="output format: gif, jpg, tiff, bmp, pnm, eps, "
+        "pdf, svg (any supported by Graphviz); default is svg",
     )
 
     parser.add_argument(
-        '--percent-zoom',
-        '-p',
+        "--percent-zoom",
+        "-p",
         required=False,
         default=100,
         type=int,
-        help='magnification percentage; default is 100',
+        help="magnification percentage; default is 100",
     )
 
     parser.add_argument(
-        '--background-color',
-        '-b',
+        "--background-color",
+        "-b",
         required=False,
-        default='white',
-        help='background color name (including \'none\' for'
-        ' transparent) in web color notation; see'
-        ' https://developer.mozilla.org/en-US/docs/Web/CSS/color_value'
-        ' for a list of valid names; default is white',
+        default="white",
+        help="background color name (including 'none' for"
+        " transparent) in web color notation; see"
+        " https://developer.mozilla.org/en-US/docs/Web/CSS/color_value"
+        " for a list of valid names; default is white",
     )
 
     parser.add_argument(
-        '--no-graph-title',
-        action='store_true',
+        "--no-graph-title",
+        action="store_true",
         default=False,
-        help='suppress graph title',
+        help="suppress graph title",
     )
 
     parser.add_argument(
-        '--no-check-dependencies',
-        action='store_true',
+        "--no-check-dependencies",
+        action="store_true",
         default=False,
-        help='suppress dependencies checking',
+        help="suppress dependencies checking",
     )
 
     parser.add_argument(
-        '--debug',
-        action='store_true',
+        "--debug",
+        action="store_true",
         default=False,
-        help='emit debug messages',
+        help="emit debug messages",
     )
 
     parser.add_argument(
-        '--version',
-        '-V',
-        action='store_true',
-        help='print the version and exit',
+        "--version",
+        "-V",
+        action="store_true",
+        help="print the version and exit",
     )
 
     return parser.parse_args()
@@ -137,17 +137,17 @@ def handle_markdown_source(
             options,
             snippet_by_name=params.snippet_by_name,
         )
-        print(f'{sys.argv[0]}: generated {params.file_name}', file=sys.stderr)
+        print(f"{sys.argv[0]}: generated {params.file_name}", file=sys.stderr)
 
 
 def handle_dfd_source(
     options: model.Options, provenance: str, input_fp: TextIO, output_path: str
 ) -> None:
     root = model.SourceLine("", provenance, None, None)
-    if output_path == '-':
+    if output_path == "-":
         # output to stdout
         with tempfile.TemporaryDirectory() as d:
-            path = os.path.join(d, 'file.svg')
+            path = os.path.join(d, "file.svg")
             dfd.build(root, input_fp.read(), path, options)
             with open(path) as f:
                 print(f.read())
@@ -160,10 +160,10 @@ def run(args: argparse.Namespace) -> None:
     # adjust input
     if args.INPUT_FILE is None:
         input_fp = sys.stdin
-        provenance = '<stdin>'
+        provenance = "<stdin>"
     else:
         input_fp = open(args.INPUT_FILE)
-        provenance = f'<file:{args.INPUT_FILE}>'
+        provenance = f"<file:{args.INPUT_FILE}>"
 
     options = model.Options(
         args.format,
@@ -183,9 +183,9 @@ def run(args: argparse.Namespace) -> None:
     if args.output_file is None:
         if args.INPUT_FILE is not None:
             basename = os.path.splitext(args.INPUT_FILE)[0]
-            output_path = basename + '.' + args.format
+            output_path = basename + "." + args.format
         else:
-            output_path = '-'
+            output_path = "-"
     else:
         output_path = args.output_file
 
@@ -200,12 +200,12 @@ def main() -> None:
 
     args = parse_args()
     if args.version:
-        print('data-flow-diagram', VERSION)
+        print("data-flow-diagram", VERSION)
         sys.exit(0)
 
     try:
         run(args)
     except model.DfdException as e:
-        text = f'ERROR: {e}'
+        text = f"ERROR: {e}"
         print_error(text)
         sys.exit(1)

{data_flow_diagram-1.12.1.post3 → data_flow_diagram-1.13.1}/src/data_flow_diagram/dependency_checker.py

@@ -15,33 +15,33 @@ def check(
         prefix = model.mk_err_prefix_from(dep.source)
 
         # load source text
-        if dep.to_graph.startswith('#'):
+        if dep.to_graph.startswith("#"):
             # from snippet
             name = dep.to_graph[1:]
             if name not in snippet_by_name:
                 errors.append(f'{prefix}Referring to unknown snippet "{name}"')
                 continue
             text = snippet_by_name[name].text
-            what = 'snippet'
+            what = "snippet"
         else:
             # from file
             name = dep.to_graph
             try:
-                with open(name, encoding='utf-8') as f:
+                with open(name, encoding="utf-8") as f:
                     text = f.read()
             except FileNotFoundError as e:
                 if name in snippet_by_name:
                     errors.append(f'{prefix}{e}. Did you mean "#{name}" ?')
                 else:
-                    errors.append(f'{prefix}{e}')
+                    errors.append(f"{prefix}{e}")
                 continue
-            what = 'file'
+            what = "file"
 
         # if only graph is targetted, we're done
         if dep.to_item is None:
             if dep.to_type != model.NONE:
                 errors.append(
-                    f'{prefix}A whole graph may only be referred to '
+                    f"{prefix}A whole graph may only be referred to "
                     f'by an item of type "{model.NONE}", and not '
                     f'"{dep.to_type}"'
                 )
@@ -69,8 +69,8 @@ def check(
         )
 
     if errors:
-        errors.insert(0, 'Dependency error(s) found:')
-        raise model.DfdException('\n\n'.join(errors))
+        errors.insert(0, "Dependency error(s) found:")
+        raise model.DfdException("\n\n".join(errors))
 
 
 def find_item(name: str, statements: model.Statements) -> model.Item | None:

{data_flow_diagram-1.12.1.post3 → data_flow_diagram-1.13.1}/src/data_flow_diagram/dfd.py

@@ -41,13 +41,13 @@ def build(
 
 def wrap(text: str, cols: int) -> str:
     res: list[str] = []
-    for each in text.strip().split('\\n'):
-        res += textwrap.wrap(each, width=cols, break_long_words=False) or ['']
-    return '\\n'.join(res)
+    for each in text.strip().split("\\n"):
+        res += textwrap.wrap(each, width=cols, break_long_words=False) or [""]
+    return "\\n".join(res)
 
 
 class Generator:
-    RX_NUMBERED_NAME = re.compile(r'(\d+[.])(.*)')
+    RX_NUMBERED_NAME = re.compile(r"(\d+[.])(.*)")
 
     def __init__(
         self, graph_options: model.GraphOptions, attribs: model.Attribs
@@ -60,32 +60,32 @@ class Generator:
         self.attribs_rx = self._compile_attribs_names(attribs)
 
     def append(self, line: str, statement: model.Statement) -> None:
-        self.lines.append('')
+        self.lines.append("")
         text = model.pack(statement.source.text)
-        self.lines.append(f'/* {statement.source.line_nr}: {text} */')
+        self.lines.append(f"/* {statement.source.line_nr}: {text} */")
         self.lines.append(line)
 
     def generate_item(self, item: model.Item) -> None:
         copy = model.Item(**item.__dict__)
         hits = self.RX_NUMBERED_NAME.findall(copy.text)
         if hits:
-            copy.text = '\\n'.join(hits[0])
+            copy.text = "\\n".join(hits[0])
 
         copy.text = wrap(copy.text, self.graph_options.item_text_width)
-        attrs = copy.attrs or ''
+        attrs = copy.attrs or ""
         attrs = self._expand_attribs(attrs)
 
         match copy.type:
             case model.PROCESS:
                 if self.graph_options.is_context:
-                    shape = 'circle'
-                    fc = 'white'
+                    shape = "circle"
+                    fc = "white"
                 else:
-                    shape = 'ellipse'
+                    shape = "ellipse"
                     fc = '"#eeeeee"'
                 line = (
                     f'"{copy.name}" [shape={shape} label="{copy.text}" '
-                    f'fillcolor={fc} style=filled {attrs}]'
+                    f"fillcolor={fc} style=filled {attrs}]"
                 )
             case model.CONTROL:
                 fc = '"#eeeeee"'
@@ -96,7 +96,7 @@ class Generator:
             case model.ENTITY:
                 line = (
                     f'"{copy.name}" [shape=rectangle label="{copy.text}" '
-                    f'{attrs}]'
+                    f"{attrs}]"
                 )
             case model.STORE:
                 d = self._attrib_to_dict(copy, attrs)
@@ -112,22 +112,22 @@ class Generator:
             case _:
                 prefix = model.mk_err_prefix_from(copy.source)
                 raise model.DfdException(
-                    f'{prefix}Unsupported item type ' f'"{copy.type}"'
+                    f"{prefix}Unsupported item type " f'"{copy.type}"'
                 )
         self.append(line, item)
 
     def _attrib_to_dict(self, item: model.Item, attrs: str) -> dict[str, str]:
         d = self._item_to_html_dict(item)
-        d.update({'fontcolor': 'black', 'color': 'black'})
+        d.update({"fontcolor": "black", "color": "black"})
         attrs_d = {
-            k: v for k, v in [each.split('=', 1) for each in attrs.split()]
+            k: v for k, v in [each.split("=", 1) for each in attrs.split()]
         }
         d.update(attrs_d)
         return d
 
     def _item_to_html_dict(self, item: model.Item) -> dict[str, Any]:
         d = item.__dict__
-        d['text'] = d['text'].replace('\\n', '<br/>')
+        d["text"] = d["text"].replace("\\n", "<br/>")
         return d
 
     def _compile_attribs_names(
@@ -135,8 +135,8 @@ class Generator:
     ) -> re.Pattern[str] | None:
         if not attribs:
             return None
-        names = ['\\b' + re.escape(k) + '\\b' for k in attribs.keys()]
-        pattern = '|'.join(names)
+        names = ["\\b" + re.escape(k) + "\\b" for k in attribs.keys()]
+        pattern = "|".join(names)
         return re.compile(pattern)
 
     def _expand_attribs(self, attrs: str) -> str:
@@ -144,10 +144,10 @@ class Generator:
             alias = m[0]
             if alias not in self.attribs:
                 raise model.DfdException(
-                    f'Alias '
+                    f"Alias "
                     f'"{alias}" '
-                    f'not found in '
-                    f'{pprint.pformat(self.attribs)}'
+                    f"not found in "
+                    f"{pprint.pformat(self.attribs)}"
                 )
 
             return self.attribs[alias].text
@@ -158,7 +158,7 @@ class Generator:
 
     def generate_star(self, text: str) -> str:
         text = wrap(text, self.graph_options.item_text_width)
-        star_name = f'__star_{self.star_nr}__'
+        star_name = f"__star_{self.star_nr}__"
         line = f'"{star_name}" [shape=none label="{text}" {TMPL.DOT_FONT_EDGE}]'
         self.lines.append(line)
         self.star_nr += 1
@@ -170,57 +170,57 @@ class Generator:
         src_item: model.Item | None,
         dst_item: model.Item | None,
     ) -> None:
-        text = conn.text or ''
+        text = conn.text or ""
         text = wrap(text, self.graph_options.connection_text_width)
 
         src_port = dst_port = ""
 
         if not src_item:
             src_name = self.generate_star(text)
-            text = ''
+            text = ""
         else:
             src_name = src_item.name
             if src_item.type == model.CHANNEL:
-                src_port = ':x:c'
+                src_port = ":x:c"
 
         if not dst_item:
             dst_name = self.generate_star(text)
-            text = ''
+            text = ""
         else:
             dst_name = dst_item.name
             if dst_item.type == model.CHANNEL:
-                dst_port = ':x:c'
+                dst_port = ":x:c"
 
         attrs = f'label="{text}"'
 
         if conn.attrs:
-            attrs += ' ' + self._expand_attribs(conn.attrs)
+            attrs += " " + self._expand_attribs(conn.attrs)
 
         match conn.type:
             case model.FLOW:
                 if conn.reversed:
-                    attrs += ' dir=back'
+                    attrs += " dir=back"
             case model.BFLOW:
-                attrs += ' dir=both'
+                attrs += " dir=both"
             case model.CFLOW:
                 if conn.reversed:
-                    attrs += ' dir=back'
-                    attrs += ' arrowtail=normalnormal'
+                    attrs += " dir=back"
+                    attrs += " arrowtail=normalnormal"
                 else:
-                    attrs += ' arrowhead=normalnormal'
+                    attrs += " arrowhead=normalnormal"
             case model.UFLOW:
-                attrs += ' dir=none'
+                attrs += " dir=none"
             case model.SIGNAL:
                 if conn.reversed:
-                    attrs += ' dir=back'
-                attrs += ' style=dashed'
+                    attrs += " dir=back"
+                attrs += " style=dashed"
             case _:
                 prefix = model.mk_err_prefix_from(conn.source)
                 raise model.DfdException(
-                    f'{prefix}Unsupported connection type ' f'"{conn.type}"'
+                    f"{prefix}Unsupported connection type " f'"{conn.type}"'
                 )
         if conn.relaxed:
-            attrs += ' constraint=false'
+            attrs += " constraint=false"
 
         line = f'"{src_name}"{src_port} -> "{dst_name}"{dst_port} [{attrs}]'
         self.append(line, conn)
@@ -229,17 +229,17 @@ class Generator:
         pass
 
     def generate_frame(self, frame: model.Frame) -> None:
-        self.append(f'subgraph cluster_{self.frame_nr} {{', frame)
+        self.append(f"subgraph cluster_{self.frame_nr} {{", frame)
         self.frame_nr += 1
 
         self.lines.append(f'  label="{frame.text}"')
         if frame.attrs:
             attrs = self._expand_attribs(frame.attrs)
-            self.lines.append(f'  {attrs}')
+            self.lines.append(f"  {attrs}")
 
         for item in frame.items:
             self.lines.append(f'  "{item}"')
-        self.lines.append('}')
+        self.lines.append("}")
 
     def generate_dot_text(self, title: str) -> str:
         graph_params = []
@@ -250,16 +250,19 @@ class Generator:
             graph_params.append(TMPL.DOT_GRAPH_TITLE.format(title=title))
 
         if self.graph_options.is_vertical:
-            graph_params.append('rankdir=TB')
+            graph_params.append("rankdir=TB")
         else:
-            graph_params.append('rankdir=LR')
+            graph_params.append("rankdir=LR")
 
-        block = '\n'.join(self.lines).replace('\n', '\n  ')
+        if self.graph_options.is_rotated:
+            graph_params.append(f"rotate=90")
+
+        block = "\n".join(self.lines).replace("\n", "\n  ")
         text = TMPL.DOT.format(
             title=title,
             block=block,
-            graph_params='\n  '.join(graph_params),
-        ).replace('\n  \n', '\n\n')
+            graph_params="\n  ".join(graph_params),
+        ).replace("\n  \n", "\n\n")
         # print(text)
         return text
 
@@ -273,7 +276,7 @@ def generate_dot(
     """Iterate over statements and generate a dot source file"""
 
     def get_item(name: str) -> Optional[model.Item]:
-        return None if name == '*' else items_by_name[name]
+        return None if name == "*" else items_by_name[name]
 
     for statement in statements:
         match statement:
@@ -328,18 +331,22 @@ def handle_options(
         match statement:
             case model.Style() as style:
                 match style.style:
-                    case 'vertical':
+                    case "vertical":
                         options.is_vertical = True
-                    case 'context':
+                    case "context":
                         options.is_context = True
-                    case 'horizontal':
+                    case "horizontal":
                         options.is_vertical = False
-                    case 'item-text-width':
+                    case "rotated":
+                        options.is_rotated = True
+                    case "unrotated":
+                        options.is_rotated = False
+                    case "item-text-width":
                         try:
                             options.item_text_width = int(style.value)
                         except ValueError as e:
                             raise model.DfdException(f'{prefix}{e}"')
-                    case 'connection-text-width':
+                    case "connection-text-width":
                         try:
                             options.connection_text_width = int(style.value)
                         except ValueError as e:
@@ -347,7 +354,7 @@ def handle_options(
 
                     case _:
                         raise model.DfdException(
-                            f'{prefix}Unsupported style ' f'"{style.style}"'
+                            f"{prefix}Unsupported style " f'"{style.style}"'
                         )
 
                 continue

{data_flow_diagram-1.12.1.post3 → data_flow_diagram-1.13.1}/src/data_flow_diagram/dfd_dot_templates.py

@@ -54,7 +54,7 @@ digraph D {{
 )
 
 
-GRAPH_PARAMS_CONTEXT_DIAGRAM = 'edge [len=2.25]'
+GRAPH_PARAMS_CONTEXT_DIAGRAM = "edge [len=2.25]"
 
 
-ITEM_EXTERNAL_ATTRS = 'fillcolor=white color=grey fontcolor=grey'
+ITEM_EXTERNAL_ATTRS = "fillcolor=white color=grey fontcolor=grey"

{data_flow_diagram-1.12.1.post3 → data_flow_diagram-1.13.1}/src/data_flow_diagram/dot.py

@@ -11,23 +11,23 @@ def generate_image(
     graph_options: model.GraphOptions, text: str, output_path: str, format: str
 ) -> None:
     if graph_options.is_context:
-        engine = 'neato'  # circo is not as good
+        engine = "neato"  # circo is not as good
     else:
-        engine = 'dot'
+        engine = "dot"
 
-    cmd = [engine, f'-T{format}', f'-o{output_path}']
+    cmd = [engine, f"-T{format}", f"-o{output_path}"]
     try:
-        subprocess.run(cmd, input=text, encoding='utf-8', check=True)
+        subprocess.run(cmd, input=text, encoding="utf-8", check=True)
     except subprocess.CalledProcessError as e:
         for n, line in enumerate(text.splitlines()):
-            print(f'{n+1:2}: {line}', file=sys.stderr)
-        print_error(f'ERROR: {e}')
+            print(f"{n+1:2}: {line}", file=sys.stderr)
+        print_error(f"ERROR: {e}")
         sys.exit(1)
     # print('Generated:', output_path, file=sys.stderr)
 
 
 def check_installed() -> None:
-    cmd = ['dot', '-V']
+    cmd = ["dot", "-V"]
     try:
         subprocess.run(cmd, stderr=subprocess.DEVNULL)
     except FileNotFoundError as e:

{data_flow_diagram-1.12.1.post3 → data_flow_diagram-1.13.1}/src/data_flow_diagram/error.py

@@ -3,5 +3,5 @@ import sys
 
 def print_error(text: str) -> None:
     if sys.stderr.isatty():
-        text = f'\033[31m{text}\033[0m'
+        text = f"\033[31m{text}\033[0m"
     print(text, file=sys.stderr)

{data_flow_diagram-1.12.1.post3 → data_flow_diagram-1.13.1}/src/data_flow_diagram/markdown.py

@@ -21,18 +21,18 @@ SnippetContexts = list[SnippetContext]
 
 def extract_snippets(text: str) -> model.Snippets:
     rx = re.compile(
-        r'^```(?P<head>\s*)'
-        r'data-flow-diagram\s+'
-        r'(?P<output>.*?)\s*'
-        r'^(?P<src>.*?)^\s*```',
+        r"^```(?P<head>\s*)"
+        r"data-flow-diagram\s+"
+        r"(?P<output>.*?)\s*"
+        r"^(?P<src>.*?)^\s*```",
         re.DOTALL | re.M,
     )
 
     return [
         model.Snippet(
-            text=match['head'] + match['src'],
-            name=os.path.splitext(match['output'])[0],
-            output=match['output'],
+            text=match["head"] + match["src"],
+            name=os.path.splitext(match["output"])[0],
+            output=match["output"],
             line_nr=len(text[: match.start()].splitlines()),
         )
         for match in rx.finditer(text)
@@ -49,12 +49,12 @@ def make_snippets_params(
 
     for snippet in snippets:
         # snippet w/o output, maybe just as includee
-        if snippet.output.startswith('#'):
+        if snippet.output.startswith("#"):
             continue
 
         # snippet with output
         input_fp = io.StringIO(snippet.text)
-        snippet_provenance = f'{provenance}<snippet:{snippet.output}>'
+        snippet_provenance = f"{provenance}<snippet:{snippet.output}>"
         root = model.SourceLine(
             "", snippet_provenance, None, snippet.line_nr, is_container=True
         )
@@ -72,5 +72,5 @@ def check_snippets_unicity(provenance: str, snippets: model.Snippets) -> None:
         root = model.SourceLine("", provenance, None, None)
         error_prefix = model.mk_err_prefix_from(root)
         raise model.DfdException(
-            f'{error_prefix}Snippets defined multiple ' f'times: {multiples}'
+            f"{error_prefix}Snippets defined multiple " f"times: {multiples}"
         )

{data_flow_diagram-1.12.1.post3 → data_flow_diagram-1.13.1}/src/data_flow_diagram/model.py

@@ -12,8 +12,8 @@ from . import config
 
 def repr(o: Any) -> str:
     name: str = o.__class__.__name__
-    val: str = json.dumps(dataclasses.asdict(o), indent='  ')
-    return f'{name} {val}'
+    val: str = json.dumps(dataclasses.asdict(o), indent="  ")
+    return f"{name} {val}"
 
 
 @dataclass
@@ -21,8 +21,8 @@ class Base:
     def __repr__(self) -> str:
         return (
             self.__class__.__name__
-            + ' '
-            + json.dumps(dataclasses.asdict(self), indent='  ')
+            + " "
+            + json.dumps(dataclasses.asdict(self), indent="  ")
         )
 
 
@@ -89,61 +89,62 @@ class Attrib(Statement):
 Attribs = dict[str, Attrib]
 
 
-STYLE = 'style'
+STYLE = "style"
 
-PROCESS = 'process'
-CONTROL = 'control'
-ENTITY = 'entity'
-STORE = 'store'
-CHANNEL = 'channel'
-NONE = 'none'
+PROCESS = "process"
+CONTROL = "control"
+ENTITY = "entity"
+STORE = "store"
+CHANNEL = "channel"
+NONE = "none"
 
-FLOW = 'flow'
-BFLOW = 'bflow'
-CFLOW = 'cflow'
-UFLOW = 'uflow'
-SIGNAL = 'signal'
+FLOW = "flow"
+BFLOW = "bflow"
+CFLOW = "cflow"
+UFLOW = "uflow"
+SIGNAL = "signal"
 
-FRAME = 'frame'
+FRAME = "frame"
 
-ATTRIB = 'attrib'
+ATTRIB = "attrib"
 
 
 @dataclass
 class GraphOptions:
     is_vertical: bool = False
     is_context: bool = False
+    is_rotated: bool = False
     item_text_width = config.DEFAULT_ITEM_TEXT_WIDTH
     connection_text_width = config.DEFAULT_CONNECTION_TEXT_WIDTH
 
 
 def pack(src_line: str | None) -> str:
     if src_line is None:
-        return '<none>'
-    return ' '.join(src_line.split())
+        return "<none>"
+    return " ".join(src_line.split())
 
 
 def mk_err_prefix_from(src: SourceLine) -> str:
 
     def _add_to_stack(stack: list[str], src: SourceLine) -> None:
         if src.line_nr is None:
-            stack += [f'  {pack(src.raw_text)}']
+            stack += [f"  {pack(src.raw_text)}"]
         else:
             if src.parent and src.parent.is_container:
                 nr = src.parent.line_nr + 1
                 delta = src.line_nr + 1
                 final = nr + delta
-                stack += [f'  line {final}: {pack(src.raw_text)}']
+                stack += [f"  line {final}: {pack(src.raw_text)}"]
             else:
                 nr = src.line_nr + 1
-                stack += [f'  line {nr}: {pack(src.raw_text)}']
+                stack += [f"  line {nr}: {pack(src.raw_text)}"]
         if src.parent:
             _add_to_stack(stack, src.parent)
 
-    stack: list[str] = ['(most recent first)']
+    stack: list[str] = ["(most recent first)"]
     _add_to_stack(stack, src)
-    stack += ['']
-    return '\n'.join(stack) + 'Error: '
+    stack += [""]
+    return "\n".join(stack) + "Error: "
 
 
 class DfdException(Exception):

{data_flow_diagram-1.12.1.post3 → data_flow_diagram-1.13.1}/src/data_flow_diagram/parser.py

@@ -31,7 +31,7 @@ def check(statements: model.Statements) -> dict[str, model.Item]:
         other_text = model.pack(other.source.text)
         raise model.DfdException(
             f'{error_prefix}Name "{name}" already exists '
-            f'at line {other.source.line_nr+1}: {other_text}'
+            f"at line {other.source.line_nr+1}: {other_text}"
         )
 
     # check references and values of connections
@@ -50,7 +50,7 @@ def check(statements: model.Statements) -> dict[str, model.Item]:
                 if point not in items_by_name:
                     raise model.DfdException(
                         f'{error_prefix}Connection "{conn.type}" links to "{point}", '
-                        f'which is not defined'
+                        f"which is not defined"
                     )
                 if (
                     items_by_name[point].type == model.CONTROL
@@ -64,8 +64,7 @@ def check(statements: model.Statements) -> dict[str, model.Item]:
 
         if nb_stars == 2:
             raise model.DfdException(
-                f'{error_prefix}Connection "{conn.type}" may not link to two '
-                f'stars'
+                f'{error_prefix}Connection "{conn.type}" may not link to two ' f"stars"
             )
 
     # check references of frames
@@ -78,16 +77,15 @@ def check(statements: model.Statements) -> dict[str, model.Item]:
             case _:
                 continue
         if not frame.items:
-            raise model.DfdException(f'{error_prefix}Frame is empty')
+            raise model.DfdException(f"{error_prefix}Frame is empty")
         for name in frame.items:
             if name not in items_by_name:
                 raise model.DfdException(
-                    f'{error_prefix}Frame includes "{name}", '
-                    f'which is not defined'
+                    f'{error_prefix}Frame includes "{name}", ' f"which is not defined"
                 )
             if name in framed_items:
                 raise model.DfdException(
-                    f'{error_prefix}Item "{name}", ' f'is in multiple frames'
+                    f'{error_prefix}Item "{name}", ' f"is in multiple frames"
                 )
             framed_items.add(name)
 
@@ -108,7 +106,7 @@ def parse(
         src_line = source.text
 
         src_line = src_line.strip()
-        if not src_line or src_line.startswith('#'):
+        if not src_line or src_line.startswith("#"):
             continue
         error_prefix = model.mk_err_prefix_from(source)
 
@@ -131,25 +129,23 @@ def parse(
             model.BFLOW: parse_bflow,
             model.UFLOW: parse_uflow,
             model.SIGNAL: parse_signal,
-            model.FLOW + '?': parse_flow_q,
-            model.CFLOW + '?': parse_cflow_q,
-            model.BFLOW + '?': parse_bflow_q,
-            model.UFLOW + '?': parse_uflow_q,
-            model.SIGNAL + '?': parse_signal_q,
-            'flow.r': parse_flow_r,
-            'cflow.r': parse_cflow_r,
-            'signal.r': parse_signal_r,
-            'flow.r?': parse_flow_r_q,
-            'cflow.r?': parse_cflow_r_q,
-            'signal.r?': parse_signal_r_q,
+            model.FLOW + "?": parse_flow_q,
+            model.CFLOW + "?": parse_cflow_q,
+            model.BFLOW + "?": parse_bflow_q,
+            model.UFLOW + "?": parse_uflow_q,
+            model.SIGNAL + "?": parse_signal_q,
+            "flow.r": parse_flow_r,
+            "cflow.r": parse_cflow_r,
+            "signal.r": parse_signal_r,
+            "flow.r?": parse_flow_r_q,
+            "cflow.r?": parse_cflow_r_q,
+            "signal.r?": parse_signal_r_q,
             model.FRAME: parse_frame,
             model.ATTRIB: parse_attrib,
         }.get(word)
 
         if f is None:
-            raise model.DfdException(
-                f'{error_prefix}Unrecognized keyword ' f'"{word}"'
-            )
+            raise model.DfdException(f"{error_prefix}Unrecognized keyword " f'"{word}"')
 
         try:
             statement = f(source)
@@ -177,27 +173,25 @@ def parse(
     return statements, dependencies, attribs
 
 
-def split_args(
-    dfd_line: str, n: int, last_is_optional: bool = False
-) -> list[str]:
+def split_args(dfd_line: str, n: int, last_is_optional: bool = False) -> list[str]:
     """Split DFD line into n (possibly n-1) tokens"""
 
     terms: list[str] = dfd_line.split(maxsplit=n)
     if len(terms) - 1 == n - 1 and last_is_optional:
-        terms.append('')
+        terms.append("")
 
     if len(terms) - 1 != n:
         if not last_is_optional:
-            raise model.DfdException(f'Expected {n} argument(s)')
+            raise model.DfdException(f"Expected {n} argument(s)")
         else:
-            raise model.DfdException(f'Expected {n-1} or {n} argument')
+            raise model.DfdException(f"Expected {n-1} or {n} argument")
 
     return terms[1:]
 
 
 def parse_item_name(name: str) -> Tuple[str, bool]:
     """If name ends with ?, make it hidable"""
-    if name.endswith('?'):
+    if name.endswith("?"):
         return name[:-1], True
     else:
         return name, False
@@ -308,57 +302,43 @@ def parse_signal_r(source: model.SourceLine) -> model.Statement:
 def parse_flow_q(source: model.SourceLine) -> model.Statement:
     """Parse directional flow statement"""
     src, dst, text = split_args(source.text, 3, True)
-    return model.Connection(
-        source, model.FLOW, text, "", src, dst, relaxed=True
-    )
+    return model.Connection(source, model.FLOW, text, "", src, dst, relaxed=True)
 
 
 def parse_flow_r_q(source: model.SourceLine) -> model.Statement:
     """Parse directional reversed flow statement"""
     src, dst, text = split_args(source.text, 3, True)
-    return model.Connection(
-        source, model.FLOW, text, "", src, dst, True, relaxed=True
-    )
+    return model.Connection(source, model.FLOW, text, "", src, dst, True, relaxed=True)
 
 
 def parse_cflow_q(source: model.SourceLine) -> model.Statement:
     """Parse continuous flow statement"""
     src, dst, text = split_args(source.text, 3, True)
-    return model.Connection(
-        source, model.CFLOW, text, "", src, dst, relaxed=True
-    )
+    return model.Connection(source, model.CFLOW, text, "", src, dst, relaxed=True)
 
 
 def parse_cflow_r_q(source: model.SourceLine) -> model.Statement:
     """Parse continuous flow statement"""
     src, dst, text = split_args(source.text, 3, True)
-    return model.Connection(
-        source, model.CFLOW, text, "", src, dst, True, relaxed=True
-    )
+    return model.Connection(source, model.CFLOW, text, "", src, dst, True, relaxed=True)
 
 
 def parse_bflow_q(source: model.SourceLine) -> model.Statement:
     """Parse bidirectional flow statement"""
     src, dst, text = split_args(source.text, 3, True)
-    return model.Connection(
-        source, model.BFLOW, text, "", src, dst, relaxed=True
-    )
+    return model.Connection(source, model.BFLOW, text, "", src, dst, relaxed=True)
 
 
 def parse_uflow_q(source: model.SourceLine) -> model.Statement:
     """Parse undirected flow flow statement"""
     src, dst, text = split_args(source.text, 3, True)
-    return model.Connection(
-        source, model.UFLOW, text, "", src, dst, relaxed=True
-    )
+    return model.Connection(source, model.UFLOW, text, "", src, dst, relaxed=True)
 
 
 def parse_signal_q(source: model.SourceLine) -> model.Statement:
     """Parse signal statement"""
     src, dst, text = split_args(source.text, 3, True)
-    return model.Connection(
-        source, model.SIGNAL, text, "", src, dst, relaxed=True
-    )
+    return model.Connection(source, model.SIGNAL, text, "", src, dst, relaxed=True)
 
 
 def parse_signal_r_q(source: model.SourceLine) -> model.Statement:
@@ -381,45 +361,45 @@ def apply_syntactic_sugars(src_line: str) -> str:
         del array[2]  # remove arrow
         if swap:
             array[1], array[2] = array[2], array[1]
-        return '\t'.join(array)
+        return "\t".join(array)
 
-    new_line = ''
-    if re.fullmatch(r'-+>[?]?', op):
-        q = '?' if op.endswith('?') else ''
+    new_line = ""
+    if re.fullmatch(r"-+>[?]?", op):
+        q = "?" if op.endswith("?") else ""
         parts = src_line.split(maxsplit=3)
-        new_line = fmt('flow' + q, parts)
-    elif re.fullmatch(r'<-+[?]?', op):
-        q = '?' if op.endswith('?') else ''
+        new_line = fmt("flow" + q, parts)
+    elif re.fullmatch(r"<-+[?]?", op):
+        q = "?" if op.endswith("?") else ""
         parts = src_line.split(maxsplit=3)
-        new_line = fmt('flow.r' + q, parts)  # , swap=True)
+        new_line = fmt("flow.r" + q, parts)  # , swap=True)
 
-    if re.fullmatch(r'-+>>[?]?', op):
-        q = '?' if op.endswith('?') else ''
+    if re.fullmatch(r"-+>>[?]?", op):
+        q = "?" if op.endswith("?") else ""
         parts = src_line.split(maxsplit=3)
-        new_line = fmt('cflow' + q, parts)
-    elif re.fullmatch(r'<<-+[?]?', op):
-        q = '?' if op.endswith('?') else ''
+        new_line = fmt("cflow" + q, parts)
+    elif re.fullmatch(r"<<-+[?]?", op):
+        q = "?" if op.endswith("?") else ""
         parts = src_line.split(maxsplit=3)
-        new_line = fmt('cflow.r' + q, parts)  # , swap=True)
+        new_line = fmt("cflow.r" + q, parts)  # , swap=True)
 
-    elif re.fullmatch(r'<-+>[?]?', op):
-        q = '?' if op.endswith('?') else ''
+    elif re.fullmatch(r"<-+>[?]?", op):
+        q = "?" if op.endswith("?") else ""
         parts = src_line.split(maxsplit=3)
-        new_line = fmt('bflow' + q, parts)
+        new_line = fmt("bflow" + q, parts)
 
-    elif re.fullmatch(r'--+[?]?', op):
-        q = '?' if op.endswith('?') else ''
+    elif re.fullmatch(r"--+[?]?", op):
+        q = "?" if op.endswith("?") else ""
         parts = src_line.split(maxsplit=3)
-        new_line = fmt('uflow' + q, parts)
+        new_line = fmt("uflow" + q, parts)
 
-    elif re.fullmatch(r':+>[?]?', op):
-        q = '?' if op.endswith('?') else ''
+    elif re.fullmatch(r":+>[?]?", op):
+        q = "?" if op.endswith("?") else ""
         parts = src_line.split(maxsplit=3)
-        new_line = fmt('signal' + q, parts)
-    elif re.fullmatch(r'<:+[?]?', op):
-        q = '?' if op.endswith('?') else ''
+        new_line = fmt("signal" + q, parts)
+    elif re.fullmatch(r"<:+[?]?", op):
+        q = "?" if op.endswith("?") else ""
         parts = src_line.split(maxsplit=3)
-        new_line = fmt('signal.r' + q, parts)  # , swap=True)
+        new_line = fmt("signal.r" + q, parts)  # , swap=True)
 
     if new_line:
         return new_line
@@ -428,8 +408,8 @@ def apply_syntactic_sugars(src_line: str) -> str:
 
 
 def parse_drawable_attrs(drawable: model.Drawable) -> None:
-    if drawable.text and drawable.text.startswith('['):
-        parts = drawable.text[1:].split(']', 1)
+    if drawable.text and drawable.text.startswith("["):
+        parts = drawable.text[1:].split("]", 1)
         drawable.attrs = parts[0]
         drawable.text = parts[1].strip()
 
@@ -441,7 +421,7 @@ def parse_drawable_attrs(drawable: model.Drawable) -> None:
 def parse_item_external(
     item: model.Item, dependencies: model.GraphDependencies
 ) -> None:
-    parts = item.name.split(':', 1)
+    parts = item.name.split(":", 1)
     if len(parts) > 1:
         item.attrs = TMPL.ITEM_EXTERNAL_ATTRS
         if parts[-1]:
@@ -449,7 +429,7 @@ def parse_item_external(
         else:
             item.name = parts[-2]
 
-        if item.name.startswith('#'):
+        if item.name.startswith("#"):
             item.name = item.name[1:]
         else:
             item.name = os.path.splitext(item.name)[0]
@@ -465,13 +445,13 @@ def parse_item_external(
 
 def parse_frame(source: model.SourceLine) -> model.Statement:
     """Parse frame statement"""
-    parts = source.text.split('=', maxsplit=1)
+    parts = source.text.split("=", maxsplit=1)
     if len(parts) == 1:
-        text = ''
+        text = ""
     else:
         text = parts[1].strip()
 
     items = parts[0].split()[1:]
-    type = ''  # so far there is only one type of frame
-    attrs = 'style=dashed'
+    type = ""  # so far there is only one type of frame
+    attrs = "style=dashed"
     return model.Frame(source, type, text, attrs, items)

{data_flow_diagram-1.12.1.post3 → data_flow_diagram-1.13.1}/src/data_flow_diagram/scanner.py

@@ -8,7 +8,7 @@ from . import model
 #   def
 # into:
 #   abcdef
-RX_LINE_CONT = re.compile('[\\\\]\\s*\n\\s*', re.MULTILINE)
+RX_LINE_CONT = re.compile("[\\\\]\\s*\n\\s*", re.MULTILINE)
 
 
 def scan(
@@ -21,21 +21,21 @@ def scan(
     includes: set[str] = set()
 
     # stitch continuated lines
-    input = RX_LINE_CONT.sub('', input)
+    input = RX_LINE_CONT.sub("", input)
 
     if provenance is None:
         provenance = model.SourceLine("", provenance, None, 0)
     _scan(input, provenance, output, snippet_by_name, includes)
 
     if debug:
-        print('=' * 40)
+        print("=" * 40)
         print(provenance)
-        print('----------')
+        print("----------")
         print(input)
-        print('----------')
+        print("----------")
         for l in output:
             print(model.repr(l))
-        print('=' * 40)
+        print("=" * 40)
 
     return output
 
@@ -52,7 +52,7 @@ def _scan(
             continue
         source_line = model.SourceLine(line, line, parent, nr)
         pair = line.split(maxsplit=1)
-        if len(pair) == 2 and pair[0] == '#include':
+        if len(pair) == 2 and pair[0] == "#include":
             include(line, source_line, output, snippet_by_name, includes)
         else:
             output.append(source_line)
@@ -73,30 +73,25 @@ def include(
         raise model.DfdException(f'{prefix}Recursive include of "{name}"')
     includes.add(name)
 
-    caller = model.SourceLine("", f'<snippet {name}>', parent, 0)
-    if name.startswith('#'):
+    caller = model.SourceLine("", f"<snippet {name}>", parent, 0)
+    if name.startswith("#"):
         # include from MD snippet
         if not snippet_by_name:
             raise model.DfdException(
-                f'{prefix}source is not markdown, '
-                f'cannot include snippet "{name}".'
+                f"{prefix}source is not markdown, " f'cannot include snippet "{name}".'
             )
         name0 = name
         name = name[1:]
         snippet = snippet_by_name.get(name) or snippet_by_name.get(name0)
         if not snippet:
-            raise model.DfdException(
-                f'{prefix}included snippet "{name}" not found.'
-            )
+            raise model.DfdException(f'{prefix}included snippet "{name}" not found.')
 
         _scan(snippet.text, caller, output, snippet_by_name, includes)
 
     else:
         # include from file
         if not os.path.exists(name):
-            raise model.DfdException(
-                f'{prefix}included file "{name}" not found.'
-            )
-        with open(name, encoding='utf-8') as f:
+            raise model.DfdException(f'{prefix}included file "{name}" not found.')
+        with open(name, encoding="utf-8") as f:
             text = f.read()
         _scan(text, caller, output, snippet_by_name, includes)

{data_flow_diagram-1.12.1.post3 → data_flow_diagram-1.13.1/src/data_flow_diagram.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: data-flow-diagram
-Version: 1.12.1.post3
+Version: 1.13.1
 Summary: Commandline tool to generate data flow diagrams from text
 Home-page: https://github.com/pbauermeister/dfd
 Author: Pascal Bauermeister