dataverse-utils 0.22.4__tar.gz → 0.22.7__tar.gz

{dataverse_utils-0.22.4 → dataverse_utils-0.22.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataverse-utils
-Version: 0.22.4
+Version: 0.22.7
 Summary: Utilities for the Dataverse data respository system
 License: MIT
 License-File: LICENCE.md
@@ -16,14 +16,14 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: bs4 (>=0.0.2,<0.0.3)
-Requires-Dist: chardet (>=5.2,<5.3)
+Requires-Dist: chardet (>=5.2)
 Requires-Dist: dryad2dataverse (>=0.8.4,<0.9.0)
 Requires-Dist: markdown (>=3.10.2,<4.0.0)
 Requires-Dist: markdown-pdf (>=1.13.1,<2.0.0)
 Requires-Dist: markdownify (>=1.2.2,<2.0.0)
 Requires-Dist: pyreadr (>=0.5.4,<0.6.0)
 Requires-Dist: pyreadstat (>=1.3.3,<2.0.0)
-Requires-Dist: requests (>=2.30.0,<3.0.0)
+Requires-Dist: requests (>=2.33,<3.0)
 Requires-Dist: requests-toolbelt (>=1.0.0,<2.0.0)
 Requires-Dist: tqdm (>=4.67.3,<5.0.0)
 Project-URL: Homepage, https://ubc-library-rc.github.io/dataverse_utils

{dataverse_utils-0.22.4 → dataverse_utils-0.22.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dataverse-utils"
-version = "0.22.4"
+version = "0.22.7"
 description = "Utilities for the Dataverse data respository system"
 authors = [
     {name = "Paul Lesack",email = "paul.lesack@ubc.ca"}
@@ -10,7 +10,6 @@ readme = "README.md"
 requires-python = ">=3.10, <4.0"
 #When requests 2.33 is released, update poetry and release
 dependencies = [
-    "requests (>=2.30.0,<3.0.0)",
     "bs4 (>=0.0.2,<0.0.3)",
     "markdown (>=3.10.2,<4.0.0)",
     "markdown-pdf (>=1.13.1,<2.0.0)",
@@ -20,7 +19,8 @@ dependencies = [
     "requests-toolbelt (>=1.0.0,<2.0.0)",
     "tqdm (>=4.67.3,<5.0.0)",
     "dryad2dataverse (>=0.8.4,<0.9.0)",
-    "chardet (>=5.2,<5.3)"
+    "chardet (>=5.2)",
+    "requests (>=2.33,<3.0)"
 ]
 #Chardet and requests will need to be changed when requests goes to 2.32; at that
 #point just remove chardet 

{dataverse_utils-0.22.4 → dataverse_utils-0.22.7}/src/dataverse_utils/__init__.py

@@ -7,7 +7,7 @@ import pathlib
 import sys
 from dataverse_utils.dataverse_utils import *
 
-VERSION = (0, 22, 4)
+VERSION = (0, 22, 7)
 __version__ = '.'.join([str(x) for x in VERSION])
 
 USERAGENT = (f'dataverse_utils/v{__version__} ({sys.platform.capitalize()}); '
@@ -15,14 +15,14 @@ USERAGENT = (f'dataverse_utils/v{__version__} ({sys.platform.capitalize()}); '
 UAHEADER = {'User-agent' : USERAGENT}
 
 SCRIPT_VERSIONS={
-'dv_collection_info' : (0, 1, 3),
+'dv_collection_info' : (0, 3, 0),
 'dv_del' : (0, 2, 4),
-'dv_ldc_uploader' : (0, 3, 0),
+'dv_ldc_uploader' : (0, 4, 1),
 'dv_list_files' : (0, 1, 1),
 'dv_manifest_gen' : (0, 5, 1),
 'dv_pg_facet_date' : (0, 1, 1),
 'dv_record_copy' : (0, 1, 2),
-'dv_release' : (0, 1, 2),
+'dv_release' : (0, 1, 3),
 'dv_replace_licence' : (0, 1, 1),
 'dv_readme_creator' : (0, 1, 1),
 'dv_study_migrator' : (0, 4, 1),

{dataverse_utils-0.22.4 → dataverse_utils-0.22.7}/src/dataverse_utils/collections.py

@@ -9,6 +9,7 @@ import io
 import logging
 import pathlib
 import string
+import sys
 import tempfile
 import textwrap
 import typing
@@ -80,11 +81,25 @@ class DvCollection:
             self.retry_strategy = RETRY
         else:
             self.retry_strategy = kwargs['retry']
+        self.collections = None
         self.session = requests.Session()
         self.session.mount('https://',
                            requests.adapters.HTTPAdapter(max_retries=self.retry_strategy))
-        self.collections = None
         self.studies = None
+        self.__root = None
+        self.all_colls = [self.root]
+
+    @property
+    def root(self):
+        '''
+        Return the name and short name of the top level collection
+        '''
+        if not self.__root:
+            x = self.session.get(f'{self.url}/api/dataverses/{self.coll}',
+                                 headers=self.headers)
+            x.raise_for_status()
+            self.__root = (x.json()['data']['name'], x.json()['data']['alias'])
+        return self.__root
 
     def __clean_url(self, badurl:str):
         '''
@@ -142,7 +157,6 @@ class DvCollection:
                     out=self.__get_shortname(_['id'])
                     dvs.append((_['title'], out))
                 except Exception as e:
-
                     obscure_error = f'''
                                         An error has occured where a collection can be
                                         identified by ID but its name cannot be determined.
@@ -155,12 +169,13 @@ class DvCollection:
 
                                         Problematic collection id number: {_.get("id",
                                         "not available")}'''
-                    print(50*'-')
-                    print(textwrap.dedent(obscure_error))
+                    #to sys.stdout?
+                    print(50*'-', file=sys.stderr)
+                    print(textwrap.dedent(obscure_error), file=sys.stderr)
                     print(e)
                     LOGGER.error(textwrap.fill(textwrap.dedent(obscure_error).strip()))
                     traceback.print_exc()
-                    print(50*'-')
+                    print(50*'-', file=sys.stderr)
                     raise e
         #---
         if not dvs:
@@ -171,6 +186,7 @@ class DvCollection:
             LOGGER.debug('recursive')
             self.get_collections(dv[1], output)
         self.collections = output
+        self.collections.append(self.root)
         return output
 
     def get_studies(self, root:str=None):
@@ -186,9 +202,8 @@ class DvCollection:
         if not root:
             root=self.coll
         all_studies = self.get_collection_listing(root)
-        #collections = self.get_collections(root, self.url)
         collections = self.get_collections(root)
-        for collection in collections:
+        for collection in tqdm.tqdm(collections):
             all_studies.extend(self.get_collection_listing(collection[1]))
         self.studies = all_studies
         return all_studies
@@ -207,12 +222,16 @@ class DvCollection:
         cl.raise_for_status()
         pids = [f"{z['protocol']}:{z['authority']}/{z['identifier']}"
                 for z in cl.json()['data'] if z['type'] == 'dataset']
-        out = [(self.get_study_info(pid), pid) for pid in pids]
+        #Pass collection info into the study because that's not available from
+        #a metadata download
+        smkwargs = [{'collection_name':_[0] , 'collection_short_name':_[1]}
+                    for _ in self.collections if coll_id == _[1]][0]
+        out = [(self.get_study_info(pid, **smkwargs), pid) for pid in pids]
         for _ in out:
             _[0].update({'pid': _[1]})
         return [x[0] for x in out]
 
-    def get_study_info(self, pid):
+    def get_study_info(self, pid, **kwargs):
         '''
         Returns a StudyMetadata object with complete metadata for a study.
 
@@ -220,13 +239,16 @@ class DvCollection:
         ----------
         pid : str
             Persistent ID of a Dataverse study
+
+        **kwargs
+            Other useful information to pass onto StudyMetadata, such as collection info, etc.
         '''
         meta = self.session.get(f'{self.url}/api/datasets/:persistentId',
                             params={'persistentId': pid},
                             headers=self.headers)
         meta.raise_for_status()
         LOGGER.debug(pid)
-        return StudyMetadata(study_meta=meta.json(), key=self.__key, url=self.url)
+        return StudyMetadata(study_meta=meta.json(), key=self.__key, url=self.url, **kwargs)
 
 class StudyMetadata(dict):
     '''
@@ -268,6 +290,10 @@ class StudyMetadata(dict):
         self.all_versions = None
         self.url = kwargs.get('url')
         self.pid = kwargs.get('pid')
+        #If only there would be an easy way to check if something was deaccessioned
+        #without yet another request. But right now, let's assume it's fine.
+        #See below (under Key Error) where it get set
+        self.deaccession_flag = 0
         if self.study_meta:
             #self.pid = kwargs.get('pid', (f"{self.study_meta['data']['protocol']}:"
             #                         f"{self.study_meta['data']['authority']}"
@@ -286,15 +312,23 @@ class StudyMetadata(dict):
         try:
             self.update(self.extract_metadata(self.study_meta['data']['latestVersion']))
         except KeyError as e:
-            raise MetadataError(f'Unable to parse study metadata. Do you need an API key?\n'
-                           f'{e} key not found.\n'
-                           f'Offending JSON: {self.study_meta}') from e
+            if (self.study_meta.get('status') == 'OK' and not
+                self.study_meta['data'].get('latestVersion')):
+                # Latest version is not available because API strips out all
+                # citation metadata for deaccessioned studies but doesn't
+                # actually indicate this in any obvious manner
+                # This is further complicated because *all* the metadata
+                # we want is in the metadata blocks, which won't exist in the JSON
+                # because for some idiotic reason it's OK to expose it in the GUI
+                # but not via API.
+                self.deaccession_flag = 1
+            else:
+                raise MetadataError(f'Unable to parse study metadata. Do you need an API key?\n'
+                               f'{e} key not found.\n'
+                               f'Offending JSON: {self.study_meta}') from e
         self.__files = None
         self.__all_files = None
-        #self.index = {f"{_['versionNumber']}.{_['versionMinorNumber']}": n
-        #         for n, _ in enumerate(self.all_versions['data'])}
-        #self.index = {_: n for _, n in enumerate(self.versions)}
-        self.index = dict(enumerate(self.versions))
+        self.index = {_: n for n, _ in enumerate(self.versions)}
 
     def __obtain_metadata(self):
         '''
@@ -354,6 +388,10 @@ class StudyMetadata(dict):
             tmp['versionStatement'] = f"{chunk['versionNumber']}.{chunk['versionMinorNumber']}"
         else:
             tmp['versionStatement'] = f"{chunk.get('versionState', '')}"
+
+        for _ in ['collection_name', 'collection_short_name']:
+            if self.kwargs.get(_):
+                tmp[_] = self.kwargs[_]
         return tmp
 
     def extract_field_metadata(self, field):
@@ -549,7 +587,7 @@ class StudyMetadata(dict):
 
         files = [self.flatten(_) for _ in filelist]
         for ff in files:
-            ff.update({'dataset_persistentId': self.pid})
+            ff.update({'dataset_pid': self.pid})
         return files
 
     def __extract_files(self):
@@ -560,9 +598,11 @@ class StudyMetadata(dict):
         #but files would (usually) be an arbitrary number of files.
         #That bothers me on an intellectual level. Therefore, it will be attribute.
         #Iterate over StudyMetadata.files if you want to know the contents
-        if not self.__files:
+        if not self.__files and not self.deaccession_flag:
             self.__files = self.extract_files(self.study_meta['data']
                                                    ['latestVersion']['files'])
+        if self.deaccession_flag:
+            self.__files = []
 
     def __extract_licence_info(self, indict)->dict:
         '''
@@ -695,7 +735,6 @@ class ReadmeCreator:
             return f'{inkey}:  \n'
         return f'{inkey}: '
 
-
     def __extract_files(self):
         '''
         Extract file level metadata, and write to self.__files.

{dataverse_utils-0.22.4 → dataverse_utils-0.22.7}/src/dataverse_utils/ldc.py

@@ -14,6 +14,7 @@ import requests
 from requests.adapters import HTTPAdapter
 from bs4 import BeautifulSoup as bs
 import dryad2dataverse.serializer as ds
+import dryad2dataverse.config as dc
 from dataverse_utils import UAHEADER
 
 #pylint: disable=invalid-name
@@ -29,7 +30,7 @@ class Ldc(ds.Serializer):#pylint: disable=too-many-instance-attributes
     An LDC item (eg, LDC2021T01)
     '''
     #pylint: disable=super-init-not-called, arguments-differ
-    def __init__(self, ldc, cert=None):
+    def __init__(self, ldc, cert=None, **kwargs):
         '''
         Returns a dict with keys created from an LDC catalogue web
         page.
@@ -54,10 +55,11 @@ class Ldc(ds.Serializer):#pylint: disable=too-many-instance-attributes
         self.cert = cert
         self.session = requests.Session()
         self.session.mount('https://',
-                           HTTPAdapter(max_retries=ds.constants.RETRY_STRATEGY))
+                           HTTPAdapter(max_retries=dc.RETRY_STRATEGY))
         if self.cert:
             self.cert = os.path.expanduser(self.cert)
         self.__fixdesc = None
+        self.kwargs = kwargs
 
     @property
     def ldcJson(self):
@@ -120,7 +122,7 @@ class Ldc(ds.Serializer):#pylint: disable=too-many-instance-attributes
         '''
         #pylint: disable=property-with-parameters
         if not maxsize:
-            maxsize = ds.constants.MAX_UPLOAD
+            maxsize = self.kwargs.get('max_upload', 68719476736)
 
     @property
     def id(self):
@@ -129,7 +131,7 @@ class Ldc(ds.Serializer):#pylint: disable=too-many-instance-attributes
         '''
         return self.ldc
 
-    def fetch_record(self, timeout=45):
+    def fetch_ldc_record(self, timeout=45):
         '''
         Downloads record from LDC website
 
@@ -150,7 +152,7 @@ class Ldc(ds.Serializer):#pylint: disable=too-many-instance-attributes
         page.
         '''
         if not self.ldcHtml:
-            self.fetch_record()
+            self.fetch_ldc_record()
         soup = bs(self.ldcHtml, 'html.parser')
         #Should data just look in the *first* table? Specifically tbody?
         #Is it always the first? I assume yes.

{dataverse_utils-0.22.4 → dataverse_utils-0.22.7}/src/dataverse_utils/scripts/dv_collection_info.py

@@ -5,8 +5,12 @@ outputs study metadata for the latest version
 import argparse
 import io
 import csv
+import pathlib
+import sqlite3
 import sys
 import textwrap
+
+import pandas as pd # I could use sqlite but why go the hassle
 import dataverse_utils
 import dataverse_utils.collections as dvc
 
@@ -19,11 +23,14 @@ def parse() -> argparse.ArgumentParser():
     description = textwrap.fill(textwrap.dedent(
                    '''
                    Recursively parses a dataverse collection and
-                   outputs study metadata for the latest version.
+                   outputs study and file metadata for the latest version.
 
                    If analyzing publicly available collections, a
                    dataverse API key for the target system is not
                    required.
+
+                   Study and file output can be joined on 'pid' (studies) and
+                   'dataset_pid' (files).
                    '''), 80)
     parser = argparse.ArgumentParser(description=description,
                                      formatter_class=argparse.RawTextHelpFormatter)
@@ -32,27 +39,24 @@ def parse() -> argparse.ArgumentParser():
                               'defaults to "https://abacus.library.ubc.ca"'))
     parser.add_argument('-k', '--key', required=False,
                         help='API key', default=None)
+    parser.add_argument('output',
+                        help=textwrap.fill(textwrap.dedent(
+                        '''
+                        Output file name prefix. If tsv output is chosen,
+                        files will be saved as [prefix]_studies.tsv
+                        and [prefix]_files.tsv.
+
+                        If SQLite output is chosen, it will be a single file file: [prefix].sqlite3.
+                        '''),80))
     parser.add_argument('-d', '--delimiter', required=False,
                         help='Delimiter for output spreadsheet. Default: tab (\\t)',
                         default='\t')
-    parser.add_argument('-f', '--fields',
-                        help=textwrap.fill(('Record metadata fields to output. '
-                              'For all fields, use "all". '
-                              'Default: title, author. for '
-                              'study metadata and file label, id for file metadata' )),
-                        nargs='*',
-                        default=['title', 'author', 'label', 'dataFile_id'])
-    parser.add_argument('-o', '--output', help='Output file name.',
-                       required=False)
     parser.add_argument('-i','--include-all-versions',
                         help='Include *all** versions, not just the current version',
                         action='store_true')
-    parser.add_argument('--files',
-                        help=textwrap.fill(('Show only the *files* associated with a study.'
-                              'The output will contain the PID of the study '
-                              'and the version (if applicable) so that study metadata '
-                              'and file metadata can be linked')),
-                              action='store_true')
+    parser.add_argument('-s', '--sqlite',
+                        help='Save output as SQLite3 database',
+                        action='store_true')
     group = parser.add_argument_group(title='Harvest options',
                                       description=textwrap.fill(
                                       ' You can obtain info for *either* a recursive crawl '
@@ -64,18 +68,17 @@ def parse() -> argparse.ArgumentParser():
                         help=('Dataverse collection shortname or id at the '
                              'top of the tree'))
     mgroup.add_argument('-p', '--pid',
-                        help=('Dataverse study persistent identifier (DOI/handle)'
-                             'top of the tree'))
+                        help='Dataverse study persistent identifier (DOI/handle)')
     parser.add_argument('-v', '--version', action='version',
                         version=dataverse_utils.script_ver_stmt(parser.prog),
                         help='Show version number and exit')
     return parser
 
-def fields(args:argparse.ArgumentParser, all_studies)->dict:
+def fields(include_all:bool, is_file:bool, all_studies)->dict:
     '''
     Outputs appropriate header fields based on argparse values
     '''
-    match (args.include_all_versions, args.files):
+    match (include_all, is_file):
         case (0, 0):
             fieldnames = sorted(list(set(key for study in all_studies for key in study)))
         case (1, 0):
@@ -104,54 +107,6 @@ def fields(args:argparse.ArgumentParser, all_studies)->dict:
 
     return fieldnames
 
-def fields_no(args:argparse.ArgumentParser, all_studies, fmeta=False)->dict:
-    '''
-    Outputs appropriate header fields based on argparse values
-    '''
-    #print(args)
-    match (args.include_all_versions, args.files, fmeta):
-        case (0, 0, 0):
-            fieldnames = sorted(list(set(key for study in all_studies for key in study)))
-        case (1, 0, 0):
-            fieldnames = sorted(list(set(key for study in all_studies
-                                         for ver in study.versions
-                                         for key in study.version_metadata(ver))))
-        case (0, 1, 0):
-            fieldnames = sorted(list(set(key for study in all_studies
-                                         for file in study.files
-                                         for key in file)))
-        #this is actually an outer join
-        #case (1, 1, 0):
-        #    fieldnames1 = sorted(list(set(key for study in coll_me.studies
-        #                  for ver in study.versions
-        #                  for file in study.version_files(ver)
-        #                  for key in file)))
-        #    fieldnames = sorted(list(set(key for study in coll_me.studies
-        #                                 for ver in study.versions
-        #                                 for key in study.version_metadata(ver))))
-        #    fieldnames.extend(fieldnames1)
-        case (1, 1, 0):
-            fieldnames = sorted(list(set(key for study in all_studies
-                          for ver in study.versions
-                          for file in study.version_files(ver)
-                          for key in file)))
-
-        case (1, 0, 1):
-            fieldnames = sorted(list(set(key for ver in all_studies[0].versions
-                                     for key in all_studies[0].version_metadata(ver))))
-        case (1, 1, 1):
-            fieldnames = sorted(list(set(key
-                      for ver in all_studies[0].versions
-                      for file in all_studies[0].version_files(ver)
-                      for key in file)))
-        case (0, 1, 1):
-            fieldnames = sorted(list(set(key for file in all_studies[0].files
-                                     for key in file)))
-
-        case (0, 0, 1):
-            fieldnames = sorted(list(set(all_studies[0])))
-    return fieldnames
-
 def output(study, include_all=False, file=False)->list:
     '''
     Returns a list of appropriately selected metadata
@@ -162,7 +117,7 @@ def output(study, include_all=False, file=False)->list:
             return [study]
         case (1,0):
             for v in study.versions:
-                out.append(study.study_version_metadata(v))
+                out.append(study.version_metadata(v))
             return out
         case (0,1):
             return study.files
@@ -184,14 +139,24 @@ def output(study, include_all=False, file=False)->list:
         case _:
             return []
 
+def extension(args:argparse.ArgumentParser):
+    '''
+    Return extension for output
+    '''
+    extype ={'\t' : '.tsv',
+             ','  : '.csv'}
+    if args.sqlite:
+        return '.sqlite3'
+    return extype.get(args.delimiter, '.txt')
+
 def main():
     '''
     You know what this is
     '''
-    #pylint: disable=too-many-branches
+    #pylint: disable=too-many-branches, too-many-locals
     args = parse().parse_args()
     if args.collection:
-        coll_me  = dvc.DvCollection(args.url, args.collection, args.key)
+        coll_me = dvc.DvCollection(args.url, args.collection, args.key)
         try:
             coll_me.get_collections()
         except TypeError:
@@ -209,36 +174,59 @@ def main():
         except (KeyError, dataverse_utils.collections.MetadataError) as e:
             print(e, file=sys.stderr)
             sys.exit()
-    #if 'all' in [x.lower() for x in args.fields] and args.collection:
-    #    fieldnames = fields(args, all_studies)
+    fname = {0: '_studies', 1:'_files'}
+    outdata = {}
+    for stud_file in range(2): # studies and files
+        fieldnames= fields(args.include_all_versions, stud_file, all_studies)
+        out = io.StringIO(newline='')
+        writer = csv.DictWriter(out,
+                                fieldnames=fieldnames,
+                                delimiter=args.delimiter,
+                                quoting=csv.QUOTE_MINIMAL,
+                                extrasaction='ignore')
+        writer.writeheader()
+        for stud in all_studies:
+            for row in output(stud, args.include_all_versions, stud_file):
+                data = {k:v.replace('\t',' ').replace('\r\n', ' ').replace('\n',' ')
+                                 if isinstance(v, str) else v
+                                 for k, v in row.items()}
+                writer.writerow(data)
+        out.seek(0)
+        outdata[fname[stud_file][1:]] = out
+        if not args.sqlite:
+            outf =  pathlib.Path(args.output+f'{fname[stud_file]}{extension(args)}').expanduser()
+            with open(outf,
+                       'w', encoding='utf-8') as f:
+                print(f'Writing {str(outf)}', file=sys.stdout)
+                f.write(out.read())
 
-    #if 'all' in [x.lower() for x in args.fields] and args.pid:
-    #    fieldnames = fields(args, all_studies, 1)
-    if 'all' in [x.lower() for x in args.fields]:
-        fieldnames = fields(args, all_studies)
 
-    else:
-        fieldnames =  args.fields[2:] if args.files else args.fields[:2]
-    out = io.StringIO(newline='')
-    writer = csv.DictWriter(out,
-                            fieldnames=fieldnames,
-                            delimiter=args.delimiter,
-                            quoting=csv.QUOTE_MINIMAL,
-                            extrasaction='ignore')
-    writer.writeheader()
-    #for stud in coll_me.studies:
-    for stud in all_studies:
-        for row in output(stud, args.include_all_versions, args.files):
-            writer.writerow({k:v.replace('\t',' ').replace('\r\n', ' ').replace('\n',' ')
-                             if isinstance(v, str) else v
-                             for k, v in row.items()})
-    out.seek(0)
-    if args.output:
-        with open(args.output, mode='w', encoding='utf-8', newline='') as f:
-            f.write(out.read())
-            return
-    else:
-        print(out.read())
+    if args.sqlite:
+        print(f'Writing {str(pathlib.Path(args.output+extension(args)).expanduser())}',
+              file=sys.stdout)
+        conn = sqlite3.connect(pathlib.Path(args.output+extension(args)).expanduser())
+        for k,v in outdata.items():
+            x=pd.read_csv(v, delimiter=args.delimiter)
+            x.to_sql(k, conn, if_exists='replace', index=0)
+        cursor = conn.cursor()
+        cursor.execute('DROP VIEW IF EXISTS short_combined_view;')
+        query = textwrap.fill(textwrap.dedent(
+                    '''CREATE VIEW short_combined_view AS
+                        SELECT studies.pid AS pid,
+                        studies.authorName AS author,
+                        studies.title AS title,
+                        studies.dateOfDeposit AS deposit_date,
+                        studies.versionStatement AS version_statement,
+                        files.dataFile_filename AS file_name,
+                        files.dataFile_id AS file_id,
+                        files.restricted AS restricted,
+                        files.version AS file_version
+                        FROM studies
+                        INNER JOIN files ON studies.pid = files.dataset_pid;
+                        '''
+                    ),80)
+        cursor.execute(query)
+        conn.close()
 
 if __name__ == '__main__':
     main()

{dataverse_utils-0.22.4 → dataverse_utils-0.22.7}/src/dataverse_utils/scripts/dv_ldc_uploader.py

@@ -6,6 +6,7 @@ python3 uploadme.py LDC20201S01 . . . LDC2021T21 apikey
 '''
 import argparse
 import sys
+import dryad2dataverse.config as dc
 import dataverse_utils as du
 from dataverse_utils import ldc
 
@@ -69,7 +70,7 @@ def parse() -> argparse.ArgumentParser():
 
 def upload_meta(ldccat: str, url: str, key: str,#pylint: disable = too-many-arguments, too-many-positional-arguments
                 dvs: str, verbose: bool = False,
-                certchain: str = None) -> str:
+                certchain: str = None, **kwargs) -> str:
     '''
     Uploads metadata to target dataverse collection. Returns persistentId.
 
@@ -85,9 +86,11 @@ def upload_meta(ldccat: str, url: str, key: str,#pylint: disable = too-many-argu
         Target Dataverse collection short name
     certchain : str
         Path to LDC .PEM certificate chain
+    **kwargs
+        Other parameters, notably dv_contact_email and dv_contact_name
     '''
-    stud = ldc.Ldc(ldccat, cert=certchain)
-    stud.fetch_record()
+    stud = ldc.Ldc(ldccat, cert=certchain, **kwargs)
+    stud.fetch_ldc_record()
     if verbose:
         print(f'Uploading {stud.ldc} metadata')
     info = stud.upload_metadata(url=url, key=key, dv=dvs)
@@ -99,15 +102,16 @@ def main() -> None:
     '''
     parser = parse()
     args = parser.parse_args()
-    ldc.ds.constants.DV_CONTACT_EMAIL = args.email
-    ldc.ds.constants.DV_CONTACT_NAME = args.cname
-    #print(args)
+    dc_config = dc.Config()
+    contact_info={'dv_contact_name' : args.cname,
+                  'dv_contact_email' : args.email}
+    dc_config.update(contact_info)
     if args.tsv:
         if len(args.studies) > 1:
             print('Error: Only one LDC study may be processed with the -t/--tsv option')
             sys.exit()
         pid = upload_meta(args.studies[0], args.url, args.key,
-                          args.dvs, args.verbose, args.certchain)
+                          args.dvs, args.verbose, args.certchain, **dc_config)
         if args.verbose:
             print(f'Uploading files to {pid}')
         with open(args.tsv, encoding='utf-8', newline='') as fil:

{dataverse_utils-0.22.4 → dataverse_utils-0.22.7}/src/dataverse_utils/scripts/dv_release.py

@@ -95,7 +95,6 @@ class Dverse():
         return [x['storageIdentifier'].replace('file://', f'{self.hdl}:') for x in data
                 if x['type'] == 'dataset']
 
-    @property
     def unreleased(self, all_stud: list = None) -> list:
         '''
         Finds only unreleased studies from a list of studies
@@ -208,7 +207,7 @@ def main():
     args = parser.parse_args()
     if args.dv:
         the_dv = Dverse(args.url, args.key, args.dv)
-        un_rel = the_dv.unreleased
+        un_rel = the_dv.unreleased()
     else:
         un_rel = args.pid
     if args.dryrun: