Skip to content

DCAT

DCAT plugin provides Package and Resource models and converters between DCAT and Data Package notations

Installation

Extra dependency needs to be installed:

pip install dplib-py[dcat]

Usage

Converting a DCAT descriptor to the Data Package notation:

from dplib.plugins.dcat.models import DcatPackage

package = DcatPackage.from_path("data/plugins/dcat/package.xml").to_dp()
print(package.to_text(format='json'))

{
  "resources": [
    {
      "name": "fishway_obstruction_data_v1",
      "path": "https://zenodo.org/records/5770714/files/Fishway_Obstruction_Data_v1.csv",
      "mediatype": "text/csv",
      "bytes": 1377
    },
    {
      "name": "readme",
      "path": "https://zenodo.org/records/5770714/files/readme.md",
      "bytes": 1577
    }
  ],
  "id": "https://doi.org/10.5281/zenodo.5770714",
  "title": "Fishway_Obstruction_Data_v1.csv",
  "description": "This dataset contains pool-weir type fishway (sumerged notch and orifice) hydraulic scenarios with and without obstruction events in accordance with\u00a0the publication:\u00a0 Fuentes-P\u00e9rez, J.F., Garc\u00eda-Vega, A., Bravo-C\u00f3rdoba, F.J., Sanz-Ronda, F.J. 2021. A Step to Smart Fishways: An Autonomous Obstruction Detection System Using Hydraulic Modeling and Sensor Networks. Sensors 2021, 21(20), 6909.",
  "version": "v1",
  "keywords": [
    "fishways",
    "hydraulics",
    "smart fishways",
    "pool-weir",
    "hydrological variability",
    "nonuniformity",
    "clogging",
    "water-level sensors"
  ]
}

Converting a Data Package to DCAT notation:

from dplib.models import Package
from dplib.plugins.dcat.models import DcatPackage

package = DcatPackage.from_dp(Package.from_path("data/package.json"))
print(package.to_text(format="xml"))

Reference

dplib.plugins.dcat.models.DcatPackage

Bases: Model

DCAT Package model

