cognite-neat 0.100.0__py3-none-any.whl → 0.101.0__py3-none-any.whl

cognite/neat/_rules/models/dms/_rules.py

@@ -94,20 +94,60 @@ def _metadata(context: Any) -> DMSMetadata | None:
 
 
 class DMSProperty(SheetRow):
-    view: ViewEntityType = Field(alias="View")
-    view_property: DmsPropertyType = Field(alias="View Property")
-    name: str | None = Field(alias="Name", default=None)
-    description: str | None = Field(alias="Description", default=None)
-    connection: Literal["direct"] | ReverseConnectionEntity | EdgeEntity | None = Field(None, alias="Connection")
-    value_type: DataType | ViewEntity | DMSUnknownEntity = Field(alias="Value Type")
-    nullable: bool | None = Field(default=None, alias="Nullable")
-    immutable: bool | None = Field(default=None, alias="Immutable")
-    is_list: bool | None = Field(default=None, alias="Is List")
-    default: str | int | dict | None = Field(None, alias="Default")
-    container: ContainerEntityType | None = Field(None, alias="Container")
-    container_property: DmsPropertyType | None = Field(None, alias="Container Property")
-    index: StrListType | None = Field(None, alias="Index")
-    constraint: StrListType | None = Field(None, alias="Constraint")
+    view: ViewEntityType = Field(alias="View", description="The property identifier.")
+    view_property: DmsPropertyType = Field(alias="View Property", description="The ViewId this property belongs to")
+    name: str | None = Field(alias="Name", default=None, description="Human readable name of the property")
+    description: str | None = Field(alias="Description", default=None, description="Short description of the property")
+    connection: Literal["direct"] | ReverseConnectionEntity | EdgeEntity | None = Field(
+        None,
+        alias="Connection",
+        description="nly applies to connection between views. "
+        "It specify how the connection should be implemented in CDF.",
+    )
+    value_type: DataType | ViewEntity | DMSUnknownEntity = Field(
+        alias="Value Type",
+        description="Value type that the property can hold. "
+        "It takes either subset of CDF primitive types or a View id",
+    )
+    nullable: bool | None = Field(
+        default=None,
+        alias="Nullable",
+        description="Used to indicate whether the property is required or not. Only applies to primitive type.",
+    )
+    immutable: bool | None = Field(
+        default=None,
+        alias="Immutable",
+        description="sed to indicate whether the property is can only be set once. Only applies to primitive type.",
+    )
+    is_list: bool | None = Field(
+        default=None,
+        alias="Is List",
+        description="Used to indicate whether the property holds single or multiple values (list). "
+        "Only applies to primitive types.",
+    )
+    default: str | int | dict | None = Field(
+        None, alias="Default", description="Specifies default value for the property."
+    )
+    container: ContainerEntityType | None = Field(
+        None,
+        alias="Container",
+        description="Specifies container where the property is stored. Only applies to primitive type.",
+    )
+    container_property: DmsPropertyType | None = Field(
+        None,
+        alias="Container Property",
+        description="Specifies property in the container where the property is stored. Only applies to primitive type.",
+    )
+    index: StrListType | None = Field(
+        None,
+        alias="Index",
+        description="The names of the indexes (comma separated) that should be created for the property.",
+    )
+    constraint: StrListType | None = Field(
+        None,
+        alias="Constraint",
+        description="The names of the uniquness (comma separated) that should be created for the property.",
+    )
     logical: URIRefType | None = Field(
         None,
         alias="Logical",
@@ -192,11 +232,21 @@ class DMSProperty(SheetRow):
 
 
 class DMSContainer(SheetRow):
-    container: ContainerEntityType = Field(alias="Container")
-    name: str | None = Field(alias="Name", default=None)
-    description: str | None = Field(alias="Description", default=None)
-    constraint: ContainerEntityList | None = Field(None, alias="Constraint")
-    used_for: Literal["node", "edge", "all"] | None = Field("all", alias="Used For")
+    container: ContainerEntityType = Field(
+        alias="Container", description="Container id, strongly advised to PascalCase usage."
+    )
+    name: str | None = Field(
+        alias="Name", default=None, description="Human readable name of the container being defined."
+    )
+    description: str | None = Field(
+        alias="Description", default=None, description="Short description of the node being defined."
+    )
+    constraint: ContainerEntityList | None = Field(
+        None, alias="Constraint", description="List of required (comma separated) constraints for the container"
+    )
+    used_for: Literal["node", "edge", "all"] | None = Field(
+        "all", alias="Used For", description=" Whether the container is used for nodes, edges or all."
+    )
 
     def _identifier(self) -> tuple[Hashable, ...]:
         return (self.container,)
@@ -240,12 +290,22 @@ class DMSContainer(SheetRow):
 
 
 class DMSView(SheetRow):
-    view: ViewEntityType = Field(alias="View")
-    name: str | None = Field(alias="Name", default=None)
-    description: str | None = Field(alias="Description", default=None)
-    implements: ViewEntityList | None = Field(None, alias="Implements")
-    filter_: HasDataFilter | NodeTypeFilter | RawFilter | None = Field(None, alias="Filter")
-    in_model: bool = Field(True, alias="In Model")
+    view: ViewEntityType = Field(alias="View", description="View id, strongly advised to PascalCase usage.")
+    name: str | None = Field(alias="Name", default=None, description="Human readable name of the view being defined.")
+    description: str | None = Field(
+        alias="Description", default=None, description="Short description of the view being defined "
+    )
+    implements: ViewEntityList | None = Field(
+        None,
+        alias="Implements",
+        description="List of parent view ids (comma separated) which the view being defined implements.",
+    )
+    filter_: HasDataFilter | NodeTypeFilter | RawFilter | None = Field(
+        None, alias="Filter", description="Explicitly define the filter for the view."
+    )
+    in_model: bool = Field(
+        True, alias="In Model", description="Indicates whether the view being defined is a part of the data model."
+    )
     logical: URIRefType | None = Field(
         None,
         alias="Logical",
@@ -292,10 +352,14 @@ class DMSView(SheetRow):
 
 
 class DMSNode(SheetRow):
-    node: DMSNodeEntity = Field(alias="Node")
-    usage: Literal["type", "collection"] = Field(alias="Usage")
-    name: str | None = Field(alias="Name", default=None)
-    description: str | None = Field(alias="Description", default=None)
+    node: DMSNodeEntity = Field(alias="Node", description="The type definition of the node.")
+    usage: Literal["type", "collection"] = Field(
+        alias="Usage", description="What the usage of the node is in the data model."
+    )
+    name: str | None = Field(alias="Name", default=None, description="Human readable name of the node being defined.")
+    description: str | None = Field(
+        alias="Description", default=None, description="Short description of the node being defined."
+    )
 
     def _identifier(self) -> tuple[Hashable, ...]:
         return (self.node,)
@@ -316,10 +380,10 @@ class DMSNode(SheetRow):
 
 
 class DMSEnum(SheetRow):
-    collection: ClassEntityType = Field(alias="Collection")
-    value: str = Field(alias="Value")
-    name: str | None = Field(alias="Name", default=None)
-    description: str | None = Field(alias="Description", default=None)
+    collection: ClassEntityType = Field(alias="Collection", description="The collection this enum belongs to.")
+    value: str = Field(alias="Value", description="The value of the enum.")
+    name: str | None = Field(alias="Name", default=None, description="Human readable name of the enum.")
+    description: str | None = Field(alias="Description", default=None, description="Short description of the enum.")
 
     def _identifier(self) -> tuple[Hashable, ...]:
         return self.collection, self.value
@@ -332,12 +396,20 @@ class DMSEnum(SheetRow):
 
 
 class DMSRules(BaseRules):
-    metadata: DMSMetadata = Field(alias="Metadata")
-    properties: SheetList[DMSProperty] = Field(alias="Properties")
-    views: SheetList[DMSView] = Field(alias="Views")
-    containers: SheetList[DMSContainer] | None = Field(None, alias="Containers")
-    enum: SheetList[DMSEnum] | None = Field(None, alias="Enum")
-    nodes: SheetList[DMSNode] | None = Field(None, alias="Nodes")
+    metadata: DMSMetadata = Field(alias="Metadata", description="Contains information about the data model.")
+    properties: SheetList[DMSProperty] = Field(
+        alias="Properties", description="Contains the properties of the data model."
+    )
+    views: SheetList[DMSView] = Field(alias="Views", description="Contains the views of the data model.")
+    containers: SheetList[DMSContainer] | None = Field(
+        None,
+        alias="Containers",
+        description="Contains the definition containers that are the physical storage of the data model.",
+    )
+    enum: SheetList[DMSEnum] | None = Field(None, alias="Enum", description="Contains the definition of enum values.")
+    nodes: SheetList[DMSNode] | None = Field(
+        None, alias="Nodes", description="Contains the definition of the node types."
+    )
 
     @field_validator("views")
     def matching_version_and_space(cls, value: SheetList[DMSView], info: ValidationInfo) -> SheetList[DMSView]:

cognite/neat/_rules/models/information/_rules.py

@@ -68,10 +68,16 @@ class InformationClass(SheetRow):
         implements: Which classes the current class implements.
     """
 
-    class_: ClassEntityType = Field(alias="Class")
-    name: str | None = Field(alias="Name", default=None)
-    description: str | None = Field(alias="Description", default=None)
-    implements: ClassEntityList | None = Field(alias="Implements", default=None)
+    class_: ClassEntityType = Field(
+        alias="Class", description="Class id being defined, use strongly advise `PascalCase` usage."
+    )
+    name: str | None = Field(alias="Name", default=None, description="Human readable name of the class.")
+    description: str | None = Field(alias="Description", default=None, description="Short description of the class.")
+    implements: ClassEntityList | None = Field(
+        alias="Implements",
+        default=None,
+        description="List of classes (comma separated) that the current class implements (parents).",
+    )
 
     physical: URIRefType | None = Field(
         None,
@@ -119,17 +125,40 @@ class InformationProperty(SheetRow):
               knowledge graph. Defaults to None (no transformation)
     """
 
-    class_: ClassEntityType = Field(alias="Class")
-    property_: InformationPropertyType = Field(alias="Property")
-    name: str | None = Field(alias="Name", default=None)
-    description: str | None = Field(alias="Description", default=None)
+    class_: ClassEntityType = Field(
+        alias="Class", description="Class id that the property is defined for, strongly advise `PascalCase` usage."
+    )
+    property_: InformationPropertyType = Field(
+        alias="Property", description="Property id, strongly advised to `camelCase` usage."
+    )
+    name: str | None = Field(alias="Name", default=None, description="Human readable name of the property.")
+    description: str | None = Field(alias="Description", default=None, description="Short description of the property.")
     value_type: DataType | ClassEntityType | MultiValueTypeType | UnknownEntity = Field(
-        alias="Value Type", union_mode="left_to_right"
+        alias="Value Type",
+        union_mode="left_to_right",
+        description="Value type that the property can hold. It takes either subset of XSD type or a class defined.",
+    )
+    min_count: int | None = Field(
+        alias="Min Count",
+        default=None,
+        description="Minimum number of values that the property can hold. "
+        "If no value is provided, the default value is  `0`, "
+        "which means that the property is optional.",
+    )
+    max_count: int | float | None = Field(
+        alias="Max Count",
+        default=None,
+        description="Maximum number of values that the property can hold. "
+        "If no value is provided, the default value is  `inf`, "
+        "which means that the property can hold any number of values (listable).",
+    )
+    default: Any | None = Field(alias="Default", default=None, description="Default value of the property.")
+    transformation: RDFPath | None = Field(
+        alias="Transformation",
+        default=None,
+        description="The rule that is used to populate the data model. "
+        "The rule is provided in a RDFPath query syntax which is converted to downstream solution query (e.g. SPARQL).",
     )
-    min_count: int | None = Field(alias="Min Count", default=None)
-    max_count: int | float | None = Field(alias="Max Count", default=None)
-    default: Any | None = Field(alias="Default", default=None)
-    transformation: RDFPath | None = Field(alias="Transformation", default=None)
     inherited: bool = Field(
         default=False,
         exclude=True,
@@ -221,10 +250,14 @@ class InformationProperty(SheetRow):
 
 
 class InformationRules(BaseRules):
-    metadata: InformationMetadata = Field(alias="Metadata")
-    properties: SheetList[InformationProperty] = Field(alias="Properties")
-    classes: SheetList[InformationClass] = Field(alias="Classes")
-    prefixes: dict[str, Namespace] = Field(default_factory=get_default_prefixes, alias="Prefixes")
+    metadata: InformationMetadata = Field(alias="Metadata", description="Metadata for the logical data model")
+    properties: SheetList[InformationProperty] = Field(alias="Properties", description="List of properties")
+    classes: SheetList[InformationClass] = Field(alias="Classes", description="List of classes")
+    prefixes: dict[str, Namespace] = Field(
+        alias="Prefixes",
+        default_factory=get_default_prefixes,
+        description="the definition of the prefixes that are used in the semantic data model",
+    )
 
     @field_validator("prefixes", mode="before")
     def parse_str(cls, values: Any) -> Any:

cognite/neat/_session/_base.py

@@ -38,6 +38,24 @@ from .exceptions import NeatSessionError, session_class_wrapper
 
 @session_class_wrapper
 class NeatSession:
+    """Creates a new NeatSession.
+
+    This is the main entry point for using Neat. It provides access to the different APIs that can be used to read,
+    write, and manipulate data and data models.
+
+    Args:
+        client: The CogniteClient to use for reading and writing data.
+        storage: The storage type to use for storing data and data models. Can be either "memory" or "oxigraph".
+            In "memory" mode works well for small data sets and when only working with data models. It is works
+            well for all notebook environments. In "oxigraph" mode, the data is stored in an Oxigraph database. This
+            is more performant for larger data sets and when working with data. Note that this option requires
+            additional dependencies to be installed and is not available in CDF Notebooks.
+        verbose: Whether to print information about the operations being performed.
+        load_engine: Whether to load the Neat Engine. Can be "newest", "cache", or "skip". "newest" will always
+            check for the newest version of the engine. "cache" will load the engine if it has been downloaded before.
+            "skip" will not load the engine.
+    """
+
     def __init__(
         self,
         client: CogniteClient | None = None,

cognite/neat/_session/_read.py

@@ -17,7 +17,7 @@ from cognite.neat._rules.importers import BaseImporter
 from cognite.neat._store._provenance import Activity as ProvenanceActivity
 from cognite.neat._store._provenance import Change
 from cognite.neat._store._provenance import Entity as ProvenanceEntity
-from cognite.neat._utils.reader import GitHubReader, NeatReader, PathReader
+from cognite.neat._utils.reader import GitHubReader, HttpFileReader, NeatReader, PathReader
 
 from ._state import SessionState
 from ._wizard import NeatObjectType, RDFFileType, XMLFileType, object_wizard, rdf_dm_wizard, xml_format_wizard
@@ -244,9 +244,9 @@ class YamlReadAPI(BaseReadAPI):
 class CSVReadAPI(BaseReadAPI):
     def __call__(self, io: Any, type: str, primary_key: str) -> None:
         reader = NeatReader.create(io)
-        if isinstance(reader, GitHubReader):
+        if isinstance(reader, HttpFileReader):
             path = Path(tempfile.gettempdir()).resolve() / reader.name
-            path.write_text(reader.read_text())
+            path.write_text(reader.read_text(), encoding="utf-8", newline="\n")
         elif isinstance(reader, PathReader):
             path = reader.path
         else:

cognite/neat/_session/_to.py

@@ -132,7 +132,7 @@ class CDFToAPI:
         dry_run: bool = False,
         drop_data: bool = False,
         components: Component | Collection[Component] | None = None,
-    ):
+    ) -> UploadResultList:
         """Export the verified DMS data model to CDF.
 
         Args:
@@ -150,7 +150,7 @@ class CDFToAPI:
         - "skip": If any component already exists, it will be skipped.
         - "update": If any component already exists, it will be updated.
         - "force": If any component already exists, and the update fails, it will be deleted and recreated.
-        - "recreate": All components will be deleted and recreated.
+        - "recreate": All components will be deleted and recreated. The exception is spaces, which will be updated.
 
         """
 
@@ -164,5 +164,5 @@ class CDFToAPI:
             result = exporter.export_to_cdf(self._state.data_model.last_verified_dms_rules[1], self._client, dry_run)
         result.insert(0, UploadResultCore(name="schema", issues=conversion_issues))
         self._state.data_model.outcome.append(result)
-        print("You can inspect the details with the .inspect.data_model.outcome(...) method.")
+        print("You can inspect the details with the .inspect.outcome.data_model(...) method.")
         return result

cognite/neat/_utils/reader/__init__.py

@@ -1,3 +1,3 @@
-from ._base import GitHubReader, NeatReader, PathReader
+from ._base import GitHubReader, HttpFileReader, NeatReader, PathReader
 
-__all__ = ["NeatReader", "PathReader", "GitHubReader"]
+__all__ = ["NeatReader", "PathReader", "GitHubReader", "HttpFileReader"]

cognite/neat/_utils/reader/_base.py

@@ -17,6 +17,8 @@ class NeatReader(ABC):
             url = urlparse(io)
             if url.scheme == "https" and url.netloc.endswith("github.com"):
                 return GitHubReader(io)
+            elif url.scheme == "https":
+                return HttpFileReader(io, url.path)
 
         if isinstance(io, str | Path):
             return PathReader(Path(io))
@@ -94,12 +96,10 @@ class PathReader(NeatReader):
         return self.path.exists()
 
 
-class GitHubReader(NeatReader):
-    raw_url = "https://raw.githubusercontent.com/"
-
-    def __init__(self, raw: str):
-        self.raw = raw
-        self.repo, self.path = self._parse_url(raw)
+class HttpFileReader(NeatReader):
+    def __init__(self, url: str, path: str):
+        self._url = url
+        self.path = path
 
     @property
     def name(self) -> str:
@@ -107,9 +107,40 @@ class GitHubReader(NeatReader):
             return self.path.rsplit("/", maxsplit=1)[-1]
         return self.path
 
-    @property
-    def _full_url(self) -> str:
-        return f"{self.raw_url}{self.repo}/main/{self.path}"
+    def read_text(self) -> str:
+        response = requests.get(self._url)
+        response.raise_for_status()
+        return response.text
+
+    def size(self) -> int:
+        response = requests.head(self._url)
+        response.raise_for_status()
+        return int(response.headers["Content-Length"])
+
+    def iterate(self, chunk_size: int) -> Iterable[str]:
+        with requests.get(self._url, stream=True) as response:
+            response.raise_for_status()
+            for chunk in response.iter_content(chunk_size):
+                yield chunk.decode("utf-8")
+
+    def __enter__(self) -> IO:
+        return StringIO(self.read_text())
+
+    def __str__(self) -> str:
+        return self._url
+
+    def exists(self) -> bool:
+        response = requests.head(self._url)
+        return 200 <= response.status_code < 400
+
+
+class GitHubReader(HttpFileReader):
+    raw_url = "https://raw.githubusercontent.com/"
+
+    def __init__(self, raw: str):
+        self.raw = raw
+        self.repo, path = self._parse_url(raw)
+        super().__init__(f"{self.raw_url}{self.repo}/main/{path}", path)
 
     @staticmethod
     def _parse_url(url: str) -> tuple[str, str]:
@@ -134,29 +165,3 @@ class GitHubReader(NeatReader):
 
     def __str__(self) -> str:
         return self.raw
-
-    def read_text(self) -> str:
-        response = requests.get(self._full_url)
-        response.raise_for_status()
-        return response.text
-
-    def size(self) -> int:
-        response = requests.head(self._full_url)
-        response.raise_for_status()
-        return int(response.headers["Content-Length"])
-
-    def iterate(self, chunk_size: int) -> Iterable[str]:
-        with requests.get(self._full_url, stream=True) as response:
-            response.raise_for_status()
-            for chunk in response.iter_content(chunk_size):
-                yield chunk.decode("utf-8")
-
-    def __enter__(self) -> IO:
-        return StringIO(self.read_text())
-
-    def __exit__(self, exc_type, exc_value, traceback) -> None:
-        pass
-
-    def exists(self) -> bool:
-        response = requests.head(self._full_url)
-        return 200 <= response.status_code < 400

cognite/neat/_utils/text.py

@@ -106,6 +106,18 @@ def to_snake(string: str) -> str:
     return "_".join(map(str.lower, words))
 
 
+def sentence_or_string_to_camel(string: str) -> str:
+    # Could be a combination of kebab and pascal/camel case
+    if " " in string:
+        parts = string.split(" ")
+        try:
+            return parts[0].casefold() + "".join(word.capitalize() for word in parts[1:])
+        except IndexError:
+            return ""
+    else:
+        return to_camel(string)
+
+
 def replace_non_alphanumeric_with_underscore(text: str) -> str:
     return re.sub(r"\W+", "_", text)
 

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.100.0"
+__version__ = "0.101.0"
 __engine__ = "^2.0.1"

cognite_neat-0.101.0.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.1
+Name: cognite-neat
+Version: 0.101.0
+Summary: Knowledge graph transformation
+Home-page: https://cognite-neat.readthedocs-hosted.com/
+License: Apache-2.0
+Author: Nikola Vasiljevic
+Author-email: nikola.vasiljevic@cognite.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: all
+Provides-Extra: docs
+Provides-Extra: google
+Provides-Extra: oxi
+Provides-Extra: service
+Requires-Dist: PyYAML
+Requires-Dist: backports.strenum (>=1.2,<2.0) ; python_version < "3.11"
+Requires-Dist: cognite-sdk (>=7.54.6,<8.0.0)
+Requires-Dist: elementpath (>=4.0.0,<5.0.0)
+Requires-Dist: exceptiongroup (>=1.1.3,<2.0.0) ; python_version < "3.11"
+Requires-Dist: fastapi (>=0,<1) ; extra == "service" or extra == "all"
+Requires-Dist: google-api-python-client ; extra == "google"
+Requires-Dist: google-auth-oauthlib ; extra == "google"
+Requires-Dist: gspread ; extra == "google"
+Requires-Dist: jsonpath-python (>=1.0.6,<2.0.0)
+Requires-Dist: lxml (>=5.3.0,<6.0.0) ; extra == "all"
+Requires-Dist: mixpanel (>=4.10.1,<5.0.0)
+Requires-Dist: mkdocs ; extra == "docs"
+Requires-Dist: mkdocs-autorefs (>=0.5.0,<0.6.0) ; extra == "docs"
+Requires-Dist: mkdocs-git-authors-plugin ; extra == "docs"
+Requires-Dist: mkdocs-git-revision-date-localized-plugin ; extra == "docs"
+Requires-Dist: mkdocs-gitbook ; extra == "docs"
+Requires-Dist: mkdocs-glightbox ; extra == "docs"
+Requires-Dist: mkdocs-jupyter ; extra == "docs"
+Requires-Dist: mkdocs-material-extensions ; extra == "docs"
+Requires-Dist: mkdocstrings[python] ; extra == "docs"
+Requires-Dist: networkx (>=3.4.2,<4.0.0)
+Requires-Dist: openpyxl
+Requires-Dist: oxrdflib[oxigraph] (>=0.4.0,<0.5.0) ; extra == "oxi" or extra == "all"
+Requires-Dist: packaging (>=22.0,<25.0)
+Requires-Dist: pandas
+Requires-Dist: prometheus-client (>=0,<1) ; extra == "service" or extra == "all"
+Requires-Dist: pydantic (>=2,<3)
+Requires-Dist: pymdown-extensions ; extra == "docs"
+Requires-Dist: pyoxigraph (==0.4.3) ; extra == "oxi" or extra == "all"
+Requires-Dist: python-multipart (==0.0.9) ; extra == "service" or extra == "all"
+Requires-Dist: pyvis (>=0.3.2,<0.4.0)
+Requires-Dist: rdflib
+Requires-Dist: requests
+Requires-Dist: rich[jupyter] (>=13.7.1,<14.0.0)
+Requires-Dist: schedule (>=1,<2) ; extra == "service" or extra == "all"
+Requires-Dist: tomli (>=2.0.1,<3.0.0) ; python_version < "3.11"
+Requires-Dist: typing_extensions (>=4.8,<5.0) ; python_version < "3.11"
+Requires-Dist: urllib3 (>=2,<3)
+Requires-Dist: uvicorn[standard] (>=0,<1) ; extra == "service" or extra == "all"
+Project-URL: Documentation, https://cognite-neat.readthedocs-hosted.com/
+Project-URL: Repository, https://github.com/cognitedata/neat
+Description-Content-Type: text/markdown
+
+# kNowlEdge grAph Transformer (NEAT)
+
+[![release](https://img.shields.io/github/actions/workflow/status/cognitedata/neat/release.yaml?style=for-the-badge)](https://github.com/cognitedata/neat/actions/workflows/release.yaml)
+[![Documentation Status](https://readthedocs.com/projects/cognite-neat/badge/?version=latest&style=for-the-badge)](https://cognite-neat.readthedocs-hosted.com/en/latest/?badge=latest)
+[![Github](https://shields.io/badge/github-cognite/neat-green?logo=github&style=for-the-badge)](https://github.com/cognitedata/neat)
+[![PyPI](https://img.shields.io/pypi/v/cognite-neat?style=for-the-badge)](https://pypi.org/project/cognite-neat/)
+[![Downloads](https://img.shields.io/pypi/dm/cognite-neat?style=for-the-badge)](https://pypistats.org/packages/cognite-neat)
+[![Docker Pulls](https://img.shields.io/docker/pulls/cognite/neat?style=for-the-badge)](https://hub.docker.com/r/cognite/neat)
+[![GitHub](https://img.shields.io/github/license/cognitedata/neat?style=for-the-badge)](https://github.com/cognitedata/neat/blob/master/LICENSE)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge)](https://github.com/ambv/black)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=for-the-badge)](https://github.com/astral-sh/ruff)
+[![mypy](https://img.shields.io/badge/mypy-checked-000000.svg?style=for-the-badge&color=blue)](http://mypy-lang.org)
+
+NEAT is a domain expert centric and developer friendly solution for rapid:
+
+- semantic data modeling
+- creation, transformation and enrichment of knowledge graphs
+- and ingestion of the models and graphs into [Cognite Data Fusion](https://www.cognite.com/en/product/cognite_data_fusion_industrial_dataops_platform)
+
+NEAT is using open and globally recognized standards maintained by the [World Wide Web Consortium (W3C)](https://www.w3.org/RDF/).
+NEAT represents an essential tool for creation of standardized, machine-actionable, linked and semantic (meta)data.
+
+> NEAT is an acronym derived from k**N**owl**Ed**ge gr**A**ph **T**ransformer hallucinated by GenAI.
+
+## Installation
+
+```bash
+pip install cognite-neat
+```
+
+## Usage
+
+The user interface for `NEAT` is a notebook-based environment. Once you have set up your notebook
+environment, you start by creating a `CogniteClient` and instantiate a `NeatSession` object.
+
+```python
+from cognite.neat import NeatSession, get_cognite_client
+
+client = get_cognite_client(".env")
+
+neat = NeatSession(client)
+
+neat.read.cdf.data_model(("my_space", "MyDataModel", "v1"))
+```
+
+## Documentation
+
+For more information, see the [documentation](https://cognite-neat.readthedocs-hosted.com/en/latest/)
+