### Install syrenka Python Package via pip

Source: https://github.com/bartlomiejcieszkowski/syrenka/blob/main/README.md

Installation command for the syrenka library from PyPI package repository.

```bash
pip install syrenka
```

--------------------------------

### Configure Class Diagram Appearance with Themes

Source: https://context7.com/bartlomiejcieszkowski/syrenka/llms.txt

Provides examples on how to configure the appearance of Syrenka class diagrams, focusing on theme selection and other display options. It lists available themes and shows how to apply a theme during diagram configuration.

```python
from syrenka.base import ThemeNames
from syrenka.classdiagram import SyrenkaClassDiagramConfig

# Available themes
themes = [
    ThemeNames.DEFAULT,
    ThemeNames.NEUTRAL,
    ThemeNames.DARK,
    ThemeNames.FOREST,
    ThemeNames.BASE,
]

# Create and configure
config = SyrenkaClassDiagramConfig()
config.theme(ThemeNames.DARK)

# Default configuration includes:
# - hideEmptyMembersBox: true (hides empty class sections)

# Use with SyrenkaClassDiagram
from syrenka.classdiagram import SyrenkaClassDiagram
diagram = SyrenkaClassDiagram("My Diagram", config)
```

--------------------------------

### Run syrenka CLI to Generate Python Class Diagrams

Source: https://github.com/bartlomiejcieszkowski/syrenka/blob/main/README.md

Command-line interface examples for generating Python class diagrams using syrenka. Supports directory analysis with optional project structure detection and file filtering. The --detect-project-dir flag automatically finds src/ directories, and --globals-as-class groups module-level functions into a _globals_ pseudo-class.

```bash
python -m syrenka -h
```

```bash
python -m syrenka classdiagram <path/to/folder>
```

```bash
python -m syrenka classdiagram <project_dir>/src
```

```bash
python -m syrenka classdiagram <project_dir> --detect-project-dir
```

```bash
python -m syrenka classdiagram -h
```

--------------------------------

### Render Mermaid Diagrams to Image Files

Source: https://context7.com/bartlomiejcieszkowski/syrenka/llms.txt

Convert Mermaid markdown syntax to SVG, PNG, or PDF image files using mermaid-cli. Supports both string-based Mermaid code and file inputs with customizable themes, dimensions, colors, and optional configuration files. Requires mermaid-cli installation.

```python
from pathlib import Path
from syrenka.generate import render_mermaid

# Render from string
mermaid_code = """
graph TD
    A[Start] --> B[Process]
    B --> C[End]
"""

render_mermaid(
    source=mermaid_code,
    output_file=Path("diagram.svg"),
    overwrite=True,
    theme="dark",  # Optional: theme override
    width=800,  # Optional: width in pixels
    height=600,  # Optional: height in pixels
    background_color="transparent",  # Optional: background color
    config_file=None,  # Optional: mermaid config file
    css_file=None  # Optional: CSS file
)

# Render from file
render_mermaid(
    source=Path("diagram.mmd"),
    output_file=Path("diagram.png"),
    overwrite=True
)
```

--------------------------------

### Generate Python Class Diagram from File Path using syrenka AST

Source: https://github.com/bartlomiejcieszkowski/syrenka/blob/main/README.md

Creates a class diagram from Python files in a specified directory path using the ast backend. This example analyzes the syrenka source code directory and generates a mermaid class diagram, supporting theme customization and multiple output formats.

```python
"""Example SyrenkaClassDiagram with ast backend."""

# from io import StringIO
import sys
from pathlib import Path

from syrenka.base import ThemeNames
from syrenka.classdiagram import SyrenkaClassDiagram, SyrenkaClassDiagramConfig
from syrenka.lang.python import PythonModuleAnalysis

class_diagram = SyrenkaClassDiagram("syrenka class diagram", SyrenkaClassDiagramConfig().theme(ThemeNames.NEUTRAL))
class_diagram.add_classes(PythonModuleAnalysis.classes_in_path(Path(__file__).parent.parent / "src"))

# file can be anything that implements TextIOBase
# out = StringIO() # string buffer in memory
out = sys.stdout  # stdout
# out = open("syrenka.md", "w") # write it to file

class_diagram.to_code(file=out)

# StringIO
# out.seek(0)
# print(out.read())
```