Source code in dplib/plugins/dcat/models/package.py 
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
class DcatPackage(Model):
    """DCAT Package model"""

    identifier: Optional[str] = None
    distributions: List[DcatResource] = []

    accural_periodicity: Optional[str] = None
    alternate_identifiers: List[str] = []
    comforms_to: List[str] = []
    description: Optional[str] = None
    has_versions: List[str] = []
    homepage: Optional[str] = None
    issued: Optional[str] = None
    is_version_of: List[str] = []
    keywords: List[str] = []
    landing_page: Optional[str] = None
    languages: List[str] = []
    modified: Optional[str] = None
    pages: List[str] = []
    provenance: Optional[str] = None
    related_resources: List[str] = []
    samples: List[str] = []
    sources: List[str] = []
    themes: List[str] = []
    title: Optional[str] = None
    version: Optional[str] = None

    # Converters

    def to_text(self, *, format: str):
        g = self.to_graph()
        return g.serialize(format=format)

    @classmethod
    def from_text(cls, text: str, *, format: str, **kwargs: Any):
        g = Graph()
        g.parse(data=text, format=format)
        return cls.from_graph(g)

    def to_graph(self):
        g = Graph()
        for prefix, namespace in ns.BINDINGS.items():
            g.bind(prefix, namespace)

        # Identifier
        if not self.identifier:
            raise Error(f"Cannot dump DCAT package without identifier: {self}")
        id = dumpers.id(g, self.identifier, predicate=ns.TYPE, object=ns.DATASET)

        # Accural periodicity
        if self.accural_periodicity:
            dumpers.node(
                g, self.accural_periodicity, subject=id, predicate=ns.ACCURAL_PERIODICITY
            )

        # Alternate identifiers
        for identifier in self.alternate_identifiers:
            dumpers.node(g, identifier, subject=id, predicate=ns.ALTERNATE_IDENTIFIER)

        # Conforms to
        for conforms_to in self.comforms_to:
            dumpers.node(g, conforms_to, subject=id, predicate=ns.COMFORMS_TO)

        # Description
        if self.description:
            dumpers.node(g, self.description, subject=id, predicate=ns.DESCRIPTION)

        # Has versions
        for has_version in self.has_versions:
            dumpers.node(g, has_version, subject=id, predicate=ns.HAS_VERSION)

        # Homepage
        if self.homepage:
            dumpers.node(g, self.homepage, subject=id, predicate=ns.HOMEPAGE)

        # Issued
        if self.issued:
            dumpers.node(g, self.issued, subject=id, predicate=ns.ISSUED)

        # Is version of
        for is_version_of in self.is_version_of:
            dumpers.node(g, is_version_of, subject=id, predicate=ns.IS_VERSION_OF)

        # Keywords
        for keyword in self.keywords:
            dumpers.node(g, keyword, subject=id, predicate=ns.KEYWORD)

        # Landing page
        if self.landing_page:
            dumpers.node(g, self.landing_page, subject=id, predicate=ns.LANDING_PAGE)

        # Languages
        for language in self.languages:
            dumpers.node(g, language, subject=id, predicate=ns.LANGUAGE)

        # Modified
        if self.modified:
            dumpers.node(g, self.modified, subject=id, predicate=ns.MODIFIED)

        # Pages
        for page in self.pages:
            dumpers.node(g, page, subject=id, predicate=ns.PAGE)

        # Provenance
        if self.provenance:
            dumpers.node(g, self.provenance, subject=id, predicate=ns.PROVENANCE)

        # Related resources
        for related_resource in self.related_resources:
            dumpers.node(g, related_resource, subject=id, predicate=ns.RELATED_RESOURCE)

        # Samples
        for sample in self.samples:
            dumpers.node(g, sample, subject=id, predicate=ns.SAMPLE)

        # Sources
        for source in self.sources:
            dumpers.node(g, source, subject=id, predicate=ns.SOURCE)

        # Themes
        for theme in self.themes:
            dumpers.node(g, theme, subject=id, predicate=ns.THEME)

        # Title
        if self.title:
            dumpers.node(g, self.title, subject=id, predicate=ns.TITLE)

        # Version
        if self.version:
            dumpers.node(g, self.version, subject=id, predicate=ns.VERSION)

        # Distributions
        for distribution in self.distributions:
            distribution_id = BNode()
            g.add((id, ns.DISTRIBUTION, distribution_id))
            g.add((distribution_id, ns.TYPE, ns.DISTRIBUTION))
            distribution.to_graph(g, id=distribution_id)

        return g

    @classmethod
    def from_graph(cls, g: Graph):
        package = DcatPackage()

        # Identifier
        id = loaders.id(g, predicate=ns.TYPE, object=ns.DATASET)
        if not id:
            raise Error(f"Cannot load DCAT package without identifier: {g}")
        package.identifier = str(id)

        # Accural periodicity
        periodicity = loaders.string(g, subject=id, predicate=ns.ACCURAL_PERIODICITY)
        if periodicity:
            package.accural_periodicity = periodicity

        # Alternate identifiers
        identifiers = loaders.strings(g, subject=id, predicate=ns.ALTERNATE_IDENTIFIER)
        if identifiers:
            package.alternate_identifiers = identifiers

        # Conforms to
        conforms_to = loaders.strings(g, subject=id, predicate=ns.COMFORMS_TO)
        if conforms_to:
            package.comforms_to = conforms_to

        # Description
        description = loaders.string(g, subject=id, predicate=ns.DESCRIPTION)
        if description:
            package.description = description

        # Has versions
        has_versions = loaders.strings(g, subject=id, predicate=ns.HAS_VERSION)
        if has_versions:
            package.has_versions = has_versions

        # Homepage
        homepage = loaders.string(g, subject=id, predicate=ns.HOMEPAGE)
        if homepage:
            package.homepage = homepage

        # Issued
        issued = loaders.string(g, subject=id, predicate=ns.ISSUED)
        if issued:
            package.issued = issued

        # Is version of
        is_version_of = loaders.strings(g, subject=id, predicate=ns.IS_VERSION_OF)
        if is_version_of:
            package.is_version_of = is_version_of

        # Keywords
        keywords = loaders.strings(g, subject=id, predicate=ns.KEYWORD)
        if keywords:
            package.keywords = keywords

        # Landing page
        landing_page = loaders.string(g, subject=id, predicate=ns.LANDING_PAGE)
        if landing_page:
            package.landing_page = landing_page

        # Languages
        languages = loaders.strings(g, subject=id, predicate=ns.LANGUAGE)
        if languages:
            package.languages = languages

        # Modified
        modified = loaders.string(g, subject=id, predicate=ns.MODIFIED)
        if modified:
            package.modified = modified

        # Pages
        pages = loaders.strings(g, subject=id, predicate=ns.PAGE)
        if pages:
            package.pages = pages

        # Provenance
        provenance = loaders.string(g, subject=id, predicate=ns.PROVENANCE)
        if provenance:
            package.provenance = provenance

        # Related resources
        related_resources = loaders.strings(g, subject=id, predicate=ns.RELATED_RESOURCE)
        if related_resources:
            package.related_resources = related_resources

        # Samples
        samples = loaders.strings(g, subject=id, predicate=ns.SAMPLE)
        if samples:
            package.samples = samples

        # Sources
        sources = loaders.strings(g, subject=id, predicate=ns.SOURCE)
        if sources:
            package.sources = sources

        # Themes
        themes = loaders.strings(g, subject=id, predicate=ns.THEME)
        if themes:
            package.themes = themes

        # Title
        title = loaders.string(g, subject=id, predicate=ns.TITLE)
        if title:
            package.title = title

        # Version
        version = loaders.string(g, subject=id, predicate=ns.VERSION)
        if version:
            package.version = version

        # Distributions
        distributions = g.objects(subject=id, predicate=ns.DISTRIBUTION)
        for distribution in distributions:
            if isinstance(distribution, (URIRef, BNode)):
                resource = DcatResource.from_graph(g, id=distribution)
                package.distributions.append(resource)

        return package

    def to_dp(self) -> Package:
        """Convert to Data Package

        Returns:
           Data Package
        """
        package = Package()

        # Id
        if self.identifier:
            package.id = self.identifier

        # Title
        if self.title:
            package.title = self.title

        # Description
        if self.description:
            package.description = self.description

        # Version
        if self.version:
            package.version = self.version

        # Homepage
        if self.homepage:
            package.homepage = self.homepage

        # Created
        if self.issued:
            if "T" in self.issued:
                package.created = self.issued

        # Keywords
        for keyword in self.keywords:
            package.keywords.append(keyword)

        # Sources
        for source in self.sources:
            source = Source(title=source)
            package.sources.append(source)

        # Resources
        for distribution in self.distributions:
            resource = distribution.to_dp()
            if resource:
                package.resources.append(resource)

        return package

    @classmethod
    def from_dp(cls, package: Package) -> DcatPackage:
        """Create a DCAT Package from Data Package

        Parameters:
            package: Data Package

        Returns:
            DCAT Package
        """
        dcat = DcatPackage()

        # Identifier
        if package.id:
            dcat.identifier = package.id

        # Title
        if package.title:
            dcat.title = package.title

        # Description
        if package.description:
            dcat.description = package.description

        # Version
        if package.version:
            dcat.version = package.version

        # Homepage
        if package.homepage:
            dcat.homepage = package.homepage

        # Issued
        if package.created:
            dcat.issued = package.created

        # Keywords
        for keyword in package.keywords:
            dcat.keywords.append(keyword)

        # Sources
        for source in package.sources:
            source = source.path or source.title
            if source:
                dcat.sources.append(source)

        # Resources
        for resource in package.resources:
            distribution = DcatResource.from_dp(resource)
            if distribution:
                dcat.distributions.append(distribution)

        return dcat

