bluecore-models 0.2.0__py3-none-any.whl

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/base.py

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

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/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/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/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/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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,13 @@
+bluecore/models/__init__.py,sha256=N8woyAHr-TJw5fNy9OZOacgp-LpZA7U_ZC88vOtH4Ys,379
+bluecore/models/base.py,sha256=kha9xmklzhuQAK8QEkNBn-mAHq8dUKbOM-3abaBpWmQ,71
+bluecore/models/bf_classes.py,sha256=ex3ezo2d2OA1tlL8i_8JRXXehL3AuEX7NcFqKN4uSgg,1425
+bluecore/models/instance.py,sha256=kFfNpyCD_sjnhWg50zvVBMZGSgzYhPEcrBq38xmRVUA,695
+bluecore/models/other_resource.py,sha256=XWZLCP3RkNejh_kSeaBbjwXfFmN3HonpB1irVBmVXa0,1837
+bluecore/models/resource.py,sha256=BtK5VIZ4fIJ4jUx7hG-R5rzftIvnohrf4RLBb8yBg1M,835
+bluecore/models/version.py,sha256=H4Qy_9n4ZAWMk2R_gNYlY1O8kvMKnmD-cVy7D7zWwJQ,962
+bluecore/models/work.py,sha256=7pFY3-YG_NY8gkwA7uNpSKbt4KKzf2LF-RqVgdqrXlc,467
+bluecore/utils/graph.py,sha256=twfFVL4fmajbRWtHnArlwgESNVPAmKen8HOvimZNxVs,3371
+bluecore_models-0.2.0.dist-info/METADATA,sha256=EqlrVbovHlwpySg8dzY8Xw1y2TVzSrl4Hj7aEty5MW8,2193
+bluecore_models-0.2.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+bluecore_models-0.2.0.dist-info/top_level.txt,sha256=Vzof03mtU80tX4CgPYUVf__PE3y8CxEISf2XxaJYSfw,9
+bluecore_models-0.2.0.dist-info/RECORD,,

bluecore_models-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bluecore_models-0.2.0.dist-info/top_level.txt

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