--------------------------------

### Define and Use Different Edge Styles in Flowcharts

Source: https://context7.com/bartlomiejcieszkowski/syrenka/llms.txt

Illustrates the usage of various `EdgeType` enums to define connection styles between nodes in a Syrenka flowchart. Includes examples of different arrow types, line styles, and text labels.

```python
import syrenka.flowchart as sf

# Available edge types
edge_types = [
    sf.EdgeType.ARROW_EDGE,      # -->
    sf.EdgeType.OPEN_LINK,       # ---
    sf.EdgeType.DOTTED_LINK,     # -.->
    sf.EdgeType.THICK_LINK,      # ==>
    sf.EdgeType.INVISIBLE_LINK,  # ~~~
    sf.EdgeType.CIRCLE_EDGE,     # --o
    sf.EdgeType.CROSS_EDGE,      # --x
    sf.EdgeType.MULTI_ARROW_EDGE,  # <-->
]

# Create flowchart and use different edge types
fl = sf.SyrenkaFlowchart("Edge Demo", sf.FlowchartDirection.TB)
fl.add(sf.Node("a", "Node A"))
fl.add(sf.Node("b", "Node B"))
fl.add(sf.Node("c", "Node C"))

# Connect with different styles
fl.connect_by_id("a", "b", sf.EdgeType.ARROW_EDGE)
fl.connect_by_id("b", "c", sf.EdgeType.DOTTED_LINK, text="optional")
```

--------------------------------

### Generate Python Class Diagram from Module using syrenka

Source: https://github.com/bartlomiejcieszkowski/syrenka/blob/main/README.md

Creates a class diagram from a Python module using importlib and ast analysis. The example generates a mermaid diagram for the syrenka module itself, demonstrating how to use SyrenkaClassDiagram with PythonModuleAnalysis.classes_in_module(). Output can be directed to stdout, file, or StringIO buffer.

```python
"""Example SyrenkaClassDiagram."""

# from io import StringIO
import sys

from syrenka.base import ThemeNames
from syrenka.classdiagram import SyrenkaClassDiagram, SyrenkaClassDiagramConfig
from syrenka.lang.python import PythonModuleAnalysis

class_diagram = SyrenkaClassDiagram("syrenka class diagram", SyrenkaClassDiagramConfig().theme(ThemeNames.NEUTRAL))
class_diagram.add_classes(PythonModuleAnalysis.classes_in_module(module_name="syrenka", nested=True))

# file can be anything that implements TextIOBase
# out = StringIO() # string buffer in memory
out = sys.stdout  # stdout
# out = open("syrenka.md", "w") # write it to file

class_diagram.to_code(file=out)

# StringIO
# out.seek(0)
# print(out.read())
```

--------------------------------

### Export uv lock file to requirements.txt

Source: https://github.com/bartlomiejcieszkowski/syrenka/blob/main/SBOM.md

Exports the uv lock file into standard requirements.txt format. This command is used to create a file containing production dependencies. Dependencies are frozen to ensure reproducibility.

```bash
uv export --frozen --format requirements.txt --no-dev -o requirements.txt
```

--------------------------------

### Generate SBOM from requirements.txt using cyclodox-python

Source: https://github.com/bartlomiejcieszkowski/syrenka/blob/main/SBOM.md

Generates a reproducible SBOM in JSON format from a requirements.txt file using the cyclodox-python tool. This command is executed within a uv run environment and targets production dependencies.

```bash
uv run --only-dev python -m cyclonedx_py requirements --output-reproducible requirements.txt --output-file syrenka-sbom.json
```