accural_periodicity: Optional[str] = None class-attribute instance-attribute

alternate_identifiers: List[str] = [] class-attribute instance-attribute

comforms_to: List[str] = [] class-attribute instance-attribute

description: Optional[str] = None class-attribute instance-attribute

distributions: List[DcatResource] = [] class-attribute instance-attribute

has_versions: List[str] = [] class-attribute instance-attribute

homepage: Optional[str] = None class-attribute instance-attribute

identifier: Optional[str] = None class-attribute instance-attribute

is_version_of: List[str] = [] class-attribute instance-attribute

issued: Optional[str] = None class-attribute instance-attribute

keywords: List[str] = [] class-attribute instance-attribute

landing_page: Optional[str] = None class-attribute instance-attribute

languages: List[str] = [] class-attribute instance-attribute

modified: Optional[str] = None class-attribute instance-attribute

pages: List[str] = [] class-attribute instance-attribute

provenance: Optional[str] = None class-attribute instance-attribute

related_resources: List[str] = [] class-attribute instance-attribute

samples: List[str] = [] class-attribute instance-attribute

sources: List[str] = [] class-attribute instance-attribute

themes: List[str] = [] class-attribute instance-attribute

title: Optional[str] = None class-attribute instance-attribute

version: Optional[str] = None class-attribute instance-attribute

