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

data_flow_diagram-1.13.1/CHANGES.md

@@ -0,0 +1,102 @@
+## 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.
+
+## Version 1.12.0:
+
+- Support style (and hence attrib) on Stores and Channels.
+
+## Version 1.11.1.post2:
+
+Bug fixes:
+
+- Apply attribs on frames.
+- Attribs are matched by whole names, so e.g. DATA and DATABASE will work.
+
+Improvements:
+
+- 'make install' to install locally.
+
+## Version 1.11.0:
+
+- Keyword "attrib" to define styles.
+
+## Version 1.10.1:
+
+- When item text is numbered, add newline after the number.
+
+## Version 1.9.1:
+
+- Add troubleshooting in README.md.
+
+## Version 1.9.0:
+
+- Allow line continuation with a trailing backslash
+
+## Version 1.8.0:
+
+- Add frames
+
+## Version 1.7.1:
+
+- Support continuous back- and relaxed- flows.
+
+## Version 1.7.0:
+
+- Add continuous flow (cflow or -->>).
+- Add control (may only connect to signals).
+
+## Version 1.6.0:
+
+- Dependencies:
+  - items with name #SNIPPET:[NAME] or FILE:[NAME] refer to another graph,
+  - referred item is rendered "ghosted",
+  - dependencies are checked (unless --no-check-dependencies is passed).
+- Add graph title (unless --no-graph-title is passed).
+- Error in snippets of MD files: display line number relative to MD file (not snippet).
+
+## Version 1.5.0:
+
+- Wrap labels by `style item-text-width N` (default N=20).
+- and `style connection-text-width N` (default N=14).
+
+## Version 1.4.1:
+
+- Processes have very light grey backgrounds.
+- Add the 'none' item type.
+- Connections with reversed direction affect the items placements.
+- A '?' postfix to a connection, removes the edge constraint.
+- Fix formatting of '\n' for Store and Channel (which are HTML nodes).
+- Colorize error messages.
+- Add drawable attributes as [ATTRS...] prefix before labels.
+
+## Version 1.3.x:
+
+- Style vertical: is supported.
+- Style context: for context (top-level) diagrams.
+- Add undirected flow (uflow aka '--').
+
+## Version 1.2.3
+
+- Snippet reference and ungenerated snippet were marked with '<'; now
+  use '#' instead.
+- Detect include (infinite) recursions and print error.
+- Can print its own version.
+
+## Version 1.1.1
+
+- Fix bug with left/bidir arrows.
+
+## Version 1.1.0
+
+- Upon error, print error stack trace.
+- Items: label can be ommitted.
+- Connections: syntactic sugars with arrows.
+
+## Version 1.0.0
+
+- Initial release.

data_flow_diagram-1.13.1/MANIFEST.in

@@ -0,0 +1 @@
+include CHANGES.md

{data_flow_diagram-1.12.1.post2 → data_flow_diagram-1.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: data-flow-diagram
-Version: 1.12.1.post2
+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.post2 → 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.post2 → 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.post2 → 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