This code provides a module that exports a function coreDependencies which retrieves and logs package dependencies from notebooks in a project directory, excluding cache.ipynb.

Run example

npm run import -- "core dependencies"

core dependencies

var path = require('path')
var importer = require('../Core')
var {relativeImports} = importer.import("builtin and local modules")
var {listInProject} = importer.import("list project files")

function coreDependencies() {
    var packages = []
    var builtin = []
    var coreNotebooks = listInProject(__dirname, '{,*,*/,*/*/*,*/*/*/*}*.ipynb')
        .filter(n => !n.includes('cache.ipynb'))
    coreNotebooks.forEach(n => {
        var cells = importer.interpret(path.basename(n))
        cells.forEach(cell => {
            try {
                var imports = relativeImports(cell.code, cell.filename)
                imports.packages.forEach(p => packages.push(p))
                imports.builtin.forEach(p => builtin.push(p))
            } catch (e) {
                console.log(`problem with ${cell.id} ${e.message}`)
            }
            
        })
    })
    console.log(packages)
    console.log(builtin)
    return packages
}

module.exports = {
    coreDependencies
}

const path = require('path');
const importer = require('../Core');

/**
 * Extracts core dependencies from notebooks in the project.
 *
 * @returns {object} An object containing core packages and built-in modules.
 */
module.exports = {
  coreDependencies: async () => {
    const { relativeImports, listInProject } = importer.import([
      'builtin and local modules',
      'list project files',
    ]);

    const projectsRoot = path.dirname(__dirname);
    const coreNotebooks = await listInProject(projectsRoot, [
      '**/*/*.ipynb',
      '**/*/*/*.ipynb',
      '**/*/*/*/*.ipynb',
    ])
     .filter(n =>!n.includes('cache.ipynb'));

    const packages = [];
    const builtin = [];

    for (const notebook of coreNotebooks) {
      try {
        const notebookPath = path.join(projectsRoot, notebook);
        const cells = await importer.interpret(path.basename(notebookPath));
        for (const cell of cells) {
          const { packages: relativeImportsPackages, builtin: relativeImportsBuiltin } = await relativeImports(
            cell.code,
            cell.filename,
          );
          packages.push(...relativeImportsPackages);
          builtin.push(...relativeImportsBuiltin);
        }
      } catch (error) {
        console.error(`Error processing notebook ${notebook}: ${error.message}`);
      }
    }

    console.log('Core packages:', packages);
    console.log('Built-in modules:', builtin);

    return { packages, builtin };
  },
};

Code Breakdown

Required Modules

• path: A built-in Node.js module for working with file paths.
• importer: A custom module located in the ../Core directory, which provides functionality for importing and interpreting modules.

Functions

• coreDependencies(): A function that exports a list of core dependencies.

Function Flow

1. Retrieves a list of notebooks in the project directory (excluding cache.ipynb).
2. Iterates through each notebook, interpreting each cell.
3. For each cell, it attempts to parse the imports, extracting package and built-in dependencies.
4. Logs any issues encountered during the processing of each cell.
5. Returns the list of package dependencies.

Exports

• module.exports: Exports the coreDependencies function as a module.