from_dp(package) classmethod

Create a DCAT Package from Data Package

Parameters:

Name Type Description Default
package Package

Data Package

 required

Returns:

Type Description
DcatPackage

DCAT Package
Source code in dplib/plugins/dcat/models/package.py 
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
@classmethod
def from_dp(cls, package: Package) -> DcatPackage:
    """Create a DCAT Package from Data Package

    Parameters:
        package: Data Package

    Returns:
        DCAT Package
    """
    dcat = DcatPackage()

    # Identifier
    if package.id:
        dcat.identifier = package.id

    # Title
    if package.title:
        dcat.title = package.title

    # Description
    if package.description:
        dcat.description = package.description

    # Version
    if package.version:
        dcat.version = package.version

    # Homepage
    if package.homepage:
        dcat.homepage = package.homepage

    # Issued
    if package.created:
        dcat.issued = package.created

    # Keywords
    for keyword in package.keywords:
        dcat.keywords.append(keyword)

    # Sources
    for source in package.sources:
        source = source.path or source.title
        if source:
            dcat.sources.append(source)

    # Resources
    for resource in package.resources:
        distribution = DcatResource.from_dp(resource)
        if distribution:
            dcat.distributions.append(distribution)

    return dcat

from_graph(g) classmethod

Source code in dplib/plugins/dcat/models/package.py 
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
@classmethod
def from_graph(cls, g: Graph):
    package = DcatPackage()

    # Identifier
    id = loaders.id(g, predicate=ns.TYPE, object=ns.DATASET)
    if not id:
        raise Error(f"Cannot load DCAT package without identifier: {g}")
    package.identifier = str(id)

    # Accural periodicity
    periodicity = loaders.string(g, subject=id, predicate=ns.ACCURAL_PERIODICITY)
    if periodicity:
        package.accural_periodicity = periodicity

    # Alternate identifiers
    identifiers = loaders.strings(g, subject=id, predicate=ns.ALTERNATE_IDENTIFIER)
    if identifiers:
        package.alternate_identifiers = identifiers

    # Conforms to
    conforms_to = loaders.strings(g, subject=id, predicate=ns.COMFORMS_TO)
    if conforms_to:
        package.comforms_to = conforms_to

    # Description
    description = loaders.string(g, subject=id, predicate=ns.DESCRIPTION)
    if description:
        package.description = description

    # Has versions
    has_versions = loaders.strings(g, subject=id, predicate=ns.HAS_VERSION)
    if has_versions:
        package.has_versions = has_versions

    # Homepage
    homepage = loaders.string(g, subject=id, predicate=ns.HOMEPAGE)
    if homepage:
        package.homepage = homepage

    # Issued
    issued = loaders.string(g, subject=id, predicate=ns.ISSUED)
    if issued:
        package.issued = issued

    # Is version of
    is_version_of = loaders.strings(g, subject=id, predicate=ns.IS_VERSION_OF)
    if is_version_of:
        package.is_version_of = is_version_of

    # Keywords
    keywords = loaders.strings(g, subject=id, predicate=ns.KEYWORD)
    if keywords:
        package.keywords = keywords

    # Landing page
    landing_page = loaders.string(g, subject=id, predicate=ns.LANDING_PAGE)
    if landing_page:
        package.landing_page = landing_page

    # Languages
    languages = loaders.strings(g, subject=id, predicate=ns.LANGUAGE)
    if languages:
        package.languages = languages

    # Modified
    modified = loaders.string(g, subject=id, predicate=ns.MODIFIED)
    if modified:
        package.modified = modified

    # Pages
    pages = loaders.strings(g, subject=id, predicate=ns.PAGE)
    if pages:
        package.pages = pages

    # Provenance
    provenance = loaders.string(g, subject=id, predicate=ns.PROVENANCE)
    if provenance:
        package.provenance = provenance

    # Related resources
    related_resources = loaders.strings(g, subject=id, predicate=ns.RELATED_RESOURCE)
    if related_resources:
        package.related_resources = related_resources

    # Samples
    samples = loaders.strings(g, subject=id, predicate=ns.SAMPLE)
    if samples:
        package.samples = samples

    # Sources
    sources = loaders.strings(g, subject=id, predicate=ns.SOURCE)
    if sources:
        package.sources = sources

    # Themes
    themes = loaders.strings(g, subject=id, predicate=ns.THEME)
    if themes:
        package.themes = themes

    # Title
    title = loaders.string(g, subject=id, predicate=ns.TITLE)
    if title:
        package.title = title

    # Version
    version = loaders.string(g, subject=id, predicate=ns.VERSION)
    if version:
        package.version = version

    # Distributions
    distributions = g.objects(subject=id, predicate=ns.DISTRIBUTION)
    for distribution in distributions:
        if isinstance(distribution, (URIRef, BNode)):
            resource = DcatResource.from_graph(g, id=distribution)
            package.distributions.append(resource)

    return package