--------------------------------

### Generate SBOM from requirements-dev.txt using cyclodox-python

Source: https://github.com/bartlomiejcieszkowski/syrenka/blob/main/SBOM.md

Generates a reproducible SBOM in JSON format from a requirements-dev.txt file using the cyclodox-python tool. This command is run within a uv environment and focuses on development dependencies.

```bash
uv run --only-dev python -m cyclonedx_py requirements --output-reproducible requirements-dev.txt --output-file syrenka-dev-sbom.json
```

--------------------------------

### Export uv lock file to requirements-dev.txt

Source: https://github.com/bartlomiejcieszkowski/syrenka/blob/main/SBOM.md

Exports the uv lock file into a requirements-dev.txt format. This command specifically includes development dependencies. Dependencies are frozen for reproducibility.

```bash
uv export --frozen --format requirements.txt --only-dev -o requirements-dev.txt
```

--------------------------------

### Generate Class Diagrams via CLI

Source: https://context7.com/bartlomiejcieszkowski/syrenka/llms.txt

Command-line interface for analyzing Python projects and generating Mermaid class diagrams. Supports project structure detection, path filtering, module-level function inclusion, and multiple command aliases with flexible output redirection.

```bash
# Display help
python -m syrenka -h

# Generate class diagram from directory
python -m syrenka classdiagram ./src

# Generate with project structure detection
python -m syrenka classdiagram . --detect-project-dir

# Exclude specific paths
python -m syrenka classdiagram ./src --exclude tests/ __pycache__/

# Include only specific paths
python -m syrenka classdiagram ./src --only models/ services/

# Include module-level functions as pseudo-class
python -m syrenka classdiagram ./src --globals-as-class

# Add module name prefix
python -m syrenka classdiagram ./src --module-name-from-path

# Alternative command aliases
python -m syrenka class ./src
python -m syrenka c ./src
python -m syrenka class_diagram ./src

# Generate from imported module (requires module to be installed)
python -m syrenka import_module mypackage

# Redirect output to file
python -m syrenka classdiagram ./src > diagram.md
```

--------------------------------

### Create Basic Flowchart with SyrenkaFlowchart

Source: https://context7.com/bartlomiejcieszkowski/syrenka/llms.txt

Demonstrates creating a simple flowchart using SyrenkaFlowchart, adding nodes with different shapes, creating a subgraph, and connecting nodes with various edge types. The output is printed to standard output.

```python
import sys
import syrenka.flowchart as sf

# Create a flowchart with top-to-bottom direction
fl = sf.SyrenkaFlowchart(title="Simple Flowchart", direction=sf.FlowchartDirection.TOP_TO_BOTTOM)

# Add nodes with different shapes
fl.add(sf.Node(identifier="1", text="First", shape=sf.NodeShape.DEFAULT))
fl.add(sf.Node(identifier="4", text="Fourth", shape=sf.NodeShape.RHOMBUS))

# Create and add a subgraph
sub = sf.Subgraph(identifier="s", text="Subgraph")
sub.add(sf.Node(identifier="2", text="Second")),
sub.add(sf.Node(identifier="3", text="Third")),
fl.add(sub)

# Connect nodes with different edge types
fl.connect_by_id("1", "2")
fl.connect_by_id(source_id="2", target_id="3", edge_type=sf.EdgeType.DOTTED_LINK)
fl.connect_by_id("3", "4").connect_by_id("4", "s", sf.EdgeType.THICK_LINK)

# Output to stdout or file
fl.to_code(file=sys.stdout)
```

--------------------------------

### Generate Class Diagrams from Source Files using AST

Source: https://context7.com/bartlomiejcieszkowski/syrenka/llms.txt

Demonstrates generating UML class diagrams by parsing Python source files directly using Abstract Syntax Tree (AST), without needing to import the modules. This method allows configuration of themes, analysis of files from a specified path, and exclusion of certain directories.

