bluecore-models 0.2.0__tar.gz

bluecore_models-0.2.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.2
+Name: bluecore-models
+Version: 0.2.0
+Summary: Blue Core BIBFRAME Data Models
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: alembic>=1.14.1
+Requires-Dist: psycopg2-binary>=2.9.10
+Requires-Dist: rdflib>=7.1.3
+
+# Blue Core Data Models
+The Blue Core Data Models are used in [Blue Core API](https://github.com/blue-core-lod/bluecore_api) 
+and in the [Blue Core Workflows](https://github.com/blue-core-lod/bluecore-workflows) services.  
+
+## Run Postgres with Docker
+To run the Postgres with the Blue Core Database, run the following command from this directory:
+
+`docker run --name bluecore_db -e POSTGRES_USER=bluecore_admin -e POSTGRES_PASSWORD=bluecore_admin -v ./create-db.sql:/docker-entrypoint-initdb.d/create_database.sql -p 5432:5432 postgres:17`
+
+## Installing
+- Install via pip: `pip install blue-core-data-models`
+- Install via uv: `uv add blue-core-data-models`
+
+## Database Management
+The [SQLAlchemy](https://www.sqlalchemy.org/) Object Relational Mapper (ORM) is used to create
+the Bluecore database models. 
+
+```mermaid
+erDiagram
+    ResourceBase ||--o{ Instance : "has"
+    ResourceBase ||--o{ Work : "has"
+    ResourceBase ||--o{ OtherResource : "has"
+    ResourceBase ||--o{ ResourceBibframeClass : "has classes"
+    ResourceBase ||--o{ Version : "has versions"
+    ResourceBase ||--o{ BibframeOtherResources : "has other resources"
+
+    Work ||--o{ Instance : "has"
+    
+    BibframeClass ||--o{ ResourceBibframeClass : "classifies"
+    
+    OtherResource ||--o{ BibframeOtherResources : "links to"
+```
+
+### Database Migrations with Alembic
+The [Alembic](https://alembic.sqlalchemy.org/en/latest/) database migration package is used
+to manage database changes with the Bluecore Data models.
+
+To create a new migration, ensure that the Postgres database is available and then run:
+- `uv run alembic revision --autogenerate -m "{short message describing change}`
+
+A new migration script will be created in the `bluecore_store_migration` directory. Be sure
+to add the new script to the repository with `git`.
+
+#### Applying Migrations
+To apply all of the migrations, run the following command:
+- `uv run alembic upgrade head`

bluecore_models-0.2.0/README.md

@@ -0,0 +1,46 @@
+# Blue Core Data Models
+The Blue Core Data Models are used in [Blue Core API](https://github.com/blue-core-lod/bluecore_api) 
+and in the [Blue Core Workflows](https://github.com/blue-core-lod/bluecore-workflows) services.  
+
+## Run Postgres with Docker
+To run the Postgres with the Blue Core Database, run the following command from this directory:
+
+`docker run --name bluecore_db -e POSTGRES_USER=bluecore_admin -e POSTGRES_PASSWORD=bluecore_admin -v ./create-db.sql:/docker-entrypoint-initdb.d/create_database.sql -p 5432:5432 postgres:17`
+
+## Installing
+- Install via pip: `pip install blue-core-data-models`
+- Install via uv: `uv add blue-core-data-models`
+
+## Database Management
+The [SQLAlchemy](https://www.sqlalchemy.org/) Object Relational Mapper (ORM) is used to create
+the Bluecore database models. 
+
+```mermaid
+erDiagram
+    ResourceBase ||--o{ Instance : "has"
+    ResourceBase ||--o{ Work : "has"
+    ResourceBase ||--o{ OtherResource : "has"
+    ResourceBase ||--o{ ResourceBibframeClass : "has classes"
+    ResourceBase ||--o{ Version : "has versions"
+    ResourceBase ||--o{ BibframeOtherResources : "has other resources"
+
+    Work ||--o{ Instance : "has"
+    
+    BibframeClass ||--o{ ResourceBibframeClass : "classifies"
+    
+    OtherResource ||--o{ BibframeOtherResources : "links to"
+```
+
+### Database Migrations with Alembic
+The [Alembic](https://alembic.sqlalchemy.org/en/latest/) database migration package is used
+to manage database changes with the Bluecore Data models.
+
+To create a new migration, ensure that the Postgres database is available and then run:
+- `uv run alembic revision --autogenerate -m "{short message describing change}`
+
+A new migration script will be created in the `bluecore_store_migration` directory. Be sure
+to add the new script to the repository with `git`.
+
+#### Applying Migrations
+To apply all of the migrations, run the following command:
+- `uv run alembic upgrade head`

bluecore_models-0.2.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "bluecore-models"
+version = "0.2.0"
+description = "Blue Core BIBFRAME Data Models"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "alembic>=1.14.1",
+    "psycopg2-binary>=2.9.10",
+    "rdflib>=7.1.3",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.4",
+    "pytest-mock-resources>=2.12.1",
+    "ruff>=0.9.6",
+]
+
+[tool.setuptools]
+license-files = []

bluecore_models-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

bluecore_models-0.2.0/src/bluecore/models/__init__.py

@@ -0,0 +1,13 @@
+
+from bluecore.models.base import Base
+from bluecore.models.resource import ResourceBase
+from bluecore.models.bf_classes import BibframeClass, ResourceBibframeClass
+from bluecore.models.instance import Instance
+from bluecore.models.version import Version
+from bluecore.models.work import Work
+from bluecore.models.other_resource import OtherResource, BibframeOtherResources
+
+
+
+
+

bluecore_models-0.2.0/src/bluecore/models/base.py

@@ -0,0 +1,3 @@
+from sqlalchemy.orm import declarative_base
+
+Base = declarative_base()

bluecore_models-0.2.0/src/bluecore/models/bf_classes.py

@@ -0,0 +1,49 @@
+from datetime import datetime
+
+
+from sqlalchemy import (
+    DateTime,
+    ForeignKey,
+    Integer,
+    String,
+)
+
+from sqlalchemy.orm import (
+    mapped_column,
+    Mapped,
+    relationship,
+)
+from bluecore.models.base import Base
+from bluecore.models.resource import ResourceBase
+
+
+class BibframeClass(Base):
+    __tablename__ = "bibframe_classes"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(String, nullable=False)
+    uri: Mapped[str] = mapped_column(String, nullable=False, unique=True)
+    created_at = mapped_column(DateTime, default=datetime.utcnow)
+    updated_at = mapped_column(
+        DateTime, default=datetime.utcnow, onupdate=datetime.utcnow
+    )
+
+    def __repr__(self):
+        return f"<BibframeClass {self.name}>"
+
+
+class ResourceBibframeClass(Base):
+    __tablename__ = "resource_bibframe_classes"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    bf_class_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("bibframe_classes.id"), nullable=False
+    )
+    bf_class: Mapped[BibframeClass] = relationship("BibframeClass")
+    resource_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("resource_base.id"), nullable=False
+    )
+    resource: Mapped[ResourceBase] = relationship("ResourceBase", backref="classes")
+
+    def __repr__(self):
+        return f"<ResourceBibframeClass {self.bf_class.name} for {self.resource.uri}>"

bluecore_models-0.2.0/src/bluecore/models/instance.py

@@ -0,0 +1,30 @@
+from sqlalchemy import (
+    ForeignKey,
+    Integer,
+)
+
+from sqlalchemy.orm import (
+    mapped_column,
+    Mapped,
+    relationship,
+)
+
+from bluecore.models.resource import ResourceBase
+
+class Instance(ResourceBase):
+    __tablename__ = "instances"
+
+    id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("resource_base.id"), primary_key=True
+    )
+    work_id: Mapped[int] = mapped_column(Integer, ForeignKey("works.id"), nullable=True)
+    work: Mapped["Work"] = relationship(
+        "Work", foreign_keys=work_id, backref="instances"
+    )
+
+    __mapper_args__ = {
+        "polymorphic_identity": "instances",
+    }
+
+    def __repr__(self):
+        return f"<Instance {self.uri}>"

bluecore_models-0.2.0/src/bluecore/models/other_resource.py

@@ -0,0 +1,66 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Boolean,
+    DateTime,
+    Integer,
+    ForeignKey
+)
+
+from sqlalchemy.orm import (
+    mapped_column,
+    Mapped,
+    relationship,
+)
+
+from bluecore.models.base import Base
+from bluecore.models.resource import ResourceBase
+
+
+class OtherResource(ResourceBase):
+    """
+    Stores JSON or JSON-LD resources used to support Work and Instances.
+    """
+
+    __tablename__ = "other_resources"
+    id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("resource_base.id"), primary_key=True
+    )
+    is_profile: Mapped[bool] = mapped_column(Boolean, default=False)
+
+    __mapper_args__ = {
+        "polymorphic_identity": "other_resources",
+    }
+
+    def __repr__(self):
+        return f"<OtherResource {self.uri or self.id}>"
+    
+
+class BibframeOtherResources(Base):
+    """
+    Creates relationships between Work or Instance and supporting resources
+    """
+
+    __tablename__ = "bibframe_other_resources"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    other_resource_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("other_resources.id"), nullable=False
+    )
+    other_resource: Mapped[OtherResource] = relationship(
+        "OtherResource", foreign_keys=other_resource_id
+    )
+    bibframe_resource_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("resource_base.id"), nullable=False
+    )
+    bibframe_resource: Mapped[ResourceBase] = relationship(
+        "ResourceBase", backref="other_resources"
+    )
+
+    created_at = mapped_column(DateTime, default=datetime.utcnow)
+    updated_at = mapped_column(
+        DateTime, default=datetime.utcnow, onupdate=datetime.utcnow
+    )
+
+    def __repr__(self):
+        return f"<BibframeOtherResources {self.other_resource.uri or self.other_resource.id} for {self.bibframe_resource.uri}>"