from_text(text, *, format, **kwargs) classmethod

Source code in dplib/plugins/dcat/models/package.py 
54
55
56
57
58
@classmethod
def from_text(cls, text: str, *, format: str, **kwargs: Any):
    g = Graph()
    g.parse(data=text, format=format)
    return cls.from_graph(g)

to_dp()

Convert to Data Package

Returns:

Type Description
Package

Data Package
Source code in dplib/plugins/dcat/models/package.py 
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
def to_dp(self) -> Package:
    """Convert to Data Package

    Returns:
       Data Package
    """
    package = Package()

    # Id
    if self.identifier:
        package.id = self.identifier

    # Title
    if self.title:
        package.title = self.title

    # Description
    if self.description:
        package.description = self.description

    # Version
    if self.version:
        package.version = self.version

    # Homepage
    if self.homepage:
        package.homepage = self.homepage

    # Created
    if self.issued:
        if "T" in self.issued:
            package.created = self.issued

    # Keywords
    for keyword in self.keywords:
        package.keywords.append(keyword)

    # Sources
    for source in self.sources:
        source = Source(title=source)
        package.sources.append(source)

    # Resources
    for distribution in self.distributions:
        resource = distribution.to_dp()
        if resource:
            package.resources.append(resource)

    return package

to_graph()

Source code in dplib/plugins/dcat/models/package.py 
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
def to_graph(self):
    g = Graph()
    for prefix, namespace in ns.BINDINGS.items():
        g.bind(prefix, namespace)

    # Identifier
    if not self.identifier:
        raise Error(f"Cannot dump DCAT package without identifier: {self}")
    id = dumpers.id(g, self.identifier, predicate=ns.TYPE, object=ns.DATASET)

    # Accural periodicity
    if self.accural_periodicity:
        dumpers.node(
            g, self.accural_periodicity, subject=id, predicate=ns.ACCURAL_PERIODICITY
        )

    # Alternate identifiers
    for identifier in self.alternate_identifiers:
        dumpers.node(g, identifier, subject=id, predicate=ns.ALTERNATE_IDENTIFIER)

    # Conforms to
    for conforms_to in self.comforms_to:
        dumpers.node(g, conforms_to, subject=id, predicate=ns.COMFORMS_TO)

    # Description
    if self.description:
        dumpers.node(g, self.description, subject=id, predicate=ns.DESCRIPTION)

    # Has versions
    for has_version in self.has_versions:
        dumpers.node(g, has_version, subject=id, predicate=ns.HAS_VERSION)

    # Homepage
    if self.homepage:
        dumpers.node(g, self.homepage, subject=id, predicate=ns.HOMEPAGE)

    # Issued
    if self.issued:
        dumpers.node(g, self.issued, subject=id, predicate=ns.ISSUED)

    # Is version of
    for is_version_of in self.is_version_of:
        dumpers.node(g, is_version_of, subject=id, predicate=ns.IS_VERSION_OF)

    # Keywords
    for keyword in self.keywords:
        dumpers.node(g, keyword, subject=id, predicate=ns.KEYWORD)

    # Landing page
    if self.landing_page:
        dumpers.node(g, self.landing_page, subject=id, predicate=ns.LANDING_PAGE)

    # Languages
    for language in self.languages:
        dumpers.node(g, language, subject=id, predicate=ns.LANGUAGE)

    # Modified
    if self.modified:
        dumpers.node(g, self.modified, subject=id, predicate=ns.MODIFIED)

    # Pages
    for page in self.pages:
        dumpers.node(g, page, subject=id, predicate=ns.PAGE)

    # Provenance
    if self.provenance:
        dumpers.node(g, self.provenance, subject=id, predicate=ns.PROVENANCE)

    # Related resources
    for related_resource in self.related_resources:
        dumpers.node(g, related_resource, subject=id, predicate=ns.RELATED_RESOURCE)

    # Samples
    for sample in self.samples:
        dumpers.node(g, sample, subject=id, predicate=ns.SAMPLE)

    # Sources
    for source in self.sources:
        dumpers.node(g, source, subject=id, predicate=ns.SOURCE)

    # Themes
    for theme in self.themes:
        dumpers.node(g, theme, subject=id, predicate=ns.THEME)

    # Title
    if self.title:
        dumpers.node(g, self.title, subject=id, predicate=ns.TITLE)

    # Version
    if self.version:
        dumpers.node(g, self.version, subject=id, predicate=ns.VERSION)

    # Distributions
    for distribution in self.distributions:
        distribution_id = BNode()
        g.add((id, ns.DISTRIBUTION, distribution_id))
        g.add((distribution_id, ns.TYPE, ns.DISTRIBUTION))
        distribution.to_graph(g, id=distribution_id)

    return g

