diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index d55bc753..e9336889 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -7,44 +7,40 @@ on: pull_request: workflow_dispatch: -env: - HOMEBREW_NO_INSTALL_CLEANUP: 1 - jobs: build: - runs-on: macos-latest + runs-on: ubuntu-latest steps: -# - -# name: Install some tools -# run: sudo apt-get install -y libcairo2-dev libfreetype6-dev libffi-dev libjpeg-dev libpng-dev libz-dev -# - -# name: Set up Homebrew -# id: set-up-homebrew -# uses: Homebrew/actions/setup-homebrew@master - - - name: Install Python - uses: actions/setup-python@v5 - with: - python-version: '3.13' - name: Set up Git repository uses: actions/checkout@v4 with: fetch-depth: 0 - - name: Cache asdf installations - uses: actions/cache@v4 + name: Install system dependencies + run: | + sudo apt-get update + sudo apt-get install -y \ + libcairo2-dev \ + libpango1.0-dev \ + libfreetype6-dev \ + libffi-dev \ + libjpeg-dev \ + libpng-dev \ + zlib1g-dev \ + graphviz \ + libgraphviz-dev + - + name: Install Python + uses: actions/setup-python@v5 with: - path: | - ~/.asdf/installs - ~/.asdf/plugins - ~/.asdf/shims - key: ${{ runner.os }}-asdf-${{ hashFiles('.tool-versions') }} - restore-keys: | - ${{ runner.os }}-asdf- + python-version: '3.14' + - + name: Install uv + run: pip install uv - name: Cache uv dependencies - uses: actions/cache@v4 + uses: actions/cache@v5 with: path: | ~/.cache/uv @@ -52,14 +48,9 @@ jobs: key: ${{ runner.os }}-uv-${{ hashFiles('uv.lock', 'pyproject.toml') }} restore-keys: | ${{ runner.os }}-uv- - - - name: Install asdf & tools - uses: asdf-vm/actions/install@v4 - name: Install all MkDocs dependencies - run: | - # echo "/home/linuxbrew/.linuxbrew/bin/brew" >> $GITHUB_PATH - make --environment-overrides docs-install-github-actions + run: make --environment-overrides docs-install-github-actions - name: Build Site # Build runs on all branches and PRs to validate changes diff --git a/.gitignore b/.gitignore index e1bf98eb..8ee2049b 100644 --- a/.gitignore +++ b/.gitignore @@ -59,3 +59,4 @@ out/ *.xdy .venv/ .pdm-python +Screenshot* diff --git a/.markdownlint.json b/.markdownlint.json new file mode 100644 index 00000000..ffa81762 --- /dev/null +++ b/.markdownlint.json @@ -0,0 +1,11 @@ +{ + "MD013": { + "line_length": 140, + "heading_line_length": 140, + "code_block_line_length": 140 + }, + "MD025": { + "front_matter_title": "" + } +} + diff --git a/.python-version b/.python-version new file mode 100644 index 00000000..1d5dadf3 --- /dev/null +++ b/.python-version @@ -0,0 +1,2 @@ +3.14.2 + diff --git a/.vscode/settings.json b/.vscode/settings.json index a49ee134..4c28511c 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,3 +1,10 @@ { - "makefile.configureOnOpen": false + "yaml.schemas": { + "https://squidfunk.github.io/mkdocs-material/schema.json": "mkdocs.yml" + }, + "yaml.customTags": [ + "tag:yaml.org,2002:python/name", + "tag:yaml.org,2002:python/object/apply" + ], + "makefile.configureOnOpen": false } diff --git a/Makefile b/Makefile index 2d00e27b..7bd77530 100644 --- a/Makefile +++ b/Makefile @@ -23,15 +23,14 @@ endif endif # -# Since we do not have asdf for Windows, we need to install these tools -# on windows in a different way. Here we assume you did that yourself in -# the local project's virtualenv directory (./.venv). +# Windows note: install the required build tools separately (outside of this Makefile), +# then run `make install` to create/use the local project's virtualenv (./.venv). # VENV_PYTHON := $(VIRTUAL_ENV)/bin/python3 UV := uv -PYTHON_VERSION := 3.13 +PYTHON_VERSION := 3.14.2 -PIPENV_DEFAULT_PYTHON_VERSION := 3.13 +PIPENV_DEFAULT_PYTHON_VERSION := 3.14.2 PIPENV_VENV_IN_PROJECT := 1 CURRENT_BRANCH := $(shell git branch --show-current) @@ -69,6 +68,10 @@ docs-install: docs-install-brew docs-install-brew-packages docs-install-python-p docs-install-github-actions: docs-install-brew-packages docs-install-python-packages info .PHONY: docs-install-brew-packages +ifeq ($(YOUR_OS), Linux) +docs-install-brew-packages: + @echo "Skip Homebrew packages on Linux (installed via apt-get in CI)" +else docs-install-brew-packages: @echo "Install packages via HomeBrew:" @brew upgrade cairo 2>/dev/null || brew install cairo @@ -80,6 +83,7 @@ docs-install-brew-packages: @brew upgrade zlib 2>/dev/null || brew install zlib @brew upgrade graphviz 2>/dev/null || brew install graphviz @brew upgrade uv 2>/dev/null || brew install uv +endif .PHONY: docs-install-brew ifeq ($(YOUR_OS), Linux) @@ -110,25 +114,8 @@ docs-install-brew-macos: @if ! command -v brew >/dev/null 2>&1 ; then echo "Install HomeBrew" ; exit 1 ; fi @brew --version -.PHONY: docs-install-asdf -docs-install-asdf: docs-install-brew - @echo "Install the asdf package manager:" - @if ! command -v asdf >/dev/null 2>&1; then \ - brew upgrade asdf 2>/dev/null || brew install asdf; \ - fi - @asdf plugin add python 2>/dev/null || true - -.PHONY: docs-install-asdf-packages -docs-install-asdf-packages: docs-install-asdf - @echo "Install packages via asdf:" - asdf install - .PHONY: docs-install-python-packages -#ifneq ($(wildcard /home/runner/.*),) -#docs-install-python-packages: docs-install-asdf -#else -docs-install-python-packages: docs-install-asdf-packages docs-install-standard-python-packages -#endif +docs-install-python-packages: docs-install-standard-python-packages .PHONY: docs-install-standard-python-packages docs-install-standard-python-packages: docs-ensure-venv @@ -183,7 +170,7 @@ docs-serve-debug-non-strict: docs-ensure-venv .PHONY: docs-deploy docs-deploy: docs-ensure-venv - $(UV) run mkdocs gh-deploy --config-file $(MKDOCS_CONFIG_FILE) --verbose + $(UV) run mkdocs gh-deploy --config-file $(MKDOCS_CONFIG_FILE) .PHONY: docs-sync-from docs-sync-from: docs-sync-from-ekg-maturity docs-sync-from-ekg-principles diff --git a/README.md b/README.md index d0e92d32..e2997772 100644 --- a/README.md +++ b/README.md @@ -2,9 +2,17 @@ Documenting the Use Case Tree method. +## Python + +This repo uses **Python 3.13+** (see `pyproject.toml`) and **uv**. + +```bash +uv sync +``` + This is an initiative of: -- agnos.ai UK Ltd -- Enterprise Knowledge Graph Foundation +- [agnos.ai UK Ltd](https://agnos.ai) +- [Object Management Group](https://omg.org) (OMG) [Enterprise Knowledge Graph Forum](https://ekgf.org) (EKGF) The content of this repository is published as https://method.ekgf.org diff --git a/docs-overrides/main.html b/docs-overrides/main.html index 5c661a1d..8250c67f 100644 --- a/docs-overrides/main.html +++ b/docs-overrides/main.html @@ -1,5 +1,11 @@ {% extends "base.html" %} + +{% block extrahead %} +{{ super() }} +{% include "partials/seo.html" %} +{% endblock %} + {% block content %} {% if page.meta.generated == True %} diff --git a/docs-overrides/partials/seo.html b/docs-overrides/partials/seo.html new file mode 100644 index 00000000..e88f0cda --- /dev/null +++ b/docs-overrides/partials/seo.html @@ -0,0 +1,92 @@ +{# SEO Meta Tags Partial #} + +{# Get page-specific description or fall back to site description #} +{% set page_description = page.meta.description if page.meta and page.meta.description else config.site_description %} + +{# Get page title #} +{% set page_title = page.title if page.title else config.site_name %} +{% set full_title = page_title + " - " + config.site_name if page_title != config.site_name else config.site_name %} + +{# Get page URL #} +{# Prefer MkDocs' canonical_url when available #} +{% set page_url = page.canonical_url if page.canonical_url else (config.site_url + page.url if page.url else config.site_url) %} + +{# Get page image (use site logo or custom image) #} +{% set page_image = config.site_url + "/assets/images/favicon.png" %} +{% if page.meta and page.meta.image %} + {% set page_image = config.site_url + page.meta.image if page.meta.image.startswith("/") else page.meta.image %} +{% endif %} + +{# Open Graph / Facebook #} + + + + + + +{% if config.site_author %} + +{% endif %} + +{# Twitter Card #} + + + + + +{% if config.extra.social %} + {% for social in config.extra.social %} + {% if "twitter" in social.link %} + + {% endif %} + {% endfor %} +{% endif %} + +{# Additional SEO meta tags #} +{% if page.meta and page.meta.keywords %} + +{% endif %} + +{# Google Search Console verification #} +{% if config.extra.google_site_verification %} + +{% endif %} + +{# JSON-LD Structured Data #} + + diff --git a/docs/assets/dikw-revised.svg b/docs/assets/dikw-revised.svg new file mode 100644 index 00000000..be993821 --- /dev/null +++ b/docs/assets/dikw-revised.svg @@ -0,0 +1,674 @@ + + + + + + + + + + + + + + + + + + + +Information + + + + + + + +Knowledge + + + + + + + +Data + + + + + + + +Behavior + + + + + + + +Reusable Use Case + + + + + + + +Composable Enterprise + + + + + + + +Wisdom + + + + + + + +i.e. Human and Agentic Understanding + + + + + + + +DIKW Model — Revised + + + + + + + +✅  + + + + + + + +❌ + + + + + + + +The Path to Executable Knowledge \ No newline at end of file diff --git a/docs/concept/.pages.yaml b/docs/concept/.pages.yaml index e96dd235..de3f5676 100644 --- a/docs/concept/.pages.yaml +++ b/docs/concept/.pages.yaml @@ -5,6 +5,7 @@ nav: - persona.md - story.md - concept.md + - term.md - outcome.md - data-product.md - ontology.md diff --git a/docs/concept/concept.md b/docs/concept/concept.md index 1d7e2baa..808b9f03 100644 --- a/docs/concept/concept.md +++ b/docs/concept/concept.md @@ -1,27 +1,277 @@ +--- +description: "A domain term or idea that links business language to semantic models, enabling the Enterprise Knowledge Graph to understand and reason about business concepts. Learn how concepts bridge business and technical domains in the Use Case Tree Method." +keywords: + - concept + - domain concept + - business concept + - semantic model + - EKG method + - enterprise knowledge graph +schema_type: "Article" +--- + # Concept -For every given Use Case we want to start with capturing the concepts and -terms that the user or "the business" uses or wants to use. - -Most of these concepts and their terms will be pre-defined in all kinds of -vocabularies but for brand-new use cases in a new domain concepts and their -terms will have to be created. - -At the initial stages of a use case, the focus should be on capturing the -language of the users in their domain, which may not necessarily involve -discussing ontologies. -The main goal is to gather requirements and understand the problem context, -as well as the terms and concepts used by the users. -Later in the use case's life cycle, once the problem is well understood, -the relevant ontologies can be mapped to the terms and concepts captured earlier. -This allows for better integration of the use case with the overall EKG ecosystem. - -As the use case evolves and the understanding of the domain becomes clearer, -it may be necessary to adjust the captured concepts and terms to better -reflect the reality of the domain. -, it may be necessary to map the captured concepts and terms to more appropriate -terms in a specific ontology or vocabulary to ensure consistency and interoperability -across the enterprise. -In either case, the important thing is to ensure that the captured concepts and -terms accurately reflect the reality of the domain and the needs of the stakeholders. + +_A domain term or idea that links business language to semantic models, +enabling the Enterprise Knowledge Graph to understand and reason about +business concepts_ + + +=== "Business & Management Audience" + + ## What Is a Concept? + + For every given [Use Case](use-case.md), we want to start with + capturing the concepts and terms that the user or "the business" + uses or wants to use. + + A **Concept** is a way to represent a business idea or term in a + way that both humans and machines can understand. + It serves as a bridge between the language your organization uses + and the formal semantic models (ontologies) that enable the + Enterprise Knowledge Graph to reason about your business. + + ## Why Concepts Matter + + Concepts ensure that: + + - **Business language is preserved** — We capture terms as the + business uses them, not as some external standard defines them + - **Semantic meaning is enabled** — Concepts link to ontologies + that give them machine-readable meaning + - **Consistency is maintained** — The same concept can be reused + across multiple use cases + - **Interoperability is achieved** — Concepts can map to + multiple ontologies, enabling integration across systems + + !!! tip "Start with business language" + + Don't worry about ontologies in the early stages. + Focus on capturing what the business calls things and what + those things mean in their context. + + ## Concept Vocabulary + + Most concepts and their terms will be pre-defined in all kinds of + vocabularies, but for brand-new use cases in a new domain, + concepts and their terms will have to be created. + + Each Use Case can have its own vocabulary of concepts, but it can + also inherit or borrow concepts from higher-level or related use + cases in the [Use Case Tree](use-case-tree.md). + This enables reuse and consistency across the enterprise. + + ## Evolution and Refinement + + As the use case evolves and the understanding of the domain + becomes clearer, it may be necessary to: + + - **Adjust concepts** — Better reflect the reality of the domain + - **Map to ontologies** — Link concepts to more appropriate + terms in specific ontologies or vocabularies to ensure + consistency and interoperability across the enterprise + + In either case, the important thing is to ensure that the + captured concepts and terms accurately reflect the reality of the + domain and the needs of the stakeholders. + +=== "Data & Tech Audience" + + ## What Is a Concept in the Use Case Tree Method? + + A **Concept** is the linking pin between local business language + and formal semantic models (ontologies). + It enables the EKG to understand business terminology while + maintaining connections to standardized vocabularies and enabling + automated reasoning. + + ## The Concept Lifecycle + + ### Initial Capture + + At the initial stages of a use case, the focus should be on + capturing the language of the users in their domain, which may not + necessarily involve discussing ontologies. + The main goal is to gather requirements and understand the + problem context, as well as the terms and concepts used by the + users. + + !!! tip "Business-first approach" + + Start with what the business calls things, not what some + ontology says they should be called. + The business owns its use cases and should recognize them + throughout their lifecycle. + + ### Mapping to Ontologies + + Later in the use case's lifecycle, once the problem is well + understood, the relevant ontologies can be mapped to the terms and + concepts captured earlier. + This allows for better integration of the use case with the + overall EKG ecosystem. + + ### Refinement and Evolution + + As the use case evolves and the understanding of the domain + becomes clearer, it may be necessary to: + + - **Adjust captured concepts** — Better reflect the reality of + the domain + - **Map to appropriate ontologies** — Link to more appropriate + terms in specific ontologies or vocabularies to ensure + consistency and interoperability across the enterprise + + ## Concept Types + + Concepts can represent different types of semantic elements: + + - **Class Concepts** — Represent types or categories (e.g., + "Person", "Account", "Transaction") + - **Property Concepts** — Represent relationships or attributes + (e.g., "hasOwner", "isLocatedIn", "hasValue") + - **Shape Concepts** — Represent validation constraints or data + shapes + + ## Concepts as Linking Pins + + Concepts are the linking pin in many ways. + They link "business terms" and "technical terms" as they are + used in the context of the given use case, by the business and + by various programs, apps, and systems, in all their variations + and manifestations. + + **Example:** + The official term for Customer could be "Customer," but it + appears in different forms: + - On forms in apps as "Cust." + - In Python code as `_customer` + - In SPARQL statements as `?cust` + - In database schemas as `cust_id` or `customer_id` + - In API endpoints as `/customers` or `/api/cust` + - In OWL ontologies as specific axioms (e.g., `owl:Class` or + `rdfs:subClassOf` relationships) + - In SHACL shapes as validation constraints (e.g., `sh:property` + or `sh:minCount`) + + All these symbols, terms, axioms, and shapes are manifestations + of the same concept and linked to it. + Even the mapping to certain axioms in an OWL ontology or + certain shapes in a SHACL shape would be seen as "technical + terms" — just yet some other manifestations of a given concept. + + This enables the EKG to understand that these different + representations all refer to the same business concept, enabling + semantic integration across diverse systems and technologies. + + ## Relationship to Ontologies + + Concepts serve as a bridge between: + + - **Local business terminology** — The language used within a + specific use case or domain + - **Technical manifestations** — How concepts appear in code, + databases, APIs, forms, and other systems + - **Standard ontologies** — Formal semantic models that enable + interoperability and reasoning + + This multi-faceted nature allows the EKG to: + - Address "the business" with their language + - Integrate with technical systems using their terminology + - Keep backend EKG models generic and linked to appropriate + ontologies + - Model semantic conundrums (e.g., different terms for the same + concept, same term for different concepts) + + ## Reuse and Inheritance + + Concepts follow the same reuse patterns as other elements in the + Use Case Tree Method: + + - **Local definition** — Each use case can define concepts + specific to its domain + - **Inheritance** — Lower-level use cases inherit concepts from + parent use cases in the Use Case Tree + - **Borrowing** — Use cases can reference concepts from related + use cases + - **Consistency** — Common concepts are defined once and reused + + This ensures that concepts are not duplicated unnecessarily and + that the EKG maintains semantic consistency across the enterprise. + + ## Relationship to Other Concepts + + Concepts are fundamental building blocks that relate to: + + - **[Use Cases](use-case.md)** — Each use case has a vocabulary + of concepts + - **[Personas](persona.md)** — Personas are Concepts, enabling + semantic definition and reasoning + - **[Stories](story.md)** — Stories reference domain concepts + that need to be understood and modeled + - **[Ontologies](ontology.md)** — Concepts link to ontology + classes, properties, and shapes + +=== "Ontology" + + ## Ontology (minimal facts we can state today) + + --8<-- "fragment/uctm-diagram-concept.md" + + We're not (yet) prescribing a full OWL ontology here. + But we can state a small set of **facts** that people can reliably use to build their own + ontology / schema / graph model around a Concept. + + ### Required facts about a Concept + + - **Opaque universally unique identifier** + - A Concept must have an **opaque**, **universally unique** identifier. + - Prefer a random identifier such as **UUIDv4**. + - Represent it as a URI, for example: + `urn:uuid:550e8400-e29b-41d4-a716-446655440000` + + - **Slug** + - A Concept should have a kebab-cased slug. + - Slug uniqueness cannot be guaranteed, but it can be used as a convenient alternative + identifier next to the real identifier (with lookup/search). + - Do **not** use the slug as a foreign key in the Knowledge Graph itself; use the real + identifier for references. + + - **Label Term (instead of a traditional label)** + - A Concept does not have a traditional label such as `skos:prefLabel` or `rdfs:label`. + - Instead, it has a **labelTerm** link to one of its **BusinessTerm** objects (a resource + in the Knowledge Graph). + - Learn more in [Term](term.md). + + - **Definition** + - A Concept must have a business-focused definition explaining what it means in context. + + - **One or more Terms (required)** + - A Concept must have **one or more Terms** (`Term`), which can be either a + **BusinessTerm** or a **TechnicalTerm**. + - A Concept without a Term has no reason to exist. + - All Terms of a Concept **mean the same thing** in the context of that Concept. + - Terms may include alternative spellings, abbreviations, synonyms, and technical + manifestations. + - Terms are **owned** by the Concept (part-of): when the Concept is deleted, its Term + objects are deleted as well. + - Learn more in [Term](term.md). + + - **Contained in a Concept Vocabulary** + - A Concept is a member of a Concept Vocabulary (a “container” of Concepts). + - A Use Case can relate to Concept Vocabularies via relationship-objects: + - it can **reference** an external vocabulary and/or + - **own** a private vocabulary. + + - **Mapping to ontologies (optional)** + - A Concept can be mapped/aligned to terms in one or more ontologies (classes, + properties, shapes). + - Model this via mapping/alignment relationships so you can capture confidence, rationale, + and provenance. + + - **Used by Stories and Workflows** + - Stories use Concepts as **input**, **output**, and **dependent** concepts. + - Workflows use Concepts through the Stories they orchestrate and the vocabulary of the + Use Case. diff --git a/docs/concept/data-product.md b/docs/concept/data-product.md index 3faebaf2..2f27ce78 100644 --- a/docs/concept/data-product.md +++ b/docs/concept/data-product.md @@ -1,10 +1,319 @@ +--- +description: "A semantic data product that provides required information for a Use Case, selected based on semantic relevance and suitability. Learn how data products enable reuse in the Use Case Tree Method." +keywords: + - data product + - semantic data product + - data asset + - EKG method + - enterprise knowledge graph + - data reuse +schema_type: "Article" +--- + # Data Product -In later stages of the use case life-cycle, we can attach the use case to those -semantic data products that already exist and can provide the required information -for the use case. -However, it's important to note that the choice of semantic data products to -be used for a given use case should be made based on their semantic relevance -and suitability to the use case's requirements. + +_A semantic data product that provides required information for a Use +Case, selected based on semantic relevance and suitability to the +use case's requirements_ + + +=== "Business & Management Audience" + + ## What Is a Data Product? + + A **Data Product** is a semantic data asset that provides the + required information for a [Use Case](use-case.md). + In later stages of the use case lifecycle, we can attach the use + case to those semantic data products that already exist and can + provide the required information. + + Data Products are reusable components that encapsulate data, + along with its meaning (semantics), making it available for use + across multiple use cases. + + ## The Data Economy + + Think of your entire data landscape or ecosystem as a **data + economy** — like any economy, it has a supply side and a demand + side. + + - **Supply side** — Data Products define what data is available, + how it's packaged, and how it can be accessed. + They represent the "supply" in the data economy. + - **Demand side** — [Use Cases](use-case.md) define who needs + data, what they need it for, and why. + They represent the "demand" in the data economy. + + People often understand Data Products (the supply side), but + struggle with "what's the demand?" + Who uses these data products, and for what reasons? + That's where Use Cases come in: a Use Case defines the demand + side, specifying what data is needed and why. + + This economic model helps organizations understand the flow of + data, identify gaps between supply and demand, and ensure that + data products are created to meet actual business needs. + + ## Why Data Products Matter + + Data Products enable: + + - **Reuse** — Data can be packaged once and reused across + multiple use cases + - **Consistency** — The same data product ensures consistent + meaning and structure across use cases + - **Efficiency** — Avoids duplicating data preparation and + transformation work + - **Quality** — Data products are designed, tested, and + maintained as reusable assets + + !!! tip "Semantic relevance matters" + + The choice of data products for a use case should be based + on their semantic relevance and suitability to the use case's + requirements, not just technical availability. + + ## When Are Data Products Used? + + Data Products are typically identified and attached to use cases + in later stages of the lifecycle, once: + + - The use case requirements are well understood + - The data needs are clearly defined + - Existing data products can be evaluated for suitability + + This allows use cases to leverage existing, proven data products + rather than creating new ones from scratch. + +=== "Data & Tech Audience" + + ## What Is a Data Product in the Use Case Tree Method? + + A **Data Product** is a semantic data asset that provides + required information for a [Use Case](use-case.md). + It encapsulates data along with its semantic meaning (defined + through [Ontologies](ontology.md)), making it a reusable + component in the Enterprise Knowledge Graph. + + ## Semantic Data Products + + Data Products in the Use Case Tree Method are **semantic** — they include: + + - **Data** — The actual data values + - **Semantics** — The meaning of the data, defined through + ontologies + - **Structure** — How the data is organized + - **Metadata** — Information about the data product itself + + This semantic nature enables the EKG to understand what the data + means, not just what it contains. + + ## Selection Criteria + + The choice of semantic data products to be used for a given use + case should be made based on: + + - **Semantic relevance** — Does the data product contain + concepts and terms that match the use case's vocabulary? + - **Suitability** — Does the data product meet the use case's + requirements? + - **Quality** — Is the data product well-maintained and + reliable? + - **Availability** — Is the data product accessible and + performant? + + !!! tip "Semantic matching" + + The most important criterion is semantic relevance — the + data product should align with the use case's concepts and + terminology, enabling semantic integration. + + ## Lifecycle Integration + + In later stages of the use case lifecycle, we can attach the use + case to those semantic data products that already exist and can + provide the required information. + + This approach: + + - **Promotes reuse** — Leverages existing data products rather + than creating new ones + - **Ensures consistency** — Multiple use cases can use the same + data product, ensuring consistent data + - **Reduces effort** — Avoids duplicating data preparation work + - **Maintains quality** — Uses proven, tested data products + + ## Relationship to Other Concepts + + Data Products relate to other core concepts: + + - **[Use Cases](use-case.md)** — Use cases consume data + products to fulfill their requirements + - **[Ontologies](ontology.md)** — Data products use ontologies + to define the semantic meaning of their data + - **[Concepts](concept.md)** — Data products contain data about + concepts that are relevant to use cases + - **[Stories](story.md)** — Stories may require specific data + products to fulfill their needs + + This integration ensures that data products are not isolated + assets but part of a cohesive, semantic model of the enterprise. + + ## Reuse and Composition + + Data Products are designed for reuse across multiple use cases. + This enables: + + - **Composition** — Use cases can combine multiple data products + to meet their requirements + - **Consistency** — The same data product ensures consistent + meaning across use cases + - **Efficiency** — Data preparation is done once and reused + many times + - **Maintainability** — Changes to a data product benefit all + use cases that use it + + This reuse pattern aligns with the [composable + business](../objective/composable-business.md) approach, where + data products become reusable components in the Enterprise + Knowledge Graph. + +=== "DPROD Ontology" + + ## What Is DPROD? + + The **Data Product Ontology (DPROD)** is a specification developed + by the Object Management Group (OMG) Enterprise Knowledge Graph Forum (EKGF) that provides + a standardized way to describe Data Products using W3C Linked Data + standards. + DPROD is available at + [https://ekgf.github.io/dprod/](https://ekgf.github.io/dprod/). + + DPROD builds on the W3C Data Catalog Vocabulary (DCAT) to enable + publishers to describe Data Products and data services in a + decentralized way. + By using a standard model and ontology, DPROD facilitates the + consumption and aggregation of metadata from multiple Data + Marketplaces, increasing discoverability and enabling federated + search. + + ## Why DPROD? + + As organizations increasingly recognize the value of data as an + asset and adopt decentralized data architectures (such as Data + Mesh), the need for standardized methods to describe and manage + data products consistently across platforms has become critical. + + Without such a standard, organizations face: + - Inconsistent metadata across diverse data products + - Limited discoverability + - Interoperability issues that hinder data integration + - Difficulty scaling as data ecosystems grow + - Increased vendor lock-in + + DPROD offers a solution by providing a clear schema for describing + data products, ensuring they are discoverable, interoperable, + and treated with the same level of accountability as traditional + products. + + ## DPROD Principles + + DPROD follows two basic principles: + + - **Decentralize Data Ownership** — To make data integration + more efficient, tasks should be shared among multiple teams. + DCAT helps by offering a standard way to publish datasets in a + decentralized manner. + - **Harmonize Data Schemas** — Using shared schemas helps unify + different data formats. + DPROD provides a common set of rules for defining a Data + Product, which users can extend as needed. + + ## DPROD Model + + The DPROD specification extends DCAT to connect Data Services to + Data Products using input and output ports. + These ports are used to publish and consume data from a Data + Product. + + The model consists of: + + - **Data Product** (`dprod:DataProduct`) — A rational, managed, + and governed collection of data, with purpose, value, and + ownership, meeting consumer needs over a planned lifecycle + - **Port** (`dcat:DataService`) — A digital interface that + provides access to a Dataset (input or output port) + - **Distribution** (`dcat:Distribution`) — A specific + representation of a dataset (CSV, JSON, Parquet, etc.) which + can conform to a physical model + - **Dataset** (`dcat:Dataset`) — A collection of related data + that can conform to a logical model + + Data Products can have: + - **Input ports** — Services that collect source data and make + it available for transformation + - **Output ports** — Services that share generated data in a way + that can be understood and trusted + - **Lifecycle status** — Development status (e.g., Ideation, + Design, Build, Deploy, Consume) + - **Owner** — The agent accountable for the data product + - **Domain** — The business or information area supported + - **Purpose** — Objectives and intended usage + + ## Relationship to Use Case Tree Method + + DPROD provides a standardized way to describe Data Products that + aligns with the Use Case Tree Method's approach: + + - **Semantic description** — DPROD uses ontologies to describe + the semantic meaning of data products + - **Reuse and composition** — DPROD enables data products to be + discovered and composed + - **Lifecycle management** — DPROD tracks the lifecycle status + of data products + - **Decentralized architecture** — DPROD supports decentralized + data ownership and management + + When implementing Data Products in the Use Case Tree Method, DPROD can be + used to provide standardized metadata that enables discovery, + integration, and governance across the enterprise. + + ## Key Features + + DPROD enables: + + - **Unambiguous semantics** — Provides clear, sharable semantics + to answer "What is a data product?" + - **Simplicity and expressiveness** — Simple enough for anyone + to use, but expressive enough to power large data marketplaces + - **Reuse of existing infrastructure** — Allows organizations to + reuse their existing data catalogues and dataset infrastructure + - **Harmonization** — Shares common semantics across different + Data Products, promoting consistency + + For more details, examples, and the complete specification, see + the [DPROD documentation](https://ekgf.github.io/dprod/). + + !!! important "Data Products as Use Cases" + + A **Data Product is basically just another Use Case** — with + its own stereotype. + You can stereotype a use case as a "data-product" or as an + "upstream data-source" or "downstream data-sink," or whatever + categorization you prefer. + But fundamentally, a data product can be seen as just another + use case. + + This unified model means that: + - Data Products follow the same lifecycle as Use Cases + - They can be organized in the [Use Case + Tree](use-case-tree.md) + - They have the same components: Personas, Stories, Concepts, + Outcomes + - They enable the same composability and reuse patterns + + The stereotype simply indicates the primary purpose or role of + that use case in the data economy. diff --git a/docs/concept/ontology.md b/docs/concept/ontology.md index 7dda4c53..1df5c1d8 100644 --- a/docs/concept/ontology.md +++ b/docs/concept/ontology.md @@ -1,16 +1,195 @@ +--- +description: "A formal, machine-readable specification of concepts and their relationships that bridges the gap between demand (Use Cases) and supply (Data Products). Learn how ontologies enable semantic interoperability in the Use Case Tree Method." +keywords: + - ontology + - semantic model + - knowledge representation + - EKG method + - enterprise knowledge graph + - data modeling +schema_type: "Article" +--- + # Ontology -The ontologies act as a crucial intermediary between the demand and supply sides -of the information economy. + +_A formal, machine-readable specification of concepts and their +relationships that bridges the gap between demand (Use Cases) and +supply (Data Products) in the data economy_ + + +=== "Business & Management Audience" + + ## What Is an Ontology? + + An **Ontology** is a formal specification of concepts and their + relationships that provides a common language for describing + business knowledge. + In the context of the Enterprise Knowledge Graph, ontologies act + as a crucial intermediary between the demand and supply sides of + the information economy. + + ## The Role of Ontologies in the Data Economy + + Think of the data economy as having two sides: + + - **Demand side** — [Use Cases](use-case.md) represent the + demands for information from various stakeholders. + They define what data is needed and why. + - **Supply side** — [Data Products](data-product.md) represent + the supply of information. + They define what data is available and how it can be accessed. + + **Ontologies bridge the gap** between these two sides by + providing a common language that can be used to describe the + [Concepts](concept.md) and relationships relevant to both the + demand and supply sides. + + !!! tip "Common language" + + Ontologies enable use cases and data products to "speak the + same language," making it possible to match what's needed with + what's available. + + ## Why Ontologies Matter + + Ontologies enable: + + - **Semantic integration** — Different systems can understand + each other's data because they share the same semantic model + - **Reuse** — Concepts defined once in an ontology can be reused + across multiple use cases and data products + - **Consistency** — Ensures that the same concept means the same + thing everywhere + - **Automated reasoning** — Machines can understand and reason + about business concepts + - **Interoperability** — Enables integration across diverse + systems and technologies + + This enables a more efficient and effective exchange of + information, allowing organizations to better leverage their data + assets and achieve their business objectives. + +=== "Data & Tech Audience" + + ## What Is an Ontology in the Use Case Tree Method? + + An **Ontology** is a formal, machine-readable specification of + concepts and their relationships, typically expressed using + standards like OWL (Web Ontology Language) or SHACL (Shapes + Constraint Language). + + In the Use Case Tree Method, ontologies serve as the semantic foundation + that enables the Enterprise Knowledge Graph to understand and + reason about business concepts. + + ## Ontologies as Intermediaries + + Ontologies act as a crucial intermediary between the demand and + supply sides of the information economy: + + - **Demand side** — [Use Cases](use-case.md) represent the + demands for information from various stakeholders. + They define what data is needed and why. + - **Supply side** — [Data Products](data-product.md) represent + the supply of information. + They define what data is available and how it can be accessed. + + The ontologies help bridge the gap between these two sides by + providing a common language that can be used to describe the + concepts and relationships relevant to both the demand and supply + sides. + + ## How Ontologies Bridge the Gap + + Ontologies enable semantic matching between use cases and data + products: + + 1. **Use Cases define concepts** — Each use case has a + vocabulary of [Concepts](concept.md) that represent the + domain knowledge it needs + 2. **Concepts link to ontologies** — Concepts are linked to + ontology classes, properties, and shapes that define their + semantic meaning + 3. **Data Products conform to ontologies** — Data products + specify which ontologies their datasets conform to + 4. **Semantic matching** — The EKG can match use cases to data + products based on shared ontology concepts + + This semantic matching enables the EKG to automatically discover + which data products can fulfill the requirements of a given use + case. + + ## Ontology Standards + + Ontologies in the Use Case Tree Method typically use: + + - **OWL (Web Ontology Language)** — For defining classes, + properties, and relationships with rich logical expressivity + - **SHACL (Shapes Constraint Language)** — For defining + validation constraints and data shapes + - **RDFS (RDF Schema)** — For basic class and property + hierarchies + + These standards enable: + + - **Machine readability** — Ontologies can be processed by + automated systems + - **Reasoning** — Automated reasoners can infer new knowledge + from ontology definitions + - **Validation** — Data can be validated against ontology + constraints + - **Interoperability** — Different systems can share and reuse + ontology definitions + + ## Relationship to Concepts + + [Concepts](concept.md) serve as the linking pin between business + language and ontologies: + + - **Business language** — Concepts capture the terms and ideas + that the business uses + - **Ontology mapping** — Concepts link to ontology classes, + properties, and shapes that define their semantic meaning + - **Multiple mappings** — A single concept can map to multiple + ontologies, enabling integration across different standards + + This dual nature allows the EKG to address "the business" with + their language while maintaining formal semantic models that + enable automated reasoning and integration. + + ## Reuse and Standardization + + Ontologies enable reuse and standardization: + + - **Standard ontologies** — Organizations can use existing + standard ontologies (e.g., FIBO, CDM, schema.org) rather than + creating everything from scratch + - **Domain ontologies** — Domain-specific ontologies can be + created and reused across use cases in the same domain + - **Extension** — Standard ontologies can be extended to meet + specific organizational needs + - **Composition** — Multiple ontologies can be combined to + create comprehensive semantic models + + This reuse ensures consistency across the enterprise and enables + interoperability with external systems and standards. + + ## Relationship to Other Concepts + + Ontologies relate to other core concepts: -On one hand, we have the use cases that represent the demands for information -from various stakeholders, and on the other hand, we have the semantic data products -that represent the supply of information. + - **[Concepts](concept.md)** — Concepts link to ontology + classes, properties, and shapes to define their semantic + meaning + - **[Use Cases](use-case.md)** — Use cases have vocabularies of + concepts that link to ontologies + - **[Data Products](data-product.md)** — Data products specify + which ontologies their datasets conform to + - **[Personas](persona.md)** — Personas are Concepts that link + to ontology classes, enabling semantic definition -The ontologies help bridge the gap between these two sides by providing a common -language that can be used to describe the concepts and relationships relevant to -both the demand and supply sides. -This enables a more efficient and effective exchange of information, -allowing organizations to better leverage their data assets and achieve -their business objectives. + This integration ensures that ontologies are not isolated + specifications but part of a cohesive, semantic model of the + enterprise. diff --git a/docs/concept/outcome.md b/docs/concept/outcome.md index 5426451c..10af3d68 100644 --- a/docs/concept/outcome.md +++ b/docs/concept/outcome.md @@ -1,13 +1,256 @@ +--- +description: "The specific result or benefit that an organization expects to achieve from a Use Case, providing the 'why' behind every business requirement. Learn how outcomes drive business value in the Use Case Tree Method." +keywords: + - outcome + - business outcome + - use case outcome + - EKG method + - enterprise knowledge graph +schema_type: "Article" +--- + # Outcome -A business outcome is the specific result or benefit that an organization expects -to achieve from a particular use case. -It is the reason why the use case exists and what it aims to accomplish. -Business outcomes can vary depending on the use case and the organization's goals, -but they should always align with the broader strategy and objectives of the -enterprise. -Measuring and tracking business outcomes is essential for evaluating the effectiveness -of a use case and its contribution to the overall success of the organization. + +_The specific result or benefit that an organization expects to achieve +from a Use Case, providing the "why" behind every business requirement_ + + +=== "Business & Management Audience" + + ## What Is an Outcome? + + A **business outcome** is the specific result or benefit that an + organization expects to achieve from a particular [Use + Case](use-case.md). + It is the reason why the use case exists and what it aims to + accomplish. + + Outcomes answer the fundamental question: **"Why are we doing + this?"** + They provide the business justification for investing time, + resources, and effort into a use case. + + ## Why Outcomes Matter + + Outcomes ensure that: + + - **Purpose is clear** — Everyone understands why the use case + exists and what it's trying to achieve + - **Alignment is maintained** — Use cases contribute to broader + strategy and objectives + - **Success can be measured** — Outcomes provide criteria for + evaluating effectiveness + - **Value is demonstrated** — Clear outcomes show how use cases + contribute to organizational success + + !!! tip "Start with outcomes" + + Before defining what a use case does, understand why it + exists. + The outcome defines success and guides all decisions about + implementation. + + ## Outcome Characteristics + + Business outcomes can vary depending on the use case and the + organization's goals, but they should always: + + - **Align with strategy** — Support the broader strategy and + objectives of the enterprise + - **Be measurable** — Provide clear criteria for success + - **Be achievable** — Realistic given available resources and + constraints + - **Be valuable** — Deliver meaningful benefit to the + organization + + ## Examples + + Examples of business outcomes include: + + - **Risk Assessment** — "Assess the Risk" (from a risk + management use case) + - **Stakeholder Verification** — "Verify Stakeholders" (from an + audit use case) + - **Operational Efficiency** — "Reduce processing time by 50%" + - **Compliance** — "Ensure regulatory compliance" + - **Customer Satisfaction** — "Improve customer experience" + + Notice how outcomes appear in [Stories](story.md) as the "why" + part: "...so that I can Assess the Risk" or "...so that I can + Verify Stakeholders." + + ## Measuring Outcomes + + Measuring and tracking business outcomes is essential for: + + - **Evaluating effectiveness** — Understanding whether the use + case is achieving its intended results + - **Demonstrating value** — Showing how use cases contribute to + organizational success + - **Informing decisions** — Providing data for prioritization + and resource allocation + - **Continuous improvement** — Identifying opportunities to + enhance outcomes + + Outcomes should be defined with measurable criteria from the + start, enabling ongoing evaluation throughout the use case's + lifecycle. + +=== "Data & Tech Audience" + + ## What Is an Outcome in the Use Case Tree Method? + + An **Outcome** represents the business value or benefit that a + [Use Case](use-case.md) is designed to deliver. + It is the "why" part of the [Story](story.md) structure: "As a + [Persona](persona.md), I need [capability], so that I can + [Outcome]." + + Outcomes provide the business justification and success criteria + for use cases, enabling alignment between business needs and + technical implementation. + + ## Outcome Structure + + Outcomes are expressed in business language and typically follow + patterns like: + + - **Action-oriented** — "Assess the Risk", "Verify Stakeholders" + - **Benefit-focused** — "Reduce processing time", "Improve + accuracy" + - **Value-driven** — "Increase revenue", "Ensure compliance" + + The key is that outcomes are expressed in terms the business + understands and values, not in technical terms. + + ## Outcome Stereotypes + + We can define **Outcome Stereotypes** to categorize outcomes + based on their nature or purpose. + If you want to call an outcome a "Goal", "Objective", or + "Definition of Done", that's just a stereotype of Outcome. + + Common outcome stereotypes include: + + - **Goal** — A high-level, strategic outcome + - **Objective** — A specific, measurable outcome + - **Definition of Done** — A completion criterion for a use case + or story + - **Success Criteria** — Measurable conditions that indicate + success + - **Key Result** — A quantifiable outcome that supports a goal + + These stereotypes help organize and categorize outcomes while + maintaining the fundamental concept that they all represent the + "why" behind business requirements. + The Use Case Tree Method uses "Outcome" as the base concept, with + stereotypes providing additional semantic meaning as needed. + + ## Relationship to Stories + + Outcomes are the "why" component of Stories. + Each Story specifies: + + - **Who** — The Persona who needs the capability + - **What** — The capability or action needed + - **Why** — The Outcome (the business benefit or purpose) + + This structure ensures that every requirement is tied to a clear + business outcome, preventing the implementation of features that + don't deliver value. + + ## Alignment with Strategy + + Outcomes should align with the broader strategy and objectives of + the enterprise. + This alignment ensures that: + + - **Use cases contribute to strategic goals** — Each use case + delivers outcomes that support enterprise objectives + - **Resources are prioritized** — Use cases with outcomes that + align with strategy receive appropriate priority + - **Value is maximized** — The EKG delivers capabilities that + matter to the business + + ## Measuring and Tracking + + Outcomes should be defined with measurable criteria, enabling: + + - **Quantitative measurement** — Metrics that can be tracked + and reported (e.g., "reduce processing time by 50%") + - **Qualitative assessment** — Evaluation of quality or + satisfaction (e.g., "improve customer experience") + - **Continuous monitoring** — Ongoing evaluation throughout the + use case lifecycle + - **Value demonstration** — Clear evidence of contribution to + organizational success + + The EKG can track outcomes by linking them to metrics, KPIs, and + other measurement mechanisms, enabling automated reporting and + analysis. + + ## Relationship to Other Concepts + + Outcomes relate to other core concepts: + + - **[Use Cases](use-case.md)** — Each use case has one or more + outcomes that define its purpose + - **[Stories](story.md)** — Stories specify outcomes as the + "why" component + - **[Personas](persona.md)** — Outcomes are achieved by + Personas through Stories + - **Strategy** — Outcomes align with enterprise strategy and + objectives + + This integration ensures that outcomes are not abstract goals but + concrete, measurable results that drive the EKG's value + proposition. + +=== "Ontology" + + ## Ontology (minimal facts we can state today) + + --8<-- "fragment/uctm-diagram-outcome.md" + + We're not (yet) prescribing a full OWL ontology here. + But we can state a small set of **facts** that people can reliably use to build their own + ontology / schema / graph model around an Outcome. + + ### Required facts about an Outcome + + - **Opaque universally unique identifier** + - An Outcome should have an **opaque**, **universally unique** identifier. + - Prefer a random identifier such as **UUIDv4**, represented as a URI: + `urn:uuid:550e8400-e29b-41d4-a716-446655440000` + + - **Business-friendly name** + - An Outcome must have a human-readable name expressed in business language. + + - **Definition** + - An Outcome must have a definition explaining the expected benefit/result. + + - **Stereotype** + - An Outcome can have an **Outcome Stereotype** (e.g. KPI, Goal, Objective, Success + Criteria, Definition of Done). + - Stereotypes categorize outcomes without changing the underlying “Outcome” concept. + + - **Time horizon (optional)** + - Outcomes often imply a time horizon (short/mid/long term). Capture it explicitly if + it matters. + - **Measurability (optional but recommended)** + - Outcomes should have measurable success criteria where possible (metrics, thresholds, + targets, baselines). + - **Owned by a Use Case (optional)** + - Outcomes are often defined/owned by a Use Case, but can be referenced by other Use + Cases (e.g., children). + - **Use Case ↔ Outcome relationship-object (recommended)** + - Model the connection between a Use Case and an Outcome via a **relationship-object** + (not just a direct link). + - This supports: + - **Inheritance**: a child Use Case referencing an Outcome defined on a parent Use Case + - **Contribution mapping**: describing *how* the child contributes to that desired Outcome + - **Local outcomes**: linking to Outcomes owned by the current Use Case as well diff --git a/docs/concept/persona.md b/docs/concept/persona.md index 7fc95556..7a61c66b 100644 --- a/docs/concept/persona.md +++ b/docs/concept/persona.md @@ -1,51 +1,255 @@ +--- +description: "A representation of the different types of players — people, systems, or entities — involved in a Use Case, defined using business language. Understand how personas shape requirements in the Use Case Tree Method." +keywords: + - persona + - user persona + - stakeholder + - EKG method + - enterprise knowledge graph +schema_type: "Article" +--- + # Persona + +_A representation of the different types of players — people, systems, +or entities — involved in a Use Case, defined using business language_ + + === "Business & Management Audience" - For any given Use Case we need to have a list of all the different types of players. - In the initial stages of the life cycle of a use case it is less relevant whether these players - are called Stakeholders, Actors, Roles, User Types or Systems, we simply need to know what terms the - actual users, the real customer(s) of the use case, are using for them in their daily practice. + ## What Is a Persona? + + For any given [Use Case](use-case.md), we need to identify all + the different types of players involved. + In the initial stages of a use case's lifecycle, it matters less + whether these players are called Stakeholders, Actors, Roles, User + Types, or Systems. + What matters is understanding what terms the actual users — the + real customers of the use case — use for them in their daily + practice. + + We call them **Personas**. + + ## Why Personas Matter + + Personas help us understand who interacts with a use case and + what their needs are. + They provide a common language that bridges business and + technology, ensuring that everyone understands who is involved + and what roles they play. - We call them Personas. + !!! tip "Use business language" - For example, in the use case "Legal Entity Management" you would have Personas like: + Start with the terms your organization already uses. + Don't force technical terminology — let the business + language guide you. - - Auditor - - Data Owner - - Shareholder - - Director - - Signator - - Signator Power Pursuent to Commercial Register - - Board Member - - Legal Council - - Liquidator + ## Examples + + For example, in the use case "Legal Entity Management," you + would have Personas like: + + - **Auditor** — Reviews and verifies legal entity information + - **Data Owner** — Responsible for maintaining accurate data + - **Shareholder** — Has ownership interest in the entity + - **Director** — Member of the board of directors + - **Signator** — Authorized to sign on behalf of the entity + - Signator Power Pursuant to Commercial Register + - **Board Member** — Serves on the entity's board + - **Legal Council** — Provides legal guidance + - **Liquidator** — Manages entity dissolution - ... - Many of these Personas are involved in multiple use cases and are grouped together in _persona taxonomies_ - and defined in _ontologies_ with "machine readable meaning" that can be used to let algorithms "understand" + ## Reuse Across Use Cases + + Many Personas are involved in multiple use cases and are + grouped together in **persona taxonomies**. + These taxonomies are defined in [ontologies](ontology.md) with + "machine-readable meaning" that enables algorithms to understand the actual context and act upon it. + This reuse ensures consistency across the enterprise and enables + the [composable business](../objective/composable-business.md) + approach, where Personas become reusable components in the + Enterprise Knowledge Graph. + === "Data & Tech Audience" - In traditional use case modelling people use the term _Actor_ rather than _Persona_. - The term _Actor_ is also used in a TOGAF Metamodel and combined with the term _Role_ whereby an actor - assumes a role to perform a task. + ## Persona vs. Actor vs. Role + + In traditional use case modeling, the term **Actor** is commonly + used rather than **Persona**. + The term Actor is also used in the TOGAF Metamodel, where it is + combined with the term **Role** — an actor assumes a role to + perform a task. + + The Use Case Tree Method does not make that distinction, primarily to keep + things simple when capturing requirements — primarily as + [Stories](story.md) — but also because the term Persona combines + both concepts into one unified model. + + ## Key Technical Characteristics + + ### Automated Role Assignment + + Actors assuming a Role is fully automated, context-dependent, + and driven by models, rules, and policies. + This means that the system determines which Persona applies + based on the current context, rather than requiring manual + assignment. + + ### Real-Time Persona Computation + + A proper EKG service layer is able to compute the set of + Personas that the current user has **in real-time** and map + them to lower-level roles and privileges local to the given + technology stack. + + This dynamic computation enables: + + - **Contextual assignment** — Some Personas are assigned to a + user temporarily, just in the context of a given use case or + when working with a specific object + - **Rule-based determination** — Personas can be computed + based on business rules (e.g., you can be the "Account + Owner" if the account is assigned to you, is in your region, + etc.) + - **Technology stack mapping** — The EKG service layer + translates high-level Personas into the specific roles and + privileges required by each technology stack (databases, + APIs, applications) + + This approach ensures that authorization and access control are + driven by business semantics (Personas) rather than + technology-specific roles, while still respecting the + constraints and capabilities of each underlying system. + + ### Ontology-Based Definition + + Technically (or ontologically), a **Persona is just another + [Concept](concept.md)** — tied to ontology-defined classes that + can inherit from other Persona types. + This fundamental equivalence enables: + + - **Inheritance relationships** — Personas can be organized in + hierarchies (e.g., "Signator Power Pursuant to Commercial + Register" is a sub-persona of "Signator") + - **Semantic meaning** — Personas have machine-readable + definitions that enable automated reasoning + - **Reuse** — Personas defined once can be used across multiple + use cases + + ### Concept Vocabulary and Reuse + + Each [Use Case](use-case.md) can have its own vocabulary of + concepts, including Personas. + However, use cases also **inherit or borrow** concepts from + higher-level or otherwise related use cases in the + [Use Case Tree](use-case-tree.md) (UCT). + + This approach enables: + + - **Local vocabulary** — Use cases can define concepts + (including Personas) specific to their domain + - **Inheritance** — Lower-level use cases inherit concepts from + their parent use cases in the UCT hierarchy + - **Borrowing** — Use cases can reference and reuse concepts + from related use cases, even if they're not direct ancestors + - **Consistency** — Common concepts (like standard Personas) are + defined once and reused, ensuring consistency across the + enterprise + + Since Personas are Concepts, they follow the same reuse and + inheritance patterns as any other concept in the Use Case Tree Method. + + ### Beyond Active Users + + Personas are not just the "users" (or systems) of the use case + but also any other party in the related data models (or EKG + models/ontologies). + + For instance, your user can have the Persona "Legal Entity + Maintainer," but since the legal entity can have a Director as + well, the Director is also a Persona, even when that Director + might never be an active user of the system. + + This broader definition ensures that all entities involved in + the domain are properly represented, whether they actively + interact with the system or are simply part of the data model. + + ## Relationship to Stories + + [Stories](story.md) define what a Persona needs to accomplish. + Each Story specifies: + + - **Who** — The Persona (e.g., "As an Auditor...") + - **What** — The action or need (e.g., "...I need to get a + list of all current board members...") + - **Why** — The business outcome (e.g., "...so that I can + Verify Stakeholders") + + This structure links Personas to business requirements in a + clear, testable way. + + ## Persona Inheritance + + Personas support inheritance through the `isSubPersonaOf` + relationship. + This enables hierarchical organization where more specific + Personas inherit characteristics from more general ones. + + **Example:** + - `Signator Power Pursuant to Commercial Register` is a + sub-persona of `Signator` + - A user associated with the sub-persona automatically inherits + the parent Persona's characteristics + + **How it works:** + This inheritance works bottom-up: if a user is associated with + ``, and `` is a sub-persona of + ``, then the user is also associated with + ``. + +=== "Ontology" + + ## Ontology (minimal facts we can state today) + + --8<-- "fragment/uctm-diagram-persona.md" + + We're not (yet) prescribing a full OWL ontology here. + But we can state a small set of **facts** that people can reliably use to build their own + ontology / schema / graph model around a Persona. + + ### Required facts about a Persona + + - **Opaque universally unique identifier** + - A Persona should have an **opaque**, **universally unique** identifier. + - Prefer a random identifier such as **UUIDv4**, represented as a URI: + `urn:uuid:550e8400-e29b-41d4-a716-446655440000` - The Use Case Tree Method does not make that distinction, primarily to keep things as simple as possible when - capturing requirements --- primarily as [stories](story.md) --- but also because the term Persona combines both - concepts into one whereby: + - **Business-friendly name** + - A Persona must have a human-readable name (e.g., “Auditor”, “Chief Risk Officer”). - - Actors assuming a Role is fully automated, context dependent, model-, rule- and policy-driven - - Personas are [Concepts](concept.md) tied to Ontology-defined Classes that can inherit from other Persona types - - Personas are not just the "users" (or systems) of the use case but also any other party in the related - data-models (or EKG models/ontologies). For instance, your user can have the persona "Legal Entity Maintainer" - but since the legal entity can have a Director as well, the Director is also a Persona, even when that - Director might never be an active user of the system. + - **Slug** + - A Persona should have a kebab-cased slug (convenient identifier; do not use as a foreign + key in the Knowledge Graph). + - Example: `auditor`, `chief-risk-officer`, `legal-entity-maintainer` + - **Definition** + - A Persona should have a definition describing who it represents in the domain. -=== "Model" + - **Persona inheritance (optional)** + - Personas can be related via `isSubPersonaOf` for hierarchical organization. -A subset of the model, as a UML Class Diagram, around **Persona**. + - **Persona taxonomy membership (required)** + - Personas are `skos:Concept`. + - Every Persona is a member of exactly one **PersonaTaxonomy** (a `skos:ConceptScheme`) + via `skos:inScheme`. + - Each Use Case can have **zero or one PersonaTaxonomy** that provides the scheme for + Personas used in that Use Case. -![Context](../diagrams/out/persona-class-diagram.svg#darkable) + - **Participation in Stories (relationship-object)** + - Stories reference Personas in the “Who” part. + - Model the connection via a relationship-object if you need to capture context such as + role, responsibility, entitlement, or provenance. diff --git a/docs/concept/story.md b/docs/concept/story.md index 87e4e0a2..c7ce7586 100644 --- a/docs/concept/story.md +++ b/docs/concept/story.md @@ -1,68 +1,254 @@ +--- +description: "A structured business requirement expressed in plain language that defines what a Persona needs to accomplish within a Use Case. Learn how stories capture requirements in the Use Case Tree Method." +keywords: + - story + - user story + - business requirement + - persona story + - EKG method + - enterprise knowledge graph +schema_type: "Article" +--- + # Story + +_A structured business requirement expressed in plain language that +defines what a Persona needs to accomplish within a Use Case_ + + === "Business & Management Audience" - A Story --- in the context of a [Use Case](use-case.md) in the - [Use Case Tree](use-case-tree.md) --- defines a business requirement. - - A business user could specify a requirement as follows: - - - _As the Chief Risk Officer, I need to know our current Risk Position against party B, so that I can Assess the Risk_ - - _As an Auditor, I need to get a list of all current board members of legal entity X, so that I can Verify Stakeholders_ - - _As an Employee, I need to get a list of all my colleagues in my unit, so that I Know my Colleagues_ - - _As a customer, I need to get a list of all products, so that I can make a product selection_ - - And so forth. That's all we ask in the early phases of a given use case. - + ## What Is a Story? + + A **Story** — in the context of a [Use Case](use-case.md) in the + [Use Case Tree](use-case-tree.md) — defines a business + requirement. + It captures what someone needs to accomplish, expressed in their + own language. + + ## Story Structure + + Stories follow a simple, structured format that captures three + essential elements: + + - **Who** — The [Persona](persona.md) who needs this capability + (e.g., "As the Chief Risk Officer...") + - **What** — What they need to do or know (e.g., "...I need to + know our current Risk Position...") + - **Why** — The business [Outcome](outcome.md) or purpose (e.g., + "...so that I can Assess the Risk") + + !!! tip "Start simple" + + In the early phases of a use case, we only ask for these + three elements. + Don't worry about how it will be implemented — that comes + later. + + ## Examples + + A business user could specify requirements as follows: + + - _As the Chief Risk Officer, I need to know our current Risk + Position against party B, so that I can Assess the Risk_ + - _As an Auditor, I need to get a list of all current board + members of legal entity X, so that I can Verify Stakeholders_ + - _As an Employee, I need to get a list of all my colleagues in + my unit, so that I Know my Colleagues_ + - _As a customer, I need to get a list of all products, so that + I can make a product selection_ + + And so forth. + That's all we ask in the early phases of a given use case. + + ## Why Stories Matter + + Stories provide a bridge between business needs and technical + implementation. + They ensure that: + + - **Business language is preserved** — Requirements are captured + in terms the business understands + - **Focus stays on outcomes** — We understand the "why" behind + each requirement + - **Everyone is aligned** — Business, data, and technology + teams share a common understanding of what needs to be + delivered + === "Data & Tech Audience" - "User Stories" start out as plain English sentences that, as the name suggests, come from the user. - In other words, "the Business" or "the Customer", the end user of a system or application, is - responsible for explaining to the people who need to deliver that system what the system is supposed to do. - - Makes sense right? Unfortunately, it's usually not that simple. - All kinds of other factors come into play that have nothing to do with specifying what the user - _really_ wants such as design, architecture, existing systems, budgets, time, regulations, policies - and technical capabilities. - - However, it is a good thing to at least capture the "real" wishes of the user without having to consider all of - those other aspects. - Where the challenge is to ask the user to step out of their normal day-to-day practices and comfort zone and to - think ahead in a way that is not restricted by all the daily hurdles and practicalities. - This method proposes to use "Structured Business User Stories" to achieve many things such as: - - * have a more strategic view on which functionality is ^^really^^ required - * allow to see "the disconnect" or "the gap" between what's required and what is currently available, - delivered and deliverable - * avoid "tunnel thinking" where everyone, especially also "the business" itself, makes all kinds of - assumptions that may or may not be true and could severely diminish creativity. - * create a clear separation of concerns: the business specifies what they need but leaves it to the - data and technology people to work out how they can deliver it. - So no more "screen designs" (that comes later) or "schema's" that are used as - "functional specification". - We need to be able to go deeper, to the core questions about **"what do you ^^really^^ need?"** - (and forget about the "How" for a minute). - * have clear testable specifications of required functionality for the whole life-cycle of a given - user story.
- As long as people need a given story to be implemented, it will continuously be tested "end-to-end", - from inception all the way to production, not only before deployment into production but actually - also in production itself. - The EKG knows about "its Stories" and continuously tests them, it therefore knows about its own - "functional health" and can detect whenever something changes (code, ontologies, ETL, new policies) - whether it can still deliver all functionality - - Here's a diagram that illustrates how we can break up a user story in some interesting components that - we can link to other data structures in the Knowledge Graph such as a taxonomy of all ["Personas"](persona.md) - -
- TODO -
- - Here's one example of a User Story, more examples will follow later: - -
- TODO -
- - + ## What Is a Story in the Use Case Tree Method? + + "User Stories" start out as plain English sentences that, as the + name suggests, come from the user. + In other words, "the Business" or "the Customer" — the end user + of a system or application — is responsible for explaining to + the people who need to deliver that system what the system is + supposed to do. + + Makes sense, right? + Unfortunately, it's usually not that simple. + All kinds of other factors come into play that have nothing to + do with specifying what the user _really_ wants, such as design, + architecture, existing systems, budgets, time, regulations, + policies, and technical capabilities. + + ## The Challenge + + However, it is a good thing to at least capture the "real" + wishes of the user without having to consider all of those other + aspects. + The challenge is to ask the user to step out of their normal + day-to-day practices and comfort zone and to think ahead in a + way that is not restricted by all the daily hurdles and + practicalities. + + ## Structured Business User Stories + + This method proposes to use "Structured Business User Stories" + to achieve many things: + + ### Strategic Focus + + Have a more strategic view on which functionality is **really** + required. + By focusing on business outcomes rather than implementation + details, we can identify what truly matters. + + ### Gap Analysis + + Allow seeing "the disconnect" or "the gap" between what's + required and what is currently available, delivered, and + deliverable. + This helps prioritize work and identify areas where new + capabilities are needed. + + ### Avoid Tunnel Thinking + + Avoid "tunnel thinking" where everyone, especially "the business" + itself, makes all kinds of assumptions that may or may not be true + and could severely diminish creativity. + Stories encourage thinking beyond current constraints. + + ### Separation of Concerns + + Create a clear separation of concerns: the business specifies what + they need but leaves it to the data and technology people to + work out how they can deliver it. + So no more "screen designs" (that comes later) or "schemas" that + are used as "functional specification". + We need to be able to go deeper, to the core questions about + **"what do you really need?"** (and forget about the "How" for a + minute). + + ### Testable Specifications + + Have clear testable specifications of required functionality for + the whole lifecycle of a given user story. + As long as people need a given story to be implemented, it will + continuously be tested "end-to-end," from inception all the way + to production, not only before deployment into production but + actually also in production itself. + + ## Continuous Testing and Functional Health + + The EKG knows about "its Stories" and continuously tests them. + It therefore knows about its own "functional health" and can + detect whenever something changes (code, ontologies, ETL, new + policies) whether it can still deliver all functionality. + + This means that Stories are not just requirements documents — + they are **living, executable specifications** that the EKG + monitors and validates throughout their entire lifecycle. + + ## Relationship to Workflows + + Stories are executed as steps within [Workflows](workflow.md). + For each Story, we always know in which Workflows it participates + as a Step. + + This bidirectional relationship enables: + + - **Story reuse** — Stories can be reused across multiple + workflows, enabling composition and consistency + - **Workflow discovery** — Understanding which workflows use a + given story helps discover related business processes + - **Impact analysis** — Knowing what workflows are affected when + a story changes enables better change management + - **Process understanding** — Seeing how stories are composed + into workflows provides insight into business processes + + Stories define the "what" (the capability), while Workflows + define the "how" (the sequence and order of execution). + + ## Relationship to Other Concepts + + Stories link to other data structures in the Knowledge Graph: + + - **[Personas](persona.md)** — Each Story specifies which + Persona needs the capability + - **[Use Cases](use-case.md)** — Stories are organized within + Use Cases, defining the functional requirements + - **[Outcomes](outcome.md)** — The "why" part of a Story links + to business outcomes + - **[Concepts](concept.md)** — Stories reference domain concepts + that need to be understood and modeled + - **[Workflows](workflow.md)** — Stories are executed as steps + within workflows + + This integration ensures that Stories are not isolated + requirements but part of a cohesive, semantic model of the + enterprise. + +=== "Ontology" + + ## Ontology (minimal facts we can state today) + + --8<-- "fragment/uctm-diagram-story.md" + + We're not (yet) prescribing a full OWL ontology here. + But we can state a small set of **facts** that people can reliably use to build their own + ontology / schema / graph model around a Story. + + ### Required facts about a Story + + - **Opaque universally unique identifier** + - A Story must have an **opaque**, **universally unique** identifier. + - Prefer a random identifier such as **UUIDv4**. + - Represent it as a URI, for example: + `urn:uuid:550e8400-e29b-41d4-a716-446655440000` + + - **Business-friendly name** + - A Story should have a concise, human-readable name. + + - **Slug** + - A Story should have a kebab-cased slug that is unique at least within the organization. + - Example: `assess-risk-position`, `verify-stakeholders` + + - **Business-focused definition** + - A Story must have a plain-language definition of what the user needs. + + - **Structured statement (who / what / why)** + - A Story should capture: + - **Who**: a reference to a Persona (or persona-like Concept) + - **What**: the capability/action needed + - **Why**: a reference to an Outcome (the intended business value) + + - **Owned by a Use Case** + - A Story is **part-of** a Use Case: the Use Case **owns** the Story. + - If the owning Use Case is deleted, its Stories are deleted as well. + + - **Concept usage (relationship-object)** + - Model the relationship between a Story and a Concept as a **relationship-object** + (not a direct link), because it carries meaning about *how* the Concept is used. + - The relationship-object defines a usage type, for example: + - **Input Concept** — required/mandatory input parameter (or optional) + - **Output Concept** — definition of the output (often a shape/compound object) + - **Dependent Concept** — referenced in filters/constraints (e.g., SQL/SPARQL `WHERE`) + + - **Workflow participation** + - A Story can participate as a **Step** in one or more WorkflowDefinitions. + - Model this via a relationship-object (e.g. a “WorkflowStep”) so you can capture step + order, conditions, and other execution semantics. diff --git a/docs/concept/term.md b/docs/concept/term.md new file mode 100644 index 00000000..73158717 --- /dev/null +++ b/docs/concept/term.md @@ -0,0 +1,159 @@ +--- +description: "A manifestation of a Concept: a business-facing or technical term (e.g., synonyms, abbreviations, variable names) that all mean the same thing in the Concept’s context. Learn how Terms work in the Use Case Tree Method." +keywords: + - term + - business term + - technical term + - concept term + - EKG method + - enterprise knowledge graph +schema_type: "Article" +--- + +# Term + + +_A manifestation of a Concept: the words (business-facing and technical) used to refer to the same underlying meaning_ + + +=== "Business & Management Audience" + + ## What Is a Term? + + A **Term** is a word or phrase people use to refer to a [Concept](concept.md) in a given + context. + Concepts are about **meaning**; Terms are about **how that meaning shows up** in language. + + A Concept can have multiple Terms (synonyms, abbreviations, variations), but they all refer + to the **same meaning** in the context of that Concept. + + ## Business Terms vs Technical Terms + + Terms come in two broad categories: + + - **Business Terms** — user-facing terminology used in conversations, documentation, UI, and + policies (e.g., “Customer”, “Counterparty”, “Risk Position”) + - **Technical Terms** — manifestations in code and data (e.g., variable names, column names, + API parameters, query bindings) + + Treat both as Terms, because both are used by people, and both need to be linked back to the + Concept so everyone stays aligned. + +=== "Data & Tech Audience" + + ## Terms as Concept Manifestations + + A Term is a **manifestation** of a Concept. + It can be: + + - a preferred business phrase + - an abbreviation + - a synonym + - a technical symbol in code (e.g., `_customer`, `cust_id`, `?cust`, `/customers`) + + Terms allow the Knowledge Graph to connect human language and technical artifacts back to a + consistent semantic core (the Concept). + + ## Discovering Technical Terms in code and data + + Technical Terms can often be **discovered automatically** by scanning the organization’s + repositories and data artifacts: + Python/Java code, SQL, configuration, CSV column headers, API specs, and more. + + Each detected manifestation becomes a **Technical Term** that links to: + + - the **Concept** it manifests, and optionally + - the **Business Term** it corresponds to in that context. + + Example: + If you detect the CSV header `P`, you can link that Technical Term to the Concept and also to + the Business Term “Patient”. + + Technical Terms also include **semantic/validation artifacts** introduced later in the Use + Case lifecycle (especially during the Build phase), such as: + + - OWL classes/properties/axioms in an ontology, and + - SHACL shapes and constraints. + + In those cases, you link the Concept (and optionally a Business Term) to the ontology/shapes + term via a **special mapping relationship** (e.g. “representsClass”, “representsProperty”, + “constrainedByShape”), pointing at the ontology IRI. + + Example: + If the Concept “patient” corresponds to the OWL class `hospital:Patient` in a Hospital + ontology, create a Technical Term representing that ontology term and link it with something + like **representsClass → `hospital:Patient`**. + + ## Preferred Term + + Concepts don’t need a traditional `rdfs:label` / `skos:prefLabel` label. + Instead, a Concept can point to a **preferred Term** (a Term object) that represents the + preferred expression in that context. + +=== "Ontology" + + ## Ontology (minimal facts we can state today) + + --8<-- "fragment/uctm-diagram-term.md" + + We're not (yet) prescribing a full OWL ontology here. + But we can state a small set of **facts** that people can reliably use to build their own + ontology / schema / graph model around a Term. + + ### Required facts about a Term + + - **Opaque universally unique identifier** + - A Term should have an **opaque**, **universally unique** identifier. + - Prefer a random identifier such as **UUIDv4**, represented as a URI: + `urn:uuid:550e8400-e29b-41d4-a716-446655440000` + + - **One or more forms (lexical variants)** + - A Term must have **one or more textual forms** (the actual strings). + - Business Terms often need multiple forms for different UI / communication contexts, for + example: + - **Singular**: “Patient” + - **Plural**: “Patients” + - **Abbreviation**: “Pat.” + - **Short label**: “P” + - These are variations of the **same Term** (think “sub-manifestations” of the Term). + They should not be mixed with the forms of a different Term. + + Example: + If “Patient” and “Client” are both used to mean the same thing in a given Use Case + context, model them as **two separate Business Term objects**, each with their own + lexical forms. + Both Terms link to the same Concept, and the Concept defines the shared meaning. + + - **Term kind** + - A Term should indicate whether it is a **Business Term** or a **Technical Term**. + + - **Owned by a Concept** + - Terms are **owned** by a Concept (part-of): when the Concept is deleted, its Term + objects are deleted as well. + - A Concept must have **one or more Terms**. + - All Terms for a Concept **mean the same thing** in that Concept’s context. + + ### Optional but useful facts + + - **Language**: natural language tag for business terms (e.g., `en`, `nl`) + - **System / artifact**: where a technical term appears (e.g., codebase, dataset, API) + - **Term subtype**: for technical terms (e.g., `VariableName`, `ColumnName`, `ApiFieldName`, + `QueryBinding`) + - **Provenance**: who introduced the term, when, and why + + ### Optional facts for Technical Terms (recommended) + + When a Term is discovered in code/data, capture **where it came from**: + + - **Repository URL** (e.g., GitHub repo) + - **File path** + - **Line range** (or equivalent location for non-text artifacts) + - **Commit / tag / revision** + - **Language / format** (e.g., Python, Java, SQL, CSV) + - **Locator URL** (deep link to the exact source line / blob for traceability) + + When a Term represents an ontology or validation artifact, capture: + + - **Ontology / shape identifier** (IRI), e.g. `hospital:Patient` + - **Mapping kind** (e.g., representsClass / representsProperty / constrainedByShape) + diff --git a/docs/concept/use-case-tree.md b/docs/concept/use-case-tree.md index 29b83d03..4f98a0b6 100644 --- a/docs/concept/use-case-tree.md +++ b/docs/concept/use-case-tree.md @@ -1,129 +1,235 @@ +--- +description: "The foundational structure that organizes business capabilities into reusable, governed components within the Enterprise Knowledge Graph. Learn how the Use Case Tree drives EKG development." +keywords: + - use case tree + - UCT + - business capabilities + - EKG method + - enterprise knowledge graph + - strategic planning +schema_type: "Article" +--- + # Use Case Tree (UCT) -!!! warn - - Work in progress - -Some notes as input for this article (to still be written): - -- The Use Case Tree is a model at a higher level of abstraction than User Stories. -- It is a differentiator in the EKG/Method -- It enables consultative discussion that can identify options enterprises may otherwise not consider -- There is a need for something above User Stories to help define scope and priority -- The most critical and most important ”artifact” in the development of an Enterprise Knowledge Graph - (EKG) is “the Use Case Tree” (UCT). - - The Use Case Tree is the EKG’s equivalent of a long term data strategy and business capability plan. - - The Use Case Tree is the EKG high level requirements overview, scoping and dependency model. - In its initial stages, in the [Plan Phase](../process/plan/index.md), it gives a mile wide, inch deep view - of business capabilities. -- The Use Case Tree is a breakdown of strategic planned-for capabilities into smaller building blocks, all - called ”use cases”. Strategic long term use cases such as - ”[Enterprise Risk Management](https://catalog.ekgf.org/use-case/risk-management/)” or - ”[Client 360](https://catalog.ekgf.org/use-case/client-360/)” - are broken down into smaller use cases that can (and should) be done first. -- Each ”use case” is a module, an EKG component so you will, a building block with which other use cases - can be constructed. -- Everything we ever do in a business, especially in the data and technology pillars of that enterprise, - should be related to ”a use case” in the Use Case Tree. -- The ”Use Case Tree” is a practice and is part of the Enterprise Knowledge Graph Method (EKG/Method). - -## The primary reasons for creating a Use Case Tree are: - -### 1. Know what the business wants. - -Know exactly what the business---i.e. the customer or product owner---really needs, short-, mid- -and long-term. - -#### (a) Plan phase: Discover the business opportunities & business needs - -One of the tasks during the planning phase of any new initiative – or iteration – is to ”Discover” -the business opportunities & needs: - -- In non-technical terms. -- Without assuming anything about existing systems and ”how things are done today”. -- Translate to ”pure” functional requirements – and ”nice to haves”. -- Looking broad horizontally, thinking ahead. Mile wide, inch deep at this stage. -- Let the business ”dream a little” about ”what could be” and ”what should be” so that future - needs can be identified and communicated – without necessarily committing to them (yet). -- Promote ”thinking outside the box”, encourage people to not make any assumptions about - what is technically possible or not – so often these assumptions unknowingly keep the bar - lower than it could be. - -#### (b) Build phase: Translate requirements into an easy to understand model i.e. the Use Case Tree - -- ”Contract with the business” i.e. the budget holder or product owner., every major change - to the Use Case Tree will have to be signed off by the product owner. -- Capture it as ”meta-data” that will be part of the EKG – all the way to production. -- Capture it in such a way that ”everything that we ever do” is always directly or indirectly - relatable to ”a use case” in ”the Use Case Tree”. -- The business never loses sight on what happens with their budget and agreed deliverables. - All reporting to the business occurs in the context of the agreed Use Case Tree, even after - delivery. - -### Bridge the traditional gap between Business & Technology. - -- Engage with the business, the product owner and get continuous buy-in from the product - owner during the life-cycle of the agreed use cases. -- But not only with the product owner of the direct use case being developed but also show to - the business what other future needs need to be considered. For instance, if one use case - e.g. ”Legal Entities” needs ”workflows”, would it make sense to invest a bit more effort to then - create a reusable workflow component that can also be used for many other use cases such - as ”Shareholding disclosure”? -- Yes, the customer is always right but the Use Case Tree shows to the customer that there are - many other customers (or future customers, in and outside the organization even) and why it - makes sense to prioritize reuse and how that not only could deliver more quality but also create - more buy-in from peer stakeholders across the firm or even across the industry. -– In other words, do not select one product owner to be the single stakeholder but also get - other stakeholders of neighboring or higher level use cases in the room, their requirements - may influence the reuse agenda and therefore the roadmap. It may sound paradoxal but - investing in reuse will not slow things down but speed things up. - -### Managed Expectations - -The Use Case Tree is the best form of ”expectation management”, creating an agreed and -realistic strategic roadmap. - -### Modularity Managed - -The Use Case Tree is a foundational mechanism to create an ecosystem of reusable components -for the EKG. - -### Avoids ”boiling the ocean” - -Semantic Technology based projects often spend a lot of time "boiling the ocean", modeling -everything in a given domain. The Use Case Tree and its individual use cases define an agreed -scope at the detail level (without becoming technical). - -- Provides focus for the Center of Excellence (CoE), ”cranking out” use cases one by one -- Ontology development will be focussed on delivering on the requirements (user stories and - concepts) of the agreed use cases rather than ending up in philosophical exercise. - -### Map of all Knowledge - -The Use Case Tree provides a ”map” of all knowledge, data and functionality (whether implemented -as running EKG use cases or not) of the enterprise. -Which is not only useful for users of the EKG but also a necessity since all of these use cases are -served by one platform – albeit distributed and federated etc – there will be many stakeholders with -different agendas that would not care – nor have to care – about the wishes of the stakeholders in -other use cases. However, updates to one use case could potentially also affect other use cases. - -That’s why: - -1. all changes & updates have to be done gradually, no ”big bang” releases and -2. all inter-dependencies need to be really clear and tested in-full automatically and continuously. - -So, for instance, when some sub-use case in a high-level use case is also used in another high-level -use case then a change that serves the needs of one could potentially also affect the other and its -users. That’s why we need the Use Case Tree, to allow us to avoid any disruption across the board. - -### Foundational structure for quality - -The Use Case Tree is a foundational structure for quality since it enforces, requires and -enables 100% test coverage based on real business scenarios and requirements. - -- A use case has a life-cycle that starts with a name and a description and ends1 with a fully - detailed model of all related concepts, personas, business outcomes, datasets, ontologies, user - stories and dependencies. That model is all captured in the EKG itself which allows the EKG - to not only fully and thoroughly test things during development time (build phase) but also - in production (run phase). Which provides the level of quality that an EKG needs to have to - become truly able to support enterprise level strategic use cases. + +_The foundational structure that organizes business capabilities into +reusable, governed components within the Enterprise Knowledge Graph_ + + +## What Is the Use Case Tree? + +The **Use Case Tree (UCT)** is the most critical artifact in the +development of an Enterprise Knowledge Graph (EKG). +It is the EKG's equivalent of a long-term data strategy and business +capability plan — a high-level requirements overview, scoping and +dependency model that organizes everything the enterprise does. + +At its core, the Use Case Tree breaks down strategic business +capabilities into smaller, reusable building blocks called +**use cases**. +Strategic use cases such as +"[Enterprise Risk Management](https://catalog.ekgf.org/use-case/risk-management/)" +or "[Client 360](https://catalog.ekgf.org/use-case/client-360/)" are +decomposed into smaller use cases that can be implemented +incrementally. + +Each use case in the tree acts as a **semantic package** — a module, +component, and building block that can be discovered, versioned, and +reused across the enterprise. +Everything done in a business, especially in data and technology, +should be traceable to a use case in the Use Case Tree. + +!!! tip "Higher-level abstraction" + + The Use Case Tree operates at a higher level of abstraction than + User Stories. + It enables consultative discussions that identify options + enterprises might otherwise overlook, and provides the structure + needed to define scope and priority above the level of individual + stories. + +## Why the Use Case Tree Matters + +The Use Case Tree serves as the organizing principle for the entire +Use Case Tree Method. +It bridges the gap between business vision and technical execution, +ensuring that every capability is designed for reuse and governed +throughout its lifecycle. + +### Know What the Business Wants + +The Use Case Tree captures exactly what the business — customers, +product owners, and stakeholders — really needs, short-, mid-, and +long-term. + +#### During Planning: Discover Opportunities + +During the [Plan Phase](../process/plan/index.md), the Use Case Tree +helps teams discover business opportunities and needs: + +- **In non-technical terms** — accessible to all stakeholders +- **Without assumptions** about existing systems or "how things are + done today" +- **As pure functional requirements** — distinguishing needs from + "nice to haves" +- **With broad, forward-looking perspective** — mile wide, inch deep + at this stage +- **Encouraging innovation** — letting the business "dream" about + "what could be" without premature technical constraints + +The goal is to think outside the box and avoid assumptions about +technical limitations that might unnecessarily constrain +possibilities. + +#### During Building: Translate to Executable Model + +In the [Build Phase](../process/build/index.md), the Use Case Tree +becomes the contract with the business: + +- **Governed changes** — every major change requires product owner + sign-off +- **Metadata in the EKG** — captured as part of the EKG itself, + persisting all the way to production +- **Complete traceability** — everything done is directly or + indirectly relatable to a use case in the tree +- **Ongoing visibility** — the business never loses sight of budget + and deliverables, with all reporting occurring in the context of + the agreed Use Case Tree + +### Bridge Business and Technology + +The Use Case Tree creates a shared language between business and +technology teams. +It enables continuous engagement with product owners and stakeholders +throughout the lifecycle of use cases. + +!!! tip "Think beyond the immediate use case" + + When developing a use case like "Legal Entities" that needs + workflows, the Use Case Tree helps identify opportunities for + broader reuse. + Should you invest more effort to create a reusable workflow + component that can also serve "Shareholding Disclosure" and other + use cases? + + The tree shows stakeholders that there are many customers — current + and future, inside and outside the organization — and demonstrates + why prioritizing reuse delivers both quality and broader buy-in + across the firm or industry. + +By engaging multiple stakeholders — not just the direct product +owner, but also stakeholders of neighboring or higher-level use cases +— teams can identify reuse opportunities that accelerate delivery +rather than slow it down. + +### Manage Expectations + +The Use Case Tree is the foundation of expectation management, +creating an agreed and realistic strategic roadmap. +It provides clarity on: + +- What will be delivered and when +- How capabilities relate to business outcomes +- Dependencies between use cases +- Priorities and sequencing + +### Enable Modularity and Reuse + +The Use Case Tree is the foundational mechanism for creating an +ecosystem of reusable components for the EKG. +Each use case can be: + +- **Designed** as a reusable building block +- **Versioned** and governed independently +- **Composed** with other use cases to create larger capabilities +- **Discovered** by teams across the enterprise + +This aligns directly with the objectives of +[**Enable Reuse**](../objective/enable-reuse.md) and +[**Composable Business**](../objective/composable-business.md). + +### Avoid "Boiling the Ocean" + +Semantic technology projects often spend excessive time modeling +everything in a domain — "boiling the ocean." +The Use Case Tree and its individual use cases define an agreed +scope at the appropriate level of detail (without becoming overly +technical). + +- **Provides focus** for the Center of Excellence (CoE), enabling + teams to deliver use cases incrementally +- **Directs ontology development** toward delivering on the + requirements of agreed use cases, rather than philosophical + exercises + +### Map All Knowledge + +The Use Case Tree provides a comprehensive map of all knowledge, +data, and functionality — whether implemented as running EKG use +cases or planned for the future — across the enterprise. + +This map is essential because: + +- All use cases are served by one platform (albeit distributed and + federated) +- Many stakeholders have different agendas and priorities +- Updates to one use case can affect others + +That's why the Use Case Tree enforces: + +1. **Gradual, incremental changes** — no "big bang" releases +2. **Clear inter-dependencies** — all dependencies are explicit and + tested automatically and continuously + +For example, when a sub-use case in one high-level use case is also +used in another, changes serving one stakeholder's needs could affect +others. +The Use Case Tree makes these relationships visible, enabling teams to +avoid disruption across the board. + +### Foundational Structure for Quality + +The Use Case Tree provides the foundational structure for quality by +enforcing, requiring, and enabling 100% test coverage based on real +business scenarios and requirements. + +A use case has a lifecycle that starts with a name and description and +evolves into a fully detailed model including: + +- Related concepts and personas +- Business outcomes and success criteria +- Datasets and ontologies +- User stories and workflows +- Dependencies and relationships + +This model is captured entirely within the EKG itself, enabling: + +- **Comprehensive testing during development** (Build phase) +- **Continuous validation in production** (Run phase) +- **Quality assurance** at the level required for enterprise-scale + strategic use cases + +## Relationship to Other Concepts + +The Use Case Tree is closely related to several other concepts in the +EKGF Method: + +- **[Use Case](use-case.md)** — Individual nodes in the tree +- **[Enable Reuse](../objective/enable-reuse.md)** — The Use Case + Tree is the primary mechanism for enabling reuse +- **[Composable Business](../objective/composable-business.md)** — + The tree organizes capabilities for composition +- **[Persona](persona.md)**, **[Story](story.md)**, + **[Workflow](workflow.md)**, **[Data Product](data-product.md)**, + **[Ontology](ontology.md)** — All registered within use cases in + the tree + +## Summary + +The Use Case Tree is not just a planning tool — it is the living +structure that organizes, governs, and enables reuse of every +business capability in the Enterprise Knowledge Graph. +It bridges business and technology, manages expectations, enables +modularity, prevents scope creep, maps enterprise knowledge, and +provides the foundation for quality at scale. diff --git a/docs/concept/use-case.md b/docs/concept/use-case.md index b7f1c52f..7066a44d 100644 --- a/docs/concept/use-case.md +++ b/docs/concept/use-case.md @@ -1,107 +1,400 @@ +--- +description: "An executable model of business requirements that delivers specific business outcomes within the Use Case Tree. Learn how use cases structure business capabilities in the Use Case Tree Method." +keywords: + - use case + - business requirements + - EKG method + - enterprise knowledge graph + - use case tree +schema_type: "Article" +--- + # Use Case + +_An executable model of business requirements that delivers specific +business outcomes within the Use Case Tree_ + === "Business & Management Audience" - A Use Case specifies a distinct set of business requirements --- ideally - but not necessarily captured as an "executable model" --- resulting in - a specific business outcome. - - It starts with ideas for use cases that could come from any person in - the organization at any point in time. - We want to capture all these ideas (and as much of the knowledge behind - those ideas) and create one data structure for it that - we call "the [Use Case Tree](use-case-tree.md)" because it looks like an inverted tree: it's - something that starts on a whiteboard, showing a break-down of a - component of the business into smaller components. - - Anyone should be able to contribute ideas that may or may not - end up as fully implemented use cases to end up in the organization's + ## What Is a Use Case? + + A **Use Case** specifies a distinct set of business requirements — + ideally, but not necessarily, captured as an "executable model" — + resulting in a specific business outcome. + + Use cases start as ideas that can come from anyone in the + organization at any time. + These ideas are captured in the + [**Use Case Tree**](use-case-tree.md) — a data structure that + organizes business capabilities into a hierarchical structure, + starting on a whiteboard and showing how components of the business + break down into smaller components. + + ## Open Contribution Model + + Anyone should be able to contribute ideas that may or may not end + up as fully implemented use cases in the organization's [Use Case Tree](use-case-tree.md), whether they are viable or not. - If an idea for a given use case is rejected then show the rationale - for that to everyone so that everyone can learn, and we're not wasting - anyones time on that idea again. - Let people contribute. - All knowledge workers, all specialist users, data architects, - technical architects, ontologists, end users, business executives, - literally anyone should be allowed to understand: - - * What's our + If an idea for a use case is rejected, the rationale should be + shared with everyone so that everyone can learn and avoid wasting + time on that idea again. + + !!! important "Let people contribute" + + A Use Case is a **shared, living artifact** across the full end-to-end lifecycle + (Plan → Build → Run → evolve). + Everyone involved — knowledge workers, specialist users, data architects, + technical architects, ontologists, end users, business executives — literally anyone — + should be able to **read it**, **talk about the same Use Case (the same version)**, + and **contribute what they know** as the work progresses. + + Everything you do in and around a Use Case should be discoverable back in the + **Knowledge Graph**, and be directly or indirectly related to that Use Case. + + ### Strategic Context + + - **Business identity and strategy**: What is our [business identity](https://maturity.ekgf.org/pillar/business/background-and-intro/#business-identity)? Our [mission and strategy](https://maturity.ekgf.org/pillar/business/capability-area/strategy-actuation/)? - What do we all this for (besides being profitable), what are the long term - objectives that we are going to achieve? - * How does that map to our current and future data and technology landscape? - * (without becoming too technical or detailed, we want everyone to be able to chip in) - * [Assess](../process/plan/assess.md) all our organization's capabalities, - as specified in the - [Maturity Model for the Enterprise Knowledge Graph (EKG/Maturity)](https://maturity.ekgf.org) - related to our own EKG and how they match with our ambitions to implement our - strategic use cases? - * How does our "technical debt" fit in? (identify the functionality of our - technical debt as use cases in the tree as well) - * How are we going to "rationalize" our current siloed landscape (and technical debt)? - * What are the short and long term priorities? - * What are the milestones and the roadmap? (see ["Chart"](../process/plan/chart.md)) - * Which ideas (for use cases) have been proposed, considered approved or rejected and why? + What do we do all this for (besides being profitable)? What are + the long-term objectives we are going to achieve? + + - **Technology landscape**: How does that map to our current and + future data and technology landscape? (Without becoming too + technical or detailed — we want everyone to be able to + contribute.) + + - **Capability assessment**: How do we + [Assess](../process/plan/assess.md) all our organization's + capabilities, as specified in the + [Maturity Model for the Enterprise Knowledge Graph (EKG/Maturity)](https://maturity.ekgf.org), + related to our own EKG and how they match with our ambitions to + implement our strategic use cases? + + - **Technical debt**: How does our "technical debt" fit in? + (Identify the functionality of our technical debt as use cases + in the tree as well.) + How are we going to "rationalize" our current siloed landscape + (and technical debt)? + + - **Priorities and roadmap**: What are the short- and long-term + priorities? What are the milestones and the roadmap? (See + ["Chart"](../process/plan/chart.md).) + + - **Transparency**: Which ideas (for use cases) have been + proposed, considered, approved, or rejected, and why? === "Data & Tech Audience" - The term "use case" means something specific to a technical audience who - usually assume that the term use case means what the Object Management Group (OMG) - defines what it is in their Unified Modeling Language (UML) and - its ["use case diagrams"](https://en.wikipedia.org/wiki/Use_case_diagram). + + ## What Is a Use Case in the Use Case Tree Method? + + A **Use Case** in the Use Case Tree Method specifies a distinct set of + business requirements — ideally captured as an "executable model" + — resulting in a specific business outcome. + Each use case is a node in the + [**Use Case Tree**](use-case-tree.md), acting as a semantic + package that can be discovered, versioned, and reused across the + enterprise. + + ## Relationship to UML Use Cases + + The term "use case" has a specific meaning for technical audiences + who typically assume it means what the Object Management Group (OMG) + defines in their Unified Modeling Language (UML) and its + ["use case diagrams"](https://en.wikipedia.org/wiki/Use_case_diagram). + + Although there are many similarities and overlap — which is why we + are repurposing the term — it is not exactly the same in our Use + Case Tree Method: + + ### Key Differences + + - **Broader abstraction**: Use cases in the Use Case Tree Method are often + used as a much broader and more abstract container concept + compared to a UML Use Case. + They can be organized in a "tree structure" where, at the + highest levels, a use case can represent a capability domain or + a "strategic use case" — basically anything that fits well with + the business. + + - **Reusable components**: At the lowest levels in this tree, we + end up with use cases that are much more like turn-key + components for the EKG — 100% reusable, delivering + "no-code"-functionality[^2]. + + [^2]: [No-code](https://en.wikipedia.org/wiki/No-code_development_platform) or + [Low-code](https://en.wikipedia.org/wiki/Low-code_development_platform) + development allows non-programmers to create applications without + hard-wiring business logic with a programming language + + - **Executable models**: Unlike UML use cases, which are primarily + descriptive, EKG use cases can be captured as executable models + that run directly in the Enterprise Knowledge Graph platform. + + - **Semantic packaging**: Each use case acts as a semantic package + containing ontologies, stories, data products, workflows, and + other reusable components — similar to how software packages + contain code, dependencies, and metadata. + + ## Technical Implementation + + From a technical perspective, a Use Case in the Use Case Tree Method: + + - **Organizes related components**: Groups together personas, + concepts, stories, workflows, datasets, and ontologies that + belong to the same business capability + + - **Enables reuse**: Provides a mechanism for discovering and + reusing business logic, data models, and workflows across + different contexts + + - **Supports versioning**: Can be versioned and evolved over time + while maintaining backward compatibility + + - **Facilitates testing**: Provides the structure for defining test + scenarios and ensuring 100% test coverage based on real business + requirements + + - **Enables composition**: Can be composed with other use cases to + create larger business capabilities, supporting the goal of + [Composable Business](../objective/composable-business.md) + +=== "Key Components" + + ## Overview + + A Use Case in the Use Case Tree Method is composed of multiple components + that evolve throughout its lifecycle. + These components work together to create a complete, executable + model of business requirements. + + ## Essential Elements + + Every Use Case starts with these fundamental components, defined + during the [Plan Phase](../process/plan/index.md): + + - **Name and description** — Clear identification and purpose. + This provides the foundation for all other components and + enables discovery within the Use Case Tree. + + - **Business outcomes** — The desired or expected business + outcome(s) and how they can be measured. + These define success criteria and provide the "why" behind + the use case. + See [Outcome](outcome.md) for more details. + + - **Personas** — The [personas](persona.md) of all the people and + systems involved in the domain or scope represented by the Use + Case. + Personas define who (or what) interacts with the use case and + their needs. + + - **Concepts and terms** — The concepts and their terms as used + in the context of the Use Case. + These form the vocabulary of the domain and link to the + semantic models (ontologies) that will be developed. + See [Concept](concept.md) for more details. + + !!! tip "Start simple, evolve iteratively" + + These essential elements can be defined at a high level + initially — "mile wide, inch deep" — and refined as the use + case progresses through its lifecycle. + + ## Additional Elements (Later in Lifecycle) + + As the Use Case moves into the [Build Phase](../process/build/index.md), + additional components are added: + + - **Stories** — The functional requirements and business logic + that implement the use case. + Stories define what the use case does and can be implemented + as executable functions or APIs. + See [Story](story.md) for more details. + + - **Datasets and ontologies** — The data structures and semantic + models that support the use case. + Datasets provide the data, while ontologies define the meaning + and relationships. + See [Data Product](data-product.md) and + [Ontology](ontology.md) for more details. + + - **Workflows** — The process flows and orchestration that + coordinate multiple stories and data flows. + Workflows define how different components work together to + deliver the business outcome. + See [Workflow](workflow.md) for more details. + + ## Specialist Contributions + + Throughout the lifecycle, specialists from various disciplines + in the organization contribute additional details: + + - **Business analysts** — Detailed business rationale, tied to + the business outcomes, and requirements refinement - Although there are many similarities and overlap --- which is why we are repurposing - the term --- it is not exactly the same, in our Use Case Tree Method: + - **Project managers** — Milestones, versions, projects, + timelines, roadmaps, and budgets - - use cases often are used a much broader and more abstract container concept --- - compared to a UML Use Case --- that can be put in a "tree structure" where at the - highest levels of these trees a use case can represent a capability domain or - a "strategic use case" --- or basically anything that fits well with the business. - - at the lowest levels in this tree we would end up with use cases that are much more - like turn-key components for the EKG, 100% reusable delivering "no code"-functionality[^2]. + - **Development teams** — Issues, tickets, and implementation + details -=== "Key components" + - **Operations teams** — Environment topologies, deployments, + and configurations - For every Use Case we specify: + - **Architects** — Detailed information about dependencies, + integrations, and technical relationships - - A name and a description - - The desired or expected business outcome(s) and how they can be measured - - The ["personas"](persona.md) of all the people and systems that are involved - in the domain or scope represented by the Use Case - - The concepts and their terms as they're used in the context of the Use Case + ## Component Relationships - At a later stage in the life-cycle of the Use Case we add: + These components are not independent — they form an integrated + whole: - - The stories, see [Story](story.md) - - The datasets and their ontologies - - The workflows + - **Personas** interact with **Stories** to deliver **Business + Outcomes** + - **Stories** consume and produce **Data Products** using + **Ontologies** for semantic meaning + - **Workflows** orchestrate **Stories** to create end-to-end + business processes + - **Concepts** link to **Ontologies** that provide the semantic + foundation + - All components are versioned, tested, and governed together as + part of the Use Case - Specialists of various disciplines in the organization can add their details - such as: + This integrated approach ensures that every component is + traceable, reusable, and aligned with the business outcomes the + use case is designed to deliver. - - detailed business rationale, tied to the before-mentioned business outcomes - - milestones, versions, projects, timelines, roadmaps, budgets - - issues, tickets - - environment topologies, deployments and configurations - - detailed information about the various types of dependencies +=== "Process" -=== "Life cycle" + + ## Continuous Improvement - Each individual Use Case itself goes through a life-cycle of continuous improvement like:[^1] + Each individual Use Case goes through a lifecycle of continuous + improvement:[^1] + This lifecycle spans the entire Use Case Tree Method process, from initial + idea through planning, building, running, and ongoing optimization. - ![Context](../diagrams/out/use-case-life-cycle.svg#darkable) + ![Use Case Lifecycle](../diagrams/out/use-case-life-cycle.svg#darkable) -=== "Plan/Build/Run" + ## Lifecycle Stages - The EKG/Method defines a process that consists of three phases where each phase has - well-defined "steps": - [Plan](../process/plan/index.md), - [Build](../process/build/index.md) and + The Use Case lifecycle aligns with the three main phases of the + Use Case Tree Method: + + ### Plan Phase + + During the [Plan Phase](../process/plan/index.md), the use case + starts as an idea and evolves into a well-defined requirement: + + - **Ideation** — Initial concept or business need identified + - **Discovery** — Business opportunities and needs explored + - **Definition** — Essential elements defined (name, description, + outcomes, personas, concepts) + - **Scoping** — Boundaries and dependencies identified + - **Prioritization** — Position in the Use Case Tree established + + At this stage, the use case is "mile wide, inch deep" — broad in + scope but not yet detailed in implementation. + + ### Build Phase + + During the [Build Phase](../process/build/index.md), the use case + becomes executable: + + - **Design** — Stories, workflows, and data models designed + - **Development** — Components implemented (ontologies, data + products, stories) + - **Testing** — Test scenarios defined and executed, ensuring 100% + test coverage + - **Integration** — Components integrated and dependencies resolved + - **Verification** — Business outcomes validated against success + criteria + + The use case transitions from a requirement to an executable, + testable capability. + + ### Run Phase + + During the [Run Phase](../process/run/index.md), the use case + operates in production: + + - **Deployment** — Use case deployed to production environment + - **Operation** — Monitoring, maintenance, and support + - **Measurement** — Business outcomes measured and tracked + - **Optimization** — Continuous improvement based on performance + data and feedback + - **Evolution** — Updates and enhancements based on changing + business needs + + The use case becomes a living, evolving capability that delivers + ongoing business value. + + ## Iterative Refinement + + The lifecycle is not linear — use cases continuously evolve: + + - **Feedback loops** — Learnings from Run phase inform future Plan + and Build activities + - **Incremental delivery** — Use cases can be delivered in + increments, with each increment building on the previous + - **Versioning** — Changes are versioned to maintain stability + while enabling evolution + - **Reuse** — Successful use cases become reusable components for + future use cases + + !!! tip "Lifecycle as a learning cycle" + + The Use Case lifecycle is fundamentally a learning cycle. + Each phase provides feedback that improves the next iteration, + ensuring that the use case continuously aligns with business + needs and delivers increasing value over time. + + ## Relationship to Use Case Tree + + The lifecycle of individual use cases is managed within the context + of the [Use Case Tree](use-case-tree.md): + + - **Tree structure** — The tree shows relationships and + dependencies between use cases + - **Governance** — Changes to use cases are governed through the + tree structure + - **Reuse** — The tree enables discovery and reuse of use cases + across the enterprise + - **Evolution** — The tree evolves as use cases progress through + their lifecycles + + This ensures that individual use case lifecycles are coordinated + and aligned with the broader enterprise strategy. + + + ## Use Cases Across the Use Case Tree Method Process + + The Use Case Tree Method defines a process consisting of three phases, each + with well-defined steps: + [Plan](../process/plan/index.md), + [Build](../process/build/index.md), and [Run](../process/run/index.md). - The common artifact across each of these phases---and most of their steps---is the Use Case Tree - where certain information is relevant to that phase for each of its Use Cases: + + The **Use Case Tree** is the common artifact across each of these + phases — and most of their steps. + As a use case progresses through these phases, different types of + information become relevant and are captured within the use case. + + !!! tip "Progressive elaboration" + + Use cases start simple in the Plan phase and progressively + gain detail as they move through Build and Run. + This approach ensures that investment is made incrementally, + with each phase building on the previous one. + + ## Information by Phase + + The following shows what information is captured for each use case + during each phase:
@@ -109,17 +402,18 @@ ----- - 1. Name + Business Description - 2. Desired Business Outcomes + 1. **Name + Business Description** + 2. **Desired Business Outcomes** - Definition of Success - 3. [Personas](../concept/persona.md), [Concepts & Terms](../concept/concept.md) + 3. **[Personas](../concept/persona.md), [Concepts & Terms](../concept/concept.md)** - Add examples i.e. input for test scenarios - 4. [Stories](../concept/story.md) & [Workflows](../concept/workflow.md) - - High level but agreed, metrics based estimates - 5. Tree Structure - - Break-down into---existing or non-existing---sub-use cases - (some of which are reusable and some of which are specific to the parent use case) - - Priority is to look up in the tree, not down, and define the longer term “strategic use cases” as well + 4. **[Stories](../concept/story.md) & [Workflows](../concept/workflow.md)** + - High level but agreed, metrics-based estimates + 5. **Tree Structure** + - Break-down into existing or non-existing sub-use cases + (some reusable, some specific to the parent use case) + - Priority is to look up in the tree, not down, and define + the longer-term "strategic use cases" as well [:octicons-arrow-right-24: Learn more about the _Discover Step_](../process/plan/discover.md) @@ -127,23 +421,26 @@ ----- - 6. Datasets - - identify existing datasets or develop new + 6. **Datasets** + - Identify existing datasets or develop new [_Self-describing datasets_ (SDDs)](https://principles.ekgf.org/vocab/sdd) - 7. Ontologies - - map the given [Concepts](../concept/concept.md) to the right Ontologies - 8. Test scenarios - - define test-datasets and test-scenarios for each [Story](../concept/story.md) - - provision continuous integration pipelines for continuous automated testing - - ensure 100% test coverage across all stories - 9. Story-implementation details - - all optional -- e.g. SPARQL, SHACL, SQL, workflow, audit, - history, provenance, entitlements, caching policies, etc - 10. Metrics - - function point or story point-like metrics - - lead / cycle time metrics - - predict cost & delivery - - based on metrics of previous use cases + 7. **Ontologies** + - Map the given [Concepts](../concept/concept.md) to the + right Ontologies + 8. **Test Scenarios** + - Define test-datasets and test-scenarios for each + [Story](../concept/story.md) + - Provision continuous integration pipelines for continuous + automated testing + - Ensure 100% test coverage across all stories + 9. **Story Implementation Details** + - All optional — e.g. SPARQL, SHACL, SQL, workflow, audit, + history, provenance, entitlements, caching policies, etc. + 10. **Metrics** + - Function point or story point-like metrics + - Lead / cycle time metrics + - Predict cost & delivery + - Based on metrics of previous use cases [:octicons-arrow-right-24: Learn more](../process/build/index.md) @@ -151,27 +448,289 @@ ----- - Additional detail added after deployment. + 11. **Operational Metrics** + - Performance data and usage statistics + - Business outcome measurements + - Quality metrics and error rates + 12. **Production Configuration** + - Environment details and deployment info + - Monitoring and alerting setup + - Backup and recovery procedures + 13. **Optimization Opportunities** + - Performance improvements identified + - User feedback and enhancement requests + - Cost optimization insights + 14. **Evolution Planning** + - Updates and enhancements planned + - Version roadmap + - Integration with new use cases [:octicons-arrow-right-24: Learn more](../process/run/index.md)
- + ## Phase Transitions + + Use cases transition between phases based on readiness criteria: + + - **Plan → Build**: When business outcomes are defined, personas + identified, and high-level stories agreed upon + - **Build → Run**: When components are implemented, tested (100% + coverage), and verified against business outcomes + - **Run → Plan/Build**: When optimization or evolution requires + new planning or building activities + + These transitions are not always linear — use cases may iterate + within phases or return to earlier phases based on feedback and + changing requirements. + + ## Continuous Evolution + + Even after deployment, use cases continue to evolve: + + - **Measurement** drives understanding of what works and what + doesn't + - **Optimization** improves performance and reduces costs + - **Evolution** adds new capabilities based on business needs + - **Reuse** enables other use cases to leverage successful + components + This continuous evolution ensures that use cases remain aligned + with business needs and continue to deliver value over time. + + [^1]: The lifecycle diagram shown is a simplification === "Similar Concepts" - * Packaged Business Capabilities - * [WalkMe - Packaged Business Capabilities (PBCs)](https://www.walkme.com/glossary/packaged-business-capabilities/) - * [ElasticPath - What Are Packaged Business Capabilities (PBCs)?](https://www.elasticpath.com/blog/what-are-packaged-business-capablities) + ## Related Approaches + + The concept of Use Cases in the Use Case Tree Method shares similarities with + several other approaches in enterprise architecture and software + development. + Understanding these relationships can help contextualize how Use + Cases fit into broader industry practices. + + ### Packaged Business Capabilities (PBCs) + + **Packaged Business Capabilities (PBCs)** are a concept from + composable commerce and enterprise architecture that emphasizes + modular, reusable business components. + + **Similarities with EKG Use Cases:** + + - **Modular design** — Both PBCs and Use Cases represent + self-contained business capabilities + - **Reusability** — Both are designed to be reused across different + contexts + - **Composability** — Both can be composed to create larger + capabilities + - **Business focus** — Both emphasize business value over technical + implementation + + **Key Differences:** + + - **Scope** — PBCs are typically focused on commerce and business + applications, while Use Cases in the Use Case Tree Method span all + enterprise capabilities + - **Semantic foundation** — EKG Use Cases are built on semantic + models (ontologies) that enable deeper integration and + interoperability + - **Executability** — EKG Use Cases can be captured as executable + models that run directly in the Enterprise Knowledge Graph + - **Tree structure** — Use Cases are organized in a hierarchical + Use Case Tree that provides governance and dependency management + + **Learn More:** + + - [WalkMe - Packaged Business Capabilities (PBCs)](https://www.walkme.com/glossary/packaged-business-capabilities/) + - [ElasticPath - What Are Packaged Business Capabilities (PBCs)?](https://www.elasticpath.com/blog/what-are-packaged-business-capablities) + + ### UML Use Cases + + As discussed in the [Data & Tech Audience](#data-tech-audience) + tab, Use Cases in the Use Case Tree Method share terminology with UML Use + Cases but operate at a different level of abstraction. -[^1]: the life-cycle diagram shown is obviously a simplification -[^2]: [No-code](https://en.wikipedia.org/wiki/No-code_development_platform) or - [Low-code](https://en.wikipedia.org/wiki/Low-code_development_platform) development - allows non-programmers to create applications without - hard-wiring business logic with a programming language + **Key Distinctions:** + - **Abstraction level** — EKG Use Cases can represent entire + capability domains, not just individual interactions + - **Executability** — EKG Use Cases can be implemented as + executable models + - **Semantic packaging** — EKG Use Cases contain ontologies, data + products, and workflows, not just interaction descriptions + - **Tree organization** — EKG Use Cases are organized in a + hierarchical tree structure for governance and reuse + ### Microservices + **Microservices** architecture emphasizes building applications as + collections of small, independent services. + **Similarities:** + + - **Modularity** — Both emphasize breaking down capabilities into + smaller, manageable components + - **Independence** — Both can be developed and deployed + independently + - **Composability** — Both can be composed to create larger systems + + **Key Differences:** + + - **Abstraction** — Use Cases operate at a business capability level, + while microservices operate at a technical service level + - **Semantics** — Use Cases are built on semantic models that + enable deeper integration + - **Business focus** — Use Cases are defined by business outcomes, + while microservices are defined by technical boundaries + - **Reusability** — Use Cases emphasize reuse of business logic, + data models, and workflows, not just code + + ### Domain-Driven Design (DDD) Bounded Contexts + + **Bounded Contexts** in Domain-Driven Design define the boundaries + within which a domain model is valid. + + **Similarities:** + + - **Domain boundaries** — Both define boundaries for business + concepts and logic + - **Contextual models** — Both recognize that the same concept can + have different meanings in different contexts + - **Business alignment** — Both align technical implementation with + business domains + + **Key Differences:** + + - **Scope** — Use Cases can span multiple bounded contexts or be + contained within one + - **Executability** — Use Cases can be captured as executable + models + - **Tree structure** — Use Cases are organized in a hierarchical + tree for governance + - **Reuse focus** — Use Cases emphasize reuse and composition across + contexts + + ## Summary + + While Use Cases in the Use Case Tree Method share concepts with these related + approaches, they are uniquely designed for the Enterprise Knowledge + Graph context: + + - **Semantic foundation** enables deeper integration and + interoperability + - **Executable models** allow use cases to run directly in the EKG + - **Tree structure** provides governance and dependency management + - **Business-first approach** ensures alignment with business + outcomes and value + +=== "Ontology" + + ## Ontology (minimal facts we can state today) + + --8<-- "fragment/uctm-diagram-use-case.md" + + We're not (yet) prescribing a full OWL ontology here. + But we can state a small set of **facts** that people can reliably use to build their own + ontology / schema / graph model around a Use Case. + + ### Required facts about a Use Case + + - **Opaque universally unique identifier** + - A Use Case must have an **opaque**, **universally unique** identifier. + - Prefer a random identifier such as **UUIDv4**. + - Represent it as a URI, for example: + + `urn:uuid:550e8400-e29b-41d4-a716-446655440000` + + - **Business-friendly name** + - A Use Case must have a **human-readable name** that resonates with business users. + - This is what people see, say, and search for. + + - **Slug** + - A Use Case must have a **slug**: a kebab-cased identifier that is **at least unique + within the organization** (and stable over time as much as possible). + - Example: `customer-360`, `reduce-churn-risk`, `supplier-risk-monitoring` + + - **Business-focused definition** + - A Use Case must have a **definition** that explains what it is, in business terms. + - Keep it implementation-agnostic: focus on intent and value, not solutions. + + - **One or more outcomes** + - A Use Case must have **at least one Outcome** explaining *why it exists* and *what + contribution is expected*. + - Outcomes can represent **KPIs**, **goals**, **objectives**, **definitions of success**, + etc. + - What an Outcome *is exactly* is determined by its **stereotype** (e.g. KPI vs Goal), + but the key is to capture expected **short/mid/long-term outcomes**. + + - **Outcome relationships (supports inheritance and contribution mapping)** + - Model the connection between a Use Case and an Outcome via a **relationship-object** + (not just a direct link). + - This enables a Use Case to relate to an Outcome it **owns**, and also enables a child + Use Case to **reference an Outcome defined on a parent Use Case** (inherited) and + capture *how the child contributes* to that desired Outcome. + + - **Use Case stereotype (optional, organization-defined)** + - A Use Case can have a **Use Case Stereotype**. + - By default, the stereotype is simply “Use Case”. + - Many organizations use different type names for scopes that are effectively the same + concept in the Use Case Tree Method. A stereotype makes the Use Case **recognizable** + in the local language without changing the underlying model. + - Organizations can define **any number** of stereotypes and how they interrelate, + including constraints like “allowed parent stereotypes” and “allowed child stereotypes”. + - Examples: + - **Business Capability Area**: allows only Business Capability Domain as child + - **Business Capability Domain**: parent must be Business Capability Area; child must be Business Capability + - **Business Capability**: parent must be Business Capability Domain; child can be anything + - **Data Domain** + - **Technical Capability** + - **Business Component** + - **Architecture Component** + - **Module** + - **API Service** + - **Application** + + - **Stories (optional, owned)** + - A Use Case can have **zero or more Stories**. + - The relationship is **part-of**: the Use Case **owns** its Stories. + - If the Use Case is deleted, its owned Stories are deleted as well. + + - **Workflow definitions (optional, owned)** + - A Use Case can have **zero or more Workflows**. + - More precisely: these are **WorkflowDefinition** objects (the definition, not a run). + - The relationship is **part-of**: the Use Case **owns** its workflow definitions. + - If the Use Case is deleted, its owned workflow definitions are deleted as well. + + - **Persona taxonomy (optional, SKOS scheme)** + - A Use Case can have **zero or one PersonaTaxonomy**. + - A PersonaTaxonomy is a `skos:ConceptScheme` that groups the Personas relevant for the + Use Case. + - Personas are `skos:Concept` and are members of exactly one PersonaTaxonomy via + `skos:inScheme`. + + - **Concept vocabularies (optional, mixed)** + - A Use Case can have **zero or more relationships** to Concept Vocabularies. + - It may **reference an external** Concept Vocabulary, and/or **own a private** Concept + Vocabulary. + - A Concept Vocabulary contains **Concepts**. + - Stories relate to Concepts via a **relationship-object** that captures usage type: + - **Input Concept** — required/mandatory input parameter (or optional) + - **Output Concept** — definition of the output (often a shape/compound object) + - **Dependent Concept** — referenced in filters/constraints (e.g., SQL/SPARQL `WHERE`) + + ### How it fits with Concepts & Terms + + In the Use Case Tree Method, [Concepts & Terms](concept.md) capture the shared vocabulary + and intent. + Ontologies make that vocabulary **precise and machine-actionable** (identifiers, relations, + constraints, and alignment to standards). + + Learn more in [Ontology](ontology.md). + + ### Governance and reuse (pragmatic guidance) + + - **Reuse first**: adopt/align to existing ontologies before creating new ones + - **Versioning**: track ontology/schema versions alongside the Use Case version + - **Change impact**: semantic changes can break queries, validation, and workflows + - **Interoperability**: shared semantics are a primary driver for cross-domain reuse diff --git a/docs/concept/workflow.md b/docs/concept/workflow.md index 332ae915..639de1ac 100644 --- a/docs/concept/workflow.md +++ b/docs/concept/workflow.md @@ -1,12 +1,363 @@ +--- +description: "A logical sequence of steps that defines the order of execution for Stories within a Use Case to achieve desired business Outcomes. Learn how workflows structure business processes in the Use Case Tree Method." +keywords: + - workflow + - business process + - process flow + - EKG method + - enterprise knowledge graph + - business automation +schema_type: "Article" +--- + # Workflow -Every [Use Case](use-case.md) has one or more Workflows. + +_A logical sequence of steps that defines the order of execution for +Stories within a Use Case to achieve desired business Outcomes_ + + +=== "Business & Management Audience" + + ## What Is a Workflow? + + A **Workflow** defines the logical order of steps needed to + accomplish a business process within a [Use Case](use-case.md). + Every Use Case has one or more Workflows that describe how + business activities should be performed. + + Workflows provide a structured way to organize and sequence the + work that needs to be done, ensuring that tasks are performed in + the right order and that dependencies are respected. + + ## Why Workflows Matter + + Workflows enable: + + - **Clarity** — Everyone understands the sequence of activities + needed to accomplish a goal + - **Consistency** — The same process is followed every time, + reducing errors and variability + - **Efficiency** — Workflows optimize the order of operations + - **Automation** — Well-defined workflows can be automated, + reducing manual effort + - **Governance** — Workflows ensure that business rules and + policies are followed + + !!! tip "Start with business logic" + + Workflows should reflect how the business actually works, not + how systems are currently implemented. + Focus on the logical order of business activities. + + ## Workflow Structure + + Workflows consist of a sequence of steps, where each step + corresponds to executing a [Story](story.md) in the use case. + The steps are organized to achieve the desired business + [Outcome](outcome.md). + + The concepts and terms used in the workflow are based on the + context-specific vocabulary identified during the requirements + gathering phase — the same [Concepts](concept.md) that define + the use case's domain. + + ## When Are Workflows Defined? + + Workflows are typically defined in later stages of the use case + lifecycle, once: + + - The use case requirements are well understood + - The Stories are clearly defined + - The logical order of activities is known + - Dependencies between activities are identified + + This allows workflows to be designed based on a solid + understanding of what needs to be accomplished and how. + +=== "Data & Tech Audience" + + ## What Is a Workflow in the Use Case Tree Method? + + A **Workflow** is a logical sequence of steps that defines the + order of execution for [Stories](story.md) within a [Use + Case](use-case.md). + Every Use Case has one or more Workflows that describe how + business processes should be executed. + + Workflows depend on the [Concepts](concept.md) captured during + the requirements gathering phase and are executed to achieve the + desired business [Outcome](outcome.md). + + ## Workflow Components + + Workflows consist of: + + - **Steps** — Each step corresponds to executing a Story in the + use case + - **Sequence** — The logical order in which steps should be + executed + - **Dependencies** — Relationships between steps that determine + execution order + - **Concepts** — The domain concepts and terms used throughout + the workflow + + The concepts and terms used in the workflow are based on the + context-specific vocabulary identified during the requirements + gathering phase — the same Concepts that define the use case's + domain. + + ## Relationship to Stories + + Each step in a workflow corresponds to executing a Story in the + use case. + This means: + + - **Stories define what** — Each Story specifies what needs to + be accomplished (the capability) + - **Workflows define how** — Workflows specify the order and + sequence in which Stories are executed + - **Together they define the process** — Stories + Workflows = + Complete business process definition + + This separation allows Stories to be reusable across different + workflows, while workflows can compose Stories in different ways + to achieve different outcomes. + + **Bidirectional relationship:** + For each Story, we always know in which Workflows it participates + as a Step. + This bidirectional relationship enables: + + - **Story reuse analysis** — Understanding which workflows use a + given story + - **Impact analysis** — Knowing what workflows are affected when + a story changes + - **Discovery** — Finding workflows that accomplish similar + outcomes by examining their constituent stories + + ## Workflow Execution + + Workflows can be executed in different ways: + + - **Manual execution** — Steps are performed by people following + the workflow definition + - **Automated execution** — Steps are performed by systems that + interpret and execute the workflow + - **Hybrid execution** — Some steps are automated, others are + manual + + The EKG can track workflow execution, monitor progress, and + ensure that business rules and policies are followed throughout + the process. + + ## Persistent Stateful Workflows + + It is expected that workflows have **persistent stateful** + execution capabilities. + This means that workflows can maintain their state across + execution sessions, enabling them to handle processes of varying + durations and complexity. + + **Short-duration workflows:** + Some workflows can be done quickly in real-time and in-memory, + where one [Story's](story.md) output can be directly used as the + next Story's input. + These workflows execute entirely within a single session and + complete in seconds or minutes. + + **Long-duration workflows:** + Some workflows may take hours, weeks, or even months to complete. + These workflows require persistent state management because: + + - **Human involvement** — Steps may require human review, + approval, or input, which can take significant time + - **Agentic steps** — Steps may involve autonomous agents that + need time to complete their tasks + - **External dependencies** — Steps may depend on external + systems or events that occur over extended periods + - **Complex processes** — Business processes may naturally span + long timeframes (e.g., procurement, project management, + regulatory approvals) + + Persistent stateful workflows enable the EKG to: + + - **Resume execution** — Workflows can pause and resume from + their last state + - **Track progress** — Long-running workflows maintain their + state and can report progress at any time + - **Handle interruptions** — Workflows can handle system + restarts, failures, or pauses without losing their state + - **Support human-in-the-loop** — Workflows can wait for human + input and resume when that input is provided + + This capability is essential for modeling real-world business + processes that don't complete instantly but unfold over time. + + ## Workflows as First-Class EKG Objects + + Ideally, workflows are persisted as part of the overall EKG as + **first-class citizen objects**. + This means that workflows, their steps, and their states can be + inspected, queried, and reasoned about like any other object in + the Enterprise Knowledge Graph. + + **Workflow lifecycle:** + + - **Workflows are initiated by Stories** — A Story can trigger + the execution of a workflow + - **Each step is a call to a Story** — Each step in a workflow + corresponds to executing a Story, maintaining the connection + between the workflow definition and the business requirements + - **State is persisted** — Workflow state is stored in the EKG, + enabling inspection, monitoring, and reasoning about workflow + execution + + **Benefits of first-class persistence:** + + - **Inspectability** — Workflow steps and states can be queried + and analyzed like any other EKG data + - **Observability** — Workflow execution can be monitored and + traced through the EKG + - **Reasoning** — The EKG can reason about workflow state, + dependencies, and execution paths + - **Integration** — Workflows are integrated with other EKG + concepts (Use Cases, Stories, Concepts, Personas) + + **Implementation:** + Conceptually, workflows are similar to + [AWS Step Functions](https://aws.amazon.com/step-functions/), + which could be one of the technologies used to implement these + workflows. + However, the key difference is that in the Use Case Tree Method, workflows + are not just execution engines but semantic objects that are part + of the knowledge graph itself, enabling deeper integration and + reasoning capabilities. + + !!! info "Provenance" + + When your EKG Service Layer fully supports the Use Case Tree Method and + you have a Story Service that can execute Stories, then + ideally you want it to automatically maintain the provenance + chain of activities. + + Like the [PROV-O](https://www.w3.org/TR/prov-o/) (Provenance + Ontology) describes, provenance has three main classes: + **Activity**, **Agent**, and **Entity**. + + The ultimate form of provenance implementation is to be able + to link an Activity to the execution of a particular Story in + the context of a particular instance of a Workflow. + Then you have everything to provide full explainability. + + This provenance chain enables: + + - **Traceability** — Understanding what happened and why + - **Explainability** — Explaining how results were produced + - **Auditability** — Tracking who did what and when + - **Debugging** — Understanding execution paths and failures + + !!! tip "Observability" + + In modern-day architectures, you have fully instrumented code + producing traces that are collected by + [OpenTelemetry](https://opentelemetry.io/) (OTEL)-compliant + collectors. + + The concept of a so-called **"span"** (in + [OTLP](https://opentelemetry.io/docs/specs/otlp/) / OTEL + jargon) perfectly aligns with a + [PROV-O](https://www.w3.org/TR/prov-o/) Activity and with a + Workflow-step execution. + + This alignment enables: + + - **Unified observability** — Workflow execution traces can + be integrated with application traces + - **End-to-end visibility** — From business process + (Workflow) to technical implementation (code spans) + - **Semantic enrichment** — OTEL spans can be enriched with + EKG semantic metadata (Story, Workflow, Persona, etc.) + - **Cross-system correlation** — Linking business activities + with technical execution across distributed systems + + ## Workflow Patterns + + Common workflow patterns include: + + - **Sequential** — Steps execute one after another in a fixed + order + - **Parallel** — Multiple steps execute simultaneously + - **Conditional** — Different steps execute based on conditions + - **Iterative** — Steps repeat until a condition is met + - **Event-driven** — Steps execute in response to events + + These patterns can be combined to create complex workflows that + model real-world business processes. + + ## Relationship to Other Concepts + + Workflows relate to other core concepts: + + - **[Use Cases](use-case.md)** — Every use case has one or more + workflows + - **[Stories](story.md)** — Each workflow step corresponds to + executing a story + - **[Concepts](concept.md)** — Workflows use concepts from the + use case's vocabulary + - **[Outcomes](outcome.md)** — Workflows are executed to achieve + desired business outcomes + - **[Personas](persona.md)** — Workflows specify which personas + are involved in each step + + This integration ensures that workflows are not isolated process + definitions but part of a cohesive, semantic model of the + enterprise. + +=== "Ontology" + + ## Ontology (minimal facts we can state today) + + --8<-- "fragment/uctm-diagram-workflow.md" + + We're not (yet) prescribing a full OWL ontology here. + But we can state a small set of **facts** that people can reliably use to build their own + ontology / schema / graph model around a Workflow. + + !!! note "WorkflowDefinition" + + When we say “Workflow” here, we primarily mean the **definition** of a workflow + (a **WorkflowDefinition**), not a specific runtime execution instance. + + ### Required facts about a WorkflowDefinition + + - **Opaque universally unique identifier** + - A WorkflowDefinition should have an **opaque**, **universally unique** identifier. + - Prefer a random identifier such as **UUIDv4**, represented as a URI: + `urn:uuid:550e8400-e29b-41d4-a716-446655440000` + + - **Business-friendly name** + - A WorkflowDefinition should have a human-readable name. + + - **Slug** + - A WorkflowDefinition should have a kebab-cased slug that is unique at least within the + organization. + - Example: `onboard-supplier`, `assess-counterparty-risk` + + - **Definition** + - A WorkflowDefinition should have a definition describing the business process it models. + + - **Owned by a Use Case** + - A WorkflowDefinition is **part-of** a Use Case: the Use Case **owns** it. + - If the owning Use Case is deleted, its workflow definitions are deleted as well. + + - **Steps that reference Stories (relationship-object)** + - A WorkflowDefinition has **zero or more Steps**. + - Each Step references a Story. + - Model Steps as relationship-objects so you can capture ordering and execution semantics + (sequence, branching/conditions, parallelism, retries, etc.). -For every given use case, we also need to describe the logical order -of things in terms of workflows or business processes. -These workflows depend on the [concepts](./concept.md) captured during -the requirements gathering phase and are executed to achieve the desired -business [outcome](./outcome.md). -Each step in the workflow corresponds to executing a story in the use case, -and the concepts and terms used in the workflow are based on the -context-specific vocabulary identified during the requirements gathering phase. + - **Outcomes and concepts** + - Workflows are executed to achieve Outcomes (directly or via the Stories they orchestrate). + - Workflows use Concepts through the Use Case’s Concept Vocabularies and the Stories in + their steps. diff --git a/docs/diagrams/src/persona-class-diagram.puml b/docs/diagrams/src/persona-class-diagram.puml deleted file mode 100644 index 4287ae92..00000000 --- a/docs/diagrams/src/persona-class-diagram.puml +++ /dev/null @@ -1,27 +0,0 @@ -!option handwritten false -@startuml -!include ../include/themes/light.puml - -class Concept { - - type : ConceptType -} -class Concept [[http://plantuml.com{Optional tooltip} This label is printed]] -class UseCase { - - vocabulary: Vocabulary - - stories: Story[] -} -UseCase --> UseCase : requires -Vocabulary "*" --> "*" Concept -Vocabulary "*" --> "*" Term -Story --> "*" Concept : input -Story --> "*" Concept : output -Term --> "1..*" Concept -Concept ---right-> OntologyAxiom -Vocabulary <--> Concept -UseCase --> "1..*" Story -Persona --up-|> Concept -Concept --> Concept : broader -Concept --> Term : preferred -UseCase --> "1" Vocabulary : use case vocabulary -Persona "1" -right-o "0..*" Story -@enduml diff --git a/docs/fragment/uctm-diagram-concept.md b/docs/fragment/uctm-diagram-concept.md new file mode 100644 index 00000000..3689928c --- /dev/null +++ b/docs/fragment/uctm-diagram-concept.md @@ -0,0 +1,36 @@ + + +```mermaid +classDiagram + direction LR + hide members + + class Concept + class Term + class BusinessTerm + class TechnicalTerm + class ConceptVocabulary + class UseCase + class Story + class StoryConceptRelationship + + %% Term specializations + Term <|-- BusinessTerm + Term <|-- TechnicalTerm + + %% Terms + Concept "1" *-- "1..*" Term : ∶term + Concept "0..1" --> "1" BusinessTerm : ∶labelTerm + + %% Vocabularies + %% Mermaid classDiagram can't parse ASCII ':' inside labels; use ratio sign (∶) instead. + ConceptVocabulary "1" o-- "0..*" Concept : skos∶inScheme + ConceptVocabulary "0..*" --> "1" UseCase : ∶useCase + + %% Usage + Story "0..*" --> "1" StoryConceptRelationship : ∶storyConcept + StoryConceptRelationship --> Concept : ∶concept +``` + + + diff --git a/docs/fragment/uctm-diagram-outcome.md b/docs/fragment/uctm-diagram-outcome.md new file mode 100644 index 00000000..f3331586 --- /dev/null +++ b/docs/fragment/uctm-diagram-outcome.md @@ -0,0 +1,23 @@ + + +```mermaid +classDiagram + direction LR + hide members + + class Outcome + class UseCase + class Story + class OutcomeRelationship + + %% Outcome linkage (relationship-object) + OutcomeRelationship "0..*" --> "1" UseCase : ∶useCase + OutcomeRelationship --> Outcome : ∶targetOutcome + + %% Stories reference outcomes as "why" + %% Mermaid classDiagram can't parse ASCII ':' inside labels; use ratio sign (∶) instead. + Story --> Outcome : ∶contributesTo +``` + + + diff --git a/docs/fragment/uctm-diagram-persona.md b/docs/fragment/uctm-diagram-persona.md new file mode 100644 index 00000000..82d57fa8 --- /dev/null +++ b/docs/fragment/uctm-diagram-persona.md @@ -0,0 +1,26 @@ + + +```mermaid +classDiagram + direction LR + hide members + + class Persona + class Story + class UseCase + class PersonaTaxonomy + + %% Personas show up in stories ("playedBy") which are owned by a use case + Story --> Persona : ∶playedBy + Story "0..*" --> "1" UseCase : ∶useCase + + %% Personas belong to a PersonaTaxonomy (SKOS concept scheme) + Persona --> PersonaTaxonomy : skos∶inScheme + PersonaTaxonomy "0..1" --> "1" UseCase : ∶useCase + + %% Persona inheritance (optional) + Persona --> Persona : ∶isSubPersonaOf +``` + + + diff --git a/docs/fragment/uctm-diagram-story.md b/docs/fragment/uctm-diagram-story.md new file mode 100644 index 00000000..40d08966 --- /dev/null +++ b/docs/fragment/uctm-diagram-story.md @@ -0,0 +1,40 @@ + + +```mermaid +classDiagram + direction LR + hide members + + class Story + class UseCase + class Persona + class Outcome + class Concept + class Term + class BusinessTerm + class TechnicalTerm + class WorkflowDefinition + class StoryConceptRelationship + + %% Term specializations + Term <|-- BusinessTerm + Term <|-- TechnicalTerm + + %% Other resources point to UseCase (typical KG modeling style) + Story "0..*" --> "1" UseCase : ∶useCase + + %% Story structure + Story --> Persona : ∶playedBy + Story --> Outcome : ∶contributesTo + + %% Concept usage + Story "0..*" --> "1" StoryConceptRelationship : ∶storyConcept + StoryConceptRelationship --> Concept : ∶concept + Concept "1" *-- "1..*" Term : ∶term + Concept "0..1" --> "1" BusinessTerm : ∶labelTerm + + %% Workflow participation + WorkflowDefinition --> Story : ∶steps +``` + + diff --git a/docs/fragment/uctm-diagram-term.md b/docs/fragment/uctm-diagram-term.md new file mode 100644 index 00000000..a2a38687 --- /dev/null +++ b/docs/fragment/uctm-diagram-term.md @@ -0,0 +1,30 @@ + + +```mermaid +classDiagram + direction LR + hide members + + class Term + class BusinessTerm + class TechnicalTerm + class Concept + class ConceptVocabulary + class UseCase + + %% Term specializations + Term <|-- BusinessTerm + Term <|-- TechnicalTerm + + %% Ownership + Concept "1" *-- "1..*" Term : ∶term + Concept "0..1" --> "1" BusinessTerm : ∶labelTerm + + %% Context (terms live inside vocabularies used by use cases) + %% Mermaid classDiagram can't parse ASCII ':' inside labels; use ratio sign (∶) instead. + ConceptVocabulary "1" o-- "0..*" Concept : skos∶inScheme + ConceptVocabulary "0..*" --> "1" UseCase : ∶useCase +``` + + + diff --git a/docs/fragment/uctm-diagram-use-case.md b/docs/fragment/uctm-diagram-use-case.md new file mode 100644 index 00000000..1e3a2a49 --- /dev/null +++ b/docs/fragment/uctm-diagram-use-case.md @@ -0,0 +1,56 @@ + + +```mermaid +classDiagram + direction LR + hide members + + class UseCase + class UseCaseStereotype + class Story + class WorkflowDefinition + class Outcome + class OutcomeRelationship + class ConceptVocabulary + class Concept + class Term + class BusinessTerm + class TechnicalTerm + class Persona + class StoryConceptRelationship + class PersonaTaxonomy + + %% Term specializations + Term <|-- BusinessTerm + Term <|-- TechnicalTerm + + %% Other resources point to UseCase (typical KG modeling style) + Story "0..*" --> "1" UseCase : ∶useCase + WorkflowDefinition "0..*" --> "1" UseCase : ∶useCase + ConceptVocabulary "0..*" --> "1" UseCase : ∶useCase + OutcomeRelationship "0..*" --> "1" UseCase : ∶useCase + PersonaTaxonomy "0..1" --> "1" UseCase : ∶useCase + + %% Local ownership / containment + Concept "1" *-- "1..*" Term : ∶term + Concept "0..1" --> "1" BusinessTerm : ∶labelTerm + %% Mermaid classDiagram can't parse ASCII ':' inside labels; use ratio sign (∶) instead. + ConceptVocabulary "1" o-- "0..*" Concept : skos∶inScheme + + %% Other key relationships + UseCase "0..1" --> "1" UseCaseStereotype : usecase∶stereotype + OutcomeRelationship --> Outcome : ∶targetOutcome + + %% Usage (high-level) + Story --> Persona : ∶playedBy + Story --> Outcome : ∶contributesTo + Story "0..*" --> "1" StoryConceptRelationship : ∶storyConcept + StoryConceptRelationship --> Concept : ∶concept + WorkflowDefinition --> Story : steps + + %% Personas belong to a PersonaTaxonomy (SKOS concept scheme) + Persona --> PersonaTaxonomy : skos∶inScheme +``` + + + diff --git a/docs/fragment/uctm-diagram-workflow.md b/docs/fragment/uctm-diagram-workflow.md new file mode 100644 index 00000000..14f8399c --- /dev/null +++ b/docs/fragment/uctm-diagram-workflow.md @@ -0,0 +1,28 @@ + + +```mermaid +classDiagram + direction LR + hide members + + class WorkflowDefinition + class UseCase + class Story + class Outcome + class Concept + class StoryConceptRelationship + + %% Other resources point to UseCase (typical KG modeling style) + WorkflowDefinition "0..*" --> "1" UseCase : ∶useCase + + %% Steps (relationship-object implied) + WorkflowDefinition --> Story : ∶steps + + %% Stories link to outcomes and concepts + Story --> Outcome : ∶contributesTo + Story "0..*" --> "1" StoryConceptRelationship : ∶storyConcept + StoryConceptRelationship --> Concept : ∶concept +``` + + + diff --git a/docs/fragment/uctm-partial-class-diagram.md b/docs/fragment/uctm-partial-class-diagram.md new file mode 100644 index 00000000..71ac544b --- /dev/null +++ b/docs/fragment/uctm-partial-class-diagram.md @@ -0,0 +1,45 @@ + + +```mermaid +classDiagram + direction LR + hide members + + class UseCase + + class UseCaseStereotype + + class Story + + class WorkflowDefinition + + class Outcome + + class OutcomeRelationship + + class Concept + + class ConceptVocabulary + class Term + class Persona + + %% Ownership / composition (part-of) + UseCase "1" *-- "0..*" Story : owns + UseCase "1" *-- "0..*" WorkflowDefinition : owns + Concept "1" *-- "1..*" Term : owns + + %% Relationships + UseCase "0..1" --> "1" UseCaseStereotype : hasStereotype + UseCase "0..*" --> "0..*" OutcomeRelationship : outcomeLink + OutcomeRelationship --> Outcome : targetOutcome + UseCase "0..*" --> "0..*" ConceptVocabulary : references/owns + ConceptVocabulary "1" o-- "0..*" Concept : contains + + %% Usage + Story --> Persona : story:playedBy + Story --> Outcome : story:contributesTo + Story --> StoryConceptRelationship : story∶relatedConcept + StoryConceptRelationship --> Concept: story∶concept + WorkflowDefinition --> Story : workflow:firstStep +``` + diff --git a/docs/index.md b/docs/index.md index 8866e071..860c1b85 100644 --- a/docs/index.md +++ b/docs/index.md @@ -1,4 +1,12 @@ --- +description: "Use Case Tree Method for developing Enterprise Knowledge Graphs (EKG). A comprehensive method to develop business capabilities through structured use cases, outcomes, and workflows." +keywords: + - EKG method + - enterprise knowledge graph + - use case tree + - business capabilities + - knowledge graph methodology +schema_type: "WebSite" hide: - navigation - toc diff --git a/docs/intro/index.md b/docs/intro/index.md index 018d1a6b..9eac441a 100644 --- a/docs/intro/index.md +++ b/docs/intro/index.md @@ -4,6 +4,14 @@ author: hide: - toc - navigation +description: "Introduction to the Use Case Tree Method for developing Enterprise Knowledge Graphs. Learn how this method enables strategic use cases, data quality, compliance, and competitive advantage." +keywords: + - use case tree method + - EKG introduction + - enterprise knowledge graph method + - business capabilities + - EKG method +schema_type: "Article" --- # Use Case Tree Method for Business Capabilities diff --git a/docs/javascript/images_dark.js b/docs/javascript/images_dark.js deleted file mode 100644 index 39f6314f..00000000 --- a/docs/javascript/images_dark.js +++ /dev/null @@ -1,91 +0,0 @@ -const paletteSwitcher1 = document.getElementById("__palette_1"); -const paletteSwitcher2 = document.getElementById("__palette_2"); - -paletteSwitcher1.addEventListener("change", function () { - documentFromDarkToLight(document) -}); - -paletteSwitcher2.addEventListener("change", function () { - documentFromLightToDark(document) -}); - -if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches) { - alert("you're in dark mode") // dark mode -} else { - alert("you're in light mode") -} - -window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', e => { - const newColorScheme = e.matches ? "dark" : "light"; - alert("zzzzz " + newColorScheme) -}); - -document.addEventListener("DOMContentLoaded", function(){ - alert('The page has fully loaded'); - const palette = __md_get("__palette"); - alert("palette: " + palette) - if (palette && typeof palette.color === "object") - if (palette.color.scheme === "slate") { - alert("dark: " + palette.color.scheme) - } - } -}); - - -// if (window.matchMedia('(prefers-color-scheme: dark)').matches === true) { -// documentFromLightToDark(document) -// } - -const darkModeMediaQuery = window.matchMedia('(prefers-color-scheme: dark)'); -darkModeMediaQuery.addListener((e) => { - const darkModeOn = e.matches; - - if (darkModeOn) - documentFromLightToDark(document) - else - documentFromDarkToLight(document) - console.log(`Dark mode is ${darkModeOn ? '🌒 on' : '☀️ off'}.`); -}); - -function documentFromDarkToLight(document) { - imagesFromDarkToLight(document.querySelectorAll('img[src$="darkable"')); - objectsFromDarkToLight(document.querySelectorAll('object[data$="darkable"')); -} - -function documentFromLightToDark(document) { - imagesFromLightToDark(document.querySelectorAll('img[src$="darkable"')); - objectsFromLightToDark(document.querySelectorAll('object[data$="darkable"')); -} - -function imagesFromLightToDark(images) { - images.forEach(image => { - const idx = image.src.lastIndexOf('.'); - if (idx > -1) { - const add = "_dark"; - image.src = [image.src.slice(0, idx), add, image.src.slice(idx)].join(''); - } - }); -} - -function imagesFromDarkToLight(images) { - images.forEach(image => { - image.src = image.src.replace("_dark", ""); - }); -} - -function objectsFromLightToDark(objects) { - objects.forEach(object => { - const idx = object.data.lastIndexOf('.'); - if (idx > -1) { - const add = "_dark"; - object.data = [object.data.slice(0, idx), add, object.data.slice(idx)].join(''); - } - }); -} - -function objectsFromDarkToLight(objects) { - objects.forEach(object => { - object.data = object.data.replace("_dark", ""); - }); -} - diff --git a/docs/javascript/refresh_on_toggle_dark_light.js b/docs/javascript/refresh_on_toggle_dark_light.js deleted file mode 100644 index a5b7fa7e..00000000 --- a/docs/javascript/refresh_on_toggle_dark_light.js +++ /dev/null @@ -1,10 +0,0 @@ -const paletteSwitcher1 = document.getElementById("__palette_1"); -const paletteSwitcher2 = document.getElementById("__palette_2"); - -paletteSwitcher1.addEventListener("change", function () { - location.reload(); -}); - -paletteSwitcher2.addEventListener("change", function () { - location.reload(); -}); \ No newline at end of file diff --git a/docs/javascripts/mermaid.js b/docs/javascripts/mermaid.js new file mode 100644 index 00000000..53a5fbe1 --- /dev/null +++ b/docs/javascripts/mermaid.js @@ -0,0 +1,48 @@ +/** + * Mermaid.js Configuration for EKGF Custom Colors + * + * IMPORTANT: + * - We use Material for MkDocs' NATIVE Mermaid support (NOT mkdocs-mermaid2-plugin!) + * - Do NOT install mkdocs-mermaid2-plugin - it conflicts with Material's native support + * - Material for MkDocs automatically looks for window.mermaidConfig in extra_javascript files + * - This configuration applies to all Mermaid diagrams site-wide + * + * Color Scheme (EKGF Brand): + * - Primary: #4051b5 (Indigo blue) - node backgrounds + * - Accent: #ff6f00 (EKGF orange) - borders and connector lines + * - Text: #ffffff (White) - for contrast on colored nodes + * + * How It Works: + * 1. Material for MkDocs reads window.mermaidConfig before initializing Mermaid + * 2. This file is loaded via extra_javascript in mkdocs.yml + * 3. The theme variables override Material's defaults + * 4. No need for inline %%{init}%% directives in diagrams + */ + +window.mermaidConfig = { + theme: 'base', + themeVariables: { + primaryColor: '#4051b5', + primaryTextColor: '#ffffff', + primaryBorderColor: '#ff6f00', + lineColor: '#ff6f00', + secondaryColor: '#4051b5', + secondaryTextColor: '#ffffff', + secondaryBorderColor: '#ff6f00', + tertiaryColor: '#4051b5', + tertiaryTextColor: '#ffffff', + tertiaryBorderColor: '#ff6f00', + background: '#ffffff', + mainBkg: '#4051b5', + secondaryBkg: '#4051b5', + tertiaryBkg: '#4051b5', + textColor: '#ffffff', + nodeBorder: '#ff6f00', + clusterBkg: '#4051b5', + clusterBorder: '#ff6f00', + defaultLinkColor: '#ff6f00', + titleColor: '#333333', + edgeLabelBackground: '#ffffff' + } +}; + diff --git a/docs/objective/.pages.yaml b/docs/objective/.pages.yaml index 5088bcc9..54674233 100644 --- a/docs/objective/.pages.yaml +++ b/docs/objective/.pages.yaml @@ -1,16 +1,16 @@ title: Objectives nav: - - Composable Business: composable-business.md - - Requirements Captured: know-what-the-business-wants.md - - Knowledge Captured: capture-knowledge.md - - Gaps Bridged: bridge-the-gap.md - - Expectations Managed: manage-expectations.md - - Did not boil the ocean: avoid-boiling-the-ocean.md - - Disruption Avoided: avoid-disruption.md - - Quality Increased: increase-quality.md - - Aligned with Strategy: align-with-business-strategy.md - - Delivered: strategic-usecases.md - - Modularity Managed: modularity.md - - Interoperability Achieved: interoperability.md - - Reuse Enabled: enable-reuse.md + - "A: Interoperability Achieved": interoperability.md + - "B: Composable Business": composable-business.md + - "C: Requirements Captured": know-what-the-business-wants.md + - "D: Knowledge Captured": capture-knowledge.md + - "E: Gaps Bridged": bridge-the-gap.md + - "F: Expectations Managed": manage-expectations.md + - "G: Did not boil the ocean": avoid-boiling-the-ocean.md + - "H: Disruption Avoided": avoid-disruption.md + - "I: Quality Increased": increase-quality.md + - "J: Aligned with Strategy": align-with-business-strategy.md + - "K: Delivered": strategic-usecases.md + - "L: Modularity Managed": modularity.md + - "M: Reuse Enabled": enable-reuse.md - ... diff --git a/docs/objective/align-with-business-strategy.md b/docs/objective/align-with-business-strategy.md index 2f5ea469..093ddba8 100644 --- a/docs/objective/align-with-business-strategy.md +++ b/docs/objective/align-with-business-strategy.md @@ -1,11 +1,20 @@ --- -title: Align with Business Strategy +title: "J: Align with Business Strategy" authors: - Jacobus Geluk hide: - - toc +- toc +description: "Align strategy of business capability improvement and execution. Learn how the Use Case Tree Method creates a single artifact that aligns all lines of business." +keywords: + - business strategy + - strategic alignment + - business capabilities + - EKG method + - enterprise knowledge graph + - capability planning +schema_type: "Article" --- -# Align with Business Strategy +# J: Align with Business Strategy _Align strategy of business capability improvement and execution._ diff --git a/docs/objective/avoid-boiling-the-ocean.md b/docs/objective/avoid-boiling-the-ocean.md index d9605e8a..7d9adad4 100644 --- a/docs/objective/avoid-boiling-the-ocean.md +++ b/docs/objective/avoid-boiling-the-ocean.md @@ -1,11 +1,20 @@ --- -title: Avoid "boiling the ocean" +title: "G: Avoid \"boiling the ocean\"" authors: - Jacobus Geluk hide: - - toc +- toc +description: "Provide focus, clarity, deliver business value fast, do the right things at the right time. Learn how the Use Case Tree Method prevents scope creep and delivers value incrementally." +keywords: + - scope management + - incremental delivery + - business value + - EKG method + - enterprise knowledge graph + - agile methodology +schema_type: "Article" --- -# Avoid "boiling the ocean" +# G: Avoid "boiling the ocean" _Provide focus, clarity, deliver business value fast, do the right things at the right time. Save money._ diff --git a/docs/objective/avoid-disruption.md b/docs/objective/avoid-disruption.md index 63ad21f2..30064f72 100644 --- a/docs/objective/avoid-disruption.md +++ b/docs/objective/avoid-disruption.md @@ -1,11 +1,20 @@ --- -title: Avoid Disruption +title: "H: Avoid Disruption" authors: - Jacobus Geluk hide: - - toc +- toc +description: "Make changes gradually with clear interdependencies to avoid disruption across use cases. Learn how the Use Case Tree Method enables safe, incremental change." +keywords: + - change management + - disruption avoidance + - incremental change + - EKG method + - enterprise knowledge graph + - use case dependencies +schema_type: "Article" --- -# Avoid Disruption +# H: Avoid Disruption _Make changes gradually with clear interdependencies to avoid disruption across use cases._ diff --git a/docs/objective/bridge-the-gap.md b/docs/objective/bridge-the-gap.md index 04656301..1253dfdf 100644 --- a/docs/objective/bridge-the-gap.md +++ b/docs/objective/bridge-the-gap.md @@ -1,14 +1,23 @@ --- -title: Bridge the traditional gap between Business & Technology +title: "E: Bridge the traditional gap between Business & Technology" authors: - Jacobus Geluk -hide: +hide: - toc +description: "Align business expectations with technology delivery. Learn how the Use Case Tree Method bridges the gap between business and IT through continuous engagement." +keywords: + - business IT alignment + - business technology gap + - stakeholder engagement + - EKG method + - enterprise knowledge graph + - product owner +schema_type: "Article" --- -# Bridge the traditional gap between Business & Technology +# E: Bridge the traditional gap between Business & Technology -Align business expectations with technology delivery. +_Align business expectations with technology delivery._ - Engage with the business, the product owner and get continuous diff --git a/docs/objective/capture-knowledge.md b/docs/objective/capture-knowledge.md index 04905cd4..1a27fcf9 100644 --- a/docs/objective/capture-knowledge.md +++ b/docs/objective/capture-knowledge.md @@ -1,11 +1,20 @@ --- -title: Capture Knowledge +title: "D: Capture Knowledge" authors: - Jacobus Geluk hide: - toc +description: "Enabling a whole new league of use cases through comprehensive knowledge capture. Learn how the Use Case Tree Method maps all knowledge, data, and functionality." +keywords: + - knowledge capture + - knowledge management + - enterprise knowledge + - EKG method + - enterprise knowledge graph + - knowledge mapping +schema_type: "Article" --- -# Capture Knowledge +# D: Capture Knowledge _Enabling a whole new league of use cases._ diff --git a/docs/objective/composable-business.md b/docs/objective/composable-business.md index 18cd5808..64635e3e 100644 --- a/docs/objective/composable-business.md +++ b/docs/objective/composable-business.md @@ -1,28 +1,145 @@ --- -title: Composable Business +title: "B: Composable Business" authors: - Jacobus Geluk hide: - toc +description: "Making the enterprise adaptive through modular knowledge and reusable capabilities. Learn how the Use Case Tree Method enables composable business architecture." +keywords: + - composable business + - business composability + - modular architecture + - EKG method + - enterprise knowledge graph + - adaptive enterprise +schema_type: "Article" --- -# Composable Business +# B: Composable Business -The Future of Business Is Composable +_Making the enterprise adaptive through modular knowledge and +reusable capabilities_ +## Objective -!!! info +A composable business is one that can adapt and reconfigure itself +continuously — not through massive reorganisations or costly rewrites, +but through modular, reusable, and semantically connected components. - Work in progress. Points to make: +Composable Business is the organisational expression of the Enterprise +Knowledge Graph (EKG) and the Use Case Tree (UCT) method. It represents +the ability to assemble business capabilities dynamically from trusted, +reusable building blocks: use cases, data products, stories, workflows, +and ontologies — all governed within the EKG. - - Explain that the [Use Case Tree (UCT)](../concept/use-case-tree.md) is the ultimate way to implement - what Gartner now calls "Composable Business": - - https://www.gartner.com/smarterwithgartner/gartner-keynote-the-future-of-business-is-composable - - Same for "Packaged Business Capabilities (PBCs)" (also called Packaged Business Components): - - https://www.elasticpath.com/blog/what-are-packaged-business-capablities - - https://www.elasticpath.com/blog/what-is-the-difference-between-PBCs-and-microservices - - https://blog.dreamfactory.com/enterprise-it-building-blocks-the-packaged-business-capability/ - - Explain what's missing with the various proposed approaches in the articles above. - Why Semantic Technology and in particular EKG & the UCT is key to _really_ make this fly. +## Why It Matters +Most organisations struggle to change because their systems, data, and +processes are tightly coupled and fragmented. Innovation requires +coordination across dozens of silos, each with its own models and +assumptions. + +Composable Business replaces this fragility with semantic modularity — +every business capability becomes a governed component that can be +reused, combined, or replaced without breaking the whole. + +The result: + +- Faster adaptation to market or regulatory change +- Continuous innovation without re-engineering core systems +- Resilience through modular design +- Clarity and governance through shared semantics + +## The Role of the Use Case Tree (UCT) + +The Use Case Tree (UCT) is the organising structure of composability. +It defines how business capabilities are decomposed into modular use +cases, each of which can be modelled, implemented, and run +independently, yet still fit coherently into the enterprise +architecture. + +Every node in the UCT represents a reusable component — a semantic +package containing: + +- Defined outcomes and personas +- Stories (tool functions or APIs) +- Data products and ontologies +- Workflows and policies + +This makes the UCT the semantic package manager of the EKG — similar to +how npmjs.org or pypi.org manage software packages — but at enterprise +scale, spanning business, data, and knowledge assets. + +## Composable Business vs. Reuse Enablement + +### Two sides of the same semantic coin + +While Composable Business and Reuse Enablement both aim to make the +enterprise modular, they operate at different levels of abstraction. +The table below outlines how they relate and reinforce one another +within the EKGF Method. + +| Aspect | Composable Business | Reuse Enablement | +|--------|---------------------|------------------| +| Focus / Orientation | _How business capabilities are composed, orchestrated, and evolved_ | _How knowledge assets and components are packaged and shared_ | +| Primary Question | "How do we assemble business capabilities from reusable parts to adapt to change?" | "How do we design those reusable parts so they can be assembled safely and meaningfully?" | +| Scope | Business and operational level — orchestrating Use Cases, Personas, and Stories into composable outcomes. | Technical and semantic level — creating and governing reusable artifacts: ontologies, datasets, shapes, workflows, data products, and Stories. | +| Key Mechanism | **Use Case Tree (UCT)** as the orchestration layer: composing and aligning modular business capabilities. | **Use Case Tree (UCT)** as the packaging layer: publishing reusable components and metadata to the Enterprise Knowledge Graph (EKG) for discovery and re-use. | +| Relationship to the EKG | The EKG provides the shared semantics and service interfaces that make cross-use-case orchestration possible. | The EKG provides the shared identifiers, ontologies, and provenance that make reuse safe and traceable. | +| Value Proposition | Agility and adaptability: the ability to reconfigure the enterprise dynamically in response to change. | Efficiency and consistency: the ability to reduce duplication and accelerate delivery through reusable, versioned components. | +| Primary Users | Business and solution architects; transformation leads. | Data and knowledge engineers; ontology and platform teams. | +| Outcome | Composable business capabilities and adaptive workflows. | Reusable semantic components and data products. | +| Relationship to Each Other | Composable business **depends** on reuse. Without reusable components, there is nothing to compose. | Reuse **finds purpose** in composability. Without higher-level composition, reuse is just technical hygiene. | + +!!! tip "Two sides of the same semantic coin" + + **Reuse Enablement** creates the *building blocks*. + + **Composable Business** assembles them into *living systems*. + + Every successful technology ecosystem has a way to share reusable + components — the JavaScript world has [*npm*](https://www.npmjs.com) + with over 3.5 million packages, the Python world has + [*PyPI*](https://pypi.org) with over 600,000 packages, and so on — each + enabling developers to build upon a vast ecosystem of reusable + components. + + The **Use Case Tree (UCT)** plays the same role for the **Enterprise + Knowledge Graph (EKG)**: it is the semantic package manager that makes + every business capability, data product, and workflow discoverable, + versioned, and ready to be reused and composed safely across the + enterprise. + + + +## Getting Started + +To move toward a composable business: + +1. Model your business capabilities using the UCT — define outcomes, + personas, and dependencies. +2. Publish reusable components (stories, data products, ontologies) to + the EKG with clear provenance and semantics. +3. Compose new capabilities by linking and orchestrating existing + components rather than building from scratch. +4. Govern the lifecycle of use cases and their subcomponents — + versioning, approval, and retirement all managed within the EKG. +5. Measure reuse and adaptability as key indicators of enterprise + maturity. + +## Related Objectives + +- [Enable Reuse](enable-reuse.md) +- [Capture Knowledge](capture-knowledge.md) +- [Manage Modularity](modularity.md) +- [Achieve Interoperability](interoperability.md) + +## Summary + +Composable Business is not a new methodology — it is the natural +outcome of applying the EKGF Method. +When business capabilities, data products, and knowledge artifacts are +structured and governed through the EKG and the UCT, the enterprise +itself becomes composable: a living system of reusable knowledge, ready +to evolve continuously. diff --git a/docs/objective/enable-reuse.md b/docs/objective/enable-reuse.md index 2b25b5ed..dd721098 100644 --- a/docs/objective/enable-reuse.md +++ b/docs/objective/enable-reuse.md @@ -1,15 +1,213 @@ --- -title: Enable Reuse +title: "M: Enable Reuse" authors: - Jacobus Geluk hide: - toc +description: "Building the foundation for composable, scalable enterprise knowledge through reuse. Learn how the Use Case Tree Method enables safe reuse of knowledge assets across teams and domains." +keywords: + - reuse + - knowledge reuse + - reusable components + - EKG method + - enterprise knowledge graph + - composability +schema_type: "Article" --- -# Enable Reuse +# M: Enable Reuse -_Create an ecosystem of reusable components for the EKG._ +_Building the foundation for composable, scalable enterprise knowledge_ -The [Use Case Tree](../concept/use-case-tree.md) is a foundational mechanism to create an ecosystem of -reusable components for the EKG. +## Objective + +**Reuse Enablement** is the discipline of designing, packaging, and +governing every knowledge asset — use case, ontology, data product, or +workflow — so that it can be safely reused across teams, domains, and +generations of technology. + +It is the foundation of the Enterprise Knowledge Graph (EKG): without +reuse, there is no composability, no scalability, and no sustainable +intelligence. +The EKGF Method defines reuse not as a technical afterthought but as a +*core architectural principle* — embedded in the way we plan, build, +and run every enterprise capability. + +## Why It Matters + +Enterprises waste enormous effort solving the same problems repeatedly — +integrating the same data, remodelling the same business rules, +recreating the same workflows. + +Most of this duplication stems from one cause: **knowledge is not shared +as reusable components**. + +When knowledge lives in silos — spreadsheets, slide decks, bespoke +systems — every project begins from zero. +By contrast, a reuse-enabled organisation captures its work as +semantically defined, governed components that can be discovered and +recomposed anywhere across the enterprise. + +The result: + +- Drastically reduced duplication and cost +- Higher quality and consistency through shared models +- Faster delivery and innovation +- Stronger alignment across business and technology + +## Beyond Data: The Real Meaning of Reuse + +Most "semantic technology" initiatives of the past two decades have been +driven from the **data perspective** — led by integration specialists and +ontology engineers. +They delivered powerful data harmonisation but rarely transformed how +the enterprise actually *works*. + +That is where the **Enterprise Knowledge Graph (EKG)** and **Use Case +Tree (UCT)** shift the paradigm. +They treat **reuse not as a data exercise**, but as the foundation for +*application composition*. +In the EKGF Method, reuse is not limited to triples or ontologies — it +extends to **behaviour**, expressed as *Stories* and *Workflows*. + +Just as **object-oriented programming** in the 1980s combined data and +methods into a reusable "object," +the **Use Case Tree (UCT)** combines data, logic, and process into a +reusable **semantic package**: +a use case that contains its meaning (ontology), its data products, and +its behaviour (stories, workflows, outcomes). + +This is the crucial difference: + +!!! tip "The EKGF Method paradigm shift" + + Instead of describing data that *others must code against*, the EKGF + Method captures *the behaviour itself* — executable, governed, and + reusable across domains — without necessarily writing code at all. + +In this sense, a **Use Case** in the EKG is just as real and reusable as +a software package in the JavaScript or Python ecosystems. +Each can be discovered, installed, versioned, extended, and composed — +but the EKG package operates at the **semantic and business level**, +spanning data, logic, and meaning. + +That's why **reuse** is not a side effect of the EKG. +It's the *reason the EKG exists.* + +### From DIKW to EKGF: Making Knowledge Executable + +The well-known **DIKW Model** (Data → Information → Knowledge → Wisdom) +has guided information management for decades. +But it assumes that *Wisdom naturally follows from Knowledge* — as if +understanding automatically produces action. +In practice, enterprises rarely reach that state because the bridge from +*knowing* to *doing* is missing. + +The **EKGF Method** extends this model by adding the **operational +dimension**: +knowledge becomes **behaviour**, behaviour becomes **reusable**, and +reuse powers **composability**. +This is the *Path to Executable Knowledge* — where understanding turns +into governed, shareable, and actionable intelligence. + +The diagram below visualises this shift — showing how the EKGF Method +transforms the classic DIKW hierarchy into a living model of executable, +reusable knowledge. + +![DIKW Model Revised – Path to Executable Knowledge](../assets/dikw-revised.svg) + +Traditional DIKW ends at understanding. +The EKGF Method continues by modelling behaviour, packaging it as reusable +use cases, and feeding it back into a composable enterprise — closing the +loop between data, knowledge, and operational wisdom. + +## The Role of the Use Case Tree (UCT) + +In the EKGF Method, the **Use Case Tree (UCT)** is the mechanism that +makes reuse practical and governed. + +Each node in the UCT acts as a *semantic package* — a defined, +versioned, and discoverable unit of business capability. +Within a UCT package, teams can register: + +- **Ontologies and shapes** defining meaning and validation +- **Stories** (tool functions or APIs) that implement reusable logic +- **Data products** describing and delivering reusable datasets +- **Workflows and policies** orchestrating repeatable patterns + +Every successful technology ecosystem has a way to **share reusable +components** — the JavaScript world has [*npm*](https://www.npmjs.com) +with over 3.5 million packages, the Python world has +[*PyPI*](https://pypi.org) with over 600,000 packages, and so on — each +enabling developers to build upon a vast ecosystem of reusable +components. +The **Use Case Tree (UCT)** plays the same role for the **Enterprise +Knowledge Graph (EKG)**: it is the *semantic package manager* that makes +every business capability, dataset, and workflow discoverable, versioned, +and ready for reuse across the organisation. + +## Reuse Enablement vs. Composable Business + +### Two sides of the same semantic coin + +While *Reuse Enablement* and *Composable Business* share the same +foundation, they operate at different levels of abstraction. +The table below summarises their relationship within the EKGF Method. + +| Aspect | Composable Business | Reuse Enablement | +|--------|---------------------|------------------| +| Focus / Orientation | _How business capabilities are composed, orchestrated, and evolved_ | _How knowledge assets and components are packaged and shared_ | +| Primary Question | "How do we assemble business capabilities from reusable parts to adapt to change?" | "How do we design those reusable parts so they can be assembled safely and meaningfully?" | +| Scope | Business and operational level — orchestrating Use Cases, Personas, and Stories into composable outcomes. | Technical and semantic level — creating and governing reusable artifacts: ontologies, datasets, shapes, workflows, data products, and Stories. | +| Key Mechanism | **Use Case Tree (UCT)** as _the orchestration layer_: composing and aligning modular business capabilities. | **Use Case Tree (UCT)** as _the packaging layer_: publishing reusable components and metadata to the Enterprise Knowledge Graph (EKG) for discovery and re-use. | +| Relationship to the EKG | The EKG provides the shared semantics and service interfaces that make cross-use-case orchestration possible. | The EKG provides the shared identifiers, ontologies, and provenance that make reuse safe and traceable. | +| Value Proposition | Agility and adaptability: the ability to reconfigure the enterprise dynamically in response to change. | Efficiency and consistency: the ability to reduce duplication and accelerate delivery through reusable, versioned components. | +| Primary Users | Business and solution architects; transformation leads. | Data and knowledge engineers; ontology and platform teams. | +| Outcome | Composable business capabilities and adaptive workflows. | Reusable semantic components and data products. | +| Relationship to Each Other | Composable business **depends on** reuse. Without reusable components, there is nothing to compose. | Reuse **finds purpose** in composability. Without higher-level composition, reuse is just technical hygiene. | + +!!! tip "Two sides of the same semantic coin" + + **Reuse Enablement** creates the *building blocks*. + + **Composable Business** assembles them into *living systems*. + + Both rely on the **Use Case Tree (UCT)** as the semantic package + manager of the Enterprise Knowledge Graph — governing how business, + data, and technical artifacts are versioned, discoverable, and + composable. + +## How to Enable Reuse in Practice + +1. **Model once, reuse everywhere:** design ontologies, shapes, and + stories as modular assets stored and versioned in the EKG. + +2. **Publish via the UCT:** register components as packages with clear + ownership, metadata, and dependency relationships. + +3. **Govern for trust:** validate with SHACL, record provenance, enforce + entitlements and lifecycle policies. + +4. **Discover and compose:** make all reusable artifacts searchable and + connectable across domains and teams. + +5. **Measure reuse:** track adoption, version dependencies, and impact + metrics to sustain continuous improvement. + +## Related Objectives + +- [Composable Business](composable-business.md) +- [Manage Modularity](modularity.md) +- [Achieve Interoperability](interoperability.md) +- [Capture Knowledge](capture-knowledge.md) + +## Summary + +Reuse Enablement is how the EKG turns knowledge into infrastructure. +By packaging every use case, ontology, and data product as a governed, +discoverable component within the Use Case Tree, the enterprise builds a +foundation for **scalable intelligence and composable business**. + +When reuse becomes second nature, innovation stops reinventing the wheel +— and starts accelerating on shared semantic ground. diff --git a/docs/objective/increase-quality.md b/docs/objective/increase-quality.md index a71d1d4f..a39a54c6 100644 --- a/docs/objective/increase-quality.md +++ b/docs/objective/increase-quality.md @@ -1,11 +1,20 @@ --- -title: Increase Quality +title: "I: Increase Quality" authors: - Jacobus Geluk hide: - toc +description: "Enforce 100% test coverage based on real business scenarios and requirements. Learn how the Use Case Tree Method ensures quality through comprehensive testing." +keywords: + - quality assurance + - test coverage + - business scenarios + - EKG method + - enterprise knowledge graph + - testing methodology +schema_type: "Article" --- -# Increase Quality +# I: Increase Quality _Enforce 100% test coverage based on real business scenarios and requirements._ diff --git a/docs/objective/index.md b/docs/objective/index.md index 38fa28d0..d6d1e9c3 100644 --- a/docs/objective/index.md +++ b/docs/objective/index.md @@ -1,3 +1,14 @@ +--- +description: "Discover the primary objectives for creating a Use Case Tree in the Use Case Tree Method. Learn how interoperability, composability, reuse, and other objectives drive enterprise knowledge graph success." +keywords: + - EKG objectives + - use case tree objectives + - enterprise knowledge graph goals + - EKG method + - business objectives +schema_type: "WebPage" +--- + # Objectives The primary reasons for creating a [Use Case Tree](../concept/use-case-tree.md) are: @@ -8,79 +19,79 @@ The primary reasons for creating a [Use Case Tree](../concept/use-case-tree.md)
-- :material-cached:{ .lg } __Interoperability Achieved__ +- __Interoperability Achieved__ {% include-markdown "objective/interoperability.md" start="" end="" %} [:octicons-arrow-right-24: Learn more](interoperability.md) -- :material-cached:{ .lg } __Business Composability Improved__ +- __Business Composability Improved__ {% include-markdown "objective/composable-business.md" start="" end="" %} [:octicons-arrow-right-24: Learn more](composable-business.md) -- :material-cached:{ .lg } __Requirements Captured__ +- __Requirements Captured__ {% include-markdown "objective/know-what-the-business-wants.md" start="" end="" %} [:octicons-arrow-right-24: Learn more](know-what-the-business-wants.md) -- :material-cached:{ .lg } __Knowledge Captured__ +- __Knowledge Captured__ {% include-markdown "objective/capture-knowledge.md" start="" end="" %} [:octicons-arrow-right-24: Learn more](capture-knowledge.md) -- :material-cached:{ .lg } __Gaps Bridged__ +- __Gaps Bridged__ {% include-markdown "objective/bridge-the-gap.md" start="" end="" %} [:octicons-arrow-right-24: Learn more](bridge-the-gap.md) -- :material-cached:{ .lg } __Expectations Managed__ +- __Expectations Managed__ {% include-markdown "objective/manage-expectations.md" start="" end="" %} [:octicons-arrow-right-24: Learn more](manage-expectations.md) -- :material-cached:{ .lg } __Did not boil the ocean__ +- __Did not boil the ocean__ {% include-markdown "objective/avoid-boiling-the-ocean.md" start="" end="" %} [:octicons-arrow-right-24: Learn more](avoid-boiling-the-ocean.md) -- :material-cached:{ .lg } __Disruption Avoided__ +- __Disruption Avoided__ {% include-markdown "objective/avoid-disruption.md" start="" end="" %} [:octicons-arrow-right-24: Learn more](avoid-disruption.md) -- :material-cached:{ .lg } __Quality Increased__ +- __Quality Increased__ {% include-markdown "objective/increase-quality.md" start="" end="" %} [:octicons-arrow-right-24: Learn more](increase-quality.md) -- :material-cached:{ .lg } __Aligned with Strategy__ +- __Aligned with Strategy__ {% include-markdown "objective/align-with-business-strategy.md" start="" end="" %} [:octicons-arrow-right-24: Learn more](align-with-business-strategy.md) -- :material-cached:{ .lg } __Delivered__ +- __Delivered__ {% include-markdown "objective/strategic-usecases.md" start="" end="" %} [:octicons-arrow-right-24: Learn more](strategic-usecases.md) -- :material-cached:{ .lg } __Modularity Managed__ +- __Modularity Managed__ {% include-markdown "objective/modularity.md" start="" end="" %} [:octicons-arrow-right-24: Learn more](modularity.md) -- :material-cached:{ .lg } __Reuse Enabled__ +- __Reuse Enabled__ {% include-markdown "objective/enable-reuse.md" start="" end="" %} diff --git a/docs/objective/interoperability.md b/docs/objective/interoperability.md index 9b36e08c..ec87ec92 100644 --- a/docs/objective/interoperability.md +++ b/docs/objective/interoperability.md @@ -1,13 +1,22 @@ --- -title: Interoperability +title: "A: Interoperability" summary: Interoperability Achieved authors: - Carlos Tubbax date: 2022-06-23 some_url: https://method.ekgf.org/objective/interoperability/ +description: "Enable interoperability across the enterprise at high levels of maturity. Learn how the Use Case Tree Method achieves enterprise-wide data and system interoperability through semantic standards." +keywords: + - interoperability + - enterprise interoperability + - data interoperability + - EKG method + - enterprise knowledge graph + - semantic interoperability +schema_type: "Article" --- -# Interoperability Achieved +# A: Interoperability Achieved _Enable interoperability across the enterprise at high levels of maturity._ diff --git a/docs/objective/know-what-the-business-wants.md b/docs/objective/know-what-the-business-wants.md index e695d459..57267526 100644 --- a/docs/objective/know-what-the-business-wants.md +++ b/docs/objective/know-what-the-business-wants.md @@ -1,11 +1,20 @@ --- -title: Know what the business wants & why +title: "C: Know what the business wants & why" authors: - Jacobus Geluk hide: - toc +description: "Know exactly what the business—the customer or product owner—really needs, short-, mid- and long-term. Learn how the Use Case Tree Method captures true business requirements." +keywords: + - business requirements + - requirements capture + - business needs + - EKG method + - enterprise knowledge graph + - product owner +schema_type: "Article" --- -# Know what the business wants & why +# C: Know what the business wants & why _Know exactly what the business---the customer or diff --git a/docs/objective/manage-expectations.md b/docs/objective/manage-expectations.md index 567144f3..79ac4634 100644 --- a/docs/objective/manage-expectations.md +++ b/docs/objective/manage-expectations.md @@ -1,11 +1,20 @@ --- -title: Best form of ”expectation management” +title: "F: Best form of \"expectation management\"" authors: - Jacobus Geluk hide: - toc +description: "Create an agreed and realistic strategic roadmap aligned to business strategy. Learn how the Use Case Tree Method manages expectations across complex enterprises." +keywords: + - expectation management + - strategic roadmap + - business strategy + - EKG method + - enterprise knowledge graph + - roadmap planning +schema_type: "Article" --- -# Best form of ”expectation management” +# F: Best form of "expectation management" _Create an agreed and realistic strategic roadmap aligned to business strategy._ diff --git a/docs/objective/modularity.md b/docs/objective/modularity.md index ba4b9dc8..3a739a93 100644 --- a/docs/objective/modularity.md +++ b/docs/objective/modularity.md @@ -1,15 +1,24 @@ --- -title: Modularity +title: "L: Modularity" summary: Introducing EKG modularity authors: - Carlos Tubbax date: 2022-05-01 some_url: https://method.ekgf.org/objective/modularity/ hide: - - toc +- toc +description: "Build with modular, reusable components instead of monolithic systems. Learn how the Use Case Tree Method enables modular architecture for enterprise systems." +keywords: + - modularity + - modular architecture + - reusable components + - EKG method + - enterprise knowledge graph + - system design +schema_type: "Article" --- -# Modularity +# L: Modularity _Build with modular, reusable components instead of monolithic systems._ diff --git a/docs/objective/strategic-usecases.md b/docs/objective/strategic-usecases.md index fa7b5e7b..70899beb 100644 --- a/docs/objective/strategic-usecases.md +++ b/docs/objective/strategic-usecases.md @@ -1,12 +1,21 @@ --- -title: The ability to deliver strategic use cases +title: "K: The ability to deliver strategic use cases" authors: - Jacobus Geluk hide: - toc +description: "Deliver strategic use cases that cannot realistically be done with other technologies. Learn how the Use Case Tree Method enables unique business capabilities." +keywords: + - strategic use cases + - unique capabilities + - EKG advantages + - EKG method + - enterprise knowledge graph + - competitive advantage +schema_type: "Article" --- -# The ability to deliver strategic use cases +# K: The ability to deliver strategic use cases _Deliver strategic use cases that cannot realistically be done with other technologies._ diff --git a/docs/other/faq.md b/docs/other/faq.md index d2cdb9a5..d8a20f3f 100644 --- a/docs/other/faq.md +++ b/docs/other/faq.md @@ -2,7 +2,16 @@ title: FAQ author: - Jacobus Geluk ---- +description: "Frequently asked questions about the Use Case Tree Method and Use Case Tree. Get answers about use cases, stories, personas, data products, and the Enterprise Knowledge Graph methodology." +keywords: + - FAQ + - frequently asked questions + - EKG method FAQ + - use case tree FAQ + - enterprise knowledge graph questions +schema_type: "FAQPage" +--- + # Frequently Asked Questions ## What is a Use Case? @@ -18,12 +27,12 @@ datasets (or data products), ontologies, workflows, user interface models and fu A user story can be seen as a black-box function with inputs and outputs. We model these inputs and outputs initially just as simple "[Concepts](../concept/concept.md)" (and the terms that are being used for those concepts). -By adding more and more detail to these stories, they eventually become runnable or -executable and can be invoked as an HTTP API, in response to a Kafka message, +By adding more and more detail to these stories, they eventually become runnable or +executable and can be invoked as an HTTP API, in response to a Kafka message, or via any other technology. -Stories can be "implemented" using SPARQL, SQL, Gremlin, or calls to external APIs -of any sort since they're seen as a "black box," it really doesn't matter, although usually, -the easiest way to implement them is, of course, SPARQL since an EKG is primarily an +Stories can be "implemented" using SPARQL, SQL, Gremlin, or calls to external APIs +of any sort since they're seen as a "black box," it really doesn't matter, although usually, +the easiest way to implement them is, of course, SPARQL since an EKG is primarily an RDF-based world. A story is (by precedent) linked to only one use case. @@ -45,19 +54,19 @@ the term [Use Case Tree](../concept/use-case-tree.md/). ## Are use case trees actually trees (hierarchies)? -No, they are [DAGs](https://en.wikipedia.org/wiki/Directed_acyclic_graph) (one use case -can support, and be supported by, many others) but we obviously didn't want to call it +No, they are [DAGs](https://en.wikipedia.org/wiki/Directed_acyclic_graph) (one use case +can support, and be supported by, many others) but we obviously didn't want to call it "Use Case DAG" :-) ## What is the detail needed behind each use case? - Narrative? Happy case? Exceptions -Here's a [template](../concept/use-case.md#__tabbed_1_5) for the kind of information that we need +Here's a [template](../concept/use-case.md#plan-build-run) for the kind of information that we need to collect for any given use case during the various phases in their life cycle. ## How are use cases named? - traditionally: verb phrase including noun, e.g., _Maintain customer accounts_ -- actual: noun phrase for a data subject area, which may be singular or plural, +- actual: noun phrase for a data subject area, which may be singular or plural, for instance, _Customer Accounts_. With just using nouns, any given use case tree starts to look like one of three things @@ -69,7 +78,7 @@ or some sort of combination of it, especially at the higher levels in the tree: This may be a bit confusing because it's none of those three things, but there is a close relationship between these four concepts (domains, capabilities, organizational units, and Use Case Trees). -And that's precisely how it should be; your EKG's modular structure should look like +And that's precisely how it should be; your EKG's modular structure should look like _your_ enterprise structure. However: @@ -124,11 +133,11 @@ life cycle, from initiation to production and beyond. Changing terms simply because some external ontology has a "better" name for the same concept is not helping. -The whole point of using semantic technology is that we can easily model all "semantic conundrums" +The whole point of using semantic technology is that we can easily model all "semantic conundrums" and make sure that we always address "the business" (i.e., the customer) with their language while keeping the backend EKG models "generic" and linked to any number of appropriate ontologies. -A "concept" in the EKG/Method is, therefore, "the linking pin," linking local business language to +A "concept" in the Use Case Tree Method is, therefore, "the linking pin," linking local business language to any other appropriate concepts in any number of other ontologies. - ` usesConcept .` @@ -137,7 +146,7 @@ any other appropriate concepts in any number of other ontologies. - ` datatype .` (optional) - ` ....` (all kinds of mapping information) - ` term ` (where term can be a multilingual context-specific name for the concept or - a technology-stack specific name) + a technology-stack specific name) - ` isInputFor ` - ` isOutputFor ` - ` isUsedInUseCase ` (derived from the stories of the use case) @@ -165,7 +174,7 @@ of this method, spanning across the workflows of many use cases. The Use Case Tree of an organization has everything to do with Strategy; overall [Business Strategy](https://maturity.ekgf.org/pillar/business/capability-area/strategy-actuation/), -[Data Strategy](https://maturity.ekgf.org/pillar/data/capability-area/data-strategy/), +[Data Strategy](https://maturity.ekgf.org/pillar/data/capability-area/data-strategy/), [Organizational Strategy](https://maturity.ekgf.org/pillar/organization/capability-area/executive-leadership/capability/organizational-strategy/) and [Technology Strategy](https://maturity.ekgf.org/pillar/technology/capability-area/technology-strategy/). @@ -208,12 +217,12 @@ just stand for some external "legacy" system. For instance if your organization an old mainframe running "Billing" for 40 years, built with COBOL, then we can add that as a Use Case, a black box really, to the Use Case Tree. -The implementation of a use case can be anything. Implementation details will be +The implementation of a use case can be anything. Implementation details will be added by engineers using their own models. Point is: everyone can talk to the Use Case Tree; business people, any stakeholder, end users, ontologists, data modelers, knowledge graph engineers or other data scientists, -COBOL programmers, devops people, they're all talking about the same deliverables that +COBOL programmers, devops people, they're all talking about the same deliverables that the business ultimately pays for. ## How, if at all, is a UCT specific to Knowledge Graphs? @@ -236,22 +245,22 @@ Selecting the "right" first use cases is a bit of an art. Some rules of thumb: - Define use cases with a minimum number of "dependencies" - - dependencies come in many forms, ontologies, datasets, people, maturity requirements, - departments and so forth. + - dependencies come in many forms, ontologies, datasets, people, maturity requirements, + departments and so forth. - Start with "reference data" (so that we have something to link to) - Build upon standard use cases (downloadable from EKGF and others, or other internal departments) - Select the shortest path in the tree - - should lead quickly to the delivery of a "lighthouse use case" or a "strategic use case", - delivering real value to the business, ideally value that no other technology stack can currently - (realistically) provide. + - should lead quickly to the delivery of a "lighthouse use case" or a "strategic use case", + delivering real value to the business, ideally value that no other technology stack can currently + (realistically) provide. - Deliver straight to production, from the first tiny use case onwards - - Implement full test-driven development with 100% test-coverage - - Implement full end-to-end [continuous deployment](https://en.wikipedia.org/wiki/Continuous_deployment) - or [GitOps](https://www.gitops.tech/). - - Get through all red-tape and learning curve with the technology first so that delivery - of all subsequent use cases is not held back and it can be proven that price and time-to-market - will be reduced drastically with each subsequent use case delivery. - + - Implement full test-driven development with 100% test-coverage + - Implement full end-to-end [continuous deployment](https://en.wikipedia.org/wiki/Continuous_deployment) + or [GitOps](https://www.gitops.tech/). + - Get through all red-tape and learning curve with the technology first so that delivery + of all subsequent use cases is not held back and it can be proven that price and time-to-market + will be reduced drastically with each subsequent use case delivery. + ## What is reusable? Most Use Cases can be developed as "reusable components" (if you do it right). @@ -272,14 +281,14 @@ competitors. Every successful technology stack has a central place where the community publishes their reusable components, for JavaScript that is [https://npmjs.org](https://npmjs.org), for Java we have [Maven Central](https://mvnrepository.com/repos/central) (and others), Python has -[https://pypi.org](https://pypi.org) and for the EKG we have the EKGF Catalog -(under development, it's in its very early stages still) at +[https://pypi.org](https://pypi.org) and for the EKG we have the EKGF Catalog +(under development, it's in its very early stages still) at [https://catalog.ekgf.org](https://catalog.ekgf.org). ## How are Use Cases "plug and play?" Any given use case can be "enriched" with more and more detail during its development. -This eventually leads to it becoming "executable", which in effect turns it into the +This eventually leads to it becoming "executable", which in effect turns it into the EKG equivalent of an "application". Use Cases at this level of sophistication are then "plug and play" and can be re-deployed in other EKGs. @@ -351,11 +360,11 @@ corporate styling etc. ## How can you drive (data) modeling? One major "lesson learned" is that semantic technology and knowledge graphs easily -allow people to "[boil the ocean](../objective/avoid-boiling-the-ocean.md)" and -"model the whole world" using generic abstract ontologies, sometimes even up to +allow people to "[boil the ocean](../objective/avoid-boiling-the-ocean.md)" and +"model the whole world" using generic abstract ontologies, sometimes even up to philosophical levels of abstraction. -One of the key objectives of the EKG/Method is to [avoid boiling the ocean](../objective/avoid-boiling-the-ocean.md) +One of the key objectives of the Use Case Tree Method is to [avoid boiling the ocean](../objective/avoid-boiling-the-ocean.md) by creating a laser sharp description of what the business needs and pays for. And make that description testable and therefore verifiable. @@ -373,7 +382,7 @@ can be built as an EKG use case. Practically, there will always be many other systems that are specialised in what they're doing. Source of record systems, PeopleSoft, Salesforce, spreadsheets, trading systems, -blockchains and the like. The EKG can serve as a layer on top of all those other systems, +blockchains and the like. The EKG can serve as a layer on top of all those other systems, connecting the dots across the enterprise or ecosystem. ## Not suitable for? @@ -383,4 +392,3 @@ semantic graph database products (aka "triple stores") are the de-facto choice t the EKG. However, many other technologies can be used as well, with a bit more work, such as time series databases, Kafka, relational databases and labeled property graph (LPG) databases. - diff --git a/docs/other/index.md b/docs/other/index.md index 8925ec70..2e046bb2 100644 --- a/docs/other/index.md +++ b/docs/other/index.md @@ -1,11 +1,22 @@ +--- +description: "Explore other Object Management Group (OMG) Enterprise Knowledge Graph Forum initiatives including EKG Principles, Maturity Model, Catalog, and related resources." +keywords: + - EKGF + - object management group + - enterprise knowledge graph forum + - EKG resources + - EKG principles + - EKG maturity model +schema_type: "WebPage" +--- + # Other -The Enterprise Knowledge Graph Foundation is working on multiple initiatives that -have lead to various websites: +The Object Management Group (OMG) Enterprise Knowledge Graph Forum (EKGF) is a managed community within OMG and is working on multiple initiatives that have lead to various websites: ## ekgf.org -The main website of the Foundation: [https://ekgf.org](https://ekgf.org) +The main website of the OMG-managed forum: [https://ekgf.org](https://ekgf.org) ## Principles diff --git a/docs/other/seo-guide.md b/docs/other/seo-guide.md new file mode 100644 index 00000000..f2c63ddf --- /dev/null +++ b/docs/other/seo-guide.md @@ -0,0 +1,192 @@ +# SEO Guide for Content Authors + +This guide explains how to optimize your content for search engines when writing documentation for the Use Case Tree Method site. + +## Page-Specific Meta Descriptions + +Every page should have a unique, descriptive meta description. Add it in the frontmatter at the top of your Markdown file: + +```yaml +--- +description: "A clear, concise description of what this page covers (150-160 characters recommended)" +keywords: + - keyword1 + - keyword2 + - keyword3 +schema_type: "Article" # or "WebPage", "HowTo", etc. +--- +``` + +### Best Practices for Descriptions + +- **Length**: Aim for 150-160 characters (Google typically shows up to 160) +- **Be specific**: Describe what the reader will learn, not generic marketing copy +- **Include keywords**: Naturally incorporate relevant search terms +- **Action-oriented**: Use active voice when possible +- **Unique**: Each page must have a different description + +### Example + +```yaml +--- +description: "Learn how outcomes define the business value and success criteria for use cases in the Use Case Tree Method. Outcomes provide the 'why' behind every requirement." +keywords: + - outcome + - business outcome + - use case outcome + - EKG method +schema_type: "Article" +--- +``` + +## Keywords + +Add relevant keywords as a list in the frontmatter. These help search engines understand your content: + +```yaml +keywords: + - primary keyword + - secondary keyword + - related term +``` + +### Keyword Best Practices + +- **3-5 keywords**: Don't overdo it +- **Relevant**: Only include terms actually discussed on the page +- **Natural**: Use terms your audience would search for +- **Specific**: Prefer specific terms over generic ones + +## Schema.org Structured Data + +The `schema_type` field determines the type of structured data (JSON-LD) added to the page: + +- **`Article`**: For documentation pages, tutorials, guides +- **`WebPage`**: For general pages +- **`HowTo`**: For step-by-step instructions +- **`FAQPage`**: For FAQ pages + +## Page Titles + +Page titles are automatically generated from your H1 heading. Best practices: + +- **Clear and descriptive**: The H1 should clearly state what the page is about +- **Include keywords**: Naturally incorporate important search terms +- **Unique**: Each page should have a distinct title +- **Concise**: Keep it under 60 characters when possible + +## Content Optimization + +### Headings Structure + +Use proper heading hierarchy: + +```markdown +# H1 - Page Title (only one per page) +## H2 - Main Sections +### H3 - Subsections +``` + +### Internal Linking + +Link to related pages within the documentation: + +```markdown +Learn more about [Use Cases](use-case.md) and [Outcomes](outcome.md). +``` + +### Images + +- Use descriptive alt text for all images +- Include relevant keywords in filenames when appropriate +- Optimize image file sizes for faster loading + +### Summary Sections + +The `` and `` comments create summary sections that can be used for SEO. Make sure summaries are: + +- Clear and concise +- Include key concepts +- Naturally incorporate keywords + +## Social Media Optimization + +Open Graph and Twitter Card tags are automatically generated from your page metadata. To customize: + +### Custom Images + +Add a custom image for social sharing: + +```yaml +--- +description: "..." +image: "/assets/images/custom-page-image.png" +--- +``` + +### Custom Titles + +The page title is used for social sharing. Make sure it's compelling and descriptive. + +## Technical SEO + +The following are handled automatically: + +- ✅ Canonical URLs +- ✅ Sitemap generation +- ✅ Mobile-responsive design +- ✅ Fast page loading +- ✅ Structured data (JSON-LD) +- ✅ Open Graph tags +- ✅ Twitter Card tags +- ✅ robots.txt (located at `/docs/robots.txt` and copied to site root during build) + +## Checklist for New Pages + +When creating a new page, ensure you have: + +- [ ] Unique meta description (150-160 chars) +- [ ] Relevant keywords (3-5 terms) +- [ ] Appropriate schema_type +- [ ] Clear, descriptive H1 title +- [ ] Proper heading hierarchy +- [ ] Internal links to related pages +- [ ] Alt text for images +- [ ] Summary section (if applicable) + +## Examples + +### Concept Page + +```yaml +--- +description: "Learn how [concept] works in the Use Case Tree Method. [Specific benefit or learning outcome]." +keywords: + - concept-name + - related-term + - EKG method +schema_type: "Article" +--- +# Concept Name +``` + +### Process Page + +```yaml +--- +description: "Step-by-step guide to [process name] in the Use Case Tree Method. Learn how to [specific action]." +keywords: + - process-name + - workflow + - EKG method +schema_type: "HowTo" +--- +# Process Name +``` + +## Questions? + +If you have questions about SEO optimization, please refer to: +- [Google's SEO Starter Guide](https://developers.google.com/search/docs/fundamentals/seo-starter-guide) +- [Schema.org Documentation](https://schema.org/) + diff --git a/docs/process/build/allocate.md b/docs/process/build/allocate.md index d9103794..909f7e0e 100644 --- a/docs/process/build/allocate.md +++ b/docs/process/build/allocate.md @@ -3,6 +3,15 @@ authors: - Jacobus Geluk hide: - toc +description: "Allocate resources, organize a team, and start creating a Center of Excellence for the EKG. Learn how to structure development workstreams for the EKG Platform and use cases." +keywords: + - allocate + - resource allocation + - EKG team + - center of excellence + - EKG method + - enterprise knowledge graph team +schema_type: "HowTo" --- # Allocate diff --git a/docs/process/build/deliver.md b/docs/process/build/deliver.md index da57c422..42ebd27a 100644 --- a/docs/process/build/deliver.md +++ b/docs/process/build/deliver.md @@ -3,6 +3,15 @@ authors: - Jacobus Geluk hide: - toc +description: "Continuously improve and deliver small increments frequently. Learn how to deploy use cases to production and establish a delivery cadence in the Deliver phase." +keywords: + - deliver + - continuous delivery + - incremental delivery + - EKG deployment + - EKG method + - enterprise knowledge graph delivery +schema_type: "HowTo" --- # Deliver diff --git a/docs/process/build/design.md b/docs/process/build/design.md index d3749778..6a19a683 100644 --- a/docs/process/build/design.md +++ b/docs/process/build/design.md @@ -3,6 +3,15 @@ authors: - Jacobus Geluk hide: - toc +description: "Design the EKG Platform architecture and use case specifications. Learn how to architect both the technical platform and business-focused use case designs in the Design phase." +keywords: + - design + - EKG architecture + - platform design + - use case design + - EKG method + - enterprise knowledge graph architecture +schema_type: "HowTo" --- # Design diff --git a/docs/process/build/implement.md b/docs/process/build/implement.md index cbbe0b17..fcba4589 100644 --- a/docs/process/build/implement.md +++ b/docs/process/build/implement.md @@ -3,6 +3,15 @@ authors: - Jacobus Geluk hide: - toc +description: "Detail the use case by implementing executable models. Learn how to transform requirements into semantic models that run on the EKG Platform in the Implement phase." +keywords: + - implement + - use case implementation + - executable models + - semantic models + - EKG method + - enterprise knowledge graph implementation +schema_type: "HowTo" --- # Implement diff --git a/docs/process/build/index.md b/docs/process/build/index.md index f2e80fd8..482a68fe 100644 --- a/docs/process/build/index.md +++ b/docs/process/build/index.md @@ -3,6 +3,15 @@ authors: - Jacobus Geluk hide: - toc +description: "Building an EKG-based use case involves detailed requirements gathering structured around the Use Case Tree, all the way to delivery. Learn the Build phase: Allocate, Design, Implement, Test, Verify, and Deliver." +keywords: + - EKG build + - build phase + - executable models + - no-code EKG + - EKG method + - enterprise knowledge graph development +schema_type: "HowTo" --- # Build diff --git a/docs/process/build/test.md b/docs/process/build/test.md index d0f1a11d..030e9b47 100644 --- a/docs/process/build/test.md +++ b/docs/process/build/test.md @@ -3,6 +3,15 @@ authors: - Jacobus Geluk hide: - toc +description: "Add test scenarios and deliver full coverage based on real business scenarios. Learn how to ensure quality through comprehensive testing in the Use Case Tree Method Test phase." +keywords: + - test + - EKG testing + - test coverage + - business scenario testing + - EKG method + - enterprise knowledge graph testing +schema_type: "HowTo" --- # Test diff --git a/docs/process/build/verify.md b/docs/process/build/verify.md index 89cf61eb..c795a979 100644 --- a/docs/process/build/verify.md +++ b/docs/process/build/verify.md @@ -3,6 +3,15 @@ authors: - Jacobus Geluk hide: - toc +description: "Verify the use case implementation with the business stakeholders. Learn how to validate that delivered functionality meets business requirements and outcomes." +keywords: + - verify + - business verification + - stakeholder validation + - requirements verification + - EKG method + - enterprise knowledge graph verification +schema_type: "HowTo" --- # Verify diff --git a/docs/process/index.md b/docs/process/index.md index 1bd99a6c..3fc80a28 100644 --- a/docs/process/index.md +++ b/docs/process/index.md @@ -2,80 +2,86 @@ hide: - toc - navigation +description: "The Use Case Tree Method process: Plan (strategy & scope), Build (executable models), and Run (operate & optimize). Learn the three-phase approach to developing Enterprise Knowledge Graphs." +keywords: + - EKG process + - EKG methodology + - plan build run + - EKG method + - enterprise knowledge graph + - development process +schema_type: "WebPage" --- # Process === "Steps" -
+
- - :material-floor-plan:{ .lg } __[Plan](plan/index.md)__ - - ----- + -
+ :material-compass:{ .lg } +
+ __[Plan](plan/index.md)__ + Strategy & Scope +
+
- Think big, start small, rinse, repeat, accelerate. + Strategic vision, stakeholder alignment, and the [Use Case Tree](../concept/use-case-tree.md). + Essential at the start, repeatable at any level---even for individual use cases. ----- - [Envision](./plan/envision.md), - [Discover](./plan/discover.md), - [Assess](./plan/assess.md), - [Train](./plan/train.md) and - [Chart](./plan/chart.md). + - [Envision](./plan/envision.md) + - [Discover](./plan/discover.md) + - [Assess](./plan/assess.md) + - [Train](./plan/train.md) + - [Chart](./plan/chart.md) [:octicons-arrow-right-24: Learn more](./plan/index.md) - - :construction_site:{ .lg } __[Build](build/index.md)__ - - ----- - - "Building" an EKG-based use case involves - everything from detailed requirements gathering---structured - around the [Use Case Tree](../concept/use-case-tree.md)---all the way up to delivery of - components for your production EKG-platform. - - [:octicons-arrow-right-24: Learn more](./build/index.md) - - - :material-run:{ .lg } __[Run](run/index.md)__ - - --- + -
+ :material-tools:{ .lg } +
+ __[Build](build/index.md)__ + Executable Models +
+
- Deploying, Operating, Measuring and Optimizing an - [EKG/Platform](../vocab/ekg-platform.md) that - serves many Use Cases across the Enterprise. - - [:octicons-arrow-right-24: Learn more](./run/index.md) - - - :material-foot-print: Steps - - ----- - - [Envision](./plan/envision.md), - [Discover](./plan/discover.md), - [Assess](./plan/assess.md), - [Train](./plan/train.md) and - [Chart](./plan/chart.md). - - - :material-foot-print: Steps + Capture [Stories](../concept/story.md), [Workflows](../concept/workflow.md), and [Concepts](../concept/concept.md). + Specify executable behavior as semantic models---mostly no-code---for reusable components. ----- - [Allocate](./build/allocate.md), - [Design](./build/design.md), - [Implement](./build/implement.md), - [Test](./build/test.md), - [Verify](./build/verify.md) and - [Deliver](./build/deliver.md). + - [Allocate](./build/allocate.md) + - [Design](./build/design.md) + - [Implement](./build/implement.md) + - [Test](./build/test.md) + - [Verify](./build/verify.md) + - [Deliver](./build/deliver.md) - - :material-foot-print: Steps + [:octicons-arrow-right-24: Learn more](./build/index.md) + + -
+ :material-rocket-launch:{ .lg } +
+ __[Run](run/index.md)__ + Operate & Optimize +
+
+ + Deploy, operate, and optimize the [EKG/Platform](../vocab/ekg-platform.md). + Measure [Outcomes](../concept/outcome.md), monitor [Workflows](../concept/workflow.md), + serve multiple use cases across the enterprise. ----- - [Deploy](./run/deploy.md), - [Operate](./run/operate.md), - [Measure](./run/measure.md) and - [Optimize](./run/optimize.md). + - [Deploy](./run/deploy.md) + - [Operate](./run/operate.md) + - [Measure](./run/measure.md) + - [Optimize](./run/optimize.md) + [:octicons-arrow-right-24: Learn more](./run/index.md) +
=== "Diagram" diff --git a/docs/process/plan/assess.md b/docs/process/plan/assess.md index 5ecee88a..af0a69e6 100644 --- a/docs/process/plan/assess.md +++ b/docs/process/plan/assess.md @@ -3,14 +3,25 @@ authors: - Jacobus Geluk hide: - toc +description: "Assess your organization's maturity in non-functional requirements using the EKG Maturity Model. Learn how to evaluate readiness and bridge gaps before implementing use cases." +keywords: + - assess + - maturity assessment + - EKG maturity model + - organizational readiness + - EKG method + - enterprise knowledge graph assessment +schema_type: "HowTo" --- # Assess -_Assess where your current organization stands in terms of the non-functional requirements and -where it should be to be able to support the use cases as they come out of the [Discover phase](discover.md). -These assessments are based on the [Maturity Model for the EKG (EKG/Maturity)](https://maturity.ekgf.org). -This is partly about "the how" and "can we?"._ + +- current state +- required next state +- maturity (buss/org/data/tech) +- scalability assessment + Perform an assessment of the current and desired state of maturity of the organization diff --git a/docs/process/plan/chart.md b/docs/process/plan/chart.md index 464a9efd..52208861 100644 --- a/docs/process/plan/chart.md +++ b/docs/process/plan/chart.md @@ -3,13 +3,25 @@ authors: - Jacobus Geluk hide: - toc +description: "Craft a proper business case, manage expectations, and define what success means. Learn how to chart a solid plan with stakeholder support and clear success criteria in the Chart phase." +keywords: + - chart + - business case + - EKG planning + - success criteria + - EKG method + - enterprise knowledge graph planning +schema_type: "HowTo" --- # Chart -_Craft a proper "business case", manage expectations, define crystal clear what success -means and what is needed to get there. -This is about "when are we done?"._ + +- viable roadmap +- business case +- stakeholder agreement +- mandate + Build a business case that charts out a solid plan, well-supported by all diff --git a/docs/process/plan/discover.md b/docs/process/plan/discover.md index af2515d8..073c640d 100644 --- a/docs/process/plan/discover.md +++ b/docs/process/plan/discover.md @@ -3,28 +3,40 @@ authors: - Jacobus Geluk hide: - toc +description: "Discover all use cases in the given scope and create a Use Case Tree that shows a viable pathway towards strategic goals. Learn how to identify business outcomes and select the shortest path to value in the Discover phase." +keywords: + - discover + - use case discovery + - use case tree creation + - EKG method + - enterprise knowledge graph + - business outcomes +schema_type: "HowTo" --- # Discover -_Discover all use cases in the given scope, short-term and long-term, -create a “[Use Case Tree](../../concept/use-case-tree.md)” that shows a viable, realistic, logical, -and successful pathway towards strategic goals. -This is about “the what” and how it relates to "the why"._ + +- strategic [use cases](../../concept/use-case.md) & desired [business outcomes](../../concept/outcome.md) +- initial [Use Case Tree](../../concept/use-case-tree.md) and primary branch +- shared business language & knowledge +- aligned priorities and reuse opportunities + -Discover all strategic use cases in the given scope that support the agreed vision -and strategy. Create the initial UCT for the organization. Identify desired mid and long term -business outcomes. Select the primary branch in the use case tree to focus on, break that part -of the use case tree down into deeper levels, identify the shortest pathway to real business +Discover all strategic [use cases](../../concept/use-case.md) in the given scope that support the agreed vision +and strategy. Create the initial [Use Case Tree (UCT)](../../concept/use-case-tree.md) for the organization. +Identify desired mid and long term [business outcomes](../../concept/outcome.md). +Select the primary branch in the Use Case Tree to focus on, break that part +of the Use Case Tree down into deeper levels, identify the shortest pathway to real business value. The Discover phase translates organizational and business priorities into strategic use cases. -We convert your priorities into data requirements devoid of any technical considerations. +In this step, priorities are converted into data requirements devoid of any technical considerations. The output aligns all stakeholders on intermediate deliverables and emphasizes those with the greatest reuse potential. -This helps you refine your business case and plan your implementation as a series of +This helps refine the business case and plan implementation as a series of steppingstones toward more strategic goals. ## Approach @@ -32,7 +44,7 @@ steppingstones toward more strategic goals. The team works with business experts and change managers in a series of interactive workshops to define requirements. The team adopts the business language in the selected context to capture goals, -data requirements, data stories and process/work flows. +data requirements, [stories](../../concept/story.md) and [workflows](../../concept/workflow.md). These are aligned as a set of visual roadmaps to be used to create onward business cases. The team leverages the [knowledge graph maturity model](../../vocab/maturity-model.md) @@ -45,14 +57,14 @@ to help frame each deliverable in terms of staged business capabilities. ## Outputs -All outputs below describe the properties of what a Use Case Tree is: +All outputs below describe the properties of what a [Use Case Tree](../../concept/use-case-tree.md) is: -* Identification of strategic use cases, priorities and desired business outcomes -* Initial scope in the form of one priority strategic use case, - one branch of the Use Case Tree to focus on +* Identification of strategic [use cases](../../concept/use-case.md), priorities and desired [business outcomes](../../concept/outcome.md) +* Initial scope in the form of one priority strategic [use case](../../concept/use-case.md), + one branch of the [Use Case Tree](../../concept/use-case-tree.md) to focus on * Evaluation criteria from both a business process and data perspective to ensure EKG synchronization with defined requirements -* Conversion of strategic priorities into a staged “use case tree” specifying +* Conversion of strategic priorities into a staged [Use Case Tree](../../concept/use-case-tree.md) specifying business functionality and data requirements * A shared understanding of the requirements for success including the investments needed to deliver against expected functionality @@ -61,8 +73,8 @@ All outputs below describe the properties of what a Use Case Tree is: * One-to-one and end-to-end linkage between a plain english business user story and the evidence that this user story has been delivered, works and stays working[^testing] * **A permanent artifact, a shared model, continuously being improved, that all stakeholders across - the enterprise can talk to for the whole life-cycle of any given use case (even in production)** -* Living data structure that becomes part of the EKG itself for its whole life-cycle + the enterprise can talk to for the whole life-cycle of any given [use case](../../concept/use-case.md) (even in production)** +* Living data structure that becomes part of the [Enterprise Knowledge Graph](../../vocab/ekg.md) itself for its whole life-cycle * Modular structure of components that allows for an ecosystem of internal and external reusable components compliant with standards set by the EKGF. @@ -74,8 +86,19 @@ and exactly trace cost, risk, timelines etc. ### The Use Case Tree practice -Explanation of the key principles of how your EKG and its development can be structured and what -leads to successful and modular implementations. +Explanation of the key principles of how an EKG and its development can be structured in an organization +and what leads to successful and modular implementations. + +### What is a "strategic use case" + +A **strategic use case** is more than just a good first candidate to implement. +It is a lighthouse use case that is of **strategic importance to the business**: +it visibly saves money, increases profit, improves quality, reduces risk, or boosts efficiency +in a way that matters at the C‑level. + +Strategic use cases are the scenarios that convince executive leadership to **invest in EKG strategically**, +not just as a one‑off project. +They demonstrate that an EKG‑based approach can unlock long‑term competitive advantage, not merely solve a local problem. ### Examples of Strategic Use Cases @@ -90,18 +113,41 @@ and Customer 360. * Improving Data Quality generally. Risk * Supporting the digitalization / Transform / Innovation agenda, capability play -### Identity your Strategic Use Cases & Business Outcomes +### Identify your Strategic Use Cases & Business Outcomes -Identify your own corporate “strategic use cases” and formulate their expected business outcomes. +Identify the organization's own “strategic use cases” and formulate their expected business outcomes. Think outside the box, “dream a little”, think long term, set long term goals so that a reuse strategy -can be derived. Rough sketch of areas where the organization could (and should) possibly go if -innovations, technology & org could deliver. +can be derived. Rough sketch areas where the organization could (and should) possibly go if +innovations, technology and organization could deliver. ### Select a Strategic Use Case & Identify Stakeholders -After step 3 we can select one area to dive into, with the agreement of all key stakeholders for that +After step 3, select one area to dive into, with the agreement of all key stakeholders for that area. +### What is "the right use case" (to start with) + +One of the key outcomes of the Discover phase is the identification and definition of the **first** [use case](../../concept/use-case.md) to start with. +Ideally, this is a **lighthouse use case**: a concrete example that shows everyone why building use cases in an Enterprise Knowledge Graph context is worth the effort in the first place. + +Expectations around this first use case are often sky-high — it can become a go/no‑go decision point for further EKG investment — so **expectation management is critical**. +Stakeholders need to understand that the first use case may actually take **longer** to implement than building something similar on the existing "bread and butter" technology stack: +teams know those tools, they have done it many times before, and can “crank out” another solution quickly. +Doing the same thing with a **new technology stack** and several **new paradigms** (graph, semantics, EKG, GenAI, etc.) almost always takes more time at first. +The real payoff is that **every subsequent use case will go faster and faster**, because: + +- you are building everything with **reuse** in mind (components, models, workflows, test assets) +- you rapidly build up a catalog of reusable EKG components +- GenAI can increasingly help you discover, combine, and implement those components faster + +When choosing the lighthouse use case: + +- pick a use case that is **not “typical”** — something that is genuinely **hard to do with existing technology**, for example because it combines complex data from multiple sources or domains +- pick a use case that sits **in the middle of the designated scope**, with **high reuse potential** into neighboring areas of the [Use Case Tree](../../concept/use-case-tree.md) + +The goal is not to “win” on raw delivery speed for the first use case, but to **prove the point**: +that an EKG‑based, reuse‑driven approach will make each subsequent use case cheaper, faster, and more robust than the last. + ### Deep-dive Strategic Use Case & Business Outcomes Develop the details of the “use case tree” of the selected top-level strategic use case. @@ -113,9 +159,3 @@ delivered in a logical sequence. All stakeholders have realistic expectations and know exactly what is going to be delivered, why, and in which order. -## TODO - -* What is "the right use case" (to start with) -* What is a "strategic use case" - - diff --git a/docs/process/plan/ekg-method.code-workspace b/docs/process/plan/ekg-method.code-workspace new file mode 100644 index 00000000..b8045b8f --- /dev/null +++ b/docs/process/plan/ekg-method.code-workspace @@ -0,0 +1,34 @@ +{ + "folders": [ + { + "path": "../../.." + }, + { + "path": "../../../../ekg-catalog" + }, + { + "path": "../../../../ekg-maturity" + }, + { + "path": "../../../../ekg-principles" + }, + { + "path": "../../../../ekglib" + }, + { + "path": "../../../../benchmark" + }, + { + "path": "../../../../agnos-website" + } + ], + "settings": { + "yaml.schemas": { + "https://squidfunk.github.io/mkdocs-material/schema.json": "mkdocs.yml" + }, + "yaml.customTags": [ + "tag:yaml.org,2002:python/name", + "tag:yaml.org,2002:python/object/apply" + ] + } +} diff --git a/docs/process/plan/envision.md b/docs/process/plan/envision.md index 302d0486..a539bc0c 100644 --- a/docs/process/plan/envision.md +++ b/docs/process/plan/envision.md @@ -3,18 +3,44 @@ authors: - Jacobus Geluk hide: - toc +description: "Create a vision for the EKG that is shared by all key-stakeholders. Learn how to establish a long-term integrated business, data, and technology strategy in the Envision phase of the Use Case Tree Method." +keywords: + - envision + - EKG vision + - strategic planning + - EKG method + - enterprise knowledge graph strategy + - stakeholder alignment +schema_type: "HowTo" --- # Envision -_Create a vision for the EKG that is shared by all key-stakeholders._ -_This is about “the why” long term._ + +- shared EKG vision +- why EKG is critical for long-term business health +- shared strategy to realize that vision + -Create a shared vision, where do we think that our organization should be, -three to ten years down the road and how do we leverage our unique data and knowledge to become, +Create a shared vision: where do we think that our organization should be +three to ten years down the road, and how do we leverage our unique data and knowledge to become, or stay, a leader in our markets? Translate this to a (long term) integrated business, data -and technology strategy, identify primary stakeholders and initial scope. +and technology strategy, and identify primary stakeholders and an agreed scope. + +That scope can range from an enterprise-wide transformation, to a single business unit or region, +down to one critical use case or system that needs to be replaced or improved. There is no golden rule. +In this phase it is important to **think big first** and allow everyone to "dream a little"—some +“pie in the sky thinking” should be tolerated to explore what *could* be possible, before converging +on a pragmatic initial scope and direction that everyone can commit to. + +At the same time, generative AI has become a board-level priority: organizations that fail to learn +how to safely and effectively leverage GenAI risk becoming irrelevant. A virtual Enterprise Knowledge Graph +is a critical enabler here. Without an EKG as a trusted semantic layer, GenAI agents are forced to interact +directly with a patchwork of legacy systems, APIs, and data sources of unknown quality—often a recipe for +fragile, unexplainable behaviour. With an EKG in place, GenAI agents can work against a coherent, +well-governed, business-aligned knowledge layer, dramatically improving reliability, explainability, +and long-term agility. Clarify the potential of knowledge graph for your enterprise and help position it as part of your overall data and technology strategy. diff --git a/docs/process/plan/index.md b/docs/process/plan/index.md index 08774d09..3ec7ab77 100644 --- a/docs/process/plan/index.md +++ b/docs/process/plan/index.md @@ -8,71 +8,91 @@ some_url: https://method.ekgf.org/process/plan/ hide: - toc - navigation +description: "Think big, start small, rinse, repeat, accelerate. Learn the Plan phase of the Use Case Tree Method: Envision, Discover, Assess, Train, and Chart your Enterprise Knowledge Graph strategy." +keywords: + - EKG planning + - plan phase + - EKG strategy + - use case tree planning + - EKG method + - enterprise knowledge graph planning +schema_type: "HowTo" --- # Plan -=== "Intro" + +**_Think big, start small, rinse, repeat, accelerate._** + - ** - _Think big, start small, rinse, repeat, accelerate._ - ** - - [//]: # (??? note "Rationale") - - In most large organizations, there are many ways to justify a migration to a more data-centric and less - siloed operation. There are countless use cases where a more data-centric and “holistic” approach could - be extremely beneficial. Starting with EKG requires planning and preparation. Think big, start small. - Start with the right use case, the right business case, the right team, prepare for success. - Establishing an EKG can be seen as a journey, it’s generally not something that can be done in “three - months”, even though---with the right amount of planning and preparation---the first use case that can - be delivered can be done in such a short time-frame, it should fit in a larger vision and strategy. Proper - expectation management is key. - - Since EKG brings in many new “paradigms”, it is crucial to have proper expectation management in place, - all relevant stakeholders in the given scope need to understand what it is that you’re trying to achieve, - what the longer-term vision behind it is, agree on that vision, whereby the first use cases need to be - very convincing and need to be delivered successfully. - - That's what this method is for. See also all other [objectives](../../objective/index.md). +[//]: # (??? note "Rationale") -=== "Steps" +In most large organizations, there are many ways to justify a migration to a more data-centric and less +siloed operation. There are countless use cases where a more data-centric and "holistic" approach could +be extremely beneficial. Starting with EKG requires planning and preparation. Think big, start small. +Start with the right use case, the right business case, the right team, prepare for success. +Establishing an EKG can be seen as a journey, it's generally not something that can be done in "three +months", even though---with the right amount of planning and preparation---the first use case that can +be delivered can be done in such a short time-frame, it should fit in a larger vision and strategy. Proper +expectation management is key. -
- - - :material-cached:{ .lg } __[Envision](envision.md)__ - - {% include-markdown "process/plan/envision.md" - start="" end="" %} - [:octicons-arrow-right-24: Learn more](envision.md) - - - :material-cached:{ .lg } __[Discover](discover.md)__ - - {% include-markdown "process/plan/discover.md" - start="" end="" %} - [:octicons-arrow-right-24: Learn more](discover.md) - - - :material-cached:{ .lg } __[Assess](assess.md)__ - - {% include-markdown "process/plan/assess.md" - start="" end="" %} - [:octicons-arrow-right-24: Learn more](assess.md) - - - :material-cached:{ .lg } __[Train](train.md)__ - - {% include-markdown "process/plan/train.md" - start="" end="" %} - [:octicons-arrow-right-24: Learn more](train.md) - - - :material-cached:{ .lg } __[Chart](chart.md)__ - - {% include-markdown "process/plan/chart.md" - start="" end="" %} - [:octicons-arrow-right-24: Learn more](chart.md) +Since EKG brings in many new "paradigms", it is crucial to have proper expectation management in place, +all relevant stakeholders in the given scope need to understand what it is that you're trying to achieve, +what the longer-term vision behind it is, agree on that vision, whereby the first use cases need to be +very convincing and need to be delivered successfully. + +That's what this method is for. See also all other [objectives](../../objective/index.md). + +## Steps + +
+ +- :material-cached:{ .lg } __[Envision](envision.md)__ + + - shared EKG vision + - why EKG is critical for long-term business health + - shared strategy to realize that vision + + [:octicons-arrow-right-24: Learn more](envision.md) + +- :material-cached:{ .lg } __[Discover](discover.md)__ + + - strategic use cases + - initial use case tree + - business knowledge + - priorities & outcomes + + [:octicons-arrow-right-24: Learn more](discover.md) + +- :material-cached:{ .lg } __[Assess](assess.md)__ + + - current state + - required next state + - maturity (buss/org/data/tech) + - scalability assessment + + [:octicons-arrow-right-24: Learn more](assess.md) + +- :material-cached:{ .lg } __[Train](train.md)__ + + Get everyone involved up to speed with all the fundamentals around EKG, + the various new paradigms and especially how EKG requires a number of + new ways of looking at various topics. -
+ [:octicons-arrow-right-24: Learn more](train.md) + +- :material-cached:{ .lg } __[Chart](chart.md)__ + + - viable roadmap + - business case + - stakeholder agreement + - mandate + + [:octicons-arrow-right-24: Learn more](chart.md) + +
-=== "Diagram" +## Process Flow -
- -
+
+ +
diff --git a/docs/process/plan/train.md b/docs/process/plan/train.md index d53d697d..14723a3d 100644 --- a/docs/process/plan/train.md +++ b/docs/process/plan/train.md @@ -3,13 +3,22 @@ authors: - Jacobus Geluk hide: - toc +description: "Get everyone involved up to speed with EKG fundamentals, new paradigms, and semantic technology. Learn how to train stakeholders, architects, and engineers for EKG success." +keywords: + - train + - EKG training + - semantic technology training + - EKG education + - EKG method + - enterprise knowledge graph training +schema_type: "HowTo" --- # Train -Get everyone involved up to speed with all the fundamentals around EKG, the various -new paradigms and especially how EKG requires a number of new ways of looking at various -topics. +Get everyone involved up to speed with all the fundamentals around EKG, +the various new paradigms and especially how EKG requires a number of +new ways of looking at various topics. Provide expert training classes covering the core concepts and technologies diff --git a/docs/process/run/deploy.md b/docs/process/run/deploy.md index f088a00b..13249b54 100644 --- a/docs/process/run/deploy.md +++ b/docs/process/run/deploy.md @@ -3,6 +3,15 @@ authors: - Jacobus Geluk hide: - toc +description: "Fully automated deployments as Infrastructure-as-Code using Continuous Deployment principles. Learn how to deploy the EKG Platform to production with automation and reliability." +keywords: + - deploy + - EKG deployment + - infrastructure as code + - continuous deployment + - EKG method + - enterprise knowledge graph deployment +schema_type: "HowTo" --- # Deploy diff --git a/docs/process/run/index.md b/docs/process/run/index.md index d9022928..ebd12fcf 100644 --- a/docs/process/run/index.md +++ b/docs/process/run/index.md @@ -1,3 +1,15 @@ +--- +description: "Deploy, operate, measure, and optimize the EKG Platform. Learn how to run an Enterprise Knowledge Graph platform that serves multiple use cases across the enterprise." +keywords: + - EKG operations + - run phase + - EKG platform operations + - EKG deployment + - EKG method + - enterprise knowledge graph operations +schema_type: "HowTo" +--- + # Run === "Intro" diff --git a/docs/process/run/measure.md b/docs/process/run/measure.md index 784dfcb3..6c491422 100644 --- a/docs/process/run/measure.md +++ b/docs/process/run/measure.md @@ -3,6 +3,15 @@ authors: - Jacobus Geluk hide: - toc +description: "Measure technical and business performance, availability, vulnerability, quality, and business outcomes. Learn how to monitor and measure EKG Platform success metrics." +keywords: + - measure + - EKG metrics + - performance measurement + - business outcomes + - EKG method + - enterprise knowledge graph metrics +schema_type: "HowTo" --- # Measure diff --git a/docs/process/run/operate.md b/docs/process/run/operate.md index c0dacf65..2f41fd07 100644 --- a/docs/process/run/operate.md +++ b/docs/process/run/operate.md @@ -3,6 +3,15 @@ authors: - Jacobus Geluk hide: - toc +description: "Operating production-level, distributed and federated EKG Platform that serves different use cases across the enterprise, guaranteeing business continuity. Learn EKG operations best practices." +keywords: + - operate + - EKG operations + - platform operations + - business continuity + - EKG method + - enterprise knowledge graph operations +schema_type: "HowTo" --- # Operate diff --git a/docs/process/run/optimize.md b/docs/process/run/optimize.md index be54e305..bb26e708 100644 --- a/docs/process/run/optimize.md +++ b/docs/process/run/optimize.md @@ -3,6 +3,15 @@ authors: - Jacobus Geluk hide: - toc +description: "Structural feedback loops, continuously improve, and continuously update the Use Case Tree. Learn how to optimize EKG use cases and platform performance as a BAU activity." +keywords: + - optimize + - continuous improvement + - EKG optimization + - use case tree evolution + - EKG method + - enterprise knowledge graph optimization +schema_type: "HowTo" --- # Optimize diff --git a/docs/robots.txt b/docs/robots.txt new file mode 100644 index 00000000..81438776 --- /dev/null +++ b/docs/robots.txt @@ -0,0 +1,13 @@ +# robots.txt for Use Case Tree Method documentation site +# https://method.ekgf.org/robots.txt + +User-agent: * +Allow: / + +# Disallow search and admin pages +Disallow: /search/ +Disallow: /*.json$ + +# Allow sitemap +Sitemap: https://method.ekgf.org/sitemap.xml + diff --git a/docs/stylesheets/extra.css b/docs/stylesheets/extra.css index cd6267dd..d4823464 100644 --- a/docs/stylesheets/extra.css +++ b/docs/stylesheets/extra.css @@ -1,7 +1,98 @@ :root { - --md-primary-fg-color: #4A23D9; - --md-primary-fg-color--light: #4A23D9; - --md-primary-fg-color--dark: #25126A; + /* EKGF custom colors - used by entire theme including Mermaid diagrams */ + --md-primary-fg-color: #4051b5; /* Material Indigo 500 for primary elements */ + --md-primary-fg-color--light: #5c6bc0; /* Lighter indigo */ + --md-primary-fg-color--dark: #303f9f; /* Darker indigo */ + --md-accent-fg-color: #ff6f00; /* EKGF orange for accents */ + --md-accent-fg-color--light: #ff9800; /* Lighter orange */ + --md-accent-fg-color--dark: #e65100; /* Darker orange */ +} + +/* Dark mode color adjustments */ +[data-md-color-scheme="slate"] { + --md-primary-fg-color: #4051b5; + --md-primary-fg-color--light: #5c6bc0; + --md-primary-fg-color--dark: #303f9f; + --md-accent-fg-color: #ff6f00; + --md-accent-fg-color--light: #ff9800; + --md-accent-fg-color--dark: #e65100; +} + +/* Force Mermaid diagram elements to use EKGF colors */ +/* Apply to all possible rect elements - node backgrounds - indigo blue */ +.mermaid rect, +.mermaid .node rect, +.mermaid .node circle, +.mermaid .node ellipse, +.mermaid .node polygon, +.mermaid .cluster rect, +.mermaid g.classGroup rect, +.mermaid g rect.divider, +.mermaid g.classGroup > rect:first-child, +.mermaid svg g rect { + fill: #4051b5 !important; + stroke: #ff6f00 !important; + stroke-width: 2px !important; +} + +/* Connector lines, relations, and arrows - orange */ +.mermaid path, +.mermaid line, +.mermaid .edgePath path, +.mermaid .flowchart-link, +.mermaid line.relation, +.mermaid path.relation, +.mermaid line[class*="messageLine"], +.mermaid path[class*="messageLine"], +.mermaid .relationshipLine { + stroke: #ff6f00 !important; + stroke-width: 2px !important; +} + +/* Arrow markers - orange */ +.mermaid marker path, +.mermaid defs marker path, +.mermaid marker polygon { + fill: #ff6f00 !important; + stroke: #ff6f00 !important; +} + +/* Text labels on nodes - white */ +.mermaid text, +.mermaid .nodeLabel, +.mermaid text.nodeLabel, +.mermaid .node text, +.mermaid .classLabel .label, +.mermaid tspan, +.mermaid g.classGroup text, +.mermaid .classLabel text { + fill: #ffffff !important; + color: #ffffff !important; +} + +/* Edge labels - keep dark for readability on light background */ +.mermaid .edgeLabel, +.mermaid .edgeLabel text, +.mermaid .edgeLabel tspan, +.mermaid .edgeLabel rect { + fill: #333333 !important; + color: #333333 !important; +} + +.mermaid .edgeLabel rect { + fill: #ffffff !important; +} + +/* Dark mode edge label adjustments */ +[data-md-color-scheme="slate"] .mermaid .edgeLabel, +[data-md-color-scheme="slate"] .mermaid .edgeLabel text, +[data-md-color-scheme="slate"] .mermaid .edgeLabel tspan { + fill: #ffffff !important; + color: #ffffff !important; +} + +[data-md-color-scheme="slate"] .mermaid .edgeLabel rect { + fill: #1e1e1e !important; } /* Card Design Enhancements */ @@ -83,13 +174,145 @@ /* Large icon styling (.lg class) */ .md-typeset .grid.cards .twemoji.lg svg, .md-typeset .grid.cards .twemoji.lg { - width: 3rem !important; - height: 3rem !important; - margin-bottom: 1rem; - opacity: 0.9; + width: 3.5rem !important; + height: 3.5rem !important; + margin-bottom: 0.75rem; + opacity: 0.85; display: block; } +/* Process cards - enhanced icon styling */ +.md-typeset .grid.cards > ul > li .twemoji.lg svg, +.md-typeset .grid.cards > ul > li .twemoji.lg { + filter: drop-shadow(0 2px 4px rgba(74, 35, 217, 0.15)); +} + +/* Process card specific styling - override ALL Material padding */ +.md-typeset .grid.process-cards > ul > li { + padding: 0 !important; + margin: 0; +} + +/* Ensure header is flush with card top */ +.md-typeset .grid.process-cards > ul > li > div:first-child { + margin-top: 0 !important; +} + +.process-card-header { + display: flex; + align-items: center; + gap: 1rem; + padding: 1rem 1.25rem; + margin: 0 0 0.25rem 0 !important; + position: relative; + overflow: hidden; + box-shadow: 0 8px 20px rgba(18, 32, 70, 0.18); + background-size: cover; + background-position: center; + background-repeat: no-repeat; + color: #fff; + isolation: isolate; + min-height: 4.5rem; +} + +.md-typeset .grid.process-cards > ul > li > *:not(.process-card-header) { + padding-left: 1.25rem; + padding-right: 1.25rem; +} + +.md-typeset .grid.process-cards > ul > li > *:last-child { + padding-bottom: 1.25rem; +} + +.process-card-header::before { + content: ""; + position: absolute; + inset: 0; + background: linear-gradient(120deg, rgba(48, 63, 159, 0.45), rgba(25, 118, 210, 0.4)); + z-index: -1; +} + +.process-card-header::after { + content: ""; + position: absolute; + inset: 0; + background-image: radial-gradient(circle at 80% -10%, rgba(255, 255, 255, 0.15), transparent 55%); + opacity: 0.35; + pointer-events: none; + z-index: -1; +} + +.process-card-header > * { + position: relative; + z-index: 1; +} + +.process-card-header .twemoji.lg, +.process-card-header .twemoji.lg svg { + margin: 0 !important; + width: 3.25rem !important; + height: 3.25rem !important; + opacity: 1; + color: #fff !important; + filter: drop-shadow(0 4px 12px rgba(15, 23, 42, 0.3)); +} + +.process-card-title { + display: flex; + flex-direction: column; + gap: 0.2rem; +} + +.process-card-header strong { + margin: 0 !important; + color: #fff !important; + font-size: 1.35em !important; +} + +.process-card-header strong a { + color: #fff !important; + text-decoration: none; +} + +.process-card-header strong a:hover { + text-decoration: underline; +} + +.process-card-subtitle { + text-transform: uppercase; + letter-spacing: 0.15em; + font-size: 0.7rem; + font-weight: 600; + color: rgba(255, 255, 255, 0.8); +} + +.process-card-body { + padding: 0 1.25rem 1.25rem; + display: flex; + flex-direction: column; + flex: 1; +} + +.process-card-body hr { + margin-left: 0; + margin-right: 0; +} + +.process-card-plan { + background-image: url("https://images.unsplash.com/photo-1500530855697-b586d89ba3ee?auto=format&fit=crop&w=1200&q=80"); + background-position: center 30%; +} + +.process-card-build { + background-image: url("https://images.unsplash.com/photo-1518770660439-4636190af475?auto=format&fit=crop&w=1200&q=80"); + background-position: center 40%; +} + +.process-card-run { + background-image: url("https://images.unsplash.com/photo-1498050108023-c5249f4df085?auto=format&fit=crop&w=1200&q=80"); + background-position: center 55%; +} + .md-typeset .grid.cards .twemoji.lg svg { width: 3rem; height: 3rem; @@ -100,6 +323,49 @@ opacity: 1; } +/* Objective badge styling - circular badges with letters */ +.md-typeset .grid.cards .objective-badge { + display: inline-flex; + align-items: center; + justify-content: center; + width: 3rem !important; + height: 3rem !important; + border-radius: 50%; + background: linear-gradient(135deg, var(--md-primary-fg-color) 0%, var(--md-primary-fg-color--dark) 100%); + color: white; + font-weight: 700; + font-size: 1.5rem; + line-height: 1; + margin-bottom: 1rem; + opacity: 0.9; + transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1); + box-shadow: 0 2px 8px rgba(74, 35, 217, 0.2); + position: relative; +} + +.md-typeset .grid.cards .objective-badge::before { + content: attr(data-letter); +} + +/* Dark mode badge styling */ +[data-md-color-scheme="slate"] .md-typeset .grid.cards .objective-badge { + background: linear-gradient(135deg, var(--md-primary-fg-color--light) 0%, var(--md-primary-fg-color) 100%); + box-shadow: 0 2px 8px rgba(74, 35, 217, 0.3); +} + +/* Badge hover effect */ +.md-typeset .grid.cards > ul > li:hover .objective-badge, +.md-typeset .grid.cards li:hover .objective-badge { + opacity: 1; + transform: scale(1.1) rotate(5deg); + box-shadow: 0 4px 12px rgba(74, 35, 217, 0.4); +} + +[data-md-color-scheme="slate"] .md-typeset .grid.cards > ul > li:hover .objective-badge, +[data-md-color-scheme="slate"] .md-typeset .grid.cards li:hover .objective-badge { + box-shadow: 0 4px 12px rgba(74, 35, 217, 0.5); +} + /* Hide "Learn more" text but keep the link functional */ .md-typeset .grid.cards > ul > li > p:last-child, .md-typeset .grid.cards li > p:last-child { @@ -157,12 +423,13 @@ /* Card title styling */ .md-typeset .grid.cards strong { - font-size: 1.1em !important; - font-weight: 600 !important; + font-size: 1.25em !important; + font-weight: 700 !important; display: block; - margin-bottom: 0.5rem; + margin-bottom: 0.75rem; color: var(--md-primary-fg-color) !important; transition: color 0.2s ease; + letter-spacing: -0.01em; } [data-md-color-scheme="slate"] .md-typeset .grid.cards strong { @@ -177,7 +444,63 @@ /* Card paragraph spacing */ .md-typeset .grid.cards p { margin: 0.5rem 0; - line-height: 1.6; + line-height: 1.5; + font-size: 0.95em; +} + +/* Show bullet points in grid cards - override Material defaults */ +.md-typeset .grid.cards > ul > li ul, +.md-typeset .grid.cards > ul > li > ul, +.md-typeset .grid.cards li ul { + list-style-type: disc !important; + list-style-position: outside !important; + margin-left: 1.5rem !important; + margin-top: 0.5rem !important; + margin-bottom: 0.5rem !important; + padding-left: 0.5rem !important; + display: block !important; +} + +.md-typeset .grid.cards > ul > li ul li, +.md-typeset .grid.cards > ul > li > ul > li, +.md-typeset .grid.cards li ul li { + list-style-type: disc !important; + display: list-item !important; + margin-left: 0 !important; + padding-left: 0.25rem !important; + padding-right: 0 !important; +} + +.md-typeset .grid.cards > ul > li ul li::marker, +.md-typeset .grid.cards > ul > li > ul > li::marker { + content: "• " !important; + color: inherit !important; +} + +/* Force a visible dot when Material hides markers */ +.md-typeset .grid.cards > ul > li ul li, +.md-typeset .grid.cards > ul > li > ul > li { + list-style: none !important; + position: relative !important; + padding-left: 1.1rem !important; +} + +.md-typeset .grid.cards > ul > li ul li::before, +.md-typeset .grid.cards > ul > li > ul > li::before { + content: "•" !important; + position: absolute !important; + left: 0 !important; + top: 0.2rem !important; + color: var(--md-primary-fg-color) !important; + font-weight: 700 !important; + line-height: 1 !important; + font-size: 1.2rem !important; +} + +/* Process cards - more compact description */ +.md-typeset .grid.cards > ul > li > hr:first-of-type + p { + margin-top: 0.25rem !important; + margin-bottom: 0.5rem !important; } /* Improve card content readability */ @@ -188,11 +511,17 @@ /* Card separator (horizontal rule) styling */ .md-typeset .grid.cards hr { - margin: 1rem 0; + margin: 0.75rem 0; border-color: rgba(0, 0, 0, 0.1); opacity: 0.5; } +/* Process cards - tighter separator spacing */ +.md-typeset .grid.cards > ul > li > hr:first-of-type { + margin-top: 0.5rem !important; + margin-bottom: 0.5rem !important; +} + [data-md-color-scheme="slate"] .md-typeset .grid.cards hr { border-color: rgba(255, 255, 255, 0.1); } @@ -203,8 +532,138 @@ } /* Focus states for accessibility */ -.md-typeset .grid.cards a:focus-visible { - outline: 2px solid var(--md-primary-fg-color); - outline-offset: 2px; - border-radius: 0.25rem; +/* Ensure bullet lists in process cards align vertically (top-aligned) */ +.md-typeset .grid.cards > ul > li { + display: flex !important; + flex-direction: column !important; } + +/* Ensure description paragraph has consistent height so separator aligns */ +.process-cards > ul > li > hr:first-of-type + p { + min-height: 3.5rem !important; + flex-grow: 0 !important; + flex-shrink: 0 !important; +} + +/* Ensure the separator before lists is at consistent vertical position */ +.process-cards > ul > li > hr:last-of-type { + margin-top: auto !important; + margin-bottom: 0.5rem !important; + flex-shrink: 0 !important; +} + +/* Ensure lists start at consistent position from top */ +.process-cards > ul > li > ul { + margin-top: 0 !important; + flex-shrink: 0 !important; +} + +/* ChatGPT-style table styling */ +.md-typeset table { + border-collapse: collapse; + width: 100%; + margin: 1.5rem 0; + background: transparent; + border: none !important; + border-top: none !important; + border-bottom: none !important; + border-left: none !important; + border-right: none !important; +} + +.md-typeset table thead { + border: none !important; +} + +.md-typeset table thead th { + border: none !important; + border-top: none !important; + border-bottom: 1px solid rgba(0, 0, 0, 0.1) !important; + border-left: none !important; + border-right: none !important; + padding: 0.75rem 1rem; + text-align: left; + font-weight: 600; + background: transparent; + color: inherit; +} + +[data-md-color-scheme="slate"] .md-typeset table thead th { + border-bottom-color: rgba(255, 255, 255, 0.1) !important; +} + +.md-typeset table tbody { + border: none !important; +} + +.md-typeset table tbody tr { + border: none !important; + border-top: none !important; + border-bottom: 1px solid rgba(0, 0, 0, 0.08) !important; + border-left: none !important; + border-right: none !important; + background: transparent; +} + +[data-md-color-scheme="slate"] .md-typeset table tbody tr { + border-bottom-color: rgba(255, 255, 255, 0.08) !important; +} + +.md-typeset table tbody tr:last-child { + border-bottom: none !important; +} + +.md-typeset table tbody td { + border: none !important; + border-top: none !important; + border-bottom: none !important; + border-left: none !important; + border-right: none !important; + padding: 0.75rem 1rem; + text-align: left; + background: transparent; + vertical-align: top; +} + +.md-typeset table tbody td:first-child { + font-weight: 600; +} + +.md-typeset table tbody tr:hover { + background: rgba(0, 0, 0, 0.02); +} + +[data-md-color-scheme="slate"] .md-typeset table tbody tr:hover { + background: rgba(255, 255, 255, 0.02); +} + +/* Enhanced blockquote styling */ +.md-typeset blockquote { + border-left: 4px solid var(--md-primary-fg-color); + padding-left: 1.5rem; + padding-right: 1rem; + padding-top: 0.5rem; + padding-bottom: 0.5rem; + margin: 1.5rem 0; + background: rgba(74, 35, 217, 0.03); + border-radius: 0 0.25rem 0.25rem 0; + font-style: normal; +} + +[data-md-color-scheme="slate"] .md-typeset blockquote { + background: rgba(74, 35, 217, 0.08); + border-left-color: var(--md-primary-fg-color--light); +} + +.md-typeset blockquote p { + margin: 0.5rem 0; +} + +.md-typeset blockquote p:first-child { + margin-top: 0; +} + +.md-typeset blockquote p:last-child { + margin-bottom: 0; +} + diff --git a/docs/vocab/coe.md b/docs/vocab/coe.md index 2b828ee7..d99807b7 100644 --- a/docs/vocab/coe.md +++ b/docs/vocab/coe.md @@ -1,3 +1,15 @@ +--- +description: "A Center of Excellence for the Enterprise Knowledge Graph (CoE) provides high competence in the Use Case Tree Method and specializes in delivering EKG solutions. Learn about EKG organizational structure." +keywords: + - CoE + - center of excellence + - EKG CoE + - EKG team + - EKG method + - enterprise knowledge graph organization +schema_type: "Article" +--- + # Center of Excellence for the Enterprise Knowledge Graph (CoE) !!! warn @@ -6,6 +18,6 @@ Some notes: -- high competence in the EKG/Method +- high competence in the Use Case Tree Method - specialized to delivering EKG solutions diff --git a/docs/vocab/ekg-id.md b/docs/vocab/ekg-id.md index ce78740a..c7f2ab27 100644 --- a/docs/vocab/ekg-id.md +++ b/docs/vocab/ekg-id.md @@ -1,3 +1,15 @@ +--- +description: "An EKG Identifier (EKG/ID) identifies an object in an EKG and is universally unique, opaque, permanent, resolvable, and non-reassignable. Learn about EKG identity principles." +keywords: + - EKG/ID + - EKG identifier + - unique identifier + - identity management + - EKG method + - enterprise knowledge graph +schema_type: "Article" +--- + # EKG Identifier (EKG/ID) _An EKG Identifier identifies an object[^object] in an [EKG](ekg.md) diff --git a/docs/vocab/ekg-iri.md b/docs/vocab/ekg-iri.md index 527bfe63..146c5c32 100644 --- a/docs/vocab/ekg-iri.md +++ b/docs/vocab/ekg-iri.md @@ -1,6 +1,15 @@ --- author: - Jacobus Geluk +description: "An EKG/IRI is an HTTPS-based Internationalised Resource Identifier that forms the primary identifier of an object in the EKG. Learn about EKG identity and web-resolvable identifiers." +keywords: + - EKG/IRI + - IRI + - internationalised resource identifier + - web-resolvable identifier + - EKG method + - enterprise knowledge graph +schema_type: "Article" --- # EKG/IRI diff --git a/docs/vocab/ekg-platform.md b/docs/vocab/ekg-platform.md index 453cf415..2e6a29f2 100644 --- a/docs/vocab/ekg-platform.md +++ b/docs/vocab/ekg-platform.md @@ -1,3 +1,15 @@ +--- +description: "EKG/Platform is the technical infrastructure that runs the Enterprise Knowledge Graph. Learn about the platform layer that provides holistic views of all connected data and knowledge." +keywords: + - EKG/Platform + - EKG platform + - knowledge graph platform + - semantic platform + - EKG method + - enterprise knowledge graph platform +schema_type: "Article" +--- + # EKG/Platform _EKG/Platform_ is EKGF's brand name for the overall technical infrastructure diff --git a/docs/vocab/ekg.md b/docs/vocab/ekg.md index 90611e93..55dc7636 100644 --- a/docs/vocab/ekg.md +++ b/docs/vocab/ekg.md @@ -1,3 +1,15 @@ +--- +description: "An Enterprise Knowledge Graph connects all data objects and their meaning across systems. Learn what an EKG is, how it works, and why it enables advanced use cases beyond traditional technologies." +keywords: + - EKG + - enterprise knowledge graph + - knowledge graph + - semantic data + - connected data + - EKG method +schema_type: "Article" +--- + # Enterprise Knowledge Graph (EKG) ## What is an EKG? diff --git a/docs/vocab/maturity-model.md b/docs/vocab/maturity-model.md index eac985cb..6633af77 100644 --- a/docs/vocab/maturity-model.md +++ b/docs/vocab/maturity-model.md @@ -1,3 +1,15 @@ +--- +description: "The Maturity Model for the Enterprise Knowledge Graph (EKG/Maturity) is the reference framework for all non-functional requirements of any given use case. Learn about EKG maturity assessment." +keywords: + - EKG maturity model + - EKG/Maturity + - maturity assessment + - non-functional requirements + - EKG method + - enterprise knowledge graph maturity +schema_type: "Article" +--- + # Maturity Model for the EKG (EKG/Maturity) The [Maturity Model for the Enterprise Knowledge Graph (EKG/Maturity)](https://maturity.ekgf.org) diff --git a/docs/vocab/positive-learning.md b/docs/vocab/positive-learning.md index 87e46c92..ba8f1daa 100644 --- a/docs/vocab/positive-learning.md +++ b/docs/vocab/positive-learning.md @@ -1,3 +1,15 @@ +--- +description: "Positive Learning in the context of Enterprise Knowledge Graph development. Learn about avoiding negative learning and fostering positive learning outcomes in EKG initiatives." +keywords: + - positive learning + - negative learning + - EKG learning + - organizational learning + - EKG method + - enterprise knowledge graph +schema_type: "Article" +--- + # Positive Learning TODO diff --git a/docs/vocab/silo.md b/docs/vocab/silo.md index cc91fd7c..b699671e 100644 --- a/docs/vocab/silo.md +++ b/docs/vocab/silo.md @@ -1,3 +1,15 @@ +--- +description: "A silo in enterprise architecture refers to isolated systems or data stores that don't integrate well. Learn how the Use Case Tree Method helps break down silos and connect enterprise data." +keywords: + - silo + - data silo + - information silo + - silo breaking + - EKG method + - enterprise knowledge graph +schema_type: "Article" +--- + # Silo TODO diff --git a/mkdocs.yml b/mkdocs.yml index 86d3ee59..48f2c73f 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -1,13 +1,13 @@ # yaml-language-server: $schema=https://squidfunk.github.io/mkdocs-material/schema.json -site_name: EKG/Method +site_name: Use Case Tree Method site_description: Use Case Tree Method, a method to develop an Enterprise Knowledge Graph (EKG) repo_name: 'EKGF/ekg-method' repo_url: https://github.com/EKGF/ekg-method site_url: https://method.ekgf.org edit_uri: edit/main/docs/ site_dir: site -site_author: Enterprise Knowledge Graph Foundation -copyright: Copyright © 2019-2023 Enterprise Knowledge Graph Foundation +site_author: Object Management Group (OMG) Enterprise Knowledge Graph Forum +copyright: "Copyright © 2025 Object Management Group®, OMG® | All Rights Reserved" # Navigation # nav: omitted, because we're using the awesome-pages plugin (https://squidfunk.github.io/mkdocs-material/plugins/awesome-pages/) @@ -26,8 +26,8 @@ theme: palette: - media: "(prefers-color-scheme: light)" scheme: default - primary: indigo - accent: light-blue + primary: custom + accent: custom toggle: # icon: material/toggle-switch-off-outline # icon: material/lightbulb-outline @@ -35,8 +35,8 @@ theme: name: Switch to dark mode - media: "(prefers-color-scheme: dark)" scheme: slate - primary: indigo - accent: deep orange + primary: custom + accent: custom toggle: # icon: material/toggle-switch # icon: material/lightbulb @@ -58,11 +58,7 @@ theme: extra: homepage: https://www.ekgf.org/quadrants generator: false - giscus: - repo_id: 'R_kgDOGyFarg' - category: - name: 'General' - id: 'DIC_kwDOGyFars4CA_Gc' + google_site_verification: "Q_9d2He8XxoBrVAXrAXsEm2R_UrGZ6KcOCXkeNRQ058" social: - icon: fontawesome/brands/twitter link: https://twitter.com/EKG_Foundation @@ -73,24 +69,8 @@ extra: analytics: provider: google property: G-9LCW4TSSRP - feedback: - title: Was this page helpful? - ratings: - - icon: material/emoticon-happy-outline - name: This page was helpful - data: 1 - note: >- - Thanks for your feedback! - - icon: material/emoticon-sad-outline - name: This page could be improved - data: 0 - note: >- - Thanks for your feedback! Help us improve this page by - using our feedback form. extra_javascript: - - "javascript/images_dark.js" - - "javascript/refresh_on_toggle_dark_light.js" - - "https://cdn.jsdelivr.net/gh/rod2ik/cdn@main/mkdocs/javascripts/mkdocs-graphviz.js" + - javascripts/mermaid.js plugins: - include-markdown - git-revision-date-localized: @@ -104,14 +84,6 @@ plugins: - search: lang: - en - - mermaid2: - javascript: "https://unpkg.com/mermaid/dist/mermaid.min.js" - arguments: - # test if its __palette_1 (dark) or __palette_2 (light) - # for mkdocs-material >=8.0.0 - theme: | - ^(JSON.parse(__md_get("__palette").index == 1)) ? 'dark' : 'light' - securityLevel: 'loose' - exclude-search: exclude: - 'fragment/*' @@ -157,7 +129,6 @@ markdown_extensions: - abbr - admonition # - mdx_emdash (causes too many warnings) - - footnotes - tables - mkdocs_graphviz - pymdownx.caret @@ -172,9 +143,7 @@ markdown_extensions: auto_append: - abbreviations.md - pymdownx.details - - pymdownx.mark - pymdownx.magiclink - - pymdownx.smartsymbols - pymdownx.critic - pymdownx.emoji: emoji_generator: !!python/name:material.extensions.emoji.to_svg @@ -182,13 +151,22 @@ markdown_extensions: options: custom_icons: - docs-overrides/.icons + # Mermaid diagram support - using Material for MkDocs native integration + # NOTE: Do NOT use mkdocs-mermaid2-plugin - it conflicts with Material's native support + # Material for MkDocs has built-in Mermaid.js support that works better with instant loading + # Custom colors are configured using: + # 1. Theme palette set to 'custom' (primary/accent colors) + # 2. CSS variables in docs/stylesheets/extra.css + # 3. Inline %%{init}%% directives in individual diagrams (docs/fragment/uctm-diagram-*.md) - pymdownx.superfences: custom_fences: - name: mermaid class: mermaid - format: !!python/name:mermaid2.fence_mermaid + format: !!python/name:pymdownx.superfences.fence_code_format - pymdownx.tabbed: alternate_style: true + slugify: !!python/object/apply:pymdownx.slugs.slugify + kwds: + case: lower - pymdownx.tasklist: custom_checkbox: true - - pymdownx.tilde diff --git a/pyproject.toml b/pyproject.toml index 494101e3..c17a18f8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -5,7 +5,7 @@ description = "" authors = [ {name = "Jacobus Geluk", email = "jacobus.geluk@ekgf.org"}, ] -requires-python = ">=3.13" +requires-python = ">=3.14.2" readme = "README.md" license = { file = "LICENSE" } dependencies = [ @@ -21,7 +21,6 @@ dependencies = [ "mkdocs-include-markdown-plugin", "mkdocs-localsearch", "mkdocs-macros-plugin", - "mkdocs-mermaid2-plugin", "mkdocs-minify-plugin", "mkdocs-redirects", "mkdocs-kroki-plugin", diff --git a/rewrite_commits.py b/rewrite_commits.py deleted file mode 100755 index aa72e112..00000000 --- a/rewrite_commits.py +++ /dev/null @@ -1,239 +0,0 @@ -#!/usr/bin/env python3 -""" -Script to rewrite git commit messages to follow conventional commits format. -This script analyzes commit messages and converts them to conventional commit format. -""" - -import re -import subprocess -import sys - -def get_commit_type_and_message(msg): - """Convert a commit message to conventional commit format.""" - - # Remove "#1 " prefix if present - msg = re.sub(r'^#1\s+', '', msg) - - # Fix typo "fromt" -> "from" regardless of format - if 'fromt' in msg.lower() and 'last call' in msg.lower(): - # If already in conventional commit format, fix the typo in place - if re.match(r'^(feat|fix|docs|style|refactor|test|chore|perf|ci|build|revert)(\(.+\))?:', msg): - return re.sub(r'fromt', 'from', msg, flags=re.IGNORECASE) - else: - return f"chore(docs): updates from the last call" - - # Already in conventional commit format - if re.match(r'^(feat|fix|docs|style|refactor|test|chore|perf|ci|build|revert)(\(.+\))?:', msg): - return msg - - # Merge commits - keep as is - if msg.startswith('Merge '): - return msg - - # Deployed commits - convert to ci(deploy) - if msg.startswith('Deployed '): - return f"ci(deploy): {msg.lower()}" - - # Bump commits - convert to chore(deps) - if msg.startswith('Bump '): - # Extract package name - match = re.search(r'Bump (.+?) from', msg) - if match: - pkg = match.group(1).replace('/', '-') - return f"chore(deps): {msg.lower()}" - return f"chore(deps): {msg.lower()}" - - # Fix commits - if any(word in msg.lower() for word in ['fix', 'fixed', 'fixing', 'fixes']): - scope = 'ci' if any(word in msg.lower() for word in ['workflow', 'github', 'action', 'ci', 'build', 'labeler', 'mkdocs', 'config']) else 'docs' - if 'typo' in msg.lower(): - scope = 'docs' - elif 'plantuml' in msg.lower() or 'diagram' in msg.lower(): - scope = 'docs' - elif 'pip' in msg.lower() or 'install' in msg.lower() or 'wheel' in msg.lower(): - scope = 'build' - return f"fix({scope}): {msg.lower()}" - - # Add/Added commits - if msg.startswith('Add') or msg.startswith('Added') or msg.startswith('add'): - scope = 'docs' - if 'content' in msg.lower(): - scope = 'docs' - elif 'plantuml' in msg.lower() or 'mermaid' in msg.lower() or 'diagram' in msg.lower(): - scope = 'docs' - elif 'github' in msg.lower() or 'action' in msg.lower() or 'workflow' in msg.lower() or 'ci' in msg.lower(): - scope = 'ci' - elif 'insiders' in msg.lower() or 'mkdocs' in msg.lower(): - scope = 'docs' - elif 'menu' in msg.lower(): - scope = 'docs' - elif 'tool' in msg.lower() or 'pre-requisite' in msg.lower(): - scope = 'build' - elif 'venv' in msg.lower() or '.gitignore' in msg.lower(): - scope = 'build' - elif 'charter' in msg.lower() or 'lock file' in msg.lower() or 'settings' in msg.lower(): - scope = 'chore' - elif 'analytics' in msg.lower(): - scope = 'chore' - elif 'objective' in msg.lower() or 'modularity' in msg.lower(): - scope = 'docs' - elif 'process' in msg.lower(): - scope = 'docs' - elif 'article' in msg.lower() or 'interoperability' in msg.lower(): - scope = 'docs' - elif 'point' in msg.lower() or 'tubbax' in msg.lower(): - scope = 'docs' - else: - scope = 'docs' - return f"feat({scope}): {msg.lower()}" - - # Update/Updated commits - if msg.startswith('Update') or msg.startswith('Updated') or msg.startswith('update'): - # Special case: fix typo "fromt" -> "from" - if 'fromt' in msg.lower() and 'last call' in msg.lower(): - return f"chore(docs): updates from the last call" - scope = 'ci' - if 'analytics' in msg.lower(): - scope = 'chore' - elif 'tool' in msg.lower() or 'version' in msg.lower(): - scope = 'build' - elif 'workflow' in msg.lower() or 'action' in msg.lower(): - scope = 'ci' - elif 'asdf' in msg.lower(): - scope = 'ci' - elif 'cname' in msg.lower(): - scope = 'docs' - else: - scope = 'ci' - return f"chore({scope}): {msg.lower()}" - - # Remove/Removed commits - if msg.startswith('Remove') or msg.startswith('Removed') or msg.startswith('remove'): - scope = 'build' - if 'java' in msg.lower() or 'node' in msg.lower() or 'plantuml' in msg.lower(): - scope = 'build' - elif 'diagram' in msg.lower(): - scope = 'docs' - elif 'job' in msg.lower() or 'macos' in msg.lower(): - scope = 'ci' - else: - scope = 'build' - return f"chore({scope}): {msg.lower()}" - - # Rename/Renamed commits - if msg.startswith('Rename') or msg.startswith('Renamed') or msg.startswith('rename'): - scope = 'docs' - if 'website' in msg.lower() or 'ekgf' in msg.lower(): - scope = 'docs' - return f"chore({scope}): {msg.lower()}" - - # Enable/Enabling commits - if msg.startswith('Enable') or msg.startswith('Enabling') or msg.startswith('enable'): - scope = 'docs' - if 'url' in msg.lower() or 'edit' in msg.lower(): - scope = 'docs' - return f"feat({scope}): {msg.lower()}" - - # Disable/Disabling commits - if msg.startswith('Disable') or msg.startswith('Disabling') or msg.startswith('disable'): - scope = 'docs' - if 'pic' in msg.lower() or 'process' in msg.lower(): - scope = 'docs' - return f"fix({scope}): {msg.lower()}" - - # Create/Delete CNAME - if 'CNAME' in msg: - action = 'create' if 'Create' in msg else 'delete' - return f"chore(docs): {action} CNAME" - - # Minor changes/updates/improvements - if any(phrase in msg.lower() for phrase in ['minor change', 'minor update', 'minor improvement', 'minor fix', 'minor fixes']): - scope = 'docs' - if 'text' in msg.lower() or 'content' in msg.lower(): - scope = 'docs' - elif 'concept' in msg.lower() or 'use case' in msg.lower() or 'plan' in msg.lower(): - scope = 'docs' - else: - scope = 'docs' - return f"chore({scope}): {msg.lower()}" - - # Content improvements - if any(phrase in msg.lower() for phrase in ['content improvement', 'many content', 'more content', 'some more content', 'added more content']): - return f"feat(docs): {msg.lower()}" - - # "Many content improvements" or similar - if 'improvement' in msg.lower() and 'content' in msg.lower(): - return f"feat(docs): {msg.lower()}" - - # "First stab", "First push", "First boilerplate" - if msg.startswith('First '): - if 'push' in msg.lower(): - return f"chore(ci): {msg.lower()}" - elif 'boilerplate' in msg.lower(): - return f"chore: {msg.lower()}" - elif 'stab' in msg.lower(): - return f"feat(docs): {msg.lower()}" - - # "Trying to" commits - if msg.startswith('Trying ') or msg.startswith('trying '): - scope = 'ci' - if 'mermaid' in msg.lower(): - scope = 'docs' - elif 'python' in msg.lower() or 'brew' in msg.lower() or 'asdf' in msg.lower(): - scope = 'ci' - return f"chore({scope}): {msg.lower()}" - - # "Making sure" or "making Makefile" - if msg.startswith('Making ') or msg.startswith('making '): - scope = 'ci' - if 'makefile' in msg.lower(): - scope = 'build' - elif 'pat' in msg.lower() or 'env' in msg.lower(): - scope = 'ci' - elif 'push' in msg.lower() or 'fetch' in msg.lower(): - scope = 'ci' - return f"chore({scope}): {msg.lower()}" - - # "Installing" or "install" - if 'install' in msg.lower(): - scope = 'build' - if 'insiders' in msg.lower() or 'mkdocs' in msg.lower(): - scope = 'build' - return f"chore({scope}): {msg.lower()}" - - # "Fetching" commits - if msg.startswith('Fetching ') or 'fetch' in msg.lower(): - return f"chore(ci): {msg.lower()}" - - # "Switching" commits - if 'switching' in msg.lower() or 'switch' in msg.lower(): - return f"chore(docs): {msg.lower()}" - - # "Added proposed" or "Added some points" - if 'proposed' in msg.lower(): - return f"feat(docs): {msg.lower()}" - - # Default: treat as feat(docs) for content-related, chore for others - if any(word in msg.lower() for word in ['content', 'text', 'page', 'section', 'concept', 'usecase', 'faq']): - return f"feat(docs): {msg.lower()}" - - # Default fallback - return f"chore: {msg.lower()}" - -def main(): - # Read from stdin (for git filter-branch) or command line argument - if len(sys.argv) >= 2: - original_msg = sys.argv[1] - else: - original_msg = sys.stdin.read().strip() - - if not original_msg: - # Empty commit message - return a default - print("chore: initial commit") - return - - new_msg = get_commit_type_and_message(original_msg) - print(new_msg) - -if __name__ == '__main__': - main() diff --git a/uv.lock b/uv.lock index 8a1c7d87..02760f6b 100644 --- a/uv.lock +++ b/uv.lock @@ -1,6 +1,6 @@ version = 1 revision = 3 -requires-python = ">=3.13" +requires-python = ">=3.14.2" [[package]] name = "anyio" @@ -37,19 +37,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/02/e3/a4fa1946722c4c7b063cc25043a12d9ce9b4323777f89643be74cef2993c/backrefs-6.1-py39-none-any.whl", hash = "sha256:a9e99b8a4867852cad177a6430e31b0f6e495d65f8c6c134b68c14c3c95bf4b0", size = 381058, upload-time = "2025-11-15T14:52:06.698Z" }, ] -[[package]] -name = "beautifulsoup4" -version = "4.14.3" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "soupsieve" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/c3/b0/1c6a16426d389813b48d95e26898aff79abbde42ad353958ad95cc8c9b21/beautifulsoup4-4.14.3.tar.gz", hash = "sha256:6292b1c5186d356bba669ef9f7f051757099565ad9ada5dd630bd9de5fa7fb86", size = 627737, upload-time = "2025-11-30T15:08:26.084Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/1a/39/47f9197bdd44df24d67ac8893641e16f386c984a0619ef2ee4c51fbbc019/beautifulsoup4-4.14.3-py3-none-any.whl", hash = "sha256:0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb", size = 107721, upload-time = "2025-11-30T15:08:24.087Z" }, -] - [[package]] name = "boto3" version = "1.42.0" @@ -158,18 +145,6 @@ dependencies = [ ] sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" }, - { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" }, - { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" }, - { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" }, - { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" }, - { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" }, - { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" }, - { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" }, - { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" }, - { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" }, - { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" }, - { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" }, { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, @@ -200,22 +175,6 @@ version = "3.4.4" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" }, - { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" }, - { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" }, - { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" }, - { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" }, - { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" }, - { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" }, - { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" }, - { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" }, - { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" }, - { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" }, - { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" }, - { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" }, - { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" }, - { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" }, - { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" }, { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" }, { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" }, { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" }, @@ -293,15 +252,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" }, ] -[[package]] -name = "editorconfig" -version = "0.17.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/88/3a/a61d9a1f319a186b05d14df17daea42fcddea63c213bcd61a929fb3a6796/editorconfig-0.17.1.tar.gz", hash = "sha256:23c08b00e8e08cc3adcddb825251c497478df1dada6aefeb01e626ad37303745", size = 14695, upload-time = "2025-06-09T08:21:37.097Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/96/fd/a40c621ff207f3ce8e484aa0fc8ba4eb6e3ecf52e15b42ba764b457a9550/editorconfig-0.17.1-py3-none-any.whl", hash = "sha256:1eda9c2c0db8c16dbd50111b710572a5e6de934e39772de1959d41f64fc17c82", size = 16360, upload-time = "2025-06-09T08:21:35.654Z" }, -] - [[package]] name = "ekg-method" version = "1.0.0" @@ -324,7 +274,6 @@ dependencies = [ { name = "mkdocs-localsearch" }, { name = "mkdocs-macros-plugin" }, { name = "mkdocs-material" }, - { name = "mkdocs-mermaid2-plugin" }, { name = "mkdocs-minify-plugin" }, { name = "mkdocs-redirects" }, { name = "pillow" }, @@ -350,7 +299,6 @@ requires-dist = [ { name = "mkdocs-localsearch" }, { name = "mkdocs-macros-plugin" }, { name = "mkdocs-material" }, - { name = "mkdocs-mermaid2-plugin" }, { name = "mkdocs-minify-plugin" }, { name = "mkdocs-redirects" }, { name = "pillow" }, @@ -545,19 +493,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/31/b4/b9b800c45527aadd64d5b442f9b932b00648617eb5d63d2c7a6587b7cafc/jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980", size = 20256, upload-time = "2022-06-17T18:00:10.251Z" }, ] -[[package]] -name = "jsbeautifier" -version = "1.15.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "editorconfig" }, - { name = "six" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/ea/98/d6cadf4d5a1c03b2136837a435682418c29fdeb66be137128544cecc5b7a/jsbeautifier-1.15.4.tar.gz", hash = "sha256:5bb18d9efb9331d825735fbc5360ee8f1aac5e52780042803943aa7f854f7592", size = 75257, upload-time = "2025-02-27T17:53:53.252Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/2d/14/1c65fccf8413d5f5c6e8425f84675169654395098000d8bddc4e9d3390e1/jsbeautifier-1.15.4-py3-none-any.whl", hash = "sha256:72f65de312a3f10900d7685557f84cb61a9733c50dcc27271a39f5b0051bf528", size = 94707, upload-time = "2025-02-27T17:53:46.152Z" }, -] - [[package]] name = "jsmin" version = "3.0.1" @@ -600,28 +535,6 @@ version = "3.0.3" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" }, - { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" }, - { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" }, - { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" }, - { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" }, - { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" }, - { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" }, - { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" }, - { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" }, - { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" }, - { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" }, - { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" }, - { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" }, - { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" }, - { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" }, - { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" }, - { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" }, - { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" }, - { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" }, - { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" }, - { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" }, - { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" }, { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" }, { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" }, { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" }, @@ -892,23 +805,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/5b/54/662a4743aa81d9582ee9339d4ffa3c8fd40a4965e033d77b9da9774d3960/mkdocs_material_extensions-1.3.1-py3-none-any.whl", hash = "sha256:adff8b62700b25cb77b53358dad940f3ef973dd6db797907c49e3c2ef3ab4e31", size = 8728, upload-time = "2023-11-22T19:09:43.465Z" }, ] -[[package]] -name = "mkdocs-mermaid2-plugin" -version = "1.2.3" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "beautifulsoup4" }, - { name = "jsbeautifier" }, - { name = "mkdocs" }, - { name = "pymdown-extensions" }, - { name = "requests" }, - { name = "setuptools" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/2a/6d/308f443a558b6a97ce55782658174c0d07c414405cfc0a44d36ad37e36f9/mkdocs_mermaid2_plugin-1.2.3.tar.gz", hash = "sha256:fb6f901d53e5191e93db78f93f219cad926ccc4d51e176271ca5161b6cc5368c", size = 16220, upload-time = "2025-10-17T19:38:53.047Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/1a/4b/6fd6dd632019b7f522f1b1f794ab6115cd79890330986614be56fd18f0eb/mkdocs_mermaid2_plugin-1.2.3-py3-none-any.whl", hash = "sha256:33f60c582be623ed53829a96e19284fc7f1b74a1dbae78d4d2e47fe00c3e190d", size = 17299, upload-time = "2025-10-17T19:38:51.874Z" }, -] - [[package]] name = "mkdocs-minify-plugin" version = "0.8.0" @@ -951,28 +847,6 @@ version = "2.3.5" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/76/65/21b3bc86aac7b8f2862db1e808f1ea22b028e30a225a34a5ede9bf8678f2/numpy-2.3.5.tar.gz", hash = "sha256:784db1dcdab56bf0517743e746dfb0f885fc68d948aba86eeec2cba234bdf1c0", size = 20584950, upload-time = "2025-11-16T22:52:42.067Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/db/69/9cde09f36da4b5a505341180a3f2e6fadc352fd4d2b7096ce9778db83f1a/numpy-2.3.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d0f23b44f57077c1ede8c5f26b30f706498b4862d3ff0a7298b8411dd2f043ff", size = 16728251, upload-time = "2025-11-16T22:50:19.013Z" }, - { url = "https://files.pythonhosted.org/packages/79/fb/f505c95ceddd7027347b067689db71ca80bd5ecc926f913f1a23e65cf09b/numpy-2.3.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:aa5bc7c5d59d831d9773d1170acac7893ce3a5e130540605770ade83280e7188", size = 12254652, upload-time = "2025-11-16T22:50:21.487Z" }, - { url = "https://files.pythonhosted.org/packages/78/da/8c7738060ca9c31b30e9301ee0cf6c5ffdbf889d9593285a1cead337f9a5/numpy-2.3.5-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:ccc933afd4d20aad3c00bcef049cb40049f7f196e0397f1109dba6fed63267b0", size = 5083172, upload-time = "2025-11-16T22:50:24.562Z" }, - { url = "https://files.pythonhosted.org/packages/a4/b4/ee5bb2537fb9430fd2ef30a616c3672b991a4129bb1c7dcc42aa0abbe5d7/numpy-2.3.5-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:afaffc4393205524af9dfa400fa250143a6c3bc646c08c9f5e25a9f4b4d6a903", size = 6622990, upload-time = "2025-11-16T22:50:26.47Z" }, - { url = "https://files.pythonhosted.org/packages/95/03/dc0723a013c7d7c19de5ef29e932c3081df1c14ba582b8b86b5de9db7f0f/numpy-2.3.5-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c75442b2209b8470d6d5d8b1c25714270686f14c749028d2199c54e29f20b4d", size = 14248902, upload-time = "2025-11-16T22:50:28.861Z" }, - { url = "https://files.pythonhosted.org/packages/f5/10/ca162f45a102738958dcec8023062dad0cbc17d1ab99d68c4e4a6c45fb2b/numpy-2.3.5-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11e06aa0af8c0f05104d56450d6093ee639e15f24ecf62d417329d06e522e017", size = 16597430, upload-time = "2025-11-16T22:50:31.56Z" }, - { url = "https://files.pythonhosted.org/packages/2a/51/c1e29be863588db58175175f057286900b4b3327a1351e706d5e0f8dd679/numpy-2.3.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ed89927b86296067b4f81f108a2271d8926467a8868e554eaf370fc27fa3ccaf", size = 16024551, upload-time = "2025-11-16T22:50:34.242Z" }, - { url = "https://files.pythonhosted.org/packages/83/68/8236589d4dbb87253d28259d04d9b814ec0ecce7cb1c7fed29729f4c3a78/numpy-2.3.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51c55fe3451421f3a6ef9a9c1439e82101c57a2c9eab9feb196a62b1a10b58ce", size = 18533275, upload-time = "2025-11-16T22:50:37.651Z" }, - { url = "https://files.pythonhosted.org/packages/40/56/2932d75b6f13465239e3b7b7e511be27f1b8161ca2510854f0b6e521c395/numpy-2.3.5-cp313-cp313-win32.whl", hash = "sha256:1978155dd49972084bd6ef388d66ab70f0c323ddee6f693d539376498720fb7e", size = 6277637, upload-time = "2025-11-16T22:50:40.11Z" }, - { url = "https://files.pythonhosted.org/packages/0c/88/e2eaa6cffb115b85ed7c7c87775cb8bcf0816816bc98ca8dbfa2ee33fe6e/numpy-2.3.5-cp313-cp313-win_amd64.whl", hash = "sha256:00dc4e846108a382c5869e77c6ed514394bdeb3403461d25a829711041217d5b", size = 12779090, upload-time = "2025-11-16T22:50:42.503Z" }, - { url = "https://files.pythonhosted.org/packages/8f/88/3f41e13a44ebd4034ee17baa384acac29ba6a4fcc2aca95f6f08ca0447d1/numpy-2.3.5-cp313-cp313-win_arm64.whl", hash = "sha256:0472f11f6ec23a74a906a00b48a4dcf3849209696dff7c189714511268d103ae", size = 10194710, upload-time = "2025-11-16T22:50:44.971Z" }, - { url = "https://files.pythonhosted.org/packages/13/cb/71744144e13389d577f867f745b7df2d8489463654a918eea2eeb166dfc9/numpy-2.3.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:414802f3b97f3c1eef41e530aaba3b3c1620649871d8cb38c6eaff034c2e16bd", size = 16827292, upload-time = "2025-11-16T22:50:47.715Z" }, - { url = "https://files.pythonhosted.org/packages/71/80/ba9dc6f2a4398e7f42b708a7fdc841bb638d353be255655498edbf9a15a8/numpy-2.3.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5ee6609ac3604fa7780e30a03e5e241a7956f8e2fcfe547d51e3afa5247ac47f", size = 12378897, upload-time = "2025-11-16T22:50:51.327Z" }, - { url = "https://files.pythonhosted.org/packages/2e/6d/db2151b9f64264bcceccd51741aa39b50150de9b602d98ecfe7e0c4bff39/numpy-2.3.5-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:86d835afea1eaa143012a2d7a3f45a3adce2d7adc8b4961f0b362214d800846a", size = 5207391, upload-time = "2025-11-16T22:50:54.542Z" }, - { url = "https://files.pythonhosted.org/packages/80/ae/429bacace5ccad48a14c4ae5332f6aa8ab9f69524193511d60ccdfdc65fa/numpy-2.3.5-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:30bc11310e8153ca664b14c5f1b73e94bd0503681fcf136a163de856f3a50139", size = 6721275, upload-time = "2025-11-16T22:50:56.794Z" }, - { url = "https://files.pythonhosted.org/packages/74/5b/1919abf32d8722646a38cd527bc3771eb229a32724ee6ba340ead9b92249/numpy-2.3.5-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1062fde1dcf469571705945b0f221b73928f34a20c904ffb45db101907c3454e", size = 14306855, upload-time = "2025-11-16T22:50:59.208Z" }, - { url = "https://files.pythonhosted.org/packages/a5/87/6831980559434973bebc30cd9c1f21e541a0f2b0c280d43d3afd909b66d0/numpy-2.3.5-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ce581db493ea1a96c0556360ede6607496e8bf9b3a8efa66e06477267bc831e9", size = 16657359, upload-time = "2025-11-16T22:51:01.991Z" }, - { url = "https://files.pythonhosted.org/packages/dd/91/c797f544491ee99fd00495f12ebb7802c440c1915811d72ac5b4479a3356/numpy-2.3.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:cc8920d2ec5fa99875b670bb86ddeb21e295cb07aa331810d9e486e0b969d946", size = 16093374, upload-time = "2025-11-16T22:51:05.291Z" }, - { url = "https://files.pythonhosted.org/packages/74/a6/54da03253afcbe7a72785ec4da9c69fb7a17710141ff9ac5fcb2e32dbe64/numpy-2.3.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:9ee2197ef8c4f0dfe405d835f3b6a14f5fee7782b5de51ba06fb65fc9b36e9f1", size = 18594587, upload-time = "2025-11-16T22:51:08.585Z" }, - { url = "https://files.pythonhosted.org/packages/80/e9/aff53abbdd41b0ecca94285f325aff42357c6b5abc482a3fcb4994290b18/numpy-2.3.5-cp313-cp313t-win32.whl", hash = "sha256:70b37199913c1bd300ff6e2693316c6f869c7ee16378faf10e4f5e3275b299c3", size = 6405940, upload-time = "2025-11-16T22:51:11.541Z" }, - { url = "https://files.pythonhosted.org/packages/d5/81/50613fec9d4de5480de18d4f8ef59ad7e344d497edbef3cfd80f24f98461/numpy-2.3.5-cp313-cp313t-win_amd64.whl", hash = "sha256:b501b5fa195cc9e24fe102f21ec0a44dffc231d2af79950b451e0d99cea02234", size = 12920341, upload-time = "2025-11-16T22:51:14.312Z" }, - { url = "https://files.pythonhosted.org/packages/bb/ab/08fd63b9a74303947f34f0bd7c5903b9c5532c2d287bead5bdf4c556c486/numpy-2.3.5-cp313-cp313t-win_arm64.whl", hash = "sha256:a80afd79f45f3c4a7d341f13acbe058d1ca8ac017c165d3fa0d3de6bc1a079d7", size = 10262507, upload-time = "2025-11-16T22:51:16.846Z" }, { url = "https://files.pythonhosted.org/packages/ba/97/1a914559c19e32d6b2e233cf9a6a114e67c856d35b1d6babca571a3e880f/numpy-2.3.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:bf06bc2af43fa8d32d30fae16ad965663e966b1a3202ed407b84c989c3221e82", size = 16735706, upload-time = "2025-11-16T22:51:19.558Z" }, { url = "https://files.pythonhosted.org/packages/57/d4/51233b1c1b13ecd796311216ae417796b88b0616cfd8a33ae4536330748a/numpy-2.3.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:052e8c42e0c49d2575621c158934920524f6c5da05a1d3b9bab5d8e259e045f0", size = 12264507, upload-time = "2025-11-16T22:51:22.492Z" }, { url = "https://files.pythonhosted.org/packages/45/98/2fe46c5c2675b8306d0b4a3ec3494273e93e1226a490f766e84298576956/numpy-2.3.5-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:1ed1ec893cff7040a02c8aa1c8611b94d395590d553f6b53629a4461dc7f7b63", size = 5093049, upload-time = "2025-11-16T22:51:25.171Z" }, @@ -1060,19 +934,6 @@ dependencies = [ ] sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload-time = "2025-09-29T23:34:51.853Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/cd/4b/18b035ee18f97c1040d94debd8f2e737000ad70ccc8f5513f4eefad75f4b/pandas-2.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:56851a737e3470de7fa88e6131f41281ed440d29a9268dcbf0002da5ac366713", size = 11544671, upload-time = "2025-09-29T23:21:05.024Z" }, - { url = "https://files.pythonhosted.org/packages/31/94/72fac03573102779920099bcac1c3b05975c2cb5f01eac609faf34bed1ca/pandas-2.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdcd9d1167f4885211e401b3036c0c8d9e274eee67ea8d0758a256d60704cfe8", size = 10680807, upload-time = "2025-09-29T23:21:15.979Z" }, - { url = "https://files.pythonhosted.org/packages/16/87/9472cf4a487d848476865321de18cc8c920b8cab98453ab79dbbc98db63a/pandas-2.3.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e32e7cc9af0f1cc15548288a51a3b681cc2a219faa838e995f7dc53dbab1062d", size = 11709872, upload-time = "2025-09-29T23:21:27.165Z" }, - { url = "https://files.pythonhosted.org/packages/15/07/284f757f63f8a8d69ed4472bfd85122bd086e637bf4ed09de572d575a693/pandas-2.3.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318d77e0e42a628c04dc56bcef4b40de67918f7041c2b061af1da41dcff670ac", size = 12306371, upload-time = "2025-09-29T23:21:40.532Z" }, - { url = "https://files.pythonhosted.org/packages/33/81/a3afc88fca4aa925804a27d2676d22dcd2031c2ebe08aabd0ae55b9ff282/pandas-2.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4e0a175408804d566144e170d0476b15d78458795bb18f1304fb94160cabf40c", size = 12765333, upload-time = "2025-09-29T23:21:55.77Z" }, - { url = "https://files.pythonhosted.org/packages/8d/0f/b4d4ae743a83742f1153464cf1a8ecfafc3ac59722a0b5c8602310cb7158/pandas-2.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2d9ab0fc11822b5eece72ec9587e172f63cff87c00b062f6e37448ced4493", size = 13418120, upload-time = "2025-09-29T23:22:10.109Z" }, - { url = "https://files.pythonhosted.org/packages/4f/c7/e54682c96a895d0c808453269e0b5928a07a127a15704fedb643e9b0a4c8/pandas-2.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:f8bfc0e12dc78f777f323f55c58649591b2cd0c43534e8355c51d3fede5f4dee", size = 10993991, upload-time = "2025-09-29T23:25:04.889Z" }, - { url = "https://files.pythonhosted.org/packages/f9/ca/3f8d4f49740799189e1395812f3bf23b5e8fc7c190827d55a610da72ce55/pandas-2.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:75ea25f9529fdec2d2e93a42c523962261e567d250b0013b16210e1d40d7c2e5", size = 12048227, upload-time = "2025-09-29T23:22:24.343Z" }, - { url = "https://files.pythonhosted.org/packages/0e/5a/f43efec3e8c0cc92c4663ccad372dbdff72b60bdb56b2749f04aa1d07d7e/pandas-2.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:74ecdf1d301e812db96a465a525952f4dde225fdb6d8e5a521d47e1f42041e21", size = 11411056, upload-time = "2025-09-29T23:22:37.762Z" }, - { url = "https://files.pythonhosted.org/packages/46/b1/85331edfc591208c9d1a63a06baa67b21d332e63b7a591a5ba42a10bb507/pandas-2.3.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6435cb949cb34ec11cc9860246ccb2fdc9ecd742c12d3304989017d53f039a78", size = 11645189, upload-time = "2025-09-29T23:22:51.688Z" }, - { url = "https://files.pythonhosted.org/packages/44/23/78d645adc35d94d1ac4f2a3c4112ab6f5b8999f4898b8cdf01252f8df4a9/pandas-2.3.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:900f47d8f20860de523a1ac881c4c36d65efcb2eb850e6948140fa781736e110", size = 12121912, upload-time = "2025-09-29T23:23:05.042Z" }, - { url = "https://files.pythonhosted.org/packages/53/da/d10013df5e6aaef6b425aa0c32e1fc1f3e431e4bcabd420517dceadce354/pandas-2.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a45c765238e2ed7d7c608fc5bc4a6f88b642f2f01e70c0c23d2224dd21829d86", size = 12712160, upload-time = "2025-09-29T23:23:28.57Z" }, - { url = "https://files.pythonhosted.org/packages/bd/17/e756653095a083d8a37cbd816cb87148debcfcd920129b25f99dd8d04271/pandas-2.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c4fc4c21971a1a9f4bdb4c73978c7f7256caa3e62b323f70d6cb80db583350bc", size = 13199233, upload-time = "2025-09-29T23:24:24.876Z" }, { url = "https://files.pythonhosted.org/packages/04/fd/74903979833db8390b73b3a8a7d30d146d710bd32703724dd9083950386f/pandas-2.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ee15f284898e7b246df8087fc82b87b01686f98ee67d85a17b7ab44143a3a9a0", size = 11540635, upload-time = "2025-09-29T23:25:52.486Z" }, { url = "https://files.pythonhosted.org/packages/21/00/266d6b357ad5e6d3ad55093a7e8efc7dd245f5a842b584db9f30b0f0a287/pandas-2.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1611aedd912e1ff81ff41c745822980c49ce4a7907537be8692c8dbc31924593", size = 10759079, upload-time = "2025-09-29T23:26:33.204Z" }, { url = "https://files.pythonhosted.org/packages/ca/05/d01ef80a7a3a12b2f8bbf16daba1e17c98a2f039cbc8e2f77a2c5a63d382/pandas-2.3.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d2cefc361461662ac48810cb14365a365ce864afe85ef1f447ff5a1e99ea81c", size = 11814049, upload-time = "2025-09-29T23:27:15.384Z" }, @@ -1116,31 +977,6 @@ version = "12.0.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/cace85a1b0c9775a9f8f5d5423c8261c858760e2466c79b2dd184638b056/pillow-12.0.0.tar.gz", hash = "sha256:87d4f8125c9988bfbed67af47dd7a953e2fc7b0cc1e7800ec6d2080d490bb353", size = 47008828, upload-time = "2025-10-15T18:24:14.008Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/62/f2/de993bb2d21b33a98d031ecf6a978e4b61da207bef02f7b43093774c480d/pillow-12.0.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:0869154a2d0546545cde61d1789a6524319fc1897d9ee31218eae7a60ccc5643", size = 4045493, upload-time = "2025-10-15T18:22:25.758Z" }, - { url = "https://files.pythonhosted.org/packages/0e/b6/bc8d0c4c9f6f111a783d045310945deb769b806d7574764234ffd50bc5ea/pillow-12.0.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:a7921c5a6d31b3d756ec980f2f47c0cfdbce0fc48c22a39347a895f41f4a6ea4", size = 4120461, upload-time = "2025-10-15T18:22:27.286Z" }, - { url = "https://files.pythonhosted.org/packages/5d/57/d60d343709366a353dc56adb4ee1e7d8a2cc34e3fbc22905f4167cfec119/pillow-12.0.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:1ee80a59f6ce048ae13cda1abf7fbd2a34ab9ee7d401c46be3ca685d1999a399", size = 3576912, upload-time = "2025-10-15T18:22:28.751Z" }, - { url = "https://files.pythonhosted.org/packages/a4/a4/a0a31467e3f83b94d37568294b01d22b43ae3c5d85f2811769b9c66389dd/pillow-12.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c50f36a62a22d350c96e49ad02d0da41dbd17ddc2e29750dbdba4323f85eb4a5", size = 5249132, upload-time = "2025-10-15T18:22:30.641Z" }, - { url = "https://files.pythonhosted.org/packages/83/06/48eab21dd561de2914242711434c0c0eb992ed08ff3f6107a5f44527f5e9/pillow-12.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5193fde9a5f23c331ea26d0cf171fbf67e3f247585f50c08b3e205c7aeb4589b", size = 4650099, upload-time = "2025-10-15T18:22:32.73Z" }, - { url = "https://files.pythonhosted.org/packages/fc/bd/69ed99fd46a8dba7c1887156d3572fe4484e3f031405fcc5a92e31c04035/pillow-12.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bde737cff1a975b70652b62d626f7785e0480918dece11e8fef3c0cf057351c3", size = 6230808, upload-time = "2025-10-15T18:22:34.337Z" }, - { url = "https://files.pythonhosted.org/packages/ea/94/8fad659bcdbf86ed70099cb60ae40be6acca434bbc8c4c0d4ef356d7e0de/pillow-12.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a6597ff2b61d121172f5844b53f21467f7082f5fb385a9a29c01414463f93b07", size = 8037804, upload-time = "2025-10-15T18:22:36.402Z" }, - { url = "https://files.pythonhosted.org/packages/20/39/c685d05c06deecfd4e2d1950e9a908aa2ca8bc4e6c3b12d93b9cafbd7837/pillow-12.0.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0b817e7035ea7f6b942c13aa03bb554fc44fea70838ea21f8eb31c638326584e", size = 6345553, upload-time = "2025-10-15T18:22:38.066Z" }, - { url = "https://files.pythonhosted.org/packages/38/57/755dbd06530a27a5ed74f8cb0a7a44a21722ebf318edbe67ddbd7fb28f88/pillow-12.0.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4f1231b7dec408e8670264ce63e9c71409d9583dd21d32c163e25213ee2a344", size = 7037729, upload-time = "2025-10-15T18:22:39.769Z" }, - { url = "https://files.pythonhosted.org/packages/ca/b6/7e94f4c41d238615674d06ed677c14883103dce1c52e4af16f000338cfd7/pillow-12.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6e51b71417049ad6ab14c49608b4a24d8fb3fe605e5dfabfe523b58064dc3d27", size = 6459789, upload-time = "2025-10-15T18:22:41.437Z" }, - { url = "https://files.pythonhosted.org/packages/9c/14/4448bb0b5e0f22dd865290536d20ec8a23b64e2d04280b89139f09a36bb6/pillow-12.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d120c38a42c234dc9a8c5de7ceaaf899cf33561956acb4941653f8bdc657aa79", size = 7130917, upload-time = "2025-10-15T18:22:43.152Z" }, - { url = "https://files.pythonhosted.org/packages/dd/ca/16c6926cc1c015845745d5c16c9358e24282f1e588237a4c36d2b30f182f/pillow-12.0.0-cp313-cp313-win32.whl", hash = "sha256:4cc6b3b2efff105c6a1656cfe59da4fdde2cda9af1c5e0b58529b24525d0a098", size = 6302391, upload-time = "2025-10-15T18:22:44.753Z" }, - { url = "https://files.pythonhosted.org/packages/6d/2a/dd43dcfd6dae9b6a49ee28a8eedb98c7d5ff2de94a5d834565164667b97b/pillow-12.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:4cf7fed4b4580601c4345ceb5d4cbf5a980d030fd5ad07c4d2ec589f95f09905", size = 7007477, upload-time = "2025-10-15T18:22:46.838Z" }, - { url = "https://files.pythonhosted.org/packages/77/f0/72ea067f4b5ae5ead653053212af05ce3705807906ba3f3e8f58ddf617e6/pillow-12.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:9f0b04c6b8584c2c193babcccc908b38ed29524b29dd464bc8801bf10d746a3a", size = 2435918, upload-time = "2025-10-15T18:22:48.399Z" }, - { url = "https://files.pythonhosted.org/packages/f5/5e/9046b423735c21f0487ea6cb5b10f89ea8f8dfbe32576fe052b5ba9d4e5b/pillow-12.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:7fa22993bac7b77b78cae22bad1e2a987ddf0d9015c63358032f84a53f23cdc3", size = 5251406, upload-time = "2025-10-15T18:22:49.905Z" }, - { url = "https://files.pythonhosted.org/packages/12/66/982ceebcdb13c97270ef7a56c3969635b4ee7cd45227fa707c94719229c5/pillow-12.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f135c702ac42262573fe9714dfe99c944b4ba307af5eb507abef1667e2cbbced", size = 4653218, upload-time = "2025-10-15T18:22:51.587Z" }, - { url = "https://files.pythonhosted.org/packages/16/b3/81e625524688c31859450119bf12674619429cab3119eec0e30a7a1029cb/pillow-12.0.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c85de1136429c524e55cfa4e033b4a7940ac5c8ee4d9401cc2d1bf48154bbc7b", size = 6266564, upload-time = "2025-10-15T18:22:53.215Z" }, - { url = "https://files.pythonhosted.org/packages/98/59/dfb38f2a41240d2408096e1a76c671d0a105a4a8471b1871c6902719450c/pillow-12.0.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:38df9b4bfd3db902c9c2bd369bcacaf9d935b2fff73709429d95cc41554f7b3d", size = 8069260, upload-time = "2025-10-15T18:22:54.933Z" }, - { url = "https://files.pythonhosted.org/packages/dc/3d/378dbea5cd1874b94c312425ca77b0f47776c78e0df2df751b820c8c1d6c/pillow-12.0.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d87ef5795da03d742bf49439f9ca4d027cde49c82c5371ba52464aee266699a", size = 6379248, upload-time = "2025-10-15T18:22:56.605Z" }, - { url = "https://files.pythonhosted.org/packages/84/b0/d525ef47d71590f1621510327acec75ae58c721dc071b17d8d652ca494d8/pillow-12.0.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aff9e4d82d082ff9513bdd6acd4f5bd359f5b2c870907d2b0a9c5e10d40c88fe", size = 7066043, upload-time = "2025-10-15T18:22:58.53Z" }, - { url = "https://files.pythonhosted.org/packages/61/2c/aced60e9cf9d0cde341d54bf7932c9ffc33ddb4a1595798b3a5150c7ec4e/pillow-12.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:8d8ca2b210ada074d57fcee40c30446c9562e542fc46aedc19baf758a93532ee", size = 6490915, upload-time = "2025-10-15T18:23:00.582Z" }, - { url = "https://files.pythonhosted.org/packages/ef/26/69dcb9b91f4e59f8f34b2332a4a0a951b44f547c4ed39d3e4dcfcff48f89/pillow-12.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:99a7f72fb6249302aa62245680754862a44179b545ded638cf1fef59befb57ef", size = 7157998, upload-time = "2025-10-15T18:23:02.627Z" }, - { url = "https://files.pythonhosted.org/packages/61/2b/726235842220ca95fa441ddf55dd2382b52ab5b8d9c0596fe6b3f23dafe8/pillow-12.0.0-cp313-cp313t-win32.whl", hash = "sha256:4078242472387600b2ce8d93ade8899c12bf33fa89e55ec89fe126e9d6d5d9e9", size = 6306201, upload-time = "2025-10-15T18:23:04.709Z" }, - { url = "https://files.pythonhosted.org/packages/c0/3d/2afaf4e840b2df71344ababf2f8edd75a705ce500e5dc1e7227808312ae1/pillow-12.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2c54c1a783d6d60595d3514f0efe9b37c8808746a66920315bfd34a938d7994b", size = 7013165, upload-time = "2025-10-15T18:23:06.46Z" }, - { url = "https://files.pythonhosted.org/packages/6f/75/3fa09aa5cf6ed04bee3fa575798ddf1ce0bace8edb47249c798077a81f7f/pillow-12.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:26d9f7d2b604cd23aba3e9faf795787456ac25634d82cd060556998e39c6fa47", size = 2437834, upload-time = "2025-10-15T18:23:08.194Z" }, { url = "https://files.pythonhosted.org/packages/54/2a/9a8c6ba2c2c07b71bec92cf63e03370ca5e5f5c5b119b742bcc0cde3f9c5/pillow-12.0.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:beeae3f27f62308f1ddbcfb0690bf44b10732f2ef43758f169d5e9303165d3f9", size = 4045531, upload-time = "2025-10-15T18:23:10.121Z" }, { url = "https://files.pythonhosted.org/packages/84/54/836fdbf1bfb3d66a59f0189ff0b9f5f666cee09c6188309300df04ad71fa/pillow-12.0.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:d4827615da15cd59784ce39d3388275ec093ae3ee8d7f0c089b76fa87af756c2", size = 4120554, upload-time = "2025-10-15T18:23:12.14Z" }, { url = "https://files.pythonhosted.org/packages/0d/cd/16aec9f0da4793e98e6b54778a5fbce4f375c6646fe662e80600b8797379/pillow-12.0.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:3e42edad50b6909089750e65c91aa09aaf1e0a71310d383f11321b27c224ed8a", size = 3576812, upload-time = "2025-10-15T18:23:13.962Z" }, @@ -1253,16 +1089,6 @@ version = "6.0.3" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, - { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, - { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, - { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, - { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, - { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, - { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, - { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, - { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, - { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, @@ -1379,15 +1205,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/04/be/d09147ad1ec7934636ad912901c5fd7667e1c858e19d355237db0d0cd5e4/smmap-5.0.2-py3-none-any.whl", hash = "sha256:b30115f0def7d7531d22a0fb6502488d879e75b260a9db4d0819cfb25403af5e", size = 24303, upload-time = "2025-01-02T07:14:38.724Z" }, ] -[[package]] -name = "soupsieve" -version = "2.8" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6d/e6/21ccce3262dd4889aa3332e5a119a3491a95e8f60939870a3a035aabac0d/soupsieve-2.8.tar.gz", hash = "sha256:e2dd4a40a628cb5f28f6d4b0db8800b8f581b65bb380b97de22ba5ca8d72572f", size = 103472, upload-time = "2025-08-27T15:39:51.78Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/14/a0/bb38d3b76b8cae341dad93a2dd83ab7462e6dbcdd84d43f54ee60a8dc167/soupsieve-2.8-py3-none-any.whl", hash = "sha256:0cc76456a30e20f5d7f2e14a98a4ae2ee4e5abdc7c5ea0aafe795f344bc7984c", size = 36679, upload-time = "2025-08-27T15:39:50.179Z" }, -] - [[package]] name = "sparqlwrapper" version = "2.0.0" @@ -1475,15 +1292,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/8a/39/39a322d7209cc259e3e27c4d498129e9583a2f3a8aea57eb1a9941cb5e9e/types_s3transfer-0.15.0-py3-none-any.whl", hash = "sha256:1e617b14a9d3ce5be565f4b187fafa1d96075546b52072121f8fda8e0a444aed", size = 19702, upload-time = "2025-11-21T21:16:25.146Z" }, ] -[[package]] -name = "typing-extensions" -version = "4.15.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, -] - [[package]] name = "tzdata" version = "2025.2" @@ -1508,9 +1316,6 @@ version = "6.0.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/db/7d/7f3d619e951c88ed75c6037b246ddcf2d322812ee8ea189be89511721d54/watchdog-6.0.0.tar.gz", hash = "sha256:9ddf7c82fda3ae8e24decda1338ede66e1c99883db93711d8fb941eaa2d8c282", size = 131220, upload-time = "2024-11-01T14:07:13.037Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/68/98/b0345cabdce2041a01293ba483333582891a3bd5769b08eceb0d406056ef/watchdog-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:490ab2ef84f11129844c23fb14ecf30ef3d8a6abafd3754a6f75ca1e6654136c", size = 96480, upload-time = "2024-11-01T14:06:42.952Z" }, - { url = "https://files.pythonhosted.org/packages/85/83/cdf13902c626b28eedef7ec4f10745c52aad8a8fe7eb04ed7b1f111ca20e/watchdog-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:76aae96b00ae814b181bb25b1b98076d5fc84e8a53cd8885a318b42b6d3a5134", size = 88451, upload-time = "2024-11-01T14:06:45.084Z" }, - { url = "https://files.pythonhosted.org/packages/fe/c4/225c87bae08c8b9ec99030cd48ae9c4eca050a59bf5c2255853e18c87b50/watchdog-6.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a175f755fc2279e0b7312c0035d52e27211a5bc39719dd529625b1930917345b", size = 89057, upload-time = "2024-11-01T14:06:47.324Z" }, { url = "https://files.pythonhosted.org/packages/a9/c7/ca4bf3e518cb57a686b2feb4f55a1892fd9a3dd13f470fca14e00f80ea36/watchdog-6.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7607498efa04a3542ae3e05e64da8202e58159aa1fa4acddf7678d34a35d4f13", size = 79079, upload-time = "2024-11-01T14:06:59.472Z" }, { url = "https://files.pythonhosted.org/packages/5c/51/d46dc9332f9a647593c947b4b88e2381c8dfc0942d15b8edc0310fa4abb1/watchdog-6.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:9041567ee8953024c83343288ccc458fd0a2d811d6a0fd68c4c22609e3490379", size = 79078, upload-time = "2024-11-01T14:07:01.431Z" }, { url = "https://files.pythonhosted.org/packages/d4/57/04edbf5e169cd318d5f07b4766fee38e825d64b6913ca157ca32d1a42267/watchdog-6.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:82dc3e3143c7e38ec49d61af98d6558288c415eac98486a5c581726e0737c00e", size = 79076, upload-time = "2024-11-01T14:07:02.568Z" },