```python
import sys
from pathlib import Path
from syrenka.base import ThemeNames
from syrenka.classdiagram import SyrenkaClassDiagram, SyrenkaClassDiagramConfig
from syrenka.lang.python import PythonModuleAnalysis

# Configure diagram
config = SyrenkaClassDiagramConfig().theme(ThemeNames.DARK)
class_diagram = SyrenkaClassDiagram("Project Class Diagram", config)

# Analyze source files from path
source_path = Path("./src")
classes = PythonModuleAnalysis.classes_in_path(
    source_path,
    recursive=True,
    detect_project_dir=True,  # Automatically detect src/ folder
    exclude=["tests/", "migrations/"],  # Exclude specific paths
    only=None,  # Or specify paths to include
    globals_as_class=True  # Wrap module-level functions in pseudo-class
)

class_diagram.add_classes(classes)

# Generate output
with open("classdiagram.md", "w") as f:
    class_diagram.to_code(file=f)
```

--------------------------------

### Create Simple Flowchart with Nodes and Edge Types in Python

Source: https://github.com/bartlomiejcieszkowski/syrenka/blob/main/README.md

Shows how to build a basic SyrenkaFlowchart with a title and TOP_TO_BOTTOM direction. Demonstrates adding nodes and subgraphs using add(), connecting nodes with different edge types (DOTTED_LINK, THICK_LINK), and using method chaining for multiple connections. Outputs the flowchart definition to stdout.

```python
"""Example Simple SyrenkaFlowchart."""

import sys

import syrenka.flowchart as sf

fl = sf.SyrenkaFlowchart(title="Simple Flowchart", direction=sf.FlowchartDirection.TOP_TO_BOTTOM)
fl.add(sf.Node(identifier="1", text="First"))
sub = sf.Subgraph(identifier="s", text="Subgraph")
sub.add(sf.Node(identifier="2", text="Second"))
sub.add(sf.Node(identifier="3", text="Third"))
fl.add(sub)
fl.add(sf.Node(identifier="4", text="Fourth"))

fl.connect_by_id("1", "2")
fl.connect_by_id(source_id="2", target_id="3", edge_type=sf.EdgeType.DOTTED_LINK)
fl.connect_by_id("3", "4").connect_by_id("4", "s", sf.EdgeType.THICK_LINK)

fl.to_code(file=sys.stdout)
```

--------------------------------

### Create Sample Flowchart with Multiple Subgraphs in Python

Source: https://github.com/bartlomiejcieszkowski/syrenka/blob/main/README.md

Demonstrates creating a SyrenkaFlowchart with multiple nested subgraphs, each with different flow directions (TOP_TO_BOTTOM, LEFT_TO_RIGHT, BOTTOM_TO_TOP). Shows how to add nodes to subgraphs, connect nodes and subgraphs using connect_by_id(), convert the flowchart to code format, and generate an SVG diagram image.

```python
"""Example SyrenkaFlowchart usage."""

from io import StringIO
from pathlib import Path

import syrenka.flowchart as sf
from syrenka.generate import generate_diagram_image

flowchart = sf.SyrenkaFlowchart(
    "",
    sf.FlowchartDirection.TOP_TO_BOTTOM,
    nodes=[
        sf.Subgraph(
            "one",
            nodes=[
                sf.Node("a1"),
                sf.Node("a2"),
            ],
        ),
        sf.Subgraph(
            "two",
            direction=sf.FlowchartDirection.LEFT_TO_RIGHT,
            nodes=[
                sf.Node("b1"),
                sf.Node("b2"),
            ],
        ),
        sf.Subgraph(
            "three",
            direction=sf.FlowchartDirection.BOTTOM_TO_TOP,
            nodes=[
                sf.Node("c1"),
                sf.Node("c2"),
            ],
        ),
    ],
)

flowchart.connect_by_id("c1", "a2").connect_by_id("a1", "a2")
flowchart.connect_by_id("b1", "b2").connect_by_id("c1", "c2")
flowchart.connect_by_id("one", "two").connect_by_id("three", "two").connect_by_id("two", "c2")

out = StringIO()
flowchart.to_code(file=out)

print(out.getvalue())

generate_diagram_image(out.getvalue(), Path("out.svg"), overwrite=True)
```