to_text(*, format)

Source code in dplib/plugins/dcat/models/package.py 
50
51
52
def to_text(self, *, format: str):
    g = self.to_graph()
    return g.serialize(format=format)

dplib.plugins.dcat.models.DcatResource

Bases: Model

DCAT Resource model

Source code in dplib/plugins/dcat/models/resource.py 
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
class DcatResource(Model):
    """DCAT Resource model"""

    access_url: Optional[str] = None
    byte_size: Optional[int] = None
    conforms_to: List[str] = []
    description: Optional[str] = None
    download_url: Optional[str] = None
    issued: Optional[str] = None
    languages: List[str] = []
    license: Optional[str] = None
    media_type: Optional[str] = None
    modified: Optional[str] = None
    pages: List[str] = []
    title: Optional[str] = None

    # Converters

    def to_graph(self, g: Graph, *, id: BNode):
        # Access URL
        if self.access_url:
            dumpers.node(g, self.access_url, subject=id, predicate=ns.ACCESS_URL)

        # Byte size
        if self.byte_size:
            dumpers.node(g, self.byte_size, subject=id, predicate=ns.BYTE_SIZE)

        # Conforms to
        for conforms_to in self.conforms_to:
            dumpers.node(g, conforms_to, subject=id, predicate=ns.COMFORMS_TO)

        # Description
        if self.description:
            dumpers.node(g, self.description, subject=id, predicate=ns.DESCRIPTION)

        # Download URL
        if self.download_url:
            dumpers.node(g, self.download_url, subject=id, predicate=ns.DOWNLOAD_URL)

        # Issued
        if self.issued:
            dumpers.node(g, self.issued, subject=id, predicate=ns.ISSUED)

        # Languages
        for language in self.languages:
            dumpers.node(g, language, subject=id, predicate=ns.LANGUAGE)

        # License
        if self.license:
            dumpers.node(g, self.license, subject=id, predicate=ns.LICENSE)

        # Media type
        if self.media_type:
            dumpers.node(g, self.media_type, subject=id, predicate=ns.MEDIA_TYPE)

        # Modified
        if self.modified:
            dumpers.node(g, self.modified, subject=id, predicate=ns.MODIFIED)

        # Pages
        for page in self.pages:
            dumpers.node(g, page, subject=id, predicate=ns.PAGE)

        # Title
        if self.title:
            dumpers.node(g, self.title, subject=id, predicate=ns.TITLE)

        return g

    @classmethod
    def from_graph(cls, g: Graph, *, id: ISubject) -> DcatResource:
        resource = DcatResource()

        # Access URL
        access_url = loaders.string(g, subject=id, predicate=ns.ACCESS_URL)
        if access_url:
            resource.access_url = access_url

        # Byte size
        byte_size = loaders.integer(g, subject=id, predicate=ns.BYTE_SIZE)
        if byte_size:
            resource.byte_size = byte_size

        # Conforms to
        conforms_to = loaders.strings(g, subject=id, predicate=ns.COMFORMS_TO)
        if conforms_to:
            resource.conforms_to = conforms_to

        # Description
        description = loaders.string(g, subject=id, predicate=ns.DESCRIPTION)
        if description:
            resource.description = description

        # Download URL
        download_url = loaders.string(g, subject=id, predicate=ns.DOWNLOAD_URL)
        if download_url:
            resource.download_url = download_url

        # Issued
        issued = loaders.string(g, subject=id, predicate=ns.ISSUED)
        if issued:
            resource.issued = issued

        # Languages
        languages = loaders.strings(g, subject=id, predicate=ns.LANGUAGE)
        if languages:
            resource.languages = languages

        # License
        license = loaders.string(g, subject=id, predicate=ns.LICENSE)
        if license:
            resource.license = license

        # Media type
        media_type = loaders.string(g, subject=id, predicate=ns.MEDIA_TYPE)
        if media_type:
            resource.media_type = media_type

        # Modified
        modified = loaders.string(g, subject=id, predicate=ns.MODIFIED)
        if modified:
            resource.modified = modified

        # Pages
        pages = loaders.strings(g, subject=id, predicate=ns.PAGE)
        if pages:
            resource.pages = pages

        # Title
        title = loaders.string(g, subject=id, predicate=ns.TITLE)
        if title:
            resource.title = title

        return resource

    def to_dp(self) -> Optional[Resource]:
        """Convert to Data Package resource

        Returns:
           Data Resource
        """
        if not self.download_url:
            return
        resource = Resource(path=self.download_url, name=slugify_name(self.download_url))

        # Title
        if self.title:
            resource.title = self.title

        # Description
        if self.description:
            resource.description = self.description

        # Media type
        if self.media_type:
            resource.mediatype = self.media_type

        # Bytes
        if self.byte_size:
            resource.bytes = self.byte_size

        # Licenses
        if self.license:
            license = License(path=self.license)
            resource.licenses.append(license)

        return resource

    @classmethod
    def from_dp(cls, resource: Resource) -> Optional[DcatResource]:
        """Create DCAT Resource from Data Resource

        Parameters:
            resource: Data Resource

        Returns:
            DCAT Resource
        """
        dcat = DcatResource()
        if not resource.path or not isinstance(resource.path, str):
            return

        # Download URL
        # TODO: improve logic -- use basepath and allow only urls
        if resource.path:
            dcat.download_url = resource.path

        # Title
        if resource.title:
            dcat.title = resource.title

        # Description
        if resource.description:
            dcat.description = resource.description

        # Media type
        if resource.mediatype:
            dcat.media_type = resource.mediatype

        # Bytes
        if resource.bytes:
            dcat.byte_size = resource.bytes

        # Licenses
        if resource.licenses:
            license = resource.licenses[0]
            if license.path:
                dcat.license = license.path

        return dcat