bluecore_models-0.2.0/src/bluecore/models/resource.py

@@ -0,0 +1,32 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    DateTime,
+    String,
+)
+
+from sqlalchemy.orm import (
+    mapped_column,
+    Mapped,
+)
+
+from sqlalchemy.dialects.postgresql import JSONB
+
+from bluecore.models.base import Base
+
+class ResourceBase(Base):
+    __tablename__ = "resource_base"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    type: Mapped[str] = mapped_column(String, nullable=False)
+    data: Mapped[bytes] = mapped_column(JSONB, nullable=False)
+    uri: Mapped[str] = mapped_column(String, nullable=True, unique=True)
+    created_at = mapped_column(DateTime, default=datetime.utcnow)
+    updated_at = mapped_column(
+        DateTime, default=datetime.utcnow, onupdate=datetime.utcnow
+    )
+
+    __mapper_args__ = {
+        "polymorphic_on": type,
+        "polymorphic_identity": "resource_base",
+    }

bluecore_models-0.2.0/src/bluecore/models/version.py

@@ -0,0 +1,35 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    DateTime,
+    Integer,
+    ForeignKey
+)
+
+from sqlalchemy.orm import (
+    mapped_column,
+    Mapped,
+    relationship,
+)
+
+from sqlalchemy.dialects.postgresql import JSONB
+
+from bluecore.models.base import Base
+from bluecore.models.resource import ResourceBase
+
+class Version(Base):
+    __tablename__ = "versions"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    resource_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("resource_base.id"), nullable=False
+    )
+    resource: Mapped[ResourceBase] = relationship("ResourceBase", backref="versions")
+    data: Mapped[bytes] = mapped_column(JSONB, nullable=False)
+    created_at = mapped_column(DateTime, default=datetime.utcnow)
+    updated_at = mapped_column(
+        DateTime, default=datetime.utcnow, onupdate=datetime.utcnow
+    )
+
+    def __repr__(self):
+        return f"<Version at {self.created_at} for {self.resource.uri}>"