--------------------------------

### Create Flowchart Nodes with Different Shapes

Source: https://context7.com/bartlomiejcieszkowski/syrenka/llms.txt

Demonstrates how to create flowchart nodes with distinct shapes such as CIRCLE, DEFAULT, RHOMBUS, and DOUBLE_CIRCLE using the Syrenka library.

```python
import syrenka.flowchart as sf

node_start = sf.Node("start", "Start", sf.NodeShape.CIRCLE)
node_process = sf.Node("proc", "Process", sf.NodeShape.DEFAULT)
node_decision = sf.Node("decision", "Decision?", sf.NodeShape.RHOMBUS)
node_end = sf.Node("end", "End", sf.NodeShape.DOUBLE_CIRCLE)
```

--------------------------------

### Create Complex Flowchart with Subgraphs and Directions using Syrenka

Source: https://context7.com/bartlomiejcieszkowski/syrenka/llms.txt

Illustrates the creation of a complex flowchart with multiple nested subgraphs, each potentially having a different direction. It shows how to chain connections and optionally render the output to an SVG image using `render_mermaid`.

```python
from io import StringIO
from pathlib import Path
import syrenka.flowchart as sf
from syrenka.generate import render_mermaid

# Create flowchart with multiple subgraphs with different directions
flowchart = sf.SyrenkaFlowchart(
    "",
    sf.FlowchartDirection.TOP_TO_BOTTOM,
    nodes=[
        sf.Subgraph(
            "one",
            nodes=[
                sf.Node("a1"),
                sf.Node("a2"),
            ],
        ),
        sf.Subgraph(
            "two",
            direction=sf.FlowchartDirection.LEFT_TO_RIGHT,
            nodes=[
                sf.Node("b1"),
                sf.Node("b2"),
            ],
        ),
        sf.Subgraph(
            "three",
            direction=sf.FlowchartDirection.BOTTOM_TO_TOP,
            nodes=[
                sf.Node("c1"),
                sf.Node("c2"),
            ],
        ),
    ],
)

# Chain connections
flowchart.connect_by_id("c1", "a2").connect_by_id("a1", "a2")
flowchart.connect_by_id("b1", "b2").connect_by_id("c1", "c2")
flowchart.connect_by_id("one", "two").connect_by_id("three", "two").connect_by_id("two", "c2")

# Generate and render
out = StringIO()
flowchart.to_code(file=out)
print(out.getvalue())

# Optional: render to image using mermaid-cli
render_mermaid(out.getvalue(), Path("out.svg"), overwrite=True)
```

--------------------------------

### Parse Python Source Files for Class Diagrams using AST

Source: https://context7.com/bartlomiejcieszkowski/syrenka/llms.txt

Explains the process of extracting class information from Python source files using AST parsing via `PythonModuleAnalysis.classes_in_path`. This method avoids module imports and allows for detailed configuration of the parsing process, including recursive searching, path exclusion, and handling of module-level functions.

```python
from pathlib import Path
from syrenka.lang.python import PythonModuleAnalysis

# The rest of the code for this snippet is incomplete in the provided text.
```

--------------------------------

### Parse Python Classes from Directory and File

Source: https://context7.com/bartlomiejcieszkowski/syrenka/llms.txt

Extract class definitions from Python files using PythonModuleAnalysis. Supports recursive directory traversal, pattern-based inclusion/exclusion, and automatic project structure detection. Returns parsed class objects that can be used for diagram generation.