access_url: Optional[str] = None class-attribute instance-attribute

byte_size: Optional[int] = None class-attribute instance-attribute

conforms_to: List[str] = [] class-attribute instance-attribute

description: Optional[str] = None class-attribute instance-attribute

download_url: Optional[str] = None class-attribute instance-attribute

issued: Optional[str] = None class-attribute instance-attribute

languages: List[str] = [] class-attribute instance-attribute

license: Optional[str] = None class-attribute instance-attribute

media_type: Optional[str] = None class-attribute instance-attribute

modified: Optional[str] = None class-attribute instance-attribute

pages: List[str] = [] class-attribute instance-attribute

title: Optional[str] = None class-attribute instance-attribute

from_dp(resource) classmethod

Create DCAT Resource from Data Resource

Parameters:

Name Type Description Default
resource Resource

Data Resource

 required

Returns:

Type Description
Optional[DcatResource]

DCAT Resource
Source code in dplib/plugins/dcat/models/resource.py 
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
@classmethod
def from_dp(cls, resource: Resource) -> Optional[DcatResource]:
    """Create DCAT Resource from Data Resource

    Parameters:
        resource: Data Resource

    Returns:
        DCAT Resource
    """
    dcat = DcatResource()
    if not resource.path or not isinstance(resource.path, str):
        return

    # Download URL
    # TODO: improve logic -- use basepath and allow only urls
    if resource.path:
        dcat.download_url = resource.path

    # Title
    if resource.title:
        dcat.title = resource.title

    # Description
    if resource.description:
        dcat.description = resource.description

    # Media type
    if resource.mediatype:
        dcat.media_type = resource.mediatype

    # Bytes
    if resource.bytes:
        dcat.byte_size = resource.bytes

    # Licenses
    if resource.licenses:
        license = resource.licenses[0]
        if license.path:
            dcat.license = license.path

    return dcat

from_graph(g, *, id) classmethod

