somef_core 0.0.1__tar.gz → 0.0.2__tar.gz

{somef_core-0.0.1 → somef_core-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: somef_core
-Version: 0.0.1
+Version: 0.0.2
 Summary: SOMEF-Core: lightweight metadata extraction engine for software repositories, usable as a CLI tool or as a library, without the ML-based classifiers and ontology detection of the full SOMEF tool.
 License-File: LICENSE
 Author: Daniel Garijo
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: bibtexparser (>=1.4.1,<2.0.0)
+Requires-Dist: bibtexparser (>=2.1.0,<3.0.0)
 Requires-Dist: bs4 (>=0.0.1,<0.0.3)
 Requires-Dist: chardet (>=5.2,<8.0)
 Requires-Dist: click (>=8.1.7,<9.0.0)
@@ -29,16 +29,21 @@ Requires-Dist: numpy (>=1.26.3,<3.0.0)
 Requires-Dist: pandas (>=2.1.4,<3.0.0)
 Requires-Dist: pytest (>=8,<10)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
+Requires-Dist: rapidfuzz (>=3.14.6,<4.0.0)
 Requires-Dist: requests (>=2.34.2,<3.0.0)
 Requires-Dist: scipy (>=1.11.4,<2.0.0)
 Requires-Dist: textblob (>=0.17.1,<0.21.0)
-Requires-Dist: validators (>=0.35.0,<0.36.0)
+Requires-Dist: validators (>=0.35,<0.37)
 Project-URL: homepage, https://github.com/SciCodes/somef-core
 Description-Content-Type: text/markdown
 
 # SOMEF - Core package functionality
 
-SOMEF-Core is the lightweight metadata extraction engine behind SOMEF. It works both as a command line tool and as a reusable library, without the machine learning components (supervised classifiers, ontology detection) that are part of the full SOMEF tool. See the SOMEF repository for the full documentation and ML capabilities.
+[![PyPI version](https://img.shields.io/pypi/v/somef-core.svg)](https://pypi.org/project/somef-core/)
+
+SOMEF-Core is a lightweight export of [SOMEF](https://github.com/KnowledgeCaptureAndDiscovery/somef) (the parent project), containing its core metadata extraction functionality. It works both as a command line tool and as a reusable library, without the machine learning components (supervised classifiers, ontology detection) that are part of the full SOMEF tool. See the SOMEF repository for the full documentation and ML capabilities.
+
+> This release of SOMEF-Core (0.0.2) corresponds to SOMEF [0.11.5](https://github.com/KnowledgeCaptureAndDiscovery/somef/releases/tag/0.11.5).
 
 **Demo:** See a [demo running somef as a service](https://somef.linkeddata.es), through the [SOMEF-Vider tool](https://github.com/SoftwareUnderstanding/SOMEF-Vider/).
 
@@ -96,6 +101,7 @@ When using `-e`, publication metadata is enriched via OpenAlex. We recognize the
 - **Identifier**: Identifier associated with the software (if any), such as Digital Object Identifiers and Software Heritage identifiers (SWH). DOIs associated with publications will also be detected. When using `-e`, the following enrichment identifiers are also added:
 - `openaire_id`: URL to the OpenAIRE explore page for the software
 - `swhid`: Software Heritage identifier (for Zenodo DOIs)
+- `provider`: Name of the identifier provider. For Software Heritage identifiers this is set to Software Heritage. For DOIs registered with DataCite, this is set to the DataCite provider name (e.g., CERN - European Organization for Nuclear Research).
 - **Images**: Images used to illustrate the software component
 - **Installation instructions**: A set of instructions that indicate how to install a target repository
 - **Invocation**: Execution command(s) needed to run a scientific software component
@@ -194,6 +200,18 @@ SOMEF-Core has been tested on Unix, MacOS and Windows Microsoft operating system
 If you face any issues when installing SOME-Core, please make sure you have installed the following packages: `build-essential`, `libssl-dev`, `libffi-dev` and `python3-dev`.
 
 
+## Install from Pypi
+
+SOMEF-Core [is available in Pypi!](https://pypi.org/project/somef-core/) To install it just type:
+
+```
+pip install somef-core
+```
+
+### NLTK data
+
+SOMEF-Core uses [NLTK](https://www.nltk.org/) / WordNet to match README section headers (e.g. "Getting Started", "Citation") against metadata categories. Running `somef_core configure` (see below) takes care of downloading the required NLTK data automatically.
+
 ## Install from GitHub
 
 To run SOMEF, please follow the next steps:

{somef_core-0.0.1 → somef_core-0.0.2}/README.md

@@ -1,6 +1,10 @@
 # SOMEF - Core package functionality
 
-SOMEF-Core is the lightweight metadata extraction engine behind SOMEF. It works both as a command line tool and as a reusable library, without the machine learning components (supervised classifiers, ontology detection) that are part of the full SOMEF tool. See the SOMEF repository for the full documentation and ML capabilities.
+[![PyPI version](https://img.shields.io/pypi/v/somef-core.svg)](https://pypi.org/project/somef-core/)
+
+SOMEF-Core is a lightweight export of [SOMEF](https://github.com/KnowledgeCaptureAndDiscovery/somef) (the parent project), containing its core metadata extraction functionality. It works both as a command line tool and as a reusable library, without the machine learning components (supervised classifiers, ontology detection) that are part of the full SOMEF tool. See the SOMEF repository for the full documentation and ML capabilities.
+
+> This release of SOMEF-Core (0.0.2) corresponds to SOMEF [0.11.5](https://github.com/KnowledgeCaptureAndDiscovery/somef/releases/tag/0.11.5).
 
 **Demo:** See a [demo running somef as a service](https://somef.linkeddata.es), through the [SOMEF-Vider tool](https://github.com/SoftwareUnderstanding/SOMEF-Vider/).
 
@@ -58,6 +62,7 @@ When using `-e`, publication metadata is enriched via OpenAlex. We recognize the
 - **Identifier**: Identifier associated with the software (if any), such as Digital Object Identifiers and Software Heritage identifiers (SWH). DOIs associated with publications will also be detected. When using `-e`, the following enrichment identifiers are also added:
 - `openaire_id`: URL to the OpenAIRE explore page for the software
 - `swhid`: Software Heritage identifier (for Zenodo DOIs)
+- `provider`: Name of the identifier provider. For Software Heritage identifiers this is set to Software Heritage. For DOIs registered with DataCite, this is set to the DataCite provider name (e.g., CERN - European Organization for Nuclear Research).
 - **Images**: Images used to illustrate the software component
 - **Installation instructions**: A set of instructions that indicate how to install a target repository
 - **Invocation**: Execution command(s) needed to run a scientific software component
@@ -156,6 +161,18 @@ SOMEF-Core has been tested on Unix, MacOS and Windows Microsoft operating system
 If you face any issues when installing SOME-Core, please make sure you have installed the following packages: `build-essential`, `libssl-dev`, `libffi-dev` and `python3-dev`.
 
 
+## Install from Pypi
+
+SOMEF-Core [is available in Pypi!](https://pypi.org/project/somef-core/) To install it just type:
+
+```
+pip install somef-core
+```
+
+### NLTK data
+
+SOMEF-Core uses [NLTK](https://www.nltk.org/) / WordNet to match README section headers (e.g. "Getting Started", "Citation") against metadata categories. Running `somef_core configure` (see below) takes care of downloading the required NLTK data automatically.
+
 ## Install from GitHub
 
 To run SOMEF, please follow the next steps:

{somef_core-0.0.1 → somef_core-0.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "somef_core"
-version = "0.0.1"
+version = "0.0.2"
 description = "SOMEF-Core: lightweight metadata extraction engine for software repositories, usable as a CLI tool or as a library, without the ML-based classifiers and ontology detection of the full SOMEF tool."
 authors = ["Daniel Garijo <daniel.garijo@upm.es>"]
 readme = "README.md"
@@ -27,19 +27,20 @@ homepage = "https://github.com/SciCodes/somef-core"
     numpy = ">=1.26.3,<3.0.0"
     pandas = "^2.1.4"
     textblob = ">=0.17.1,<0.21.0"
-    validators = "^0.35.0"
+    validators = ">=0.35,<0.37"
     scipy = "^1.11.4"
     inflect = "^7.0.0"
     contractions = "^0.1.73"
     chardet = ">=5.2,<8.0"
     pytest = ">=8,<10"
-    bibtexparser = "^1.4.1"
+    bibtexparser = "^2.1.0"
     nbformat = "^5.9.2"
     markdown = "^3.5.2"
     requests = "^2.34.2"
     pyyaml = "^6.0.2"
     lxml = "^6.1.1"
     markdown-it-py = ">=3,<5"
+    rapidfuzz = "^3.14.6"
     
 [tool.poetry.scripts]
 somef_core = "somef_core.__main__:cli"

{somef_core-0.0.1 → somef_core-0.0.2}/src/somef_core/__init__.py

@@ -1,3 +1,3 @@
 # -*- coding: utf-8 -*-
 
-__version__ = "0.0.1"
+__version__ = "0.0.2"

{somef_core-0.0.1 → somef_core-0.0.2}/src/somef_core/__main__.py

@@ -111,6 +111,11 @@ def test():
     type=URLParamType(),
     help="Github/Gitlab Repository URL",
 )
+@optgroup.option(
+    "--doi",
+    help="Zenodo DOI or record URL (e.g. https://doi.org/10.5281/zenodo.22943101, "
+         "10.5281/zenodo.22943101or https://zenodo.org/records/22943101)",
+)
 @optgroup.option(
     "--doc_src",
     "-d",

{somef_core-0.0.1 → somef_core-0.0.2}/src/somef_core/header_analysis.py

@@ -5,7 +5,8 @@ import string
 import numpy as np
 import pandas as pd
 from textblob import Word
-
+from rapidfuzz import process
+from rapidfuzz.distance import Levenshtein
 from .process_results import Result
 from .parser import mardown_parser
 from .utils import constants
@@ -306,17 +307,20 @@ def label_text(text: str, similarity_threshold=constants.CONF_DEFAULT_SIMILARITY
     for token in tokenize_header(text):
         synsets = get_synsets(token)
         if synsets:
-            grp = match_group(synsets, similarity_threshold )
+            # grp = match_group(synsets, similarity_threshold )
             # Skip if the header matches a known false positive for this group
-           
-            # if isinstance(text, list):
-            #     text = " ".join(text)
-
-            if is_false_positive_header(text, grp):
-                # print(f"Skipping false positive header '{text}' for category '{grp}'")
-                continue
-            if grp and grp not in labels:
-                labels.append(grp)
+            grp = match_group(synsets, similarity_threshold)
+        else:
+            grp = fuzzy_group(token)
+
+        # if isinstance(text, list):
+        #     text = " ".join(text)
+
+        if is_false_positive_header(text, grp):
+            # print(f"Skipping false positive header '{text}' for category '{grp}'")
+            continue
+        if grp and grp not in labels:
+            labels.append(grp)
     return labels
 
 def is_false_positive_header(text: str, category: str) -> bool:
@@ -710,3 +714,20 @@ def extract_os_from_content(text: str) -> List[dict]:
                 })
 
     return results
+
+def fuzzy_group(token, max_distance=1, min_length=5):
+
+    """
+    Try to match a word to a category, allowing small typos (ej: 'Instalation' would be accpet as 'installation').
+    See the dictionary in constants.
+    """
+
+    t = token.lower()
+    if t in constants.HEADER_VOCABULARY:
+        return constants.HEADER_VOCABULARY[t]
+    if len(t) < min_length:
+        return ""
+    match = process.extractOne(t, constants.HEADER_VOCABULARY.keys(),
+                            scorer=Levenshtein.distance, score_cutoff=max_distance)
+    return constants.HEADER_VOCABULARY[match[0]] if match else ""
+

{somef_core-0.0.1 → somef_core-0.0.2}/src/somef_core/parser/codemeta_parser.py

@@ -642,16 +642,22 @@ def parse_codemeta_json_file(file_path, metadata_result: Result, source):
                 )
 
             if "identifier" in data:
-                metadata_result.add_result(
-                    constants.CAT_IDENTIFIER,
-                    {
-                        "value": data["identifier"],
-                        "type": constants.STRING
-                    },
-                    1,
-                    constants.TECHNIQUE_CODE_CONFIG_PARSER,
-                    source
-                )
+                if isinstance(data["identifier"], list) :
+                    identifiers = data["identifier"]
+                else:
+                    identifiers = [data["identifier"]]
+
+                for identifier in identifiers:
+                    metadata_result.add_result(
+                        constants.CAT_IDENTIFIER,
+                        {
+                            "value": identifier,
+                            "type": constants.STRING
+                        },
+                        1,
+                        constants.TECHNIQUE_CODE_CONFIG_PARSER,
+                        source
+                    )
 
             if "readme" in data:
                 metadata_result.add_result(

{somef_core-0.0.1 → somef_core-0.0.2}/src/somef_core/parser/codeowners_parser.py

@@ -5,6 +5,7 @@ import requests
 from pathlib import Path
 from ..process_results import Result
 from ..utils import constants
+from .. import configuration
 
 def parse_codeowners_structured(dir_path, filename):
     codeowners = []
@@ -159,11 +160,23 @@ def enrich_user(username, repo_type, server_url=None, gitlab_authorization=None)
             # response = requests.get(api_url, timeout=5)
             # Build auth header — same token works for gitlab.com and self-hosted instances
             gl_headers = {}
-            if gitlab_authorization:
-                token = gitlab_authorization
-                if not token.startswith("Bearer "):
-                    token = "Bearer " + token
-                gl_headers["Authorization"] = token
+            token = gitlab_authorization
+            if not token:
+                try:
+                    file_paths = configuration.get_configuration_file()
+                    if constants.CONF_GITLAB_AUTHORIZATION in file_paths:
+                        token = file_paths[constants.CONF_GITLAB_AUTHORIZATION]
+                except Exception:
+                    pass
+            if token and isinstance(token, str):
+                t = token.strip()
+                if t.lower().startswith('bearer '):
+                    t = t[7:].strip()
+                elif t.lower().startswith('token '):
+                    t = t[6:].strip()
+                elif t.lower().startswith('private-token '):
+                    t = t[14:].strip()
+                gl_headers['Authorization'] = f'Bearer {t}'
             response = requests.get(api_url, headers=gl_headers, timeout=5)
             if response.status_code != 200:
                 logging.warning(f"GitLab API request failed for {username}: {response.status_code}")
@@ -180,7 +193,6 @@ def enrich_user(username, repo_type, server_url=None, gitlab_authorization=None)
         except Exception as e:
             logging.error(f"Error enriching GitLab user {username}: {e}")
             return None
-
     elif repo_type == constants.RepositoryType.CODEBERG:
         url = f"https://codeberg.org/api/v1/users/{username}"
         response = requests.get(url, timeout=5)

{somef_core-0.0.1 → somef_core-0.0.2}/src/somef_core/parser/description_parser.py

@@ -211,7 +211,9 @@ def parse_description_file(file_path, metadata_result: Result, source):
                                     "value": req,
                                     "name": name,
                                     "version": version,
-                                    "type": constants.SOFTWARE_DEPENDENCY
+                                    "type": constants.SOFTWARE_DEPENDENCY,
+                                    "dependency_type": constants.DEPENDENCY_TYPE_RUNTIME,
+                                    "dependency_resolver": "cran"
                                 },
                                 1,
                                 constants.TECHNIQUE_CODE_CONFIG_PARSER,

{somef_core-0.0.1 → somef_core-0.0.2}/src/somef_core/parser/gemspec_parser.py

@@ -168,7 +168,9 @@ def parse_gemspec_file(file_path, metadata_result: Result, source):
                             constants.CAT_REQUIREMENTS,
                             {
                                 "value": dependencies,
-                                "type": constants.SOFTWARE_DEPENDENCY
+                                "type": constants.SOFTWARE_DEPENDENCY,
+                                "dependency_type": constants.DEPENDENCY_TYPE_RUNTIME,
+                                "dependency_resolver": "bundler"
                             },
                             1,
                             constants.TECHNIQUE_CODE_CONFIG_PARSER,

{somef_core-0.0.1 → somef_core-0.0.2}/src/somef_core/parser/python_parser.py

@@ -97,7 +97,9 @@ def parse_requirements_txt(file_path, metadata_result: Result, source):
                         req = {
                                 "value": line,
                                 "name": name,
-                                "type": constants.SOFTWARE_DEPENDENCY
+                                "type": constants.SOFTWARE_DEPENDENCY,
+                                "dependency_type": constants.DEPENDENCY_TYPE_RUNTIME,
+                                "dependency_resolver": "pip"
                             }
                         if version:
                             req['version'] = version

somef_core-0.0.2/src/somef_core/parser/zenodo_parser.py

@@ -0,0 +1,162 @@
+import json
+import logging
+from pathlib import Path
+import re
+from ..process_results import Result
+from ..regular_expressions import detect_license_spdx
+from ..utils import constants
+
+
+def parse_zenodo_file(file_path, metadata_result: Result, source):
+    """
+    Parse a .zenodo.json file and extract relevant metadata.
+
+    Parameters
+    ----------
+    file_path: path of the zenodo file being analysed
+    metadata_result: metadata object where the metadata dictionary is kept
+    source: source of the package file (URL)
+
+    Returns
+    -------
+    metadata_result
+    """
+    try:
+        if Path(file_path).name.lower() in [".zenodo.json"]:
+            with open(file_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+
+            if not isinstance(data, dict):
+                return metadata_result
+
+            def add(category, value_dict):
+                metadata_result.add_result(category, value_dict, 1, constants.TECHNIQUE_CODE_CONFIG_PARSER, source)
+
+            if isinstance(data.get("title"), str) and data["title"].strip():
+                add(constants.CAT_NAME, {constants.PROP_VALUE: data["title"].strip(),constants.PROP_TYPE: constants.STRING})
+
+            description = data.get("description")
+            if isinstance(description, str):
+                description = re.sub(constants.REGEXP_CLEAN_HTML_TAGS, '', description).strip()
+                if description:
+                    add(constants.CAT_DESCRIPTION, {constants.PROP_VALUE: description,constants.PROP_TYPE: constants.STRING})
+
+            if data.get("version"):
+                add(constants.CAT_VERSION, {constants.PROP_VALUE: str(data["version"]).strip(), constants.PROP_TYPE: constants.STRING})
+
+            keywords = data.get("keywords")
+            if isinstance(keywords, str):
+                keywords = keywords.split(",")
+            if isinstance(keywords, list):
+                for kw in keywords:
+                    if isinstance(kw, str) and kw.strip():
+                        add(constants.CAT_KEYWORDS, {constants.PROP_VALUE: kw.strip(), constants.PROP_TYPE: constants.STRING})
+
+            license_info = parse_zenodo_license(data.get("license"))
+            if license_info:
+                license_data = {
+                    constants.PROP_VALUE: license_info["value"],
+                    constants.PROP_TYPE: constants.LICENSE,
+                }
+                if license_info.get("spdx_id"):
+                    license_data[constants.PROP_NAME] = license_info["name"]
+                    license_data[constants.PROP_SPDX_ID] = license_info["spdx_id"]
+                    license_data[constants.PROP_IDENTIFIER] = license_info["identifier"]
+                add(constants.CAT_LICENSE, license_data)
+
+            if data.get("publication_date"):
+                add(constants.CAT_DATE_PUBLISHED, {constants.PROP_VALUE: data["publication_date"], constants.PROP_TYPE: constants.STRING})
+
+            for person in data.get("creators") or []:
+                info = parse_zenodo_person(person)
+                if info:
+                    add(constants.CAT_AUTHORS, info)
+
+            for person in data.get("contributors") or []:
+                info = parse_zenodo_person(person)
+                if info:
+                    add(constants.CAT_CONTRIBUTORS, info)
+
+    except Exception as e:
+        logging.error(f"Error parsing zenodo.json from {file_path}: {str(e)}")
+
+    return metadata_result
+
+
+def clean_html(text):
+    """Remove HTML tags from a string, keeping readable text. The description in zenodo is usually in HTML format."""
+    if not isinstance(text, str):
+        return ""
+    soup = BeautifulSoup(text, "html.parser")
+    for br in soup.find_all("br"):
+        br.replace_with(" ")
+    for tag in soup.find_all(["p", "div", "li", "ul", "ol", "h1", "h2", "h3", "h4", "h5", "h6"]):
+        tag.append(" ")
+    return " ".join(soup.get_text().split())
+
+
+def parse_zenodo_license(license_data):
+    """
+    Parse the license field of a .zenodo.json file.
+    Zenodo uses either {"id": "mit"} or a plain string id.
+
+    Returns
+    -------
+    dict or None
+        Always has "value". If the license is recognised, it also has
+        name, spdx_id and identifier (SPDX URL).
+    """
+    if isinstance(license_data, dict):
+        license_id = license_data.get("id") or license_data.get("name")
+    elif isinstance(license_data, str):
+        license_id = license_data
+    else:
+        return None
+
+    if not isinstance(license_id, str) or not license_id.strip():
+        return None
+    license_id = license_id.strip()
+
+    license_info = {"value": license_id}
+    license_info_spdx = detect_license_spdx(license_id, "JSON")
+    if license_info_spdx:
+        license_info["name"] = license_info_spdx.get("name")
+        license_info["spdx_id"] = license_info_spdx.get("spdx_id")
+        license_info["identifier"] = license_info_spdx.get("identifier")
+    return license_info
+
+
+def parse_zenodo_person(person):
+    """
+    Parse an entry of 'creators' / 'contributors'.
+    Zenodo names usually come as "Family, Given".
+    """
+    if isinstance(person, str):
+        person = {"name": person}
+    if not isinstance(person, dict):
+        return None
+
+    name = (person.get("name") or "").strip()
+    if not name:
+        return None
+
+    info = {constants.PROP_TYPE: constants.AGENT}
+    if "," in name:
+        family, given = [p.strip() for p in name.split(",", 1)]
+        info[constants.PROP_VALUE] = f"{given} {family}".strip()
+        if given:
+            info[constants.PROP_GIVEN_NAME] = given
+        if family:
+            info[constants.PROP_LAST_NAME] = family
+    else:
+        info[constants.PROP_VALUE] = name
+    info[constants.PROP_NAME] = info[constants.PROP_VALUE]
+
+    if person.get("affiliation"):
+        info[constants.PROP_AFFILIATION] = person["affiliation"]
+    if person.get("orcid"):
+        orcid = person["orcid"].strip()
+        info[constants.PROP_IDENTIFIER] = orcid if orcid.startswith("http") else f"https://orcid.org/{orcid}"
+    return info
+
+

{somef_core-0.0.1 → somef_core-0.0.2}/src/somef_core/process_files.py

@@ -27,6 +27,7 @@ from .parser.publiccode_parser import parse_publiccode_file
 from .parser.codeowners_parser import parse_codeowners_file
 from .parser.conda_environment_parser import parse_conda_environment_file
 from .parser.setupcfg_parser import parse_setup_cfg
+from .parser.zenodo_parser import parse_zenodo_file
 from chardet import detect
 
 
@@ -159,8 +160,17 @@ def process_repository_files(repo_dir, metadata_result: Result, repo_type, owner
                                             logging.warning("Could not detect encoding. Using utf-8 with replacement.")
                                             text = data_file_text.decode("utf-8", errors="replace")
                                     text = clean_text(text)
-                               
-                                    if repo_type == constants.RepositoryType.GITHUB:
+
+                                    if repo_type == constants.RepositoryType.LOCAL:
+                                        readme_url = os.path.join(repo_dir, filename)
+                                        metadata_result.add_result(constants.CAT_README_URL,
+                                                                {
+                                                                    constants.PROP_VALUE: readme_url,
+                                                                    constants.PROP_TYPE: constants.URL
+                                                                },
+                                                                1,
+                                                                constants.TECHNIQUE_FILE_EXPLORATION)
+                                    elif repo_type == constants.RepositoryType.GITHUB and owner and repo_name:
                                         readme_url = convert_to_raw_user_content_github(filename, owner,
                                                                                         repo_name,
                                                                                         repo_default_branch)
@@ -311,8 +321,8 @@ def process_repository_files(repo_dir, metadata_result: Result, repo_type, owner
                             metadata_result = parse_conda_environment_file(os.path.join(dir_path, filename), metadata_result, build_file_url)
                         if filename.lower() == "setup.cfg":
                             metadata_result = parse_setup_cfg(os.path.join(dir_path, filename), metadata_result, build_file_url)
-                        # if filename.lower() == ".zenodo":
-                        #     metadata_result = parse_zenodo_file(os.path.join(dir_path, filename), metadata_result, build_file_url)
+                        if filename.lower() == ".zenodo.json":
+                            metadata_result = parse_zenodo_file(os.path.join(dir_path, filename), metadata_result, build_file_url)
                         parsed_build_files.add(filename.lower())
                           
                 # if repo_type == constants.RepositoryType.GITLAB: