cognite-neat 0.87.6__py3-none-any.whl → 0.88.1__py3-none-any.whl

cognite/neat/legacy/rules/exporters/_rules2excel.py

@@ -1,213 +0,0 @@
-from pathlib import Path
-from typing import cast
-
-from openpyxl import Workbook
-from openpyxl.cell import Cell
-from openpyxl.styles import Alignment, Border, Font, NamedStyle, PatternFill, Side
-from openpyxl.worksheet.worksheet import Worksheet
-
-from cognite.neat.legacy.rules.models._base import EntityTypes
-
-from ._base import BaseExporter
-
-
-class ExcelExporter(BaseExporter[Workbook]):
-    """Class for exporting transformation rules object to excel file."""
-
-    def _export_to_file(self, filepath: Path) -> None:
-        """Exports transformation rules to excel file."""
-        data = self.export()
-        try:
-            data.save(filepath)
-        finally:
-            data.close()
-
-    def export(self) -> Workbook:
-        """Generates workbook from transformation rules."""
-        data = Workbook()
-        # Remove default sheet named "Sheet"
-        data.remove(data["Sheet"])
-        # Serialize the rules to the excel file
-
-        # map rules metadata to excel
-        metadata = self.rules.metadata
-        metadata_sheet = data.create_sheet("Metadata")
-
-        # add each metadata property to the sheet as a row
-        metadata_sheet.append(["prefix", metadata.prefix])
-        metadata_sheet.append(["namespace", metadata.namespace])
-        metadata_sheet.append(["external_id", metadata.suffix])
-        metadata_sheet.append(["title", metadata.name])
-        metadata_sheet.append(["description", metadata.description])
-        metadata_sheet.append(["version", metadata.version])
-        metadata_sheet.append(
-            [
-                "creator",
-                (
-                    ",".join(metadata.creator if isinstance(metadata.creator, list) else [metadata.creator])
-                    if metadata.creator
-                    else ""
-                ),
-            ]
-        )
-        metadata_sheet.append(
-            [
-                "contributor",
-                (
-                    ",".join(metadata.contributor if isinstance(metadata.contributor, list) else [metadata.contributor])
-                    if metadata.contributor
-                    else ""
-                ),
-            ]
-        )
-        metadata_sheet.append(["created", metadata.created])
-        metadata_sheet.append(["updated", metadata.updated])
-        metadata_sheet.append(["rights", metadata.rights])
-
-        # map classes to excel sheet named "Classes" and add each class as a row
-        classes_sheet = data.create_sheet("Classes")
-
-        classes_sheet.append(["Solution model", "", "", "Knowledge acquisition", "", "", ""])
-        classes_sheet.merge_cells("A1:C1")
-        classes_sheet.merge_cells("D1:G1")
-        classes_sheet.append(
-            ["Class", "Description", "Parent Class", "Source", "Source Entity Name", "Match Type", "Comment"]
-        )  # A  ... # G
-
-        for class_ in self.rules.classes.values():
-            classes_sheet.append(
-                [
-                    class_.class_id,
-                    class_.description,
-                    (
-                        ",".join([parent_class.versioned_id for parent_class in class_.parent_class])
-                        if class_.parent_class
-                        else None
-                    ),
-                    str(class_.source),
-                    class_.source_entity_name,
-                    class_.match_type,
-                    class_.comment,
-                ]
-            )
-
-        # map properties to excel sheet named "Properties" and add each property as a row
-        properties_sheet = data.create_sheet("Properties")
-        properties_sheet.append(
-            [
-                "Solution model",  # A
-                "",  # B
-                "",  # C
-                "",  # D
-                "",  # E
-                "",  # F
-                "Solution classic CDF resources",  # G
-                "",  # H
-                "",  # I
-                "",  # J
-                "",  # K
-                "",  # L
-                "Transformation rules",  # M
-                "",  # N
-                "Knowledge acquisition",  # O
-                "",  # P
-                "",  # Q
-                "",  # R
-            ]
-        )
-        properties_sheet.merge_cells("A1:F1")
-        properties_sheet.merge_cells("G1:L1")
-        properties_sheet.merge_cells("M1:N1")
-        properties_sheet.merge_cells("O1:R1")
-        properties_sheet.append(
-            [
-                "Class",  # A
-                "Property",  # B
-                "Description",  # C
-                "Type",  # D
-                "Min Count",  # E
-                "Max Count",  # F
-                "Resource Type",  # G
-                "Resource Type Property",  # H
-                "Relationship Source Type",  # I
-                "Relationship Target Type",  # J
-                "Relationship Label",  # K
-                "Relationship ExternalID Rule",  # L
-                "Rule Type",  # M
-                "Rule",  # N
-                "Source",  # O
-                "Source Entity Name",  # P
-                "Match Type",  # Q
-                "Comment",  # R
-            ]
-        )
-
-        for property_ in self.rules.properties.values():
-            properties_sheet.append(
-                [
-                    property_.class_id,  # A
-                    property_.property_id,  # B
-                    property_.description,  # C
-                    (
-                        property_.expected_value_type.versioned_id
-                        if property_.property_type == EntityTypes.object_property
-                        else property_.expected_value_type.suffix
-                    ),  # D
-                    property_.min_count,  # E
-                    property_.max_count,  # F
-                    ",".join(property_.cdf_resource_type) if property_.cdf_resource_type else "",  # G
-                    ",".join(property_.resource_type_property) if property_.resource_type_property else "",  # H
-                    property_.source_type,  # I
-                    property_.target_type,  # J
-                    property_.label,  # K
-                    property_.relationship_external_id_rule,  # L
-                    property_.rule_type,  # M
-                    property_.rule,  # N
-                    str(property_.source),  # O
-                    property_.source_entity_name,  # P
-                    property_.match_type,  # Q
-                    property_.comment,  # R
-                ]
-            )
-
-        prefixes_sheet = data.create_sheet("Prefixes")
-        prefixes_sheet.append(["Prefix", "URI"])  # A  # B
-
-        for prefix, uri in self.rules.prefixes.items():
-            prefixes_sheet.append([prefix, uri])  # A  # B
-
-        return self._set_header_style(data)
-
-    @staticmethod
-    def _set_header_style(data: Workbook):
-        """Sets the header style for all sheets in the self.workbook"""
-        style = NamedStyle(name="header style")
-        style.font = Font(bold=True, size=16)
-        side = Side(style="thin", color="000000")
-        style.border = Border(left=side, right=side, top=side, bottom=side)
-        data.add_named_style(style)
-
-        for sheet in data.sheetnames:
-            if sheet == "Metadata":
-                continue
-            if sheet == "Classes" or sheet == "Properties":
-                sheet_obj = cast(Worksheet, data[sheet])
-                if sheet == "Classes":
-                    sheet_obj.freeze_panes = "A3"
-                else:
-                    sheet_obj.freeze_panes = "D3"
-
-                for cell in sheet_obj[1]:
-                    cell = cast(Cell, cell)  # type: ignore[index]
-                    cell.style = style
-                    cell.fill = PatternFill("solid", start_color="D5B2CF")
-                    cell.alignment = Alignment(horizontal="center", vertical="center")
-                for cell in sheet_obj[2]:
-                    cell = cast(Cell, cell)  # type: ignore[index]
-                    cell.style = style
-                    cell.fill = PatternFill("solid", start_color="D5DBD5")
-                    cell.alignment = Alignment(horizontal="center", vertical="center")
-                    adjusted_width = (len(str(cell.value)) + 5) * 1.2
-                    cast(Worksheet, data[sheet]).column_dimensions[cell.column_letter].width = adjusted_width
-
-        return data