bluecore_models-0.2.0/src/bluecore/models/work.py

@@ -0,0 +1,25 @@
+from sqlalchemy import (
+    ForeignKey,
+    Integer,
+)
+
+from sqlalchemy.orm import (
+    mapped_column,
+    Mapped,
+)
+
+from bluecore.models.resource import ResourceBase
+
+
+class Work(ResourceBase):
+    __tablename__ = "works"
+    id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("resource_base.id"), primary_key=True
+    )
+
+    __mapper_args__ = {
+        "polymorphic_identity": "works",
+    }
+
+    def __repr__(self):
+        return f"<Work {self.uri}>"

bluecore_models-0.2.0/src/bluecore/utils/graph.py

@@ -0,0 +1,88 @@
+"""Utility functions for working with RDF graphs."""
+import rdflib
+
+BF = rdflib.Namespace("http://id.loc.gov/ontologies/bibframe/")
+BFLC = rdflib.Namespace("http://id.loc.gov/ontologies/bflc/")
+LCLOCAL = rdflib.Namespace("http://id.loc.gov/ontologies/lclocal/")
+MADS = rdflib.Namespace("http://www.loc.gov/mads/rdf/v1#")
+
+def init_graph() -> rdflib.Graph:
+    """Initialize a new RDF graph with the necessary namespaces."""
+    new_graph = rdflib.Graph()
+    new_graph.namespace_manager.bind("bf", BF)
+    new_graph.namespace_manager.bind("bflc", BFLC)
+    new_graph.namespace_manager.bind("mads", MADS)
+    new_graph.namespace_manager.bind("lclocal", LCLOCAL)
+    return new_graph
+
+
+def _check_for_namespace(node: rdflib.URIRef) -> bool:
+    """Check if a node is in the LCLOCAL or DCTERMS namespace."""
+    return node in LCLOCAL or node in rdflib.DCTERMS
+
+
+def _exclude_uri_from_other_resources(uri: rdflib.URIRef) -> bool:
+    """Checks if uri is in the BF, MADS, or RDF namespaces"""
+    return (
+        uri in BF or uri in MADS or uri in rdflib.RDF
+    )
+
+
+def _expand_bnode(graph: rdflib.Graph, entity_graph: rdflib.Graph, bnode: rdflib.BNode):
+    """Expand a blank node in the entity graph."""
+    for pred, obj in graph.predicate_objects(subject=bnode):
+        if _check_for_namespace(pred) or _check_for_namespace(obj):
+            continue
+        entity_graph.add((bnode, pred, obj))
+        if isinstance(obj, rdflib.BNode):
+            _expand_bnode(graph, entity_graph, obj)
+
+
+def _is_work_or_instance(uri: rdflib.URIRef, graph: rdflib.Graph) -> bool:
+    """Checks if uri is a BIBFRAME Work or Instance"""
+    for class_ in graph.objects(subject=uri, predicate=rdflib.RDF.type):
+        # In the future we may want to include Work and Instances subclasses
+        # maybe through inference
+        if class_ == BF.Work or class_ == BF.Instance:
+            return True
+        return False
+
+
+def generate_entity_graph(graph: rdflib.Graph, entity: rdflib.URIRef) -> rdflib.Graph:
+    """Generate an entity graph from a larger RDF graph."""
+    entity_graph = init_graph()
+    for pred, obj in graph.predicate_objects(subject=entity):
+        if _check_for_namespace(pred) or _check_for_namespace(obj):
+            continue
+        entity_graph.add((entity, pred, obj))
+        if isinstance(obj, rdflib.BNode):
+            _expand_bnode(graph, entity_graph, obj)
+    return entity_graph
+
+
+def generate_other_resources(record_graph: rdflib.Graph, entity_graph: rdflib.Graph) -> list:
+    """
+    Takes a Record Graph and Entity Graph and returns a list of dictionaries 
+    where each dict contains the sub-graphs and URIs that referenced in the 
+    entity graph and present in the record graph. 
+    """
+    other_resources = []
+    for row in entity_graph.query("""
+      SELECT DISTINCT ?object
+      WHERE {
+        ?subject ?predicate ?object .
+        FILTER(isIRI(?object))
+      }
+    """):
+        uri = row[0]
+        if _exclude_uri_from_other_resources(uri) or _is_work_or_instance(uri, record_graph):
+            continue
+        other_resource_graph = generate_entity_graph(record_graph, uri)
+        if len(other_resource_graph) > 0:
+            other_resources.append(
+                {
+                    "uri": str(uri),
+                    "graph": other_resource_graph
+                }
+            )
+        return other_resources