```python
classes = PythonModuleAnalysis.classes_in_path(
    path=Path("./src"),
    module_name=None,  # Optional module name prefix
    recursive=True,  # Include subdirectories
    detect_project_dir=True,  # Auto-detect src/ folder structure
    exclude=["tests/", "__pycache__/"],  # Exclude patterns
    only=["models/", "services/"],  # Only include patterns
    globals_as_class=False  # Wrap module-level functions
)

# Parse single file
single_file_classes = PythonModuleAnalysis.classes_in_path(
    path=Path("./myfile.py"),
    recursive=False
)

# Use parsed classes
from syrenka.classdiagram import SyrenkaClassDiagram
diagram = SyrenkaClassDiagram("Codebase Structure")
diagram.add_classes(classes)
```

--------------------------------

### Create Flowchart Nodes and Edges

Source: https://context7.com/bartlomiejcieszkowski/syrenka/llms.txt

Programmatically build flowcharts by creating individual nodes with various shapes and edges with custom labels and types. Supports multiple node shapes (stadium, rhombus, circle) and edge types (arrow, dotted, cross) for detailed flowchart control and connections.

```python
import syrenka.flowchart as sf

# Create nodes with text and shapes
node1 = sf.Node(identifier="n1", text="Start Process", shape=sf.NodeShape.STADIUM_SHAPED_NODE)
node2 = sf.Node(identifier="n2", text="Check Condition", shape=sf.NodeShape.RHOMBUS)
node3 = sf.Node(identifier="n3", text="End", shape=sf.NodeShape.CIRCLE)

# Create edges with text labels
edge1 = sf.Edge(
    edge_type=sf.EdgeType.ARROW_EDGE,
    text="success",
    source=node1,
    target=node2
)

edge2 = sf.Edge(
    edge_type=sf.EdgeType.DOTTED_LINK,
    text="failure",
    source=node2,
    target=node3
)

# Build flowchart
flowchart = sf.SyrenkaFlowchart("Process Flow", sf.FlowchartDirection.TB)
flowchart.add(node1)
flowchart.add(node2)
flowchart.add(node3)

# Add edges via connect method
flowchart.connect(node1, node2, sf.EdgeType.ARROW_EDGE, "normal flow")
flowchart.connect(node2, node3, sf.EdgeType.CROSS_EDGE, "error")
```

--------------------------------

### Generate UML Class Diagrams from Python Modules

Source: https://context7.com/bartlomiejcieszkowski/syrenka/llms.txt

Shows how to generate UML class diagrams from Python modules using runtime introspection. It configures the diagram theme and adds classes from a specified module, including nested ones. The output can be directed to stdout or a file.

```python
import sys
from syrenka.base import ThemeNames
from syrenka.classdiagram import SyrenkaClassDiagram, SyrenkaClassDiagramConfig
from syrenka.lang.python import PythonModuleAnalysis

# Configure diagram with theme
config = SyrenkaClassDiagramConfig().theme(ThemeNames.NEUTRAL)
class_diagram = SyrenkaClassDiagram("syrenka class diagram", config)

# Add classes from a module (including nested modules)
class_diagram.add_classes(
    PythonModuleAnalysis.classes_in_module(module_name="syrenka", nested=True)
)

# Output to stdout
class_diagram.to_code(file=sys.stdout)

# Alternative: output to file
# with open("diagram.md", "w") as f:
#     class_diagram.to_code(file=f)
```

--------------------------------

### Organize Flowcharts with Subgraphs

Source: https://context7.com/bartlomiejcieszkowski/syrenka/llms.txt

Create hierarchical flowchart structures using subgraphs with independent directional configurations. Enables connecting nodes across subgraphs, searching nested structures by ID, and removing nodes with associated edges.