Source code in dplib/plugins/dcat/models/resource.py 
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
@classmethod
def from_graph(cls, g: Graph, *, id: ISubject) -> DcatResource:
    resource = DcatResource()

    # Access URL
    access_url = loaders.string(g, subject=id, predicate=ns.ACCESS_URL)
    if access_url:
        resource.access_url = access_url

    # Byte size
    byte_size = loaders.integer(g, subject=id, predicate=ns.BYTE_SIZE)
    if byte_size:
        resource.byte_size = byte_size

    # Conforms to
    conforms_to = loaders.strings(g, subject=id, predicate=ns.COMFORMS_TO)
    if conforms_to:
        resource.conforms_to = conforms_to

    # Description
    description = loaders.string(g, subject=id, predicate=ns.DESCRIPTION)
    if description:
        resource.description = description

    # Download URL
    download_url = loaders.string(g, subject=id, predicate=ns.DOWNLOAD_URL)
    if download_url:
        resource.download_url = download_url

    # Issued
    issued = loaders.string(g, subject=id, predicate=ns.ISSUED)
    if issued:
        resource.issued = issued

    # Languages
    languages = loaders.strings(g, subject=id, predicate=ns.LANGUAGE)
    if languages:
        resource.languages = languages

    # License
    license = loaders.string(g, subject=id, predicate=ns.LICENSE)
    if license:
        resource.license = license

    # Media type
    media_type = loaders.string(g, subject=id, predicate=ns.MEDIA_TYPE)
    if media_type:
        resource.media_type = media_type

    # Modified
    modified = loaders.string(g, subject=id, predicate=ns.MODIFIED)
    if modified:
        resource.modified = modified

    # Pages
    pages = loaders.strings(g, subject=id, predicate=ns.PAGE)
    if pages:
        resource.pages = pages

    # Title
    title = loaders.string(g, subject=id, predicate=ns.TITLE)
    if title:
        resource.title = title

    return resource

to_dp()

Convert to Data Package resource

Returns:

Type Description
Optional[Resource]

Data Resource
Source code in dplib/plugins/dcat/models/resource.py 
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
def to_dp(self) -> Optional[Resource]:
    """Convert to Data Package resource

    Returns:
       Data Resource
    """
    if not self.download_url:
        return
    resource = Resource(path=self.download_url, name=slugify_name(self.download_url))

    # Title
    if self.title:
        resource.title = self.title

    # Description
    if self.description:
        resource.description = self.description

    # Media type
    if self.media_type:
        resource.mediatype = self.media_type

    # Bytes
    if self.byte_size:
        resource.bytes = self.byte_size

    # Licenses
    if self.license:
        license = License(path=self.license)
        resource.licenses.append(license)

    return resource

to_graph(g, *, id)

Source code in dplib/plugins/dcat/models/resource.py 
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
def to_graph(self, g: Graph, *, id: BNode):
    # Access URL
    if self.access_url:
        dumpers.node(g, self.access_url, subject=id, predicate=ns.ACCESS_URL)

    # Byte size
    if self.byte_size:
        dumpers.node(g, self.byte_size, subject=id, predicate=ns.BYTE_SIZE)

    # Conforms to
    for conforms_to in self.conforms_to:
        dumpers.node(g, conforms_to, subject=id, predicate=ns.COMFORMS_TO)

    # Description
    if self.description:
        dumpers.node(g, self.description, subject=id, predicate=ns.DESCRIPTION)

    # Download URL
    if self.download_url:
        dumpers.node(g, self.download_url, subject=id, predicate=ns.DOWNLOAD_URL)

    # Issued
    if self.issued:
        dumpers.node(g, self.issued, subject=id, predicate=ns.ISSUED)

    # Languages
    for language in self.languages:
        dumpers.node(g, language, subject=id, predicate=ns.LANGUAGE)

    # License
    if self.license:
        dumpers.node(g, self.license, subject=id, predicate=ns.LICENSE)

    # Media type
    if self.media_type:
        dumpers.node(g, self.media_type, subject=id, predicate=ns.MEDIA_TYPE)

    # Modified
    if self.modified:
        dumpers.node(g, self.modified, subject=id, predicate=ns.MODIFIED)

    # Pages
    for page in self.pages:
        dumpers.node(g, page, subject=id, predicate=ns.PAGE)

    # Title
    if self.title:
        dumpers.node(g, self.title, subject=id, predicate=ns.TITLE)

    return g