bluecore_models-0.2.0/src/bluecore_models.egg-info/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.2
+Name: bluecore-models
+Version: 0.2.0
+Summary: Blue Core BIBFRAME Data Models
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: alembic>=1.14.1
+Requires-Dist: psycopg2-binary>=2.9.10
+Requires-Dist: rdflib>=7.1.3
+
+# Blue Core Data Models
+The Blue Core Data Models are used in [Blue Core API](https://github.com/blue-core-lod/bluecore_api) 
+and in the [Blue Core Workflows](https://github.com/blue-core-lod/bluecore-workflows) services.  
+
+## Run Postgres with Docker
+To run the Postgres with the Blue Core Database, run the following command from this directory:
+
+`docker run --name bluecore_db -e POSTGRES_USER=bluecore_admin -e POSTGRES_PASSWORD=bluecore_admin -v ./create-db.sql:/docker-entrypoint-initdb.d/create_database.sql -p 5432:5432 postgres:17`
+
+## Installing
+- Install via pip: `pip install blue-core-data-models`
+- Install via uv: `uv add blue-core-data-models`
+
+## Database Management
+The [SQLAlchemy](https://www.sqlalchemy.org/) Object Relational Mapper (ORM) is used to create
+the Bluecore database models. 
+
+```mermaid
+erDiagram
+    ResourceBase ||--o{ Instance : "has"
+    ResourceBase ||--o{ Work : "has"
+    ResourceBase ||--o{ OtherResource : "has"
+    ResourceBase ||--o{ ResourceBibframeClass : "has classes"
+    ResourceBase ||--o{ Version : "has versions"
+    ResourceBase ||--o{ BibframeOtherResources : "has other resources"
+
+    Work ||--o{ Instance : "has"
+    
+    BibframeClass ||--o{ ResourceBibframeClass : "classifies"
+    
+    OtherResource ||--o{ BibframeOtherResources : "links to"
+```
+
+### Database Migrations with Alembic
+The [Alembic](https://alembic.sqlalchemy.org/en/latest/) database migration package is used
+to manage database changes with the Bluecore Data models.
+
+To create a new migration, ensure that the Postgres database is available and then run:
+- `uv run alembic revision --autogenerate -m "{short message describing change}`
+
+A new migration script will be created in the `bluecore_store_migration` directory. Be sure
+to add the new script to the repository with `git`.
+
+#### Applying Migrations
+To apply all of the migrations, run the following command:
+- `uv run alembic upgrade head`

bluecore_models-0.2.0/src/bluecore_models.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+src/bluecore/models/__init__.py
+src/bluecore/models/base.py
+src/bluecore/models/bf_classes.py
+src/bluecore/models/instance.py
+src/bluecore/models/other_resource.py
+src/bluecore/models/resource.py
+src/bluecore/models/version.py
+src/bluecore/models/work.py
+src/bluecore/utils/graph.py
+src/bluecore_models.egg-info/PKG-INFO
+src/bluecore_models.egg-info/SOURCES.txt
+src/bluecore_models.egg-info/dependency_links.txt
+src/bluecore_models.egg-info/requires.txt
+src/bluecore_models.egg-info/top_level.txt
+tests/test_models.py
+tests/test_utils.py

bluecore_models-0.2.0/src/bluecore_models.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bluecore_models-0.2.0/src/bluecore_models.egg-info/requires.txt

@@ -0,0 +1,3 @@
+alembic>=1.14.1
+psycopg2-binary>=2.9.10
+rdflib>=7.1.3

bluecore_models-0.2.0/src/bluecore_models.egg-info/top_level.txt

@@ -0,0 +1 @@
+bluecore

bluecore_models-0.2.0/tests/test_models.py

@@ -0,0 +1,198 @@
+import json
+import pathlib
+from datetime import datetime, UTC
+
+import pytest
+from pytest_mock_resources import create_sqlite_fixture, Rows
+
+from sqlalchemy.orm import sessionmaker
+
+from bluecore.models import (
+    Base,
+    BibframeClass,
+    ResourceBibframeClass,
+    Instance,
+    OtherResource,
+    Version,
+    Work,
+    BibframeOtherResources,
+)
+
+
+def create_test_rows():
+    return Rows(
+        # BibframeClass
+        BibframeClass(
+            id=1,
+            name="Instance",
+            uri="http://id.loc.gov/ontologies/bibframe/Instance",
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+        ),
+        BibframeClass(
+            id=2,
+            name="Work",
+            uri="http://id.loc.gov/ontologies/bibframe/Work",
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+        ),
+        # Work
+        Work(
+            id=1,
+            uri="https://bluecore.info/work/e0d6-40f0-abb3-e9130622eb8a",
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+            data=pathlib.Path("tests/blue-core-work.jsonld").read_text(),
+            type="works",
+        ),
+        # Instance
+        Instance(
+            id=2,
+            uri="https://bluecore.info/instance/75d831b9-e0d6-40f0-abb3-e9130622eb8a",
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+            data=pathlib.Path("tests/blue-core-instance.jsonld").read_text(),
+            type="instances",
+            work_id=1,
+        ),
+        # OtherResource
+        OtherResource(
+            id=3,
+            uri="https://bluecore.info/other-resource/sample",
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+            data='{"description": "Sample Other Resource"}',
+            type="other_resources",
+            is_profile=False,
+        ),
+        # ResourceBibframeClass
+        ResourceBibframeClass(
+            id=1,
+            bf_class_id=1,
+            resource_id=2,
+        ),
+        ResourceBibframeClass(
+            id=2,
+            bf_class_id=2,
+            resource_id=1,
+        ),
+        # Version
+        Version(
+            id=1,
+            resource_id=1,
+            data=pathlib.Path("tests/blue-core-work.jsonld").read_text(),
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+        ),
+        Version(
+            id=2,
+            resource_id=2,
+            data=pathlib.Path("tests/blue-core-instance.jsonld").read_text(),
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+        ),
+        # BibframeOtherResources
+        BibframeOtherResources(
+            id=1,
+            other_resource_id=3,
+            bibframe_resource_id=1,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+        ),
+    )
+
+
+engine = create_sqlite_fixture(create_test_rows())
+
+
+@pytest.fixture()
+def pg_session(engine):
+    Base.metadata.create_all(engine)
+    return sessionmaker(bind=engine)
+
+
+def test_bibframe_class(pg_session):
+    with pg_session() as session:
+        bf_instance = (
+            session.query(BibframeClass).where(BibframeClass.name == "Instance").first()
+        )
+        assert bf_instance is not None
+        assert bf_instance.uri.startswith(
+            "http://id.loc.gov/ontologies/bibframe/Instance"
+        )
+        assert bf_instance.created_at
+        assert bf_instance.updated_at
+
+
+def test_resource_bibframe_class(pg_session):
+    with pg_session() as session:
+        resource_bf_class = (
+            session.query(ResourceBibframeClass)
+            .where(ResourceBibframeClass.id == 1)
+            .first()
+        )
+        assert resource_bf_class.resource.uri.startswith(
+            "https://bluecore.info/instance"
+        )
+        assert resource_bf_class.bf_class.name == "Instance"
+
+
+def test_instance(pg_session):
+    with pg_session() as session:
+        instance = session.query(Instance).where(Instance.id == 2).first()
+        assert instance.uri.startswith("https://bluecore.info/instance")
+        assert instance.data
+        assert instance.created_at
+        assert instance.updated_at
+        assert instance.work is not None
+        assert instance.work.uri.startswith("https://bluecore.info/work")
+
+
+def test_work(pg_session):
+    with pg_session() as session:
+        work = session.query(Work).where(Work.id == 1).first()
+        assert work.uri.startswith("https://bluecore.info/work")
+        assert work.data
+        assert work.created_at
+        assert work.updated_at
+        assert len(work.instances) > 0
+
+
+def test_other_resource(pg_session):
+    with pg_session() as session:
+        other_resource = (
+            session.query(OtherResource).where(OtherResource.id == 3).first()
+        )
+        assert other_resource.uri.startswith("https://bluecore.info/other-resource")
+        assert other_resource.data
+        assert other_resource.created_at
+        assert other_resource.updated_at
+        assert other_resource.is_profile is False
+
+
+def test_versions(pg_session):
+    with pg_session() as session:
+        version = session.query(Version).where(Version.id == 1).first()
+        work = session.query(Work).where(Work.id == 1).first()
+        assert version.resource is not None
+        assert version.resource == work
+        assert version.data
+        assert version.created_at
+        assert version.updated_at
+        version2 = session.query(Version).where(Version.id == 2).first()
+        instance = session.query(Instance).where(Instance.id == 2).first()
+        assert version2.resource == instance
+
+
+def test_bibframe_other_resources(pg_session):
+    with pg_session() as session:
+        bibframe_other_resource = (
+            session.query(BibframeOtherResources)
+            .where(BibframeOtherResources.id == 1)
+            .first()
+        )
+        assert bibframe_other_resource.other_resource is not None
+        assert bibframe_other_resource.bibframe_resource is not None
+        assert bibframe_other_resource.created_at
+        assert bibframe_other_resource.updated_at
+

bluecore_models-0.2.0/tests/test_utils.py

@@ -0,0 +1,36 @@
+import pathlib
+
+import rdflib
+
+from bluecore.utils.graph import (
+    BF,
+    BFLC,
+    MADS,
+    generate_entity_graph,
+    init_graph,
+)
+
+def test_init_graph():
+    graph = init_graph()
+    assert graph.namespace_manager.store.namespace("bf") == rdflib.URIRef(BF)
+    assert graph.namespace_manager.store.namespace("bflc") == rdflib.URIRef(BFLC) 
+    assert graph.namespace_manager.store.namespace("mads") == rdflib.URIRef(MADS)
+
+
+def test_generate_entity_graph():
+    loc_graph = init_graph()
+    loc_graph.parse(data=pathlib.Path("tests/23807141.jsonld").read_text(), format="json-ld")
+    work_uri = rdflib.URIRef("http://id.loc.gov/resources/works/23807141")
+    dcterm_part_of = loc_graph.value(subject=work_uri, predicate=rdflib.DCTERMS.isPartOf)
+    assert dcterm_part_of == rdflib.URIRef("http://id.loc.gov/resources/works")
+    work_graph = generate_entity_graph(loc_graph, work_uri)
+    assert len(work_graph) == 118
+
+    work_title = work_graph.value(subject=work_uri, predicate=BF.title)
+    main_title = work_graph.value(subject=work_title, predicate=BF.mainTitle)
+    assert str(main_title).startswith("HBR guide to generative AI for managers")
+    
+    # Tests if DCTERMs triples are filtered out of entity graph
+    work_dcterm_part_of = work_graph.value(subject=work_uri, predicate=rdflib.DCTERMS.isPartOf)
+    assert work_dcterm_part_of is None
+