cognite/neat/legacy/rules/exporters/_rules2graphql.py

@@ -1,183 +0,0 @@
-import sys
-import warnings
-from dataclasses import dataclass
-from pathlib import Path
-from typing import TYPE_CHECKING
-
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
-from cognite.neat.legacy.rules import exceptions
-from cognite.neat.legacy.rules.analysis import to_class_property_pairs
-from cognite.neat.legacy.rules.exporters._validation import are_entity_names_dms_compliant, are_properties_redefined
-from cognite.neat.legacy.rules.models.rules import Rules
-from cognite.neat.legacy.rules.models.value_types import XSD_VALUE_TYPE_MAPPINGS
-from cognite.neat.utils.auxiliary import generate_exception_report
-
-from ._base import BaseExporter
-
-if TYPE_CHECKING:
-    from jinja2 import Template
-
-
-class GraphQLSchemaExporter(BaseExporter[str]):
-    def _export_to_file(self, filepath: Path):
-        if filepath.suffix != ".graphql":
-            warnings.warn("File extension is not .graphql, adding it to the file name", stacklevel=2)
-            filepath = filepath.with_suffix(".graphql")
-        filepath.write_text(self.export())
-
-    def export(self) -> str:
-        return GraphQLSchema.from_rules(self.rules).schema
-
-
-_TYPE = (
-    "{% include 'type_header' %}type {{ class_definition.class_id }} {{'{'}}"
-    "{%-for property_definition in class_properties%}"
-    "{% include 'field' %}"
-    "{% endfor %}\n}\n"
-)
-
-_TYPE_HEADER = (
-    "{%- if header %}"
-    "{%- if class_definition.description and class_definition.class_name %}"
-    '"""\n{{class_definition.description}}\n@name {{ class_definition.class_name }}\n"""\n{##}\n'
-    "{%- elif class_definition.description %}"
-    '\n"""\n{{class_definition.description}}\n"""\n'
-    "{%- endif %}"
-    "{%- endif %}"
-)
-
-
-_FIELD = (
-    "{% include 'field_header' %}\n"
-    "  {{ property_definition.property_id }}: "
-    "{%-if property_definition.property_type == 'DatatypeProperty'%}"
-    "{% include 'attribute_occurrence' %}"
-    "{%-else%}"
-    "{% include 'edge_occurrence' %}"
-    "{%- endif -%}"
-)
-
-_FIELD_HEADER = (
-    "{%- if header %}"
-    "{%- if property_definition.description and property_definition.property_name %}"
-    '\n  """\n  {{property_definition.description}}'
-    "\n  @name {{ property_definition.property_name }}"
-    '\n  """\n  '
-    "{%- elif property_definition.description %}"
-    '\n  """\n  {{property_definition.description}}'
-    '\n  """\n  '
-    "{%- endif %}"
-    "{%- endif %}"
-)
-
-_ATTRIBUTE_OCCURRENCE = (
-    "{%-if property_definition.min_count and property_definition.max_count == 1%}"
-    " {% include 'value_type' %}!"
-    "{%-elif property_definition.min_count and property_definition.max_count != 1%}"
-    " [{% include 'value_type' %}!]!"
-    "{%-elif property_definition.max_count != 1%}"
-    " [{% include 'value_type' %}!]!"
-    "{%-else%}{% include 'value_type' %}"
-    "{%- endif -%}"
-)
-
-_EDGE_OCCURRENCE = (
-    "{%-if not(property_definition.min_count and property_definition.max_count == 1)%}"
-    " [{% include 'value_type' %}]"
-    "{%-else%}"
-    " {% include 'value_type' %}"
-    "{%- endif -%}"
-)
-
-_FIELD_VALUE_TYPE = """{{property_definition.expected_value_type.mapping.graphql
-                if property_definition.expected_value_type.suffix in value_type_mapping
-                else property_definition.expected_value_type.suffix}}"""
-
-
-@dataclass
-class GraphQLSchema:
-    """
-    Represents a GraphQL schema.
-
-    This can be used to generate a GraphQL schema from TransformationRules.
-
-    Args:
-        schema: The GraphQL schema.
-
-    """
-
-    schema: str
-
-    @classmethod
-    def from_rules(cls, transformation_rules: Rules, verbose: bool = False) -> Self:
-        """
-        Generates a GraphQL schema from TransformationRules.
-
-        Args:
-            transformation_rules: The TransformationRules to generate a GraphQL schema from.
-            verbose: Whether to include descriptions and names in the schema.
-
-        Returns:
-            A GraphQLSchema instance.
-        """
-        names_compliant, name_warnings = are_entity_names_dms_compliant(transformation_rules, return_report=True)
-        if not names_compliant:
-            raise exceptions.EntitiesContainNonDMSCompliantCharacters(report=generate_exception_report(name_warnings))
-
-        properties_redefined, redefinition_warnings = are_properties_redefined(transformation_rules, return_report=True)
-        if properties_redefined:
-            raise exceptions.PropertiesDefinedMultipleTimes(report=generate_exception_report(redefinition_warnings))
-
-        return cls(schema=cls.generate_schema(transformation_rules, verbose))
-
-    @staticmethod
-    def generate_schema(transformation_rules: Rules, verbose: bool) -> str:
-        """
-        Generates a GraphQL schema from TransformationRules.
-
-        Args:
-            transformation_rules: Instance of TransformationRules to generate a GraphQL schema from.
-            verbose: Whether to include descriptions and names in the schema.
-
-        Returns:
-            A GraphQL schema.
-        """
-        class_properties = to_class_property_pairs(transformation_rules)
-
-        type_definitions = []
-
-        for class_id in class_properties:
-            parameters = {
-                "class_definition": transformation_rules.classes[class_id],
-                "class_properties": list(class_properties[class_id].values()),
-                "value_type_mapping": XSD_VALUE_TYPE_MAPPINGS,
-                "header": verbose,
-            }
-
-            type_definitions.append(GraphQLSchema.template().render(parameters))
-
-        return "\n\n".join(type_definitions)
-
-    @staticmethod
-    def template() -> "Template":
-        from jinja2 import DictLoader, Environment, Template
-
-        template: Template = Environment(
-            loader=DictLoader(
-                {
-                    "type_header": _TYPE_HEADER,
-                    "type": _TYPE,
-                    "field_header": _FIELD_HEADER,
-                    "field": _FIELD,
-                    "value_type": _FIELD_VALUE_TYPE,
-                    "edge_occurrence": _EDGE_OCCURRENCE,
-                    "attribute_occurrence": _ATTRIBUTE_OCCURRENCE,
-                }
-            ),
-            cache_size=1000,
-        ).get_template("type")
-        return template