fix grammar mistakes

Jens Kürten · Jens Kürten · commit 83f56b442bfb · 2025-05-23T12:37:03.000+02:00
diff --git a/README.md b/README.md
@@ -12,7 +12,7 @@ Functions are deeply integrated in the CIM Database Cloud Webhooks technology. T
 
 Python 3.10+
 
-csfunctions is build with [Pydantic 2](https://docs.pydantic.dev/latest/)
+csfunctions is built with [Pydantic 2](https://docs.pydantic.dev/latest/)
 
 ## Installation
 Install using pip:
diff --git a/docs/development_server.md b/docs/development_server.md
@@ -1,6 +1,8 @@
+# Development Server
+
 The Functions SDK includes a development server that allows you to run your Functions in your development environment. The server reads Functions from the `environment.yaml` file and makes them available via HTTP endpoints. You can then connect these Functions to your CIM Database Cloud instance using webhooks.
 
-This speeds up the development of Functions, because you can instantly test your changes, without deploying them to the cloud infrastructure first.
+This speeds up the development of Functions because you can instantly test your changes without deploying them to the cloud infrastructure first.
 
 ## Starting the Server
 
@@ -16,7 +18,7 @@ You can set the port of the server using the `--port` flag (default is 8000), or
 python -m csfunctions.devserver --port 8080
 ```
 
-You can set the directory containing the `environment.yaml` file using the `--dir` flag (by default the current working directory is used) or by setting the `CON_DEV_DIR` environment variable:
+You can set the directory containing the `environment.yaml` file using the `--dir` flag (by default, the current working directory is used) or by setting the `CON_DEV_DIR` environment variable:
 
 ```bash
 python -m csfunctions.devserver --dir ./my_functions
@@ -32,7 +34,7 @@ python -m csfunctions.devserver --secret my_secret
 
 The development server will automatically restart if you make changes to your Functions code or to the `environment.yaml` file.
 
-## Exposing the server
+## Exposing the Server
 
 To enable your CIM Database Cloud instance to send webhook requests to your Functions, you need to make the server accessible from the internet. Here are several ways to do this:
 
@@ -50,26 +52,25 @@ If you are developing Functions locally, you can use services like [ngrok](https
 
 Please refer to the documentation of the specific service for instructions on how to do this.
 
-
-## Create a webhook in CIM Database Cloud
+## Create a Webhook in CIM Database Cloud
 
 To test your Functions locally, create a webhook in your CIM Database Cloud instance and point it to your development server.
 
 The webhook URL should combine your development server URL with the Function name from your `environment.yaml` file using this format:
 
 `https://<development-server-url>/<function-name>`
 
-For example the `example` function would be available at:
-
-```https://mycodespace-5g7grjgvrv9h4jrx-8000.app.github.dev/example```
+For example, the `example` function would be available at:
 
+```
+https://mycodespace-5g7grjgvrv9h4jrx-8000.app.github.dev/example
+```
 
-Make sure to set the webhooks event to the correct event you want to test with your Function.
+Make sure to set the webhook's event to the correct event you want to test with your Function.
 
 For more detailed information on how to create a webhook in CIM Database Cloud, please refer to the [CIM Database Cloud documentation](https://saas-docs.contact-cloud.com/2025.7.0-en/admin/admin-contact_cloud/saas_admin/webhooks).
 
-
-## Securing the development server
+## Securing the Development Server
 
 Since the development server is exposed to the outside world, you should secure it to prevent unauthorized access.
 
diff --git a/docs/examples/enforce_field_rules.md b/docs/examples/enforce_field_rules.md
@@ -1,10 +1,10 @@
-Functions can be used to validate user input and thus ensure that fields on e.g. parts or documents are filled out correctly.
+Functions can be used to validate user input and ensure that fields on, for example, parts or documents are filled out correctly.
 
 
 ### Required field based on Part category
-This example shows how you can enforce parts of category *"Single Part"* to have a material assigned to them.
+This example shows how you can enforce that parts in the category *"Single Part"* must have a material assigned.
 
-The example Function can be connected to the [PartCreateCheckEvent](../reference/events.md#partcreatecheckevent) and [PartModifyCheckEvent](../reference/events.md#partmodifycheckevent) and will return an [AbortAndShowErrorAction](../reference/actions.md#abortandshowerroraction) to abort the creation or modification of the part if the condition is not met.
+The example Function can be connected to the [PartCreateCheckEvent](../reference/events.md#partcreatecheckevent) and [PartModifyCheckEvent](../reference/events.md#partmodifycheckevent). It will return an [AbortAndShowErrorAction](../reference/actions.md#abortandshowerroraction) to abort the creation or modification of the part if the condition is not met.
 
 ```python
 from csfunctions import MetaData, Service
@@ -21,33 +21,32 @@ def single_part_needs_material(
     service: Service,
 ):
     """
-    If a part of category ' Single Part' is created, a material has to be assigned.
+    If a part of category 'Single Part' is created or modified, a material must be assigned.
     This should be checked when the part is created or modified.
     """
 
     for part in event.data.parts:
-        # the event contains a list of parts that are about to be created
+        # The event contains a list of parts that are about to be created or modified
         if part.t_kategorie_name_en == "Single Part" and not part.material_object_id:
             return AbortAndShowErrorAction(
-                message="A material has to be assigned to a part of category 'Single Part'."
+                message="A material must be assigned to a part of category 'Single Part'."
             )
 
 ```
 
 ### Require parts to be classified before release
 
-Classification is a powerful tool for organizing your parts, however the best tool only works if users use it.
-With this example Function you can require parts to be classified before they can be released.
+Classification is a powerful tool for organizing your parts. However, even the best tool is only effective if users actually use it.
+With this example Function, you can require that parts are classified before they can be released.
 
-This Function should be connected to the [PartReleaseCheckEvent](../reference/events.md#partreleasecheckevent) and will return an [AbortAndShowErrorAction](../reference/actions.md#abortandshowerroraction) to prevent the release, if classification data is missing.
+This Function should be connected to the [PartReleaseCheckEvent](../reference/events.md#partreleasecheckevent) and will return an [AbortAndShowErrorAction](../reference/actions.md#abortandshowerroraction) to prevent the release if classification data is missing.
 
-The example code shows you how to fetch classification data for parts from the [CIM Database Cloud GraphQL API](https://saas-docs.contact-cloud.com/latest-en/admin/admin-contact_cloud/saas_admin/webhooks_graphql){:target="_blank"}. The Function then checks if any classification data is present, however you can easily expand this to check for specific classes.
+The example code demonstrates how to fetch classification data for parts from the [CIM Database Cloud GraphQL API](https://saas-docs.contact-cloud.com/latest-en/admin/admin-contact_cloud/saas_admin/webhooks_graphql){:target="_blank"}. The Function then checks if any classification data is present, but you can easily expand this to check for specific classes.
 
 ```python
 from csfunctions import MetaData, Service
 from csfunctions.actions import AbortAndShowErrorAction
 from csfunctions.events import (
-
     PartReleaseCheckEvent,
 )
 import requests
@@ -80,16 +79,16 @@ def fetch_part_classification_property_codes(cdb_object_id: str, metadata: MetaD
 
 def parts_need_classification(
     metadata: MetaData,
-    event: PartReleaseCheckEvent ,
+    event: PartReleaseCheckEvent,
     service: Service,
 ):
     """
-    Parts need to be classified before they can be released.
+    Parts must be classified before they can be released.
     """
 
     for part in event.data.parts:
-        # the event contains a list of parts that are about to be released
-        # for each part fetch the classification property codes and check if they are empty
+        # The event contains a list of parts that are about to be released
+        # For each part, fetch the classification property codes and check if they are empty
         property_codes = fetch_part_classification_property_codes(part.cdb_object_id, metadata)
         if not property_codes:
             return AbortAndShowErrorAction(
diff --git a/docs/examples/field_calculation.md b/docs/examples/field_calculation.md
@@ -1,19 +1,19 @@
 # Field calculation
 
-The data sheet editor in CIM Database Cloud already allows you to define some basic [field calculations](https://saas-docs.contact-cloud.com/2025.13.1-en/admin/admin-contact_cloud/saas_admin/app_setup_data_edit_field_calc){:target="_blank"} to fill out fields automatically.
+The datasheet editor in CIM Database Cloud already allows you to define some basic [field calculations](https://saas-docs.contact-cloud.com/2025.13.1-en/admin/admin-contact_cloud/saas_admin/app_setup_data_edit_field_calc){:target="_blank"} to fill out fields automatically.
 
-However, the Python expressions available in the datasheet editor are limited. Functions allow for much more freedom in defining your field calculations, and allow you to do things like *"fetching external data"* or *"referencing other objects"*.
+However, the Python expressions available in the datasheet editor are limited. Functions allow for much more flexibility in defining your field calculations, enabling you to do things like *fetching external data* or *referencing other objects*.
 
-Field calculations with Functions utilize the "<Object\>FieldCalulationEvent", e.g. [PartFieldCalculationEvent](../reference/events.md#partfieldcalculationevent), which expect the response to contain a `DataResponse` with a dictionary containing the fields that should be updated.
+Field calculations with Functions utilize the `<Object>FieldCalculationEvent`, e.g. [PartFieldCalculationEvent](../reference/events.md#partfieldcalculationevent), which expects the response to contain a `DataResponse` with a dictionary of the fields that should be updated.
 
 ```python
-return DataResponse(data={somefield="new value"})
+return DataResponse(data={"somefield": "new value"})
 ```
 
 
 ## Custom part number for external parts
 
-This example shows you the basics of calculating fields with Functions and how to use the `service` parameter to generate a fresh number.
+This example shows you the basics of calculating fields with Functions and how to use the `service` parameter to generate a new number.
 
 The example Function checks if the part is an *"External"* part and generates a custom part number for it.
 
@@ -23,59 +23,53 @@ from csfunctions.events import PartFieldCalculationEvent
 from csfunctions.metadata import MetaData
 from csfunctions.service import Service
 
-
 def calculate_part_number(metadata: MetaData, event: PartFieldCalculationEvent, service: Service):
     """
     Example Function.
-    This function is triggered when a part fields should be calculated.
-    For "External" parts we want to set the part number as "E-000123".
+    This function is triggered when a part field should be calculated.
+    For "External" parts, we want to set the part number as "E-000123".
     All other parts should keep the standard part number.
-
     """
     if event.data.action != "create":
-        # part number can only be set when the part is created
+        # Part number can only be set when the part is created
         return
 
-    # match "External Single Part" or "External Assembly"
+    # Match "External Single Part" or "External Assembly"
     if event.data.part.t_kategorie_name_en.startswith("External"):
-
-        # generate a new number using the service
+        # Generate a new number using the service
         new_number = service.generator.get_number("external_part_number")
-
         # new_number is an integer, so we need to convert it to a string
         # and pad it with leading zeros to 6 digits
         new_part_number = str(new_number).zfill(6)
-
-        # then add the prefix "E-" to the number
+        # Add the prefix "E-" to the number
         new_part_number = "E-" + new_part_number
-
-        # finally we return the new part number (teilenummer)
+        # Return the new part number (teilenummer)
         return DataResponse(data={"teilenummer": new_part_number})
 ```
 
 !!! tip
-    You can check `event.data.action` to decide for which operations (*copy*,*create*,*index* and *modify*) you want your field calculation to return a new value.
-    Some fields, like part number (*teilenummer*) can only be set during the initial creation.
+    You can check `event.data.action` to decide for which operations (*copy*, *create*, *index*, and *modify*) you want your field calculation to return a new value.
+    Some fields, like part number (*teilenummer*), can only be set during the initial creation.
 
 ## Translate a field with DeepL
 
-Inside Functions you can fetch data from external systems and fill out fields based on that data. This is something that would not be possible with the field calculations in the datasheet editor. You could use this for example to fetch new part numbers from an ERP system.
+Inside Functions, you can fetch data from external systems and fill out fields based on that data. This is something that would not be possible with the field calculations in the datasheet editor. For example, you could use this to fetch new part numbers from an ERP system.
 
-This example uses the API from [DeepL](https://www.deepl.com) to translate a field from German to English. The example uses the additional attributes 1 and 2 on parts, but you can of course change that to any attributes that fit your use-case.
+This example uses the API from [DeepL](https://www.deepl.com) to translate a field from German to English. The example uses the additional attributes 1 and 2 on parts, but you can of course change that to any attributes that fit your use case.
 
 ```python
 import os
 from csfunctions import DataResponse
 from csfunctions.events import PartFieldCalculationEvent
 import requests
 
-# set the DEEPL_API_KEY during deployment like this:
+# Set the DEEPL_API_KEY during deployment like this:
 # cfc env deploy <environment name> --environment-variables "DEEPL_API_KEY=<your API key>"
 DEEPL_API_KEY = os.getenv("DEEPL_API_KEY")
 
 def part_field_calculation(metadata, event: PartFieldCalculationEvent, service):
     if event.data.action != "create":
-        # only translate on creation
+        # Only translate on creation
         return
 
     if event.data.part.cssaas_frame_add_attr_1:
diff --git a/docs/examples/workflows.md b/docs/examples/workflows.md
@@ -1,19 +1,18 @@
 # Working with workflows
 
-Functions can interact with workflows. You can trigger Functions from within workflows using the [Trigger Webhook](https://saas-docs.contact-cloud.com/latest-en/admin/admin-contact_cloud/saas_admin/webhooks_workflow){:target="_blank"} task and you can even start new workflows by using the [StartWorkflowAction](../reference/actions.md#startworkflowaction)!
+Functions can interact with workflows. You can trigger Functions from within workflows using the [Trigger Webhook](https://saas-docs.contact-cloud.com/latest-en/admin/admin-contact_cloud/saas_admin/webhooks_workflow){:target="_blank"} task, and you can even start new workflows by using the [StartWorkflowAction](../reference/actions.md#startworkflowaction)!
 
 
-## Start workflow on EC status change
+## Start a workflow on EC status change
 
-This example shows you how to start a workflow template in response to an engineering change status change.
+This example shows how to start a workflow template in response to an engineering change status change.
 
 !!! note
-    Starting workflows in response to engineering change status changes is already possible in CIM Database Cloud without the use of Functions. However Functions allow you to dynamically select different templates and fill out task parameters, based on the nature of the change.
+    Starting workflows in response to engineering change status changes is already possible in CIM Database Cloud without the use of Functions. However, Functions allow you to dynamically select different templates and fill out task parameters based on the nature of the change.
 
-This example uses a very simple template, containing just an *information task*. If an engineering change contains external parts, users with the *External Part Manager* Role should be notified of the planned change during the evaluation phase.
-
-You can easily adapt this example to your use-case, by adding additional tasks to the template or changing the conditions under which the workflow should be started.
+This example uses a very simple template containing just an *information task*. If an engineering change contains external parts, users with the *External Part Manager* role should be notified of the planned change during the evaluation phase.
 
+You can easily adapt this example to your use case by adding additional tasks to the template or changing the conditions under which the workflow should be started.
 
 ```python
 from csfunctions.actions.start_workflow import (
@@ -24,7 +23,7 @@ from csfunctions.actions.start_workflow import (
 from csfunctions.events import EngineeringChangeStatusChangedEvent
 from csfunctions import MetaData
 
-# change these to match your template and roles!!!
+# Change these to match your template and roles!
 TEMPLATE_ID = "PT00000002"
 INFORMATION_TASK_ID = "T00000008"
 INFORM_ROLE = "External Part Manager"
@@ -34,42 +33,40 @@ def start_workflow_on_ec_status_change(
     metadata: MetaData, event: EngineeringChangeStatusChangedEvent, service
 ):
     if event.data.engineering_change.status != 30:
-        # only start the workflow if the status changed to 30 (Evaluation)
+        # Only start the workflow if the status changed to 30 (Evaluation)
         return
 
-    # check if the ec contains external parts
+    # Check if the EC contains external parts
     if not any(
         part.t_kategorie_name_en.startswith("External")
         for part in event.data.engineering_change.planned_changes_parts
     ):
-        # no external parts, so we don't need to start the workflow
+        # No external parts, so we don't need to start the workflow
         return
 
     return StartWorkflowAction(
         template_id=TEMPLATE_ID,
         title=f"Information about EC {event.data.engineering_change.cdb_ec_id}",
-        # attach the engineering change to the workflow
+        # Attach the engineering change to the workflow
         global_briefcase_object_ids=[
             event.data.engineering_change.cdb_object_id],
         task_configurations=[
             TaskConfiguration(
                 task_id=INFORMATION_TASK_ID,
-                description="A an engineering change containing external parts moved to the evaluation phase.",
+                description="An engineering change containing external parts moved to the evaluation phase.",
                 recipients=[
                     Subject(
                         subject_type="Common Role",
                         subject_id=INFORM_ROLE,
                     )
                 ],
             )
-
         ],
     )
 ```
 
 !!! note
-    To sucessfully execute this example you need to:
-
-    - Create a workflow template with an information task and adjust the `TEMPLATE_ID` and `INFORMATION_TASK_ID` to match them
+    To successfully execute this example, you need to:
 
-    - Create and assign an "External Part Manager" role to a user
+    - Create a workflow template with an information task and adjust the `TEMPLATE_ID` and `INFORMATION_TASK_ID` to match them.
+    - Create and assign an "External Part Manager" role to a user.
diff --git a/docs/index.md b/docs/index.md