```python
import syrenka.flowchart as sf

# Create main flowchart
flowchart = sf.SyrenkaFlowchart("System Architecture", sf.FlowchartDirection.TB)

# Create subgraph for frontend
frontend = sf.Subgraph(
    identifier="frontend",
    text="Frontend Services",
    direction=sf.FlowchartDirection.LR
)
frontend.add(sf.Node("ui", "UI Layer"))
frontend.add(sf.Node("api", "API Client"))

# Create subgraph for backend
backend = sf.Subgraph(
    identifier="backend",
    text="Backend Services",
    direction=sf.FlowchartDirection.LR
)
backend.add(sf.Node("server", "Web Server"))
backend.add(sf.Node("db", "Database", sf.NodeShape.CYLINDRICAL_SHAPE))

# Add subgraphs to flowchart
flowchart.add(frontend)
flowchart.add(backend)

# Connect nodes across subgraphs
flowchart.connect_by_id("api", "server")
flowchart.connect_by_id("server", "db")

# Get node by ID from nested structure
node = flowchart.get_by_id("db")  # Searches through all subgraphs

# Remove node (and associated edges)
flowchart.remove(node)
```

--------------------------------

### Define Node Appearance with NodeShape Enum

Source: https://context7.com/bartlomiejcieszkowski/syrenka/llms.txt

Demonstrates the use of the `NodeShape` enum in Syrenka to specify the visual appearance of flowchart nodes. It lists various available shapes, from default rectangles to circles, hexagons, and more complex forms.

```python
import syrenka.flowchart as sf

# Available shapes
shapes = [
    sf.NodeShape.DEFAULT,          # []
    sf.NodeShape.ROUND_EDGES,      # ()
    sf.NodeShape.STADIUM_SHAPED_NODE,  # ([])
    sf.NodeShape.SUBROUTINE_SHAPE,     # [[]]
    sf.NodeShape.CYLINDRICAL_SHAPE,    # [()]
    sf.NodeShape.CIRCLE,               # (()))
    sf.NodeShape.RHOMBUS,              # {}
    sf.NodeShape.HEXAGON_NODE,         # {{}}
    sf.NodeShape.PARALLELOGRAM,        # [//]
    sf.NodeShape.TRAPEZOID,            # [/\\]
    sf.NodeShape.DOUBLE_CIRCLE,        # ((()))
]


```

--------------------------------

### Introspect Python Module Classes for Class Diagrams

Source: https://context7.com/bartlomiejcieszkowski/syrenka/llms.txt

Details how to use `PythonModuleAnalysis.classes_in_module` to extract class information from Python modules. It covers options for including nested modules and how to integrate the extracted class data into a Syrenka class diagram.

```python
from syrenka.lang.python import PythonModuleAnalysis

# Get all classes from a module (non-nested)
classes = PythonModuleAnalysis.classes_in_module(
    module_name="mypackage.mymodule",
    nested=False
)

# Get classes including submodules
all_classes = PythonModuleAnalysis.classes_in_module(
    module_name="mypackage",
    nested=True
)

# Use with class diagram
from syrenka.classdiagram import SyrenkaClassDiagram
diagram = SyrenkaClassDiagram("Module Classes")
diagram.add_classes(all_classes)
```

--------------------------------

### Define Flowchart Direction with FlowchartDirection Enum

Source: https://context7.com/bartlomiejcieszkowski/syrenka/llms.txt

Shows how to use the `FlowchartDirection` enum in Syrenka to control the orientation of flowchart elements. The available directions are TOP_TO_BOTTOM (TB), LEFT_TO_RIGHT (LR), BOTTOM_TO_TOP (BT), and RIGHT_TO_LEFT (RL).

```python
import syrenka.flowchart as sf

# Available directions
direction_tb = sf.FlowchartDirection.TOP_TO_BOTTOM  # "TB"
direction_lr = sf.FlowchartDirection.LEFT_TO_RIGHT  # "LR"
direction_bt = sf.FlowchartDirection.BOTTOM_TO_TOP  # "BT"
direction_rl = sf.FlowchartDirection.RIGHT_TO_LEFT  # "RL"

# Use in flowchart creation
flowchart = sf.SyrenkaFlowchart(title="My Flowchart", direction=direction_lr)
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.