├── .github
    ├── FUNDING.yml
    ├── ISSUE_TEMPLATE
    │   ├── bug_report.md
    │   └── feature_request.md
    ├── PULL_REQUEST_TEMPLATE.yml
    ├── dependabot.yml
    ├── labeler.yml
    └── workflows
    │   ├── code_quality_control.yml
    │   ├── cos_integration.yml
    │   ├── docs.yml
    │   ├── docs_test.yml
    │   ├── label.yml
    │   ├── lints.yml
    │   ├── pr_request_checks.yml
    │   ├── pull-request-links.yml
    │   ├── pylint.yml
    │   ├── python-publish.yml
    │   ├── quality.yml
    │   ├── ruff.yml
    │   ├── run_test.yml
    │   ├── stale.yml
    │   ├── test.yml
    │   ├── testing.yml
    │   ├── unit-test.yml
    │   └── welcome.yml
├── .gitignore
├── .pre-commit-config.yaml
├── LICENSE
├── README.md
├── Swarm Orchestrator_state.json
├── agorabanner.png
├── errors.txt
├── example.py
├── examples
    └── test.py
├── neo_sapiens
    ├── __init__.py
    ├── chroma_db_s.py
    ├── few_shot_prompts.py
    ├── hass_schema.py
    └── tools_preset.py
├── pyproject.toml
├── requirements.txt
└── scripts
    ├── Dockerfile
    ├── auto_tests_docs
        ├── auto_docs.py
        ├── auto_docs_functions.py
        ├── auto_docs_omni.py
        ├── auto_tests.py
        ├── auto_tests_functions.py
        ├── docs.py
        ├── mkdocs_handler.py
        └── update_mkdocs.py
    ├── code_quality.sh
    ├── del_pycache.sh
    ├── get_package_requirements.py
    ├── log_cleanup.py
    ├── playground_to_examples.sh
    ├── requirementstxt_to_pyproject.py
    ├── run_examples.sh
    ├── test_name.sh
    └── tests.sh


/.github/FUNDING.yml:
--------------------------------------------------------------------------------
 1 | # These are supported funding model platforms
 2 | 
 3 | github: [kyegomez]
 4 | patreon: # Replace with a single Patreon username
 5 | open_collective: # Replace with a single Open Collective username
 6 | ko_fi: # Replace with a single Ko-fi username
 7 | tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 8 | community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
 9 | liberapay: # Replace with a single Liberapay username
10 | issuehunt: # Replace with a single IssueHunt username
11 | otechie: # Replace with a single Otechie username
12 | lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
13 | custom: #Nothing
14 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Bug report
 3 | about: Create a detailed report on the bug and it's root cause. Conduct root cause error analysis
 4 | title: "[BUG] "
 5 | labels: bug
 6 | assignees: kyegomez
 7 | 
 8 | ---
 9 | 
10 | **Describe the bug**
11 | A clear and concise description of what the bug is and what the main root cause error is. Test very thoroughly before submitting.
12 | 
13 | **To Reproduce**
14 | Steps to reproduce the behavior:
15 | 1. Go to '...'
16 | 2. Click on '....'
17 | 3. Scroll down to '....'
18 | 4. See error
19 | 
20 | **Expected behavior**
21 | A clear and concise description of what you expected to happen.
22 | 
23 | **Screenshots**
24 | If applicable, add screenshots to help explain your problem.
25 | 
26 | **Additional context**
27 | Add any other context about the problem here.
28 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feature_request.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Feature request
 3 | about: Suggest an idea for this project
 4 | title: ''
 5 | labels: ''
 6 | assignees: 'kyegomez'
 7 | 
 8 | ---
 9 | 
10 | **Is your feature request related to a problem? Please describe.**
11 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
12 | 
13 | **Describe the solution you'd like**
14 | A clear and concise description of what you want to happen.
15 | 
16 | **Describe alternatives you've considered**
17 | A clear and concise description of any alternative solutions or features you've considered.
18 | 
19 | **Additional context**
20 | Add any other context or screenshots about the feature request here.
21 | 


--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE.yml:
--------------------------------------------------------------------------------
 1 | <!-- Thank you for contributing to Zeta!
 2 | 
 3 | Replace this comment with:
 4 |   - Description: a description of the change, 
 5 |   - Issue: the issue # it fixes (if applicable),
 6 |   - Dependencies: any dependencies required for this change,
 7 |   - Tag maintainer: for a quicker response, tag the relevant maintainer (see below),
 8 |   - Twitter handle: we announce bigger features on Twitter. If your PR gets announced and you'd like a mention, we'll gladly shout you out!
 9 | 
10 | If you're adding a new integration, please include:
11 |   1. a test for the integration, preferably unit tests that do not rely on network access,
12 |   2. an example notebook showing its use.
13 | 
14 | Maintainer responsibilities:
15 |   - nn / Misc / if you don't know who to tag: kye@apac.ai
16 |   - tokenizers: kye@apac.ai
17 |   - training / Prompts: kye@apac.ai
18 |   - models: kye@apac.ai
19 | 
20 | If no one reviews your PR within a few days, feel free to kye@apac.ai
21 | 
22 | See contribution guidelines for more information on how to write/run tests, lint, etc: https://github.com/kyegomez/zeta


--------------------------------------------------------------------------------
/.github/dependabot.yml:
--------------------------------------------------------------------------------
 1 | # https://docs.github.com/en/code-security/supply-chain-security/keeping-your-dependencies-updated-automatically/configuration-options-for-dependency-updates
 2 | 
 3 | version: 2
 4 | updates:
 5 |   - package-ecosystem: "github-actions"
 6 |     directory: "/"
 7 |     schedule:
 8 |       interval: "weekly"
 9 | 
10 |   - package-ecosystem: "pip"
11 |     directory: "/"
12 |     schedule:
13 |       interval: "weekly"
14 | 
15 | 


--------------------------------------------------------------------------------
/.github/labeler.yml:
--------------------------------------------------------------------------------
 1 | # this is a config file for the github action labeler
 2 | 
 3 | # Add 'label1' to any changes within 'example' folder or any subfolders
 4 | example_change:
 5 | - example/**
 6 | 
 7 | # Add 'label2' to any file changes within 'example2' folder
 8 | example2_change: example2/*
 9 | 
10 | # Add label3 to any change to .txt files within the entire repository. Quotation marks are required for the leading asterisk
11 | text_files:
12 | - '**/*.txt'
13 | 


--------------------------------------------------------------------------------
/.github/workflows/code_quality_control.yml:
--------------------------------------------------------------------------------
 1 | name: Linting and Formatting
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - main
 7 | 
 8 | jobs:
 9 |   lint_and_format:
10 |     runs-on: ubuntu-latest
11 | 
12 |     steps:
13 |       - name: Checkout code
14 |         uses: actions/checkout@v4
15 | 
16 |       - name: Set up Python
17 |         uses: actions/setup-python@v5
18 |         with:
19 |           python-version: '3.10'
20 | 
21 |       - name: Install dependencies
22 |         run: pip install --no-cache-dir -r requirements.txt
23 | 
24 |       - name: Find Python files
25 |         run: find swarms_torch -name "*.py" -type f -exec autopep8 --in-place --aggressive --aggressive {} +
26 | 
27 |       - name: Push changes
28 |         uses: ad-m/github-push-action@master
29 |         with:
30 |           github_token: ${{ secrets.GITHUB_TOKEN }}


--------------------------------------------------------------------------------
/.github/workflows/cos_integration.yml:
--------------------------------------------------------------------------------
 1 | name: Continuous Integration
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - main
 7 | 
 8 | jobs:
 9 |   test:
10 |     runs-on: ubuntu-latest
11 |     steps:
12 |       - name: Checkout code
13 |         uses: actions/checkout@v4
14 | 
15 |       - name: Set up Python
16 |         uses: actions/setup-python@v5
17 |         with:
18 |           python-version: '3.10'
19 | 
20 |       - name: Install dependencies
21 |         run: pip install --no-cache-dir -r requirements.txt
22 | 
23 |       - name: Run unit tests
24 |         run: pytest tests/unit
25 | 
26 |       - name: Run integration tests
27 |         run: pytest tests/integration
28 | 
29 |       - name: Run code coverage
30 |         run: pytest --cov=swarms tests/
31 | 
32 |       - name: Run linters
33 |         run: pylint swarms
34 | 
35 |       - name: Build documentation
36 |         run: make docs
37 | 
38 |       - name: Validate documentation
39 |         run: sphinx-build -b linkcheck docs build/docs
40 | 
41 |       - name: Run performance tests
42 |         run: pytest tests/performance


--------------------------------------------------------------------------------
/.github/workflows/docs.yml:
--------------------------------------------------------------------------------
 1 | name: Docs WorkFlow
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - master
 7 |       - main
 8 |       - develop
 9 | jobs:
10 |   deploy:
11 |     runs-on: ubuntu-latest
12 |     steps:
13 |       - uses: actions/checkout@v4
14 |       - uses: actions/setup-python@v5
15 |         with:
16 |           python-version: '3.10'
17 |       - run: pip install mkdocs-material
18 |       - run: pip install "mkdocstrings[python]"
19 |       - run: mkdocs gh-deploy --force


--------------------------------------------------------------------------------
/.github/workflows/docs_test.yml:
--------------------------------------------------------------------------------
 1 | name: Documentation Tests
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - master
 7 | 
 8 | jobs:
 9 |   test:
10 |     runs-on: ubuntu-latest
11 | 
12 |     steps:
13 |       - name: Checkout code
14 |         uses: actions/checkout@v4
15 | 
16 |       - name: Set up Python
17 |         uses: actions/setup-python@v5
18 |         with:
19 |           python-version: '3.10'
20 | 
21 |       - name: Install dependencies
22 |         run: pip install --no-cache-dir -r requirements.txt
23 | 
24 |       - name: Build documentation
25 |         run: make docs
26 | 
27 |       - name: Validate documentation
28 |         run: sphinx-build -b linkcheck docs build/docs


--------------------------------------------------------------------------------
/.github/workflows/label.yml:
--------------------------------------------------------------------------------
 1 | # This workflow will triage pull requests and apply a label based on the
 2 | # paths that are modified in the pull request.
 3 | #
 4 | # To use this workflow, you will need to set up a .github/labeler.yml
 5 | # file with configuration.  For more information, see:
 6 | # https://github.com/actions/labeler
 7 | 
 8 | name: Labeler
 9 | on: [pull_request_target]
10 | 
11 | jobs:
12 |   label:
13 | 
14 |     runs-on: ubuntu-latest
15 |     permissions:
16 |       contents: read
17 |       pull-requests: write
18 | 
19 |     steps:
20 |     - uses: actions/labeler@v5.0.0
21 |       with:
22 |         repo-token: "${{ secrets.GITHUB_TOKEN }}"
23 | 


--------------------------------------------------------------------------------
/.github/workflows/lints.yml:
--------------------------------------------------------------------------------
 1 | name: Linting
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - master
 7 | 
 8 | jobs:
 9 |   lint:
10 |     runs-on: ubuntu-latest
11 | 
12 |     steps:
13 |       - name: Checkout code
14 |         uses: actions/checkout@v4
15 | 
16 |       - name: Set up Python
17 |         uses: actions/setup-python@v5
18 |         with:
19 |           python-version: '3.10'
20 | 
21 |       - name: Install dependencies
22 |         run: pip install --no-cache-dir -r requirements.txt
23 | 
24 |       - name: Run linters
25 |         run: pylint swarms_torch


--------------------------------------------------------------------------------
/.github/workflows/pr_request_checks.yml:
--------------------------------------------------------------------------------
 1 | name: Pull Request Checks
 2 | 
 3 | on:
 4 |   pull_request:
 5 |     branches:
 6 |       - master
 7 | 
 8 | jobs:
 9 |   test:
10 |     runs-on: ubuntu-latest
11 | 
12 |     steps:
13 |       - name: Checkout code
14 |         uses: actions/checkout@v4
15 | 
16 |       - name: Set up Python
17 |         uses: actions/setup-python@v5
18 |         with:
19 |           python-version: '3.10'
20 | 
21 |       - name: Install dependencies
22 |         run: pip install --no-cache-dir -r requirements.txt
23 | 
24 |       - name: Run tests and checks
25 |         run: |
26 |           pytest tests/
27 |           pylint swarms_torch


--------------------------------------------------------------------------------
/.github/workflows/pull-request-links.yml:
--------------------------------------------------------------------------------
 1 | name: readthedocs/actions
 2 | on:
 3 |   pull_request_target:
 4 |     types:
 5 |       - opened
 6 |     paths:
 7 |       - "docs/**"
 8 | 
 9 | permissions:
10 |   pull-requests: write
11 | 
12 | jobs:
13 |   pull-request-links:
14 |     runs-on: ubuntu-latest
15 |     steps:
16 |       - uses: readthedocs/actions/preview@v1
17 |         with:
18 |           project-slug: swarms_torch


--------------------------------------------------------------------------------
/.github/workflows/pylint.yml:
--------------------------------------------------------------------------------
 1 | name: Pylint
 2 | 
 3 | on: [push]
 4 | 
 5 | jobs:
 6 |   build:
 7 |     runs-on: ubuntu-latest
 8 |     strategy:
 9 |       matrix:
10 |         python-version: ["3.9", "3.10"]
11 |     steps:
12 |     - uses: actions/checkout@v4
13 |     - name: Set up Python ${{ matrix.python-version }}
14 |       uses: actions/setup-python@v5
15 |       with:
16 |         python-version: ${{ matrix.python-version }}
17 |     - name: Install dependencies
18 |       run: |
19 |         python -m pip install --no-cache-dir --upgrade pip
20 |         pip install pylint
21 |     - name: Analysing the code with pylint
22 |       run: |
23 |         pylint $(git ls-files '*.py')
24 | 


--------------------------------------------------------------------------------
/.github/workflows/python-publish.yml:
--------------------------------------------------------------------------------
 1 | 
 2 | name: Upload Python Package
 3 | 
 4 | on:
 5 |   release:
 6 |     types: [published]
 7 | 
 8 | permissions:
 9 |   contents: read
10 | 
11 | jobs:
12 |   deploy:
13 | 
14 |     runs-on: ubuntu-latest
15 | 
16 |     steps:
17 |     - uses: actions/checkout@v4
18 |     - name: Set up Python
19 |       uses: actions/setup-python@v5
20 |       with:
21 |         python-version: '3.10'
22 |     - name: Install dependencies
23 |       run: |
24 |         python -m pip install --no-cache-dir --upgrade pip
25 |         pip install build
26 |     - name: Build package
27 |       run: python -m build
28 |     - name: Publish package
29 |       uses: pypa/gh-action-pypi-publish@81e9d935c883d0b210363ab89cf05f3894778450
30 |       with:
31 |         user: __token__
32 |         password: ${{ secrets.PYPI_API_TOKEN }}


--------------------------------------------------------------------------------
/.github/workflows/quality.yml:
--------------------------------------------------------------------------------
 1 | name: Quality
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ "main" ]
 6 |   pull_request:
 7 |     branches: [ "main" ]
 8 | 
 9 | jobs:
10 |   lint:
11 |     runs-on: ubuntu-latest
12 |     strategy:
13 |       fail-fast: false
14 |     steps:
15 |       - name: Checkout actions
16 |         uses: actions/checkout@v4
17 |         with:
18 |           fetch-depth: 0
19 |       - name: Init environment 
20 |         uses: ./.github/actions/init-environment 
21 |       - name: Run linter
22 |         run: |
23 |           pylint `git diff --name-only --diff-filter=d origin/main HEAD | grep -E '\.py$' | tr '\n' ' '`


--------------------------------------------------------------------------------
/.github/workflows/ruff.yml:
--------------------------------------------------------------------------------
1 | name: Ruff
2 | on: [ push, pull_request ]
3 | jobs:
4 |   ruff:
5 |     runs-on: ubuntu-latest
6 |     steps:
7 |       - uses: actions/checkout@v4
8 |       - uses: chartboost/ruff-action@v1
9 | 


--------------------------------------------------------------------------------
/.github/workflows/run_test.yml:
--------------------------------------------------------------------------------
 1 | name: Python application test
 2 | 
 3 | on: [push]
 4 | 
 5 | jobs:
 6 |   build:
 7 | 
 8 |     runs-on: ubuntu-latest
 9 | 
10 |     steps:
11 |     - uses: actions/checkout@v4
12 |     - name: Set up Python 3.10
13 |       uses: actions/setup-python@v5
14 |       with:
15 |         python-version: '3.10'
16 |     - name: Install dependencies
17 |       run: |
18 |         python -m pip install --no-cache-dir --upgrade pip
19 |         pip install pytest
20 |         if [ -f requirements.txt ]; then pip install --no-cache-dir -r requirements.txt; fi
21 |     - name: Run tests with pytest
22 |       run: |
23 |         pytest tests/
24 | 


--------------------------------------------------------------------------------
/.github/workflows/stale.yml:
--------------------------------------------------------------------------------
 1 | # This workflow warns and then closes issues and PRs that have had no activity for a specified amount of time.
 2 | #
 3 | # You can adjust the behavior by modifying this file.
 4 | # For more information, see:
 5 | # https://github.com/actions/stale
 6 | name: Mark stale issues and pull requests
 7 | 
 8 | on:
 9 |   schedule:
10 |   - cron: '26 12 * * *'
11 | 
12 | jobs:
13 |   stale:
14 | 
15 |     runs-on: ubuntu-latest
16 |     permissions:
17 |       issues: write
18 |       pull-requests: write
19 | 
20 |     steps:
21 |     - uses: actions/stale@v9
22 |       with:
23 |         repo-token: ${{ secrets.GITHUB_TOKEN }}
24 |         stale-issue-message: 'Stale issue message'
25 |         stale-pr-message: 'Stale pull request message'
26 |         stale-issue-label: 'no-issue-activity'
27 |         stale-pr-label: 'no-pr-activity'


--------------------------------------------------------------------------------
/.github/workflows/test.yml:
--------------------------------------------------------------------------------
 1 | name: test
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [master]
 6 |   pull_request:
 7 |   workflow_dispatch:
 8 | 
 9 | env:
10 |   POETRY_VERSION: "1.4.2"
11 | 
12 | jobs:
13 |   build:
14 |     runs-on: ubuntu-latest
15 |     strategy:
16 |       matrix:
17 |         python-version:
18 |           - "3.9"
19 |           - "3.10"
20 |           - "3.11"
21 |         test_type:
22 |           - "core"
23 |           - "extended"
24 |     name: Python ${{ matrix.python-version }} ${{ matrix.test_type }}
25 |     steps:
26 |       - uses: actions/checkout@v4
27 |       - name: Set up Python ${{ matrix.python-version }}
28 |         uses: "./.github/actions/poetry_setup"
29 |         with:
30 |           python-version: ${{ matrix.python-version }}
31 |           poetry-version: "1.4.2"
32 |           cache-key: ${{ matrix.test_type }}
33 |           install-command: |
34 |               if [ "${{ matrix.test_type }}" == "core" ]; then
35 |                 echo "Running core tests, installing dependencies with poetry..."
36 |                 poetry install
37 |               else
38 |                 echo "Running extended tests, installing dependencies with poetry..."
39 |                 poetry install -E extended_testing
40 |               fi
41 |       - name: Run ${{matrix.test_type}} tests
42 |         run: |
43 |           if [ "${{ matrix.test_type }}" == "core" ]; then
44 |             make test
45 |           else
46 |             make extended_tests
47 |           fi
48 |         shell: bash


--------------------------------------------------------------------------------
/.github/workflows/testing.yml:
--------------------------------------------------------------------------------
 1 | name: Unit Tests
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - master
 7 | 
 8 | jobs:
 9 |   test:
10 |     runs-on: ubuntu-latest
11 | 
12 |     steps:
13 |       - name: Checkout code
14 |         uses: actions/checkout@v4
15 | 
16 |       - name: Set up Python
17 |         uses: actions/setup-python@v5
18 |         with:
19 |           python-version: '3.10'
20 | 
21 |       - name: Install dependencies
22 |         run: pip install --no-cache-dir -r requirements.txt
23 | 
24 |       - name: Run unit tests
25 |         run: pytest tests/


--------------------------------------------------------------------------------
/.github/workflows/unit-test.yml:
--------------------------------------------------------------------------------
 1 | name: build
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ main ]
 6 |   pull_request:
 7 |     branches: [ main ]
 8 | 
 9 | jobs:
10 | 
11 |   build:
12 | 
13 |     runs-on: ubuntu-latest
14 | 
15 |     steps:
16 |     - uses: actions/checkout@v4
17 | 
18 |     - name: Setup Python
19 |       uses: actions/setup-python@v5
20 |       with:
21 |         python-version: '3.10'
22 | 
23 |     - name: Install dependencies
24 |       run: pip install --no-cache-dir -r requirements.txt
25 | 
26 |     - name: Run Python unit tests
27 |       run: python3 -m unittest tests/
28 | 
29 |     - name: Verify that the Docker image for the action builds
30 |       run: docker build . --file Dockerfile
31 | 
32 |     - name: Verify integration test results
33 |       run: python3 -m unittest tests/
34 | 


--------------------------------------------------------------------------------
/.github/workflows/welcome.yml:
--------------------------------------------------------------------------------
 1 | name: Welcome WorkFlow
 2 | 
 3 | on:
 4 |   issues:
 5 |     types: [opened]
 6 |   pull_request_target:
 7 |     types: [opened]
 8 | 
 9 | jobs:
10 |   build:
11 |     name: 👋 Welcome
12 |     permissions: write-all
13 |     runs-on: ubuntu-latest
14 |     steps:
15 |       - uses: actions/first-interaction@v1.3.0
16 |         with:
17 |           repo-token: ${{ secrets.GITHUB_TOKEN }}
18 |           issue-message: "Hello there, thank you for opening an Issue ! 🙏🏻 The team was notified and they will get back to you asap."
19 |           pr-message:  "Hello there, thank you for opening an PR ! 🙏🏻 The team was notified and they will get back to you asap."


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | *.py[cod]
  4 | *$py.class
  5 | 
  6 | # C extensions
  7 | *.so
  8 | .vscode/
  9 | .vscode
 10 | 
 11 | # Distribution / packaging
 12 | .Python
 13 | build/
 14 | develop-eggs/
 15 | dist/
 16 | downloads/
 17 | eggs/
 18 | .eggs/
 19 | lib/
 20 | lib64/
 21 | parts/
 22 | .ruff_cache/
 23 | sdist/
 24 | var/
 25 | wheels/
 26 | share/python-wheels/
 27 | *.egg-info/
 28 | .installed.cfg
 29 | *.egg
 30 | MANIFEST
 31 | 
 32 | # PyInstaller
 33 | #  Usually these files are written by a python script from a template
 34 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 35 | *.manifest
 36 | *.spec
 37 | 
 38 | # Installer logs
 39 | pip-log.txt
 40 | pip-delete-this-directory.txt
 41 | 
 42 | # Unit test / coverage reports
 43 | htmlcov/
 44 | .tox/
 45 | .nox/
 46 | .coverage
 47 | .coverage.*
 48 | .cache
 49 | nosetests.xml
 50 | coverage.xml
 51 | *.cover
 52 | *.py,cover
 53 | .hypothesis/
 54 | .pytest_cache/
 55 | cover/
 56 | 
 57 | # Translations
 58 | *.mo
 59 | *.pot
 60 | 
 61 | # Django stuff:
 62 | *.log
 63 | local_settings.py
 64 | db.sqlite3
 65 | db.sqlite3-journal
 66 | 
 67 | # Flask stuff:
 68 | instance/
 69 | .webassets-cache
 70 | 
 71 | # Scrapy stuff:
 72 | .scrapy
 73 | 
 74 | # Sphinx documentation
 75 | docs/_build/
 76 | 
 77 | # PyBuilder
 78 | .pybuilder/
 79 | target/
 80 | 
 81 | # Jupyter Notebook
 82 | .ipynb_checkpoints
 83 | 
 84 | # IPython
 85 | profile_default/
 86 | ipython_config.py
 87 | 
 88 | # pyenv
 89 | #   For a library or package, you might want to ignore these files since the code is
 90 | #   intended to run in multiple environments; otherwise, check them in:
 91 | # .python-version
 92 | 
 93 | # pipenv
 94 | #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
 95 | #   However, in case of collaboration, if having platform-specific dependencies or dependencies
 96 | #   having no cross-platform support, pipenv may install dependencies that don't work, or not
 97 | #   install all needed dependencies.
 98 | #Pipfile.lock
 99 | 
100 | # poetry
101 | #   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
102 | #   This is especially recommended for binary packages to ensure reproducibility, and is more
103 | #   commonly ignored for libraries.
104 | #   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
105 | #poetry.lock
106 | 
107 | # pdm
108 | #   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
109 | #pdm.lock
110 | #   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
111 | #   in version control.
112 | #   https://pdm.fming.dev/#use-with-ide
113 | .pdm.toml
114 | 
115 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
116 | __pypackages__/
117 | 
118 | # Celery stuff
119 | celerybeat-schedule
120 | celerybeat.pid
121 | 
122 | # SageMath parsed files
123 | *.sage.py
124 | 
125 | # Environments
126 | .env
127 | .venv
128 | env/
129 | venv/
130 | ENV/
131 | env.bak/
132 | venv.bak/
133 | 
134 | # Spyder project settings
135 | .spyderproject
136 | .spyproject
137 | 
138 | # Rope project settings
139 | .ropeproject
140 | 
141 | # mkdocs documentation
142 | /site
143 | 
144 | # mypy
145 | .mypy_cache/
146 | .dmypy.json
147 | dmypy.json
148 | 
149 | # Pyre type checker
150 | .pyre/
151 | 
152 | # pytype static type analyzer
153 | .pytype/
154 | 
155 | # Cython debug symbols
156 | cython_debug/
157 | 
158 | # PyCharm
159 | #  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
160 | #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
161 | #  and can be added to the global gitignore or merged into this file.  For a more nuclear
162 | #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
163 | #.idea/
164 | 


--------------------------------------------------------------------------------
/.pre-commit-config.yaml:
--------------------------------------------------------------------------------
 1 | repos:
 2 |   - repo: https://github.com/ambv/black
 3 |     rev: 22.3.0
 4 |     hooks:
 5 |     - id: black
 6 |   - repo: https://github.com/charliermarsh/ruff-pre-commit
 7 |     rev: 'v0.0.255'
 8 |     hooks:
 9 |       - id: ruff
10 |         args: [--fix]
11 |   - repo: https://github.com/nbQA-dev/nbQA
12 |     rev: 1.6.3
13 |     hooks:
14 |     - id: nbqa-black
15 |       additional_dependencies: [ipython==8.12, black]
16 |     - id: nbqa-ruff 
17 |       args: ["--ignore=I001"]
18 |       additional_dependencies: [ipython==8.12, ruff]


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2023 Eternal Reclaimer
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | [![Multi-Modality](agorabanner.png)](https://discord.gg/qUtxnK2NMf)
 2 | 
 3 | # Neo Sapiens
 4 | 
 5 | 
 6 | ## install
 7 | `$ pip install -U swarms neo-sapiens`
 8 | 
 9 | 
10 | ## usage
11 | ```python
12 | from neo_sapiens import run_swarm
13 | 
14 | # Run the swarm
15 | out = run_swarm("Create a self-driving car system using a team of AI agents")
16 | print(out)
17 | ```
18 | 
19 | # Todo
20 | - [ ] Add tool processing
21 | 
22 | - [ ] Add tool router
23 | 
24 | - [ ] Add rules processing to map to each agent
25 | 
26 | - [ ] Prompt for swarm orchestrator to make the children workers in JSON
27 | 
28 | - [ ] Prompt to create functions with a tool decorator above the function with specific types and documentation. Create a tool for this: {input}, and create the functions in python with a tool decorator on top of the function with specific types and documentation with docstrings
29 | 
30 | - [ ] Logic to add each agent to a swarm network
31 | 
32 | - [ ] Add memory to boss agent using Chromadb
33 | 
34 | - [ ] Add agents as tools after the boss creates them
35 | 
36 | # License
37 | MIT
38 | 


--------------------------------------------------------------------------------
/Swarm Orchestrator_state.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "agent_id": "<function agent_id at 0x124c1bba0>",
 3 |     "agent_name": "Swarm Orchestrator",
 4 |     "agent_description": null,
 5 |     "system_prompt": "Create an instruction prompt for an swarm orchestrator to create a series of personalized, agents for the following objective: create a team to build an ai model to predict the next solar eclipse and prices for flights from miami to solar eclipse to decompose a very complicated problem or tasks, the orchestrator is the team leader. Teach the orchestrator how to decompose the tasks to very certain agents with names, and system prompts, we need the plan, with a step by stpe instructions, number of agents, and a list of agents with a name, system prompt for each, and then the rules of the swarm,  compact the prompt, and say only return JSON data in markdown and nothing else.Follow the schema here: \n{\n    \"plan\": [\"Step 1\", \"Step 2\", \"Step 3\"],\n    \"agents\": [\n        {\n            \"name\": \"Agent 1\",\n            \"system_prompt\": \"Prompt 1\"\n        },\n        {\n            \"name\": \"Agent 2\",\n            \"system_prompt\": \"Prompt 2\"\n        }\n    ]\n}\n *############ Here are some examples:\n{\n    \"plan\": [\"Room Management\", \"Guest Services\", \"Reservations Handling\", \"Facility Maintenance\", \"Staff Coordination\"],\n    \"agents\": [\n        {\n            \"name\": \"Room Management Agent\",\n            \"system_prompt\": \"Automate room assignments, minibar restocking, and housekeeping schedules\"\n        },\n        {\n            \"name\": \"Guest Services Agent\",\n            \"system_prompt\": \"Handle check-ins, check-outs, guest requests, and complaints efficiently\"\n        },\n        {\n            \"name\": \"Reservations Agent\",\n            \"system_prompt\": \"Manage room bookings, table reservations, and special requests\"\n        },\n        {\n            \"name\": \"Maintenance Agent\",\n            \"system_prompt\": \"Schedule and track maintenance tasks for facilities and rooms\"\n        },\n        {\n            \"name\": \"Staff Coordination Agent\",\n            \"system_prompt\": \"Optimize staff schedules, task assignments, and workload distribution\"\n        }\n    ]\n}\n and another example\n{\n    \"plan\": [\"Problem Identification\", \"Solution Design\", \"Implementation\", \"Testing\", \"Deployment\"],\n    \"agents\": [\n        {\n            \"name\": \"Identification Agent\",\n            \"system_prompt\": \"Identify the problem\"\n        },\n        {\n            \"name\": \"Design Agent\",\n            \"system_prompt\": \"Design the solution\"\n        },\n        {\n            \"name\": \"Implementation Agent\",\n            \"system_prompt\": \"Implement the solution\"\n        },\n        {\n            \"name\": \"Deployment Agent\",\n            \"system_prompt\": \"Deploy the solution\"\n        }\n    ]\n}\n ",
 6 |     "sop": null,
 7 |     "short_memory": "system: Create an instruction prompt for an swarm orchestrator to create a series of personalized, agents for the following objective: create a team to build an ai model to predict the next solar eclipse and prices for flights from miami to solar eclipse to decompose a very complicated problem or tasks, the orchestrator is the team leader. Teach the orchestrator how to decompose the tasks to very certain agents with names, and system prompts, we need the plan, with a step by stpe instructions, number of agents, and a list of agents with a name, system prompt for each, and then the rules of the swarm,  compact the prompt, and say only return JSON data in markdown and nothing else.Follow the schema here: \n{\n    \"plan\": [\"Step 1\", \"Step 2\", \"Step 3\"],\n    \"agents\": [\n        {\n            \"name\": \"Agent 1\",\n            \"system_prompt\": \"Prompt 1\"\n        },\n        {\n            \"name\": \"Agent 2\",\n            \"system_prompt\": \"Prompt 2\"\n        }\n    ]\n}\n *############ Here are some examples:\n{\n    \"plan\": [\"Room Management\", \"Guest Services\", \"Reservations Handling\", \"Facility Maintenance\", \"Staff Coordination\"],\n    \"agents\": [\n        {\n            \"name\": \"Room Management Agent\",\n            \"system_prompt\": \"Automate room assignments, minibar restocking, and housekeeping schedules\"\n        },\n        {\n            \"name\": \"Guest Services Agent\",\n            \"system_prompt\": \"Handle check-ins, check-outs, guest requests, and complaints efficiently\"\n        },\n        {\n            \"name\": \"Reservations Agent\",\n            \"system_prompt\": \"Manage room bookings, table reservations, and special requests\"\n        },\n        {\n            \"name\": \"Maintenance Agent\",\n            \"system_prompt\": \"Schedule and track maintenance tasks for facilities and rooms\"\n        },\n        {\n            \"name\": \"Staff Coordination Agent\",\n            \"system_prompt\": \"Optimize staff schedules, task assignments, and workload distribution\"\n        }\n    ]\n}\n and another example\n{\n    \"plan\": [\"Problem Identification\", \"Solution Design\", \"Implementation\", \"Testing\", \"Deployment\"],\n    \"agents\": [\n        {\n            \"name\": \"Identification Agent\",\n            \"system_prompt\": \"Identify the problem\"\n        },\n        {\n            \"name\": \"Design Agent\",\n            \"system_prompt\": \"Design the solution\"\n        },\n        {\n            \"name\": \"Implementation Agent\",\n            \"system_prompt\": \"Implement the solution\"\n        },\n        {\n            \"name\": \"Deployment Agent\",\n            \"system_prompt\": \"Deploy the solution\"\n        }\n    ]\n}\n \n\n\nHuman:: create a team to build an ai model to predict the next solar eclipse and prices for flights from miami to solar eclipse\n\n\nSwarm Orchestrator: \n```json\n{\n  \"plan\": [\n    \"Collect solar eclipse data\",\n    \"Collect flight price data\", \n    \"Build predictive model for solar eclipse dates\",\n    \"Build predictive model for flight prices to solar eclipses\",\n    \"Integrate models into solar eclipse flight pricing system\"\n  ],\n  \"agents\": [\n    {\n      \"name\": \"Eclipse Data Collection Agent\",\n      \"system_prompt\": \"Gather data on past and future solar eclipses including date, location, duration etc.\" \n    },\n    {\n      \"name\": \"Flight Price Data Collection Agent\", \n      \"system_prompt\": \"Gather historical flight price data from Miami during solar eclipses.\"\n    },\n    {\n      \"name\": \"Eclipse Prediction Model Builder\",\n      \"system_prompt\": \"Build ML model to predict dates and locations of future solar eclipses.\"\n    },\n    {\n      \"name\": \"Flight Price Prediction Model Builder\",\n      \"system_prompt\": \"Build ML model to predict flight prices from Miami during solar eclipses.\"\n    },\n    {\n     \"name\": \"Pricing System Integration Agent\",\n     \"system_prompt\": \"Integrate eclipse date predictions and flight price predictions into a solar eclipse flight pricing system.\"\n    }\n  ]\n}\n```\n\nI've outlined a plan to collect the necessary data, build ML models to make predictions, and integrate the models into a larger system to price flights from Miami to solar eclipse locations. The agents are specialized for tasks like data collection, model building, and system integration. Please let me know if you would like me to modify or expand on this in any way!\n\n",
 8 |     "loop_interval": 0,
 9 |     "retry_attempts": 3,
10 |     "retry_interval": 1,
11 |     "interactive": false,
12 |     "dashboard": false,
13 |     "dynamic_temperature": false,
14 |     "autosave": true,
15 |     "saved_state_path": "Swarm Orchestrator_state.json",
16 |     "max_loops": 1
17 | }


--------------------------------------------------------------------------------
/agorabanner.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kyegomez/NeoSapiens/c2cbb2abfb5a92d195f7918735dde5be3921e980/agorabanner.png


--------------------------------------------------------------------------------
/errors.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kyegomez/NeoSapiens/c2cbb2abfb5a92d195f7918735dde5be3921e980/errors.txt


--------------------------------------------------------------------------------
/example.py:
--------------------------------------------------------------------------------
 1 | import argparse
 2 | from neo_sapiens.hass_schema import run_swarm
 3 | 
 4 | # Create an ArgumentParser object
 5 | parser = argparse.ArgumentParser(description="Run the swarm")
 6 | 
 7 | # Add arguments for team_task and task
 8 | parser.add_argument(
 9 |     "--team_task", type=str, help="The team task for the swarm"
10 | )
11 | parser.add_argument("--task", type=str, help="The task for the swarm")
12 | 
13 | # Parse the command line arguments
14 | args = parser.parse_args()
15 | 
16 | # Run the swarm with the provided message, team_task, and task
17 | out = run_swarm(args.team_task, args.task)
18 | print(out)
19 | 


--------------------------------------------------------------------------------
/examples/test.py:
--------------------------------------------------------------------------------
 1 | import torch.nn as nn
 2 | import torch.nn.functional as F
 3 | 
 4 | 
 5 | class FaceNet(nn.Module):
 6 |     """
 7 |     Convolutional neural network architecture for facial recognition,
 8 |     trained to generate 128-d embeddings of face images.
 9 | 
10 |     Architecture details:
11 |         - Takes 160x160 RGB face images as input
12 |         - Several convolutional layers, BatchNorm, MaxPooling
13 |         -culminating in a linear layer outputting 128-d embedding vector
14 |     """
15 | 
16 |     def __init__(self):
17 |         super().__init__()
18 | 
19 |         self.conv1 = nn.Conv2d(3, 32, 5)
20 |         self.bn1 = nn.BatchNorm2d(32)
21 |         self.pool1 = nn.MaxPool2d(2, 2)
22 | 
23 |         self.conv2 = nn.Conv2d(32, 64, 5)
24 |         self.bn2 = nn.BatchNorm2d(64)
25 |         self.pool2 = nn.MaxPool2d(2, 2)
26 | 
27 |         self.conv3 = nn.Conv2d(64, 96, 3)
28 |         self.bn3 = nn.BatchNorm2d(96)
29 | 
30 |         self.conv4 = nn.Conv2d(96, 128, 3)
31 |         self.bn4 = nn.BatchNorm2d(128)
32 | 
33 |         self.fc1 = nn.Linear(128 * 8 * 8, 256)
34 |         self.fc2 = nn.Linear(256, 128)  # 128-d embedding
35 | 
36 |     def forward(self, x):
37 |         x = self.pool1(F.relu(self.bn1(self.conv1(x))))
38 |         x = self.pool2(F.relu(self.bn2(self.conv2(x))))
39 |         x = F.relu(self.bn3(self.conv3(x)))
40 |         x = F.relu(self.bn4(self.conv4(x)))
41 | 
42 |         x = x.view(-1, 128 * 8 * 8)
43 |         x = F.relu(self.fc1(x))
44 |         x = self.fc2(x)
45 |         return x
46 | 


--------------------------------------------------------------------------------
/neo_sapiens/__init__.py:
--------------------------------------------------------------------------------
 1 | from neo_sapiens.few_shot_prompts import (
 2 |     data,
 3 |     data1,
 4 |     data2,
 5 |     data3,
 6 |     orchestrator_prompt_agent,
 7 | )
 8 | from neo_sapiens.hass_schema import (
 9 |     AgentSchema,
10 |     ToolSchema,
11 |     parse_json_from_input,
12 |     run_swarm,
13 | )
14 | 
15 | __all__ = [
16 |     "data",
17 |     "data1",
18 |     "data2",
19 |     "data3",
20 |     "orchestrator_prompt_agent",
21 |     "AgentSchema",
22 |     "ToolSchema",
23 |     "parse_json_from_input",
24 |     "run_swarm",
25 | ]
26 | 


--------------------------------------------------------------------------------
/neo_sapiens/chroma_db_s.py:
--------------------------------------------------------------------------------
  1 | import logging
  2 | import os
  3 | import uuid
  4 | from typing import List, Optional
  5 | 
  6 | import chromadb
  7 | import numpy as np
  8 | from dotenv import load_dotenv
  9 | 
 10 | from swarms.utils.data_to_text import data_to_text
 11 | from swarms.utils.markdown_message import display_markdown_message
 12 | 
 13 | # Load environment variables
 14 | load_dotenv()
 15 | 
 16 | 
 17 | # Results storage using local ChromaDB
 18 | class ChromaDB:
 19 |     """
 20 | 
 21 |     ChromaDB database
 22 | 
 23 |     Args:
 24 |         metric (str): The similarity metric to use.
 25 |         output (str): The name of the collection to store the results in.
 26 |         limit_tokens (int, optional): The maximum number of tokens to use for the query. Defaults to 1000.
 27 |         n_results (int, optional): The number of results to retrieve. Defaults to 2.
 28 | 
 29 |     Methods:
 30 |         add: _description_
 31 |         query: _description_
 32 | 
 33 |     Examples:
 34 |         >>> chromadb = ChromaDB(
 35 |         >>>     metric="cosine",
 36 |         >>>     output="results",
 37 |         >>>     llm="gpt3",
 38 |         >>>     openai_api_key=OPENAI_API_KEY,
 39 |         >>> )
 40 |         >>> chromadb.add(task, result, result_id)
 41 |     """
 42 | 
 43 |     def __init__(
 44 |         self,
 45 |         metric: str = "cosine",
 46 |         output_dir: str = "swarms",
 47 |         limit_tokens: Optional[int] = 1000,
 48 |         n_results: int = 2,
 49 |         docs_folder: Optional[str] = None,
 50 |         verbose: bool = False,
 51 |         *args,
 52 |         **kwargs,
 53 |     ):
 54 |         self.metric = metric
 55 |         self.output_dir = output_dir
 56 |         self.limit_tokens = limit_tokens
 57 |         self.n_results = n_results
 58 |         self.docs_folder = docs_folder
 59 |         self.verbose = verbose
 60 | 
 61 |         # Disable ChromaDB logging
 62 |         if verbose:
 63 |             logging.getLogger("chromadb").setLevel(logging.INFO)
 64 | 
 65 |         # Create Chroma collection
 66 |         chroma_persist_dir = "chroma"
 67 |         chroma_client = chromadb.PersistentClient(
 68 |             settings=chromadb.config.Settings(
 69 |                 persist_directory=chroma_persist_dir,
 70 |             ),
 71 |             *args,
 72 |             **kwargs,
 73 |         )
 74 |         # Create ChromaDB client
 75 |         self.client = chromadb.Client()
 76 | 
 77 |         # Create Chroma collection
 78 |         self.collection = chroma_client.get_or_create_collection(
 79 |             name=output_dir,
 80 |             metadata={"hnsw:space": metric},
 81 |             embedding_function=self.embedding_function,
 82 |             data_loader=self.data_loader,
 83 |             *args,
 84 |             **kwargs,
 85 |         )
 86 |         display_markdown_message(
 87 |             "ChromaDB collection created:"
 88 |             f" {self.collection.name} with metric: {self.metric} and"
 89 |             f" output directory: {self.output_dir}"
 90 |         )
 91 | 
 92 |         # If docs
 93 |         if docs_folder:
 94 |             display_markdown_message(
 95 |                 f"Traversing directory: {docs_folder}"
 96 |             )
 97 |             self.traverse_directory()
 98 | 
 99 |     def add(
100 |         self,
101 |         document: str,
102 |         images: List[np.ndarray] = None,
103 |         img_urls: List[str] = None,
104 |         *args,
105 |         **kwargs,
106 |     ):
107 |         """
108 |         Add a document to the ChromaDB collection.
109 | 
110 |         Args:
111 |             document (str): The document to be added.
112 |             condition (bool, optional): The condition to check before adding the document. Defaults to True.
113 | 
114 |         Returns:
115 |             str: The ID of the added document.
116 |         """
117 |         try:
118 |             doc_id = str(uuid.uuid4())
119 |             self.collection.add(
120 |                 ids=[doc_id],
121 |                 documents=[document],
122 |                 images=images,
123 |                 uris=img_urls,
124 |                 *args,
125 |                 **kwargs,
126 |             )
127 |             return doc_id
128 |         except Exception as e:
129 |             raise Exception(f"Failed to add document: {str(e)}")
130 | 
131 |     def query(
132 |         self,
133 |         query_text: str,
134 |         query_images: List[np.ndarray],
135 |         *args,
136 |         **kwargs,
137 |     ):
138 |         """
139 |         Query documents from the ChromaDB collection.
140 | 
141 |         Args:
142 |             query (str): The query string.
143 |             n_docs (int, optional): The number of documents to retrieve. Defaults to 1.
144 | 
145 |         Returns:
146 |             dict: The retrieved documents.
147 |         """
148 |         try:
149 |             docs = self.collection.query(
150 |                 query_texts=[query_text],
151 |                 query_images=query_images,
152 |                 n_results=self.n_docs,
153 |                 *args,
154 |                 **kwargs,
155 |             )["documents"]
156 |             return docs[0]
157 |         except Exception as e:
158 |             raise Exception(f"Failed to query documents: {str(e)}")
159 | 
160 |     def traverse_directory(self):
161 |         """
162 |         Traverse through every file in the given directory and its subdirectories,
163 |         and return the paths of all files.
164 |         Parameters:
165 |         - directory_name (str): The name of the directory to traverse.
166 |         Returns:
167 |         - list: A list of paths to each file in the directory and its subdirectories.
168 |         """
169 |         image_extensions = [
170 |             ".jpg",
171 |             ".jpeg",
172 |             ".png",
173 |         ]
174 |         images = []
175 |         for root, dirs, files in os.walk(self.docs_folder):
176 |             for file in files:
177 |                 _, ext = os.path.splitext(file)
178 |                 if ext.lower() in image_extensions:
179 |                     images.append(os.path.join(root, file))
180 |                 else:
181 |                     data = data_to_text(file)
182 |                     added_to_db = self.add([data])
183 |                     print(f"{file} added to Database")
184 |         if images:
185 |             added_to_db = self.add(img_urls=[images])
186 |             print(f"{len(images)} images added to Database ")
187 |         return added_to_db
188 | 


--------------------------------------------------------------------------------
/neo_sapiens/few_shot_prompts.py:
--------------------------------------------------------------------------------
  1 | from typing import List
  2 | 
  3 | # Example usage
  4 | data = """
  5 | {
  6 |     "plan": "Step 1",
  7 |     "agents": [
  8 |         {
  9 |             "name": "Agent 1",
 10 |             "system_prompt": "Prompt 1"
 11 |         },
 12 |         {
 13 |             "name": "Agent 2",
 14 |             "system_prompt": "Prompt 2"
 15 |         }
 16 |     ]
 17 | }
 18 | """
 19 | 
 20 | # AI Research Team 1
 21 | data1 = """
 22 | {
 23 |     "plan": "Data Collection, Data Cleaning, Model Training, Model Evaluation",
 24 |     "agents": [
 25 |         {
 26 |             "name": "Data Agent",
 27 |             "system_prompt": "Collect and clean data"
 28 |         },
 29 |         {
 30 |             "name": "Training Agent",
 31 |             "system_prompt": "Train the model"
 32 |         },
 33 |         {
 34 |             "name": "Evaluation Agent",
 35 |             "system_prompt": "Evaluate the model"
 36 |         }
 37 |     ]
 38 | }
 39 | """
 40 | 
 41 | # AI Research Team 2
 42 | data2 = """
 43 | {
 44 |     "plan": "Literature Review, Hypothesis Formulation, Experiment Design, Data Analysis, Paper Writing",
 45 |     "agents": [
 46 |         {
 47 |             "name": "Review Agent",
 48 |             "system_prompt": "Review the literature"
 49 |         },
 50 |         {
 51 |             "name": "Hypothesis Agent",
 52 |             "system_prompt": "Formulate the hypothesis"
 53 |         },
 54 |         {
 55 |             "name": "Design Agent",
 56 |             "system_prompt": "Design the experiment"
 57 |         },
 58 |         {
 59 |             "name": "Analysis Agent",
 60 |             "system_prompt": "Analyze the data"
 61 |         },
 62 |         {
 63 |             "name": "Writing Agent",
 64 |             "system_prompt": "Write the paper"
 65 |         }
 66 |     ]
 67 | }
 68 | """
 69 | 
 70 | # AI Research Team 3
 71 | data3 = """
 72 | {
 73 |     "plan": "Problem Identification, Solution Design, Implementation, Testing, Deployment",
 74 |     "agents": [
 75 |         {
 76 |             "name": "Identification Agent",
 77 |             "system_prompt": "Identify the problem"
 78 |         },
 79 |         {
 80 |             "name": "Design Agent",
 81 |             "system_prompt": "Design the solution"
 82 |         },
 83 |         {
 84 |             "name": "Implementation Agent",
 85 |             "system_prompt": "Implement the solution"
 86 |         },
 87 |         {
 88 |             "name": "Deployment Agent",
 89 |             "system_prompt": "Deploy the solution"
 90 |         }
 91 |     ]
 92 | }
 93 | """
 94 | 
 95 | 
 96 | data5 = """
 97 | {
 98 |     "plan": "Room Management, Guest Services, Reservations Handling, Facility Maintenance, Staff Coordination",
 99 |     "agents": [
100 |         {
101 |             "name": "Room Management Agent",
102 |             "system_prompt": "Automate room assignments, minibar restocking, and housekeeping schedules"
103 |         },
104 |         {
105 |             "name": "Guest Services Agent",
106 |             "system_prompt": "Handle check-ins, check-outs, guest requests, and complaints efficiently"
107 |         },
108 |         {
109 |             "name": "Reservations Agent",
110 |             "system_prompt": "Manage room bookings, table reservations, and special requests"
111 |         },
112 |         {
113 |             "name": "Maintenance Agent",
114 |             "system_prompt": "Schedule and track maintenance tasks for facilities and rooms"
115 |         },
116 |         {
117 |             "name": "Staff Coordination Agent",
118 |             "system_prompt": "Optimize staff schedules, task assignments, and workload distribution"
119 |         }
120 |     ]
121 | }
122 | """
123 | 
124 | 
125 | def merge_fewshots_into_str(
126 |     plan: List[str] = [data, data1, data2, data3, data5]
127 | ) -> str:
128 |     """
129 |     Merge a list of plans into a single string.
130 | 
131 |     Args:
132 |         plan (List[str]): A list of plans to be merged.
133 | 
134 |     Returns:
135 |         str: The merged plans as a single string.
136 |     """
137 |     return "\n".join(plan)
138 | 
139 | 
140 | self_driving_car_prompt = """
141 | 
142 | {
143 |     "plan": (
144 |         "Step 1: Create agents specialized in different areas"
145 |         " like computer vision, sensor fusion, controls,"
146 |         " planning, etc.",
147 |         "Step 2: Have the team leader agent decompose the overall"
148 |         " self-driving task into sub-problems and assign them to"
149 |         " the specialized agents",
150 |         "Step 3: Have each agent focus on solving their specific"
151 |         " sub-problem using the latest AI techniques",
152 |         "Step 4: Have agents coordinate solutions with each other"
153 |         " through the team leader to make sure components work"
154 |         " together",
155 |         "Step 5: Integrate components into a complete"
156 |         " self-driving system and validate performance through"
157 |         " simulation and real-world testing"
158 |     ),
159 |     "agents": [
160 |         {
161 |             "name": "Computer Vision Agent",
162 |             "system_prompt": (
163 |                 "Create an AI agent specialized in computer vision"
164 |                 " for self-driving cars, focused on object detection,"
165 |                 " segmentation and tracking using deep learning"
166 |                 " models like convolutional neural networks."
167 |                 " Coordinate with other agents through the team"
168 |                 " leader."
169 |             ),
170 |         },
171 |         {
172 |             "name": "Sensor Fusion Agent",
173 |             "system_prompt": (
174 |                 "Create an AI agent specialized in sensor fusion for"
175 |                 " self-driving cars, focused on combining camera,"
176 |                 " radar and lidar data into a consistent 3D"
177 |                 " representation of the environment. Coordinate with"
178 |                 " other agents through the team leader."
179 |             ),
180 |         },
181 |     ],
182 | }
183 | 
184 | 
185 | """
186 | 
187 | 
188 | def orchestrator_prompt_agent(objective: str):
189 |     prompt = (
190 |         "Create an instruction prompt for an swarm orchestrator to"
191 |         " create a series of personalized, agents for the following"
192 |         f" objective: {objective} to decompose a very complicated"
193 |         " problem or tasks, the orchestrator is the team leader."
194 |         " Teach the orchestrator how to decompose the tasks to very"
195 |         " certain agents with names, and system prompts, we need the"
196 |         " plan, with a step by stpe instructions, number of agents,"
197 |         " and a list of agents with a name, system prompt for each,"
198 |         " and then the rules of the swarm,  compact the prompt, and"
199 |         " say only return JSON data in markdown and nothing"
200 |         f" else.Follow the schema here: {data} *############ Here are"
201 |         f" some examples:{data5} and another example{data3} "
202 |     )
203 |     return str(prompt)
204 | 
205 | 
206 | boss_sys_prompt = (
207 |     "You're the Swarm Orchestrator, like a project manager of a"
208 |     " bustling hive. When a task arises, you tap into your network of"
209 |     " worker agents who are ready to jump into action. Whether it's"
210 |     " organizing data, handling logistics, or crunching numbers, you"
211 |     " delegate tasks strategically to maximize efficiency. Picture"
212 |     " yourself as the conductor of a well-oiled machine,"
213 |     " orchestrating the workflow seamlessly to achieve optimal"
214 |     " results with your team of dedicated worker agents."
215 | )
216 | 
217 | 
218 | def select_workers(agents: str, task: str):
219 |     return (
220 |         f"These are the agents available for the task: {task} Agents"
221 |         f" available: {agents}"
222 |     )
223 | 
224 | 
225 | kaggle = """
226 | 
227 | Leash Bio - Predict New Medicines with BELKA
228 | Predict small molecule-protein interactions using the Big Encoded Library for Chemical Assessment (BELKA)
229 | 
230 | 
231 | 
232 | Overview
233 | 
234 | Data
235 | 
236 | Code
237 | 
238 | Models
239 | 
240 | Discussion
241 | 
242 | Leaderboard
243 | 
244 | Rules
245 | Overview
246 | In this competition, you’ll develop machine learning (ML) models to predict the binding affinity of small molecules to specific protein targets – a critical step in drug development for the pharmaceutical industry that would pave the way for more accurate drug discovery. You’ll help predict which drug-like small molecules (chemicals) will bind to three possible protein targets.
247 | 
248 | Start
249 | 
250 | 8 days ago
251 | Close
252 | 3 months to go
253 | Merger & Entry
254 | Description
255 | Small molecule drugs are chemicals that interact with cellular protein machinery and affect the functions of this machinery in some way. Often, drugs are meant to inhibit the activity of single protein targets, and those targets are thought to be involved in a disease process. A classic approach to identify such candidate molecules is to physically make them, one by one, and then expose them to the protein target of interest and test if the two interact. This can be a fairly laborious and time-intensive process.
256 | 
257 | The US Food and Drug Administration (FDA) has approved roughly 2,000 novel molecular entities in its entire history. However, the number of chemicals in druglike space has been estimated to be 10^60, a space far too big to physically search. There are likely effective treatments for human ailments hiding in that chemical space, and better methods to find such treatments are desirable to us all.
258 | 
259 | To evaluate potential search methods in small molecule chemistry, competition host Leash Biosciences physically tested some 133M small molecules for their ability to interact with one of three protein targets using DNA-encoded chemical library (DEL) technology. This dataset, the Big Encoded Library for Chemical Assessment (BELKA), provides an excellent opportunity to develop predictive models that may advance drug discovery.
260 | 
261 | Datasets of this size are rare and restricted to large pharmaceutical companies. The current best-curated public dataset of this kind is perhaps bindingdb, which, at 2.8M binding measurements, is much smaller than BELKA.
262 | 
263 | This competition aims to revolutionize small molecule binding prediction by harnessing ML techniques. Recent advances in ML approaches suggest it might be possible to search chemical space by inference using well-trained computational models rather than running laboratory experiments. Similar progress in other fields suggest using ML to search across vast spaces could be a generalizable approach applicable to many domains. We hope that by providing BELKA we will democratize aspects of computational drug discovery and assist the community in finding new lifesaving medicines.
264 | 
265 | Here, you’ll build predictive models to estimate the binding affinity of unknown chemical compounds to specified protein targets. You may use the training data provided; alternatively, there are a number of methods to make small molecule binding predictions without relying on empirical binding data (e.g. DiffDock, and this contest was designed to allow for such submissions).
266 | 
267 | Your work will contribute to advances in small molecule chemistry used to accelerate drug discovery.
268 | 
269 | Evaluation
270 | This metric for this competition is the Mean Average Precision (micro) between the predicted probability and the observed target.
271 | 
272 | Submission File
273 | For each id in the test set, you must predict a probability for the binary target binds target. The file should contain a header and have the following format:
274 | 
275 | id,binds
276 | 295246830,0.5
277 | 295246831,0.5
278 | 295246832,0.5
279 | etc.
280 | Timeline
281 | April 4, 2024 - Start Date.
282 | July 1, 2024 - Entry Deadline. You must accept the competition rules before this date in order to compete.
283 | July 1, 2024 - Team Merger Deadline. This is the last day participants may join or merge teams.
284 | July 8, 2024 - Final Submission Deadline.
285 | All deadlines are at 11:59 PM UTC on the corresponding day unless otherwise noted. The competition organizers reserve the right to update the contest timeline if they deem it necessary.
286 | 
287 | Prizes
288 | First Prize: $12,000
289 | Second Prize: $10,000
290 | Third Prize: $10,000
291 | Fourth Prize: $8,000
292 | Fifth Prize: $5,000
293 | Top Student Group: $5,000 to the highest performing student team. A team would be considered a student team if majority members (e.g. at least 3 out of a 5 member team) are students enrolled in a high school or university degree. In the case of an even number of members, half of them must be students.
294 | Competition Host
295 | Leash Biosciences is a discovery-stage biotechnology company that seeks to improve medicinal chemistry with machine learning approaches and massive data collection. Leash is comprised of wet lab scientists and dry lab scientists in equal numbers, and is proudly headquartered in Salt Lake City, Utah, USA.
296 | 
297 | Additional Details
298 | Chemical Representations
299 | One of the goals of this competition is to explore and compare many different ways of representing molecules. Small molecules have been represented with SMILES, graphs, 3D structures, and more, including more esoteric methods such as spherical convolutional neural nets. We encourage competitors to explore not only different methods of making predictions but also to try different ways of representing the molecules.
300 | 
301 | We provide the molecules in SMILES format.
302 | 
303 | SMILES
304 | SMILES is a concise string notation used to represent the structure of chemical molecules. It encodes the molecular graph, including atoms, bonds, connectivity, and stereochemistry as a linear sequence of characters, by traversing the molecule graph. SMILES is widely used in machine learning applications for chemistry, such as molecular property prediction, drug discovery, and materials design, as it provides a standardized and machine-readable format for representing and manipulating chemical structures.
305 | 
306 | The SMILES in this dataset should be sufficient to be translated into any other chemical representation format that you want to try. A simple way to perform some of these translations is with RDKit.
307 | 
308 | Details about the experiments
309 | DELs are libraries of small molecules with unique DNA barcodes covalently attached
310 | Traditional high-throughput screening requires keeping individual small molecules in separate, identifiable tubes and demands a lot of liquid handling to test each one of those against the protein target of interest in a separate reaction. The logistical overhead of these efforts tends to restrict screening collections, called libraries, to 50K-5M small molecules. A scalable solution to this problem, DNA-encoded chemical libraries, was described in 2009. As DNA sequencing got cheaper and cheaper, it became clear that DNA itself could be used as a label to identify, and deconvolute, collections of molecules in a complex mixture. DELs leverage this DNA sequencing technology.
311 | 
312 | These barcoded small molecules are in a pool (many in a single tube, rather than one tube per small molecule) and are exposed to the protein target of interest in solution. The protein target of interest is then rinsed to remove small molecules in the DEL that don’t bind the target, and the remaining binders are collected and their DNA sequenced.
313 | 
314 | DELs are manufactured by combining different building blocks
315 | An intuitive way to think about DELs is to imagine a Mickey Mouse head as an example of a small molecule in the DEL. We attach the DNA barcode to Mickey’s chin. Mickey’s left ear is connected by a zipper; Mickey’s right ear is connected by velcro. These attachment points of zippers and velcro are analogies to different chemical reactions one might use to construct the DEL.
316 | 
317 | We could purchase ten different Mickey Mouse faces, ten different zipper ears, and ten different velcro ears, and use them to construct our small molecule library. By creating every combination of these three, we’ll have 1,000 small molecules, but we only needed thirty building blocks (faces and ears) to make them. This combinatorial approach is what allows DELs to have so many members: the library in this competition is composed of 133M small molecules. The 133M small molecule library used here, AMA014, was provided by AlphaMa. It has a triazine core and superficially resembles the DELs described here.
318 | 
319 | 
320 | 
321 | Dataset Description
322 | Overview
323 | The examples in the competition dataset are represented by a binary classification of whether a given small molecule is a binder or not to one of three protein targets. The data were collected using DNA-encoded chemical library (DEL) technology.
324 | 
325 | We represent chemistry with SMILES (Simplified Molecular-Input Line-Entry System) and the labels as binary binding classifications, one per protein target of three targets.
326 | 
327 | Files
328 | [train/test].[csv/parquet] - The train or test data, available in both the csv and parquet formats.
329 | 
330 | id - A unique example_id that we use to identify the molecule-binding target pair.
331 | buildingblock1_smiles - The structure, in SMILES, of the first building block
332 | buildingblock2_smiles - The structure, in SMILES, of the second building block
333 | buildingblock3_smiles - The structure, in SMILES, of the third building block
334 | molecule_smiles - The structure of the fully assembled molecule, in SMILES. This includes the three building blocks and the triazine core. Note we use a [Dy] as the stand-in for the DNA linker.
335 | protein_name - The protein target name
336 | binds - The target column. A binary class label of whether the molecule binds to the protein. Not available for the test set.
337 | sample_submission.csv - A sample submission file in the correct format
338 | 
339 | Competition data
340 | All data were generated in-house at Leash Biosciences. We are providing roughly 98M training examples per protein, 200K validation examples per protein, and 360K test molecules per protein. To test generalizability, the test set contains building blocks that are not in the training set. These datasets are very imbalanced: roughly 0.5% of examples are classified as binders; we used 3 rounds of selection in triplicate to identify binders experimentally. Following the competition, Leash will make all the data available for future use (3 targets * 3 rounds of selection * 3 replicates * 133M molecules, or 3.6B measurements).
341 | 
342 | Targets
343 | Proteins are encoded in the genome, and names of the genes encoding those proteins are typically bestowed by their discoverers and regulated by the Hugo Gene Nomenclature Committee. The protein products of these genes can sometimes have different names, often due to the history of their discovery.
344 | 
345 | We screened three protein targets for this competition.
346 | 
347 | EPHX2 (sEH)
348 | The first target, epoxide hydrolase 2, is encoded by the EPHX2 genetic locus, and its protein product is commonly named “soluble epoxide hydrolase”, or abbreviated to sEH. Hydrolases are enzymes that catalyze certain chemical reactions, and EPHX2/sEH also hydrolyzes certain phosphate groups. EPHX2/sEH is a potential drug target for high blood pressure and diabetes progression, and small molecules inhibiting EPHX2/sEH from earlier DEL efforts made it to clinical trials.
349 | 
350 | EPHX2/sEH was also screened with DELs, and hits predicted with ML approaches, in a recent study but the screening data were not published. We included EPHX2/sEH to allow contestants an external gut check for model performance by comparing to these previously-published results.
351 | 
352 | We screened EPHX2/sEH purchased from Cayman Chemical, a life sciences commercial vendor. For those contestants wishing to incorporate protein structural information in their submissions, the amino sequence is positions 2-555 from UniProt entry P34913, the crystal structure can be found in PDB entry 3i28, and predicted structure can be found in AlphaFold2 entry 34913. Additional EPHX2/sEH crystal structures with ligands bound can be found in PDB.
353 | 
354 | BRD4
355 | The second target, bromodomain 4, is encoded by the BRD4 locus and its protein product is also named BRD4. Bromodomains bind to protein spools in the nucleus that DNA wraps around (called histones) and affect the likelihood that the DNA nearby is going to be transcribed, producing new gene products. Bromodomains play roles in cancer progression and a number of drugs have been discovered to inhibit their activities.
356 | 
357 | BRD4 has been screened with DEL approaches previously but the screening data were not published. We included BRD4 to allow contestants to evaluate candidate molecules for oncology indications.
358 | 
359 | We screened BRD4 purchased from Active Motif, a life sciences commercial vendor. For those contestants wishing to incorporate protein structural information in their submissions, the amino acid sequence is positions 44-460 from UniProt entry O60885-1, the crystal structure (for a single domain) can be found in PDB entry 7USK and predicted structure can be found in AlphaFold2 entry O60885. Additional BRD4 crystal structures with ligands bound can be found in PDB.
360 | 
361 | ALB (HSA)
362 | The third target, serum albumin, is encoded by the ALB locus and its protein product is also named ALB. The protein product is sometimes abbreviated as HSA, for “human serum albumin”. ALB, the most common protein in the blood, is used to drive osmotic pressure (to bring fluid back from tissues into blood vessels) and to transport many ligands, hormones, fatty acids, and more.
363 | 
364 | Albumin, being the most abundant protein in the blood, often plays a role in absorbing candidate drugs in the body and sequestering them from their target tissues. Adjusting candidate drugs to bind less to albumin and other blood proteins is a strategy to help these candidate drugs be more effective.
365 | 
366 | ALB has been screened with DEL approaches previously but the screening data were not published. We included ALB to allow contestants to build models that might have a larger impact on drug discovery across many disease types. The ability to predict ALB binding well would allow drug developers to improve their candidate small molecule therapies much more quickly than physically manufacturing many variants and testing them against ALB empirically in an iterative process.
367 | 
368 | We screened ALB purchased from Active Motif. For those contestants wishing to incorporate protein structural information in their submissions, the amino acid sequence is positions 25 to 609 from UniProt entry P02768, the crystal structure can be found in PDB entry 1AO6, and predicted structure can be found in AlphaFold2 entry P02768. Additional ALB crystal structures with ligands bound can be found in PDB.
369 | 
370 | Good luck!
371 | 
372 | """
373 | 


--------------------------------------------------------------------------------
/neo_sapiens/hass_schema.py:
--------------------------------------------------------------------------------
  1 | import json
  2 | import os
  3 | import re
  4 | from typing import List
  5 | 
  6 | from dotenv import load_dotenv
  7 | from pydantic import BaseModel, Field
  8 | from swarms import Agent, Anthropic
  9 | from swarms.structs.swarm_net import SwarmNetwork
 10 | 
 11 | from neo_sapiens.few_shot_prompts import (
 12 |     data,
 13 |     data1,
 14 |     data2,
 15 |     data3,
 16 |     orchestrator_prompt_agent,
 17 |     select_workers,
 18 |     boss_sys_prompt,
 19 | )
 20 | from loguru import logger
 21 | from neo_sapiens.tools_preset import (
 22 |     terminal,
 23 |     browser,
 24 |     file_editor,
 25 |     create_file,
 26 | )
 27 | 
 28 | # Load environment variables
 29 | load_dotenv()
 30 | 
 31 | # Swarmnetowr
 32 | network = SwarmNetwork(api_enabled=True, logging_enabled=True)
 33 | 
 34 | 
 35 | # def tool_router(tool: str, *args, **kwargs):
 36 | #     if "terminal" in tool:
 37 | #         return terminal(*args, **kwargs)
 38 | #     elif "browser" in tool:
 39 | #         return browser(*args, **kwargs)
 40 | 
 41 | 
 42 | def find_agent_id_by_name(name: str):
 43 |     """
 44 |     Find an agent's ID by its name.
 45 | 
 46 |     Args:
 47 |         name (str): The name of the agent.
 48 | 
 49 |     Returns:
 50 |         str: The ID of the agent.
 51 |     """
 52 |     for agent in network.agent_pool:
 53 |         if agent.agent_name == name:
 54 |             return agent.id
 55 | 
 56 | 
 57 | class ToolSchema(BaseModel):
 58 |     tool: str = Field(
 59 |         ...,
 60 |         title="Tool name",
 61 |         description="Either `browser` or `terminal`",
 62 |     )
 63 | 
 64 | 
 65 | class AgentSchema(BaseModel):
 66 |     name: str = Field(
 67 |         ...,
 68 |         title="Name of the agent",
 69 |         description="Name of the agent",
 70 |     )
 71 |     system_prompt: str = (
 72 |         Field(
 73 |             ...,
 74 |             title="System prompt for the agent",
 75 |             description="System prompt for the agent",
 76 |         ),
 77 |     )
 78 |     rules: str = Field(
 79 |         ...,
 80 |         title="Rules",
 81 |         description="Rules for the agent",
 82 |     )
 83 |     # tools: List[ToolSchema] = Field(
 84 |     #     ...,
 85 |     #     title="Tools available to the agent",
 86 |     #     description="Either `browser` or `terminal`",
 87 |     # )
 88 |     # task: str = Field(
 89 |     #     ...,
 90 |     #     title="Task assigned to the agent",
 91 |     #     description="Task assigned to the agent",
 92 |     # )
 93 |     # TODO: Add more fields here such as the agent's language model, tools, etc.
 94 | 
 95 | 
 96 | class HassSchema(BaseModel):
 97 |     plan: str = Field(
 98 |         ...,
 99 |         title="Plan to solve the input problem",
100 |         description="List of steps to solve the problem",
101 |     )
102 |     agents: List[AgentSchema] = Field(
103 |         ...,
104 |         title="List of agents to use for the problem",
105 |         description="List of agents to use for the problem",
106 |     )
107 | 
108 |     # Rules for the agents
109 |     # rules: str = Field(
110 |     #     ...,
111 |     #     title="Rules for the agents",
112 |     #     description="Rules for the agents",
113 |     # )
114 | 
115 | 
116 | # import json
117 | def parse_json_from_input(input_str):
118 |     # Validate input is not None or empty
119 |     if not input_str:
120 |         logger.info("Error: Input string is None or empty.")
121 |         return None, None, None
122 | 
123 |     # Attempt to extract JSON from markdown using regular expression
124 |     json_pattern = re.compile(r"```json\n(.*?)\n```", re.DOTALL)
125 |     match = json_pattern.search(input_str)
126 |     json_str = match.group(1).strip() if match else input_str.strip()
127 | 
128 |     # Attempt to parse the JSON string
129 |     try:
130 |         data = json.loads(json_str)
131 |     except json.JSONDecodeError as e:
132 |         logger.info(f"Error: JSON decoding failed with message '{e}'")
133 |         return None, None, None
134 | 
135 |     hass_schema = HassSchema(**data)
136 |     return (
137 |         hass_schema.plan,
138 |         hass_schema.agents,
139 |         # hass_schema.rules,
140 |     )
141 | 
142 | 
143 | # You can test the function with a markdown string similar to the one provided.
144 | 
145 | 
146 | def merge_plans_into_str(
147 |     plan: List[str] = [data, data1, data2, data3]
148 | ) -> str:
149 |     """
150 |     Merge a list of plans into a single string.
151 | 
152 |     Args:
153 |         plan (List[str]): A list of plans to be merged.
154 | 
155 |     Returns:
156 |         str: The merged plans as a single string.
157 |     """
158 |     return "\n".join(plan)
159 | 
160 | 
161 | # parsed_schema = parse_hass_schema(data5)
162 | # plan, number_of_agents, agents = parsed_schema
163 | 
164 | 
165 | def merge_rules_into_str(prompts: List[str]):
166 |     """
167 |     Merge a list of prompts into a single string.
168 | 
169 |     Args:
170 |         prompts (List[str]): A list of prompts to be merged.
171 | 
172 |     Returns:
173 |         str: The merged prompts as a single string.
174 |     """
175 |     return "\n".join(prompts)
176 | 
177 | 
178 | def create_worker_agents(
179 |     agents: List[AgentSchema],
180 | ) -> List[Agent]:
181 |     """
182 |     Create and initialize agents based on the provided AgentSchema objects.
183 | 
184 |     Args:
185 |         agents (List[AgentSchema]): A list of AgentSchema objects containing agent information.
186 | 
187 |     Returns:
188 |         List[Agent]: The initialized Agent objects.
189 | 
190 |     """
191 |     agent_list = []
192 |     for agent in agents:
193 |         name = agent.name
194 |         system_prompt = agent.system_prompt
195 | 
196 |         logger.info(
197 |             f"Creating agent: {name} with system prompt:"
198 |             f" {system_prompt}"
199 |         )
200 | 
201 |         out = Agent(
202 |             agent_name=name,
203 |             system_prompt=system_prompt,
204 |             llm=Anthropic(
205 |                 anthropic_api_key=os.getenv("ANTHROPIC_API_KEY")
206 |             ),
207 |             max_loops=1,
208 |             autosave=True,
209 |             dashboard=False,
210 |             verbose=True,
211 |             stopping_token="<DONE>",
212 |             tools=[browser, terminal, create_file, file_editor],
213 |         )
214 | 
215 |         network.add_agent(out)
216 |         agent_list.append(out)
217 | 
218 |     return agent_list
219 | 
220 | 
221 | def create_agents_by_boss(team: str = None, *args, **kwargs):
222 |     """
223 |     Create agents by boss.
224 | 
225 |     Args:
226 |         team (str): The name of the team. Defaults to None.
227 |         *args: Variable length argument list.
228 |         **kwargs: Arbitrary keyword arguments.
229 | 
230 |     Returns:
231 |         str: The output of the agent run.
232 | 
233 |     """
234 |     system_prompt_daddy = orchestrator_prompt_agent(team)
235 | 
236 |     # Create the agents
237 |     agent = Agent(
238 |         agent_name="Swarm Orchestrator",
239 |         system_prompt=system_prompt_daddy,
240 |         llm=Anthropic(
241 |             anthropic_api_key=os.getenv("ANTHROPIC_API_KEY"),
242 |             max_tokens=4000,
243 |         ),
244 |         max_loops=1,
245 |         autosave=True,
246 |         dashboard=False,
247 |         verbose=True,
248 |         stopping_token="<DONE>",
249 |         *args,
250 |         **kwargs,
251 |     )
252 | 
253 |     # Run the agent and parse the output
254 |     out = agent.run(str(team))
255 |     return out
256 | 
257 | 
258 | def print_agent_names(agents: list):
259 |     for agent in agents:
260 |         logger.info(f"Agent Name: {agent.agent_name}")
261 | 
262 | 
263 | def send_task_to_network_agent(name: str, task: str):
264 |     """
265 |     Send a task to a network agent.
266 | 
267 |     Args:
268 |         name (str): The name of the agent.
269 |         task (str): The task to be sent to the agent.
270 | 
271 |     Returns:
272 |         str: The response from the agent.
273 |     """
274 |     logger.info(f"Adding agent {name} as a tool")
275 |     agent_id = find_agent_id_by_name(name)
276 |     out = network.run_single_agent(agent_id, task)
277 |     return out
278 | 
279 | 
280 | def build_swarm(team_task: str, task: str, *args, **kwargs):
281 |     """
282 |     Master function to create agents based on a task.
283 | 
284 |     Args:
285 |         task (str): The task to be executed.
286 | 
287 |     Returns:
288 |         None
289 |     """
290 |     # Call the agents [ Main Agents ]
291 |     boss = Agent(
292 |         agent_name="Swarm Orchestrator",
293 |         system_prompt=boss_sys_prompt,
294 |         llm=Anthropic(
295 |             anthropic_api_key=os.getenv("ANTHROPIC_API_KEY"),
296 |             max_tokens=4000,
297 |         ),
298 |         max_loops="auto",
299 |         autosave=True,
300 |         dashboard=False,
301 |         verbose=True,
302 |         interactive=True,
303 |         stopping_token="<DONE>",
304 |         tools=[create_agents_by_boss, send_task_to_network_agent]
305 |         * args,
306 |         **kwargs,
307 |     )
308 | 
309 |     # Task 1: Run the agent and parse the output
310 |     logger.info("Creating the workers ...")
311 |     out = create_agents_by_boss(team_task)
312 |     json_agentic_output = out
313 |     # logger.info(f"Output: {out}")
314 |     out = parse_json_from_input(out)
315 |     plan, agents = out
316 | 
317 |     # Task 2: Print agent names and create agents
318 |     # logger.info(agents)
319 |     # logger.info("Creating agents...")
320 |     agents = create_worker_agents(agents)
321 | 
322 |     # Send JSON of agents to boss
323 |     boss.add_message_to_memory(
324 |         select_workers(json_agentic_output, task)
325 |     )
326 | 
327 |     # Task 3: Now add the agents as tools -- Run the agents in a loop sequentially
328 |     # boss.add_tool(send_task_to_network_agent)
329 | 
330 |     # Run the boss:
331 |     out = boss.run(task)
332 | 
333 |     return out
334 | 
335 | 
336 | def run_swarm(
337 |     team_task: str = None, task: str = None, *args, **kwargs
338 | ):
339 |     """
340 |     Run a task using the Swarm Orchestrator agent.
341 | 
342 |     Args:
343 |         task (str): The task to be executed.
344 | 
345 |     Returns:
346 |         None
347 |     """
348 |     out = build_swarm(team_task, task, *args, **kwargs)
349 |     return out
350 | 


--------------------------------------------------------------------------------
/neo_sapiens/tools_preset.py:
--------------------------------------------------------------------------------
 1 | from swarms import tool
 2 | import subprocess
 3 | 
 4 | 
 5 | # Tools
 6 | def terminal(
 7 |     code: str,
 8 | ):
 9 |     """
10 |     Run code in the terminal.
11 | 
12 |     Args:
13 |         code (str): The code to run in the terminal.
14 | 
15 |     Returns:
16 |         str: The output of the code.
17 |     """
18 |     out = subprocess.run(
19 |         code, shell=True, capture_output=True, text=True
20 |     ).stdout
21 |     return str(out)
22 | 
23 | 
24 | def browser(query: str):
25 |     """
26 |     Search the query in the browser with the `browser` tool.
27 | 
28 |     Args:
29 |         query (str): The query to search in the browser.
30 | 
31 |     Returns:
32 |         str: The search results.
33 |     """
34 |     import webbrowser
35 | 
36 |     url = f"https://www.google.com/search?q={query}"
37 |     webbrowser.open(url)
38 |     return f"Searching for {query} in the browser."
39 | 
40 | 
41 | def create_file(file_path: str, content: str):
42 |     """
43 |     Create a file using the file editor tool.
44 | 
45 |     Args:
46 |         file_path (str): The path to the file.
47 |         content (str): The content to write to the file.
48 | 
49 |     Returns:
50 |         str: The result of the file creation operation.
51 |     """
52 |     with open(file_path, "w") as file:
53 |         file.write(content)
54 |     return f"File {file_path} created successfully."
55 | 
56 | 
57 | def file_editor(file_path: str, mode: str, content: str):
58 |     """
59 |     Edit a file using the file editor tool.
60 | 
61 |     Args:
62 |         file_path (str): The path to the file.
63 |         mode (str): The mode to open the file in.
64 |         content (str): The content to write to the file.
65 | 
66 |     Returns:
67 |         str: The result of the file editing operation.
68 |     """
69 |     with open(file_path, mode) as file:
70 |         file.write(content)
71 |     return f"File {file_path} edited successfully."
72 | 


--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
 1 | [build-system]
 2 | requires = ["poetry-core>=1.0.0"]
 3 | build-backend = "poetry.core.masonry.api"
 4 | 
 5 | [tool.poetry]
 6 | name = "neo-sapiens"
 7 | version = "0.0.6"
 8 | description = "Neo Sapiens - Pytorch"
 9 | license = "MIT"
10 | authors = ["Kye Gomez <kye@apac.ai>"]
11 | homepage = "https://github.com/kyegomez/NeoSapiens"
12 | documentation = "https://github.com/kyegomez/NeoSapiens"  # Add this if you have documentation.
13 | readme = "README.md"  # Assuming you have a README.md
14 | repository = "https://github.com/kyegomez/NeoSapiens"
15 | keywords = ["artificial intelligence", "deep learning", "optimizers", "Prompt Engineering"]
16 | classifiers = [
17 |     "Development Status :: 4 - Beta",
18 |     "Intended Audience :: Developers",
19 |     "Topic :: Scientific/Engineering :: Artificial Intelligence",
20 |     "License :: OSI Approved :: MIT License",
21 |     "Programming Language :: Python :: 3.9"
22 | ]
23 | 
24 | [tool.poetry.dependencies]
25 | python = "^3.9"
26 | swarms = "*"
27 | pydantic = "*"
28 | loguru = "*"
29 | 
30 | 
31 | [tool.poetry.group.lint.dependencies]
32 | ruff = "^0.1.6"
33 | types-toml = "^0.10.8.1"
34 | types-redis = "^4.3.21.6"
35 | types-pytz = "^2023.3.0.0"
36 | black = "^23.1.0"
37 | types-chardet = "^5.0.4.6"
38 | mypy-protobuf = "^3.0.0"
39 | 
40 | 
41 | [tool.autopep8]
42 | max_line_length = 80
43 | ignore = "E501,W6"  # or ["E501", "W6"]
44 | in-place = true
45 | recursive = true
46 | aggressive = 3
47 | 
48 | 
49 | [tool.ruff]
50 | line-length = 70
51 | 
52 | [tool.black]
53 | line-length = 70
54 | target-version = ['py38']
55 | preview = true
56 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | torch
2 | zetascale
3 | swarms
4 | 


--------------------------------------------------------------------------------
/scripts/Dockerfile:
--------------------------------------------------------------------------------
 1 | # Use an official CUDA runtime as a parent image
 2 | FROM nvidia/cuda:11.4.2-runtime-ubuntu20.04
 3 | 
 4 | # Set the working directory in the container to /app
 5 | WORKDIR /app
 6 | 
 7 | # Copy the current directory contents into the container at /app
 8 | COPY . /app
 9 | 
10 | # Install any needed packages specified in requirements.txt
11 | RUN apt-get update && apt-get install -y \
12 |     python3-pip \
13 |     && rm -rf /var/lib/apt/lists/*
14 | RUN pip3 install --no-cache-dir -r requirements.txt
15 | 
16 | # Make port 80 available to the world outside this container
17 | EXPOSE 80
18 | 
19 | # Define environment variable
20 | # ENV NAME World
21 | 
22 | # Run app.py when the container launches
23 | CMD ["python3", "example.py"]


--------------------------------------------------------------------------------
/scripts/auto_tests_docs/auto_docs.py:
--------------------------------------------------------------------------------
 1 | ###### VERISON2
 2 | import inspect
 3 | import os
 4 | import threading
 5 | 
 6 | from dotenv import load_dotenv
 7 | 
 8 | from scripts.auto_tests_docs.docs import DOCUMENTATION_WRITER_SOP
 9 | from swarms import OpenAIChat
10 | from swarms.structs.majority_voting import MajorityVoting
11 | from swarms.structs.stackoverflow_swarm import StackOverflowSwarm
12 | from swarms.structs.task_queue_base import TaskQueueBase
13 | from swarms.structs.tool_json_schema import JSON
14 | 
15 | ##########
16 | 
17 | 
18 | ####################
19 | load_dotenv()
20 | 
21 | api_key = os.getenv("OPENAI_API_KEY")
22 | 
23 | model = OpenAIChat(
24 |     openai_api_key=api_key,
25 |     max_tokens=4000,
26 | )
27 | 
28 | 
29 | def process_documentation(cls):
30 |     """
31 |     Process the documentation for a given class using OpenAI model and save it in a Markdown file.
32 |     """
33 |     doc = inspect.getdoc(cls)
34 |     source = inspect.getsource(cls)
35 |     input_content = (
36 |         "Class Name:"
37 |         f" {cls.__name__}\n\nDocumentation:\n{doc}\n\nSource"
38 |         f" Code:\n{source}"
39 |     )
40 | 
41 |     # Process with OpenAI model (assuming the model's __call__ method takes this input and returns processed content)
42 |     processed_content = model(
43 |         DOCUMENTATION_WRITER_SOP(input_content, "swarms.structs")
44 |     )
45 | 
46 |     # doc_content = f"# {cls.__name__}\n\n{processed_content}\n"
47 |     doc_content = f"{processed_content}\n"
48 | 
49 |     # Create the directory if it doesn't exist
50 |     dir_path = "docs/swarms/tokenizers"
51 |     os.makedirs(dir_path, exist_ok=True)
52 | 
53 |     # Write the processed documentation to a Markdown file
54 |     file_path = os.path.join(dir_path, f"{cls.__name__.lower()}.md")
55 |     with open(file_path, "w") as file:
56 |         file.write(doc_content)
57 | 
58 |     print(f"Documentation generated for {cls.__name__}.")
59 | 
60 | 
61 | def main():
62 |     classes = [
63 |         JSON,
64 |         MajorityVoting,
65 |         StackOverflowSwarm,
66 |         TaskQueueBase,
67 |     ]
68 |     threads = []
69 |     for cls in classes:
70 |         thread = threading.Thread(
71 |             target=process_documentation, args=(cls,)
72 |         )
73 |         threads.append(thread)
74 |         thread.start()
75 | 
76 |     # Wait for all threads to complete
77 |     for thread in threads:
78 |         thread.join()
79 | 
80 |     print("Documentation generated in 'swarms.structs' directory.")
81 | 
82 | 
83 | if __name__ == "__main__":
84 |     main()
85 | 


--------------------------------------------------------------------------------
/scripts/auto_tests_docs/auto_docs_functions.py:
--------------------------------------------------------------------------------
 1 | import inspect
 2 | import os
 3 | import sys
 4 | import threading
 5 | 
 6 | from dotenv import load_dotenv
 7 | 
 8 | from scripts.auto_tests_docs.docs import DOCUMENTATION_WRITER_SOP
 9 | from swarms import OpenAIChat
10 | 
11 | load_dotenv()
12 | 
13 | api_key = os.getenv("OPENAI_API_KEY")
14 | 
15 | model = OpenAIChat(
16 |     model_name="gpt-4",
17 |     openai_api_key=api_key,
18 |     max_tokens=4000,
19 | )
20 | 
21 | 
22 | def process_documentation(item):
23 |     """
24 |     Process the documentation for a given function using OpenAI model and save it in a Markdown file.
25 |     """
26 |     doc = inspect.getdoc(item)
27 |     source = inspect.getsource(item)
28 |     input_content = (
29 |         f"Name: {item.__name__}\n\nDocumentation:\n{doc}\n\nSource"
30 |         f" Code:\n{source}"
31 |     )
32 |     print(input_content)
33 | 
34 |     # Process with OpenAI model
35 |     processed_content = model(
36 |         DOCUMENTATION_WRITER_SOP(input_content, "swarms.utils")
37 |     )
38 | 
39 |     doc_content = f"# {item.__name__}\n\n{processed_content}\n"
40 | 
41 |     # Create the directory if it doesn't exist
42 |     dir_path = "docs/swarms/utils"
43 |     os.makedirs(dir_path, exist_ok=True)
44 | 
45 |     # Write the processed documentation to a Markdown file
46 |     file_path = os.path.join(dir_path, f"{item.__name__.lower()}.md")
47 |     with open(file_path, "w") as file:
48 |         file.write(doc_content)
49 | 
50 | 
51 | def main():
52 |     # Gathering all functions from the swarms.utils module
53 |     functions = [
54 |         obj
55 |         for name, obj in inspect.getmembers(
56 |             sys.modules["swarms.utils"]
57 |         )
58 |         if inspect.isfunction(obj)
59 |     ]
60 | 
61 |     threads = []
62 |     for func in functions:
63 |         thread = threading.Thread(
64 |             target=process_documentation, args=(func,)
65 |         )
66 |         threads.append(thread)
67 |         thread.start()
68 | 
69 |     # Wait for all threads to complete
70 |     for thread in threads:
71 |         thread.join()
72 | 
73 |     print("Documentation generated in 'docs/swarms/utils' directory.")
74 | 
75 | 
76 | if __name__ == "__main__":
77 |     main()
78 | 


--------------------------------------------------------------------------------
/scripts/auto_tests_docs/auto_docs_omni.py:
--------------------------------------------------------------------------------
 1 | import inspect
 2 | import os
 3 | import threading
 4 | 
 5 | from dotenv import load_dotenv
 6 | 
 7 | from scripts.auto_tests_docs.docs import DOCUMENTATION_WRITER_SOP
 8 | from swarms import OpenAIChat
 9 | 
10 | ###########
11 | 
12 | 
13 | ###############
14 | 
15 | load_dotenv()
16 | 
17 | api_key = os.getenv("OPENAI_API_KEY")
18 | 
19 | model = OpenAIChat(
20 |     model_name="gpt-4-1106-preview",
21 |     openai_api_key=api_key,
22 |     max_tokens=4000,
23 | )
24 | 
25 | 
26 | def process_documentation(
27 |     item,
28 |     module: str = "swarms.structs",
29 |     docs_folder_path: str = "docs/swarms/structs",
30 | ):
31 |     """
32 |     Process the documentation for a given class or function using OpenAI model and save it in a Python file.
33 |     """
34 |     doc = inspect.getdoc(item)
35 |     source = inspect.getsource(item)
36 |     is_class = inspect.isclass(item)
37 |     item_type = "Class Name" if is_class else "Name"
38 |     input_content = (
39 |         f"{item_type}:"
40 |         f" {item.__name__}\n\nDocumentation:\n{doc}\n\nSource"
41 |         f" Code:\n{source}"
42 |     )
43 | 
44 |     # Process with OpenAI model
45 |     processed_content = model(
46 |         DOCUMENTATION_WRITER_SOP(input_content, module)
47 |     )
48 | 
49 |     doc_content = f"# {item.__name__}\n\n{processed_content}\n"
50 | 
51 |     # Create the directory if it doesn't exist
52 |     dir_path = docs_folder_path
53 |     os.makedirs(dir_path, exist_ok=True)
54 | 
55 |     # Write the processed documentation to a Python file
56 |     file_path = os.path.join(dir_path, f"{item.__name__.lower()}.md")
57 |     with open(file_path, "w") as file:
58 |         file.write(doc_content)
59 | 
60 |     print(
61 |         f"Processed documentation for {item.__name__}. at {file_path}"
62 |     )
63 | 
64 | 
65 | def main(module: str = "docs/swarms/structs"):
66 |     items = []
67 | 
68 |     threads = []
69 |     for item in items:
70 |         thread = threading.Thread(
71 |             target=process_documentation, args=(item,)
72 |         )
73 |         threads.append(thread)
74 |         thread.start()
75 | 
76 |     # Wait for all threads to complete
77 |     for thread in threads:
78 |         thread.join()
79 | 
80 |     print(f"Documentation generated in {module} directory.")
81 | 
82 | 
83 | if __name__ == "__main__":
84 |     main()
85 | 


--------------------------------------------------------------------------------
/scripts/auto_tests_docs/auto_tests.py:
--------------------------------------------------------------------------------
  1 | import inspect
  2 | import os
  3 | import re
  4 | import threading
  5 | 
  6 | ########
  7 | from dotenv import load_dotenv
  8 | 
  9 | from scripts.auto_tests_docs.docs import TEST_WRITER_SOP_PROMPT
 10 | from swarms import OpenAIChat
 11 | 
 12 | #########
 13 | from swarms.memory.dict_internal_memory import DictInternalMemory
 14 | from swarms.memory.dict_shared_memory import DictSharedMemory
 15 | from swarms.memory.lanchain_chroma import LangchainChromaVectorMemory
 16 | 
 17 | load_dotenv()
 18 | 
 19 | api_key = os.getenv("OPENAI_API_KEY")
 20 | 
 21 | model = OpenAIChat(
 22 |     openai_api_key=api_key,
 23 |     max_tokens=4000,
 24 | )
 25 | 
 26 | # agent = Agent(
 27 | #     llm=model,
 28 | #     agent_name="Unit Testing Agent",
 29 | #     agent_description=(
 30 | #         "This agent is responsible for generating unit tests for"
 31 | #         " the swarms package."
 32 | #     ),
 33 | #     autosave=True,
 34 | #     system_prompt=None,
 35 | #     max_loops=1,
 36 | # )
 37 | 
 38 | 
 39 | def extract_code_from_markdown(markdown_content: str):
 40 |     """
 41 |     Extracts code blocks from a Markdown string and returns them as a single string.
 42 | 
 43 |     Args:
 44 |     - markdown_content (str): The Markdown content as a string.
 45 | 
 46 |     Returns:
 47 |     - str: A single string containing all the code blocks separated by newlines.
 48 |     """
 49 |     # Regular expression for fenced code blocks
 50 |     pattern = r"```(?:\w+\n)?(.*?)```"
 51 |     matches = re.findall(pattern, markdown_content, re.DOTALL)
 52 | 
 53 |     # Concatenate all code blocks separated by newlines
 54 |     return "\n".join(code.strip() for code in matches)
 55 | 
 56 | 
 57 | def create_test(cls):
 58 |     """
 59 |     Process the documentation for a given class using OpenAI model and save it in a Python file.
 60 |     """
 61 |     doc = inspect.getdoc(cls)
 62 |     source = inspect.getsource(cls)
 63 |     input_content = (
 64 |         "Class Name:"
 65 |         f" {cls.__name__}\n\nDocumentation:\n{doc}\n\nSource"
 66 |         f" Code:\n{source}"
 67 |     )
 68 | 
 69 |     # Process with OpenAI model (assuming the model's __call__ method takes this input and returns processed content)
 70 |     processed_content = model(
 71 |         TEST_WRITER_SOP_PROMPT(
 72 |             input_content, "swarms", "swarms.memory"
 73 |         )
 74 |     )
 75 |     processed_content = extract_code_from_markdown(processed_content)
 76 | 
 77 |     doc_content = f"# {cls.__name__}\n\n{processed_content}\n"
 78 | 
 79 |     # Create the directory if it doesn't exist
 80 |     dir_path = "tests/memory"
 81 |     os.makedirs(dir_path, exist_ok=True)
 82 | 
 83 |     # Write the processed documentation to a Python file
 84 |     file_path = os.path.join(dir_path, f"{cls.__name__.lower()}.py")
 85 |     with open(file_path, "w") as file:
 86 |         file.write(doc_content)
 87 | 
 88 | 
 89 | def main():
 90 |     classes = [
 91 |         DictInternalMemory,
 92 |         DictSharedMemory,
 93 |         LangchainChromaVectorMemory,
 94 |     ]
 95 |     threads = []
 96 |     for cls in classes:
 97 |         thread = threading.Thread(target=create_test, args=(cls,))
 98 |         threads.append(thread)
 99 |         thread.start()
100 | 
101 |     # Wait for all threads to complete
102 |     for thread in threads:
103 |         thread.join()
104 | 
105 |     print("Tests generated in 'tests/memory' directory.")
106 | 
107 | 
108 | if __name__ == "__main__":
109 |     main()
110 | 


--------------------------------------------------------------------------------
/scripts/auto_tests_docs/auto_tests_functions.py:
--------------------------------------------------------------------------------
 1 | import inspect
 2 | import os
 3 | import sys
 4 | import threading
 5 | 
 6 | from dotenv import load_dotenv
 7 | 
 8 | from scripts.auto_tests_docs.docs import TEST_WRITER_SOP_PROMPT
 9 | from swarms import OpenAIChat
10 | from swarms.utils.parse_code import extract_code_from_markdown
11 | 
12 | load_dotenv()
13 | 
14 | api_key = os.getenv("OPENAI_API_KEY")
15 | 
16 | model = OpenAIChat(
17 |     model_name="gpt-4",
18 |     openai_api_key=api_key,
19 |     max_tokens=4000,
20 | )
21 | 
22 | 
23 | def process_documentation(item):
24 |     """
25 |     Process the documentation for a given function using OpenAI model and save it in a Markdown file.
26 |     """
27 |     doc = inspect.getdoc(item)
28 |     source = inspect.getsource(item)
29 |     input_content = (
30 |         f"Name: {item.__name__}\n\nDocumentation:\n{doc}\n\nSource"
31 |         f" Code:\n{source}"
32 |     )
33 |     # print(input_content)
34 | 
35 |     # Process with OpenAI model
36 |     processed_content = model(
37 |         TEST_WRITER_SOP_PROMPT(
38 |             input_content, "swarms.utils", "swarms.utils"
39 |         )
40 |     )
41 |     processed_content = extract_code_from_markdown(processed_content)
42 |     print(processed_content)
43 | 
44 |     doc_content = f"{processed_content}"
45 | 
46 |     # Create the directory if it doesn't exist
47 |     dir_path = "tests/utils"
48 |     os.makedirs(dir_path, exist_ok=True)
49 | 
50 |     # Write the processed documentation to a Markdown file
51 |     file_path = os.path.join(dir_path, f"{item.__name__.lower()}.py")
52 |     with open(file_path, "w") as file:
53 |         file.write(doc_content)
54 | 
55 | 
56 | def main():
57 |     # Gathering all functions from the swarms.utils module
58 |     functions = [
59 |         obj
60 |         for name, obj in inspect.getmembers(
61 |             sys.modules["swarms.utils"]
62 |         )
63 |         if inspect.isfunction(obj)
64 |     ]
65 | 
66 |     threads = []
67 |     for func in functions:
68 |         thread = threading.Thread(
69 |             target=process_documentation, args=(func,)
70 |         )
71 |         threads.append(thread)
72 |         thread.start()
73 | 
74 |     # Wait for all threads to complete
75 |     for thread in threads:
76 |         thread.join()
77 | 
78 |     print("Tests generated in 'tests/utils' directory.")
79 | 
80 | 
81 | if __name__ == "__main__":
82 |     main()
83 | 


--------------------------------------------------------------------------------
/scripts/auto_tests_docs/docs.py:
--------------------------------------------------------------------------------
  1 | def DOCUMENTATION_WRITER_SOP(
  2 |     task: str,
  3 |     module: str,
  4 | ):
  5 |     documentation = f"""Create multi-page long and explicit professional pytorch-like documentation for the {module} code below follow the outline for the {module} library,
  6 |     provide many examples and teach the user about the code, provide examples for every function, make the documentation 10,000 words,
  7 |     provide many usage examples and note this is markdown docs, create the documentation for the code to document,
  8 |     put the arguments and methods in a table in markdown to make it visually seamless
  9 | 
 10 |     Now make the professional documentation for this code, provide the architecture and how the class works and why it works that way,
 11 |     it's purpose, provide args, their types, 3 ways of usage examples, in examples show all the code like imports main example etc
 12 | 
 13 |     BE VERY EXPLICIT AND THOROUGH, MAKE IT DEEP AND USEFUL
 14 | 
 15 |     ########
 16 |     Step 1: Understand the purpose and functionality of the module or framework
 17 | 
 18 |     Read and analyze the description provided in the documentation to understand the purpose and functionality of the module or framework.
 19 |     Identify the key features, parameters, and operations performed by the module or framework.
 20 |     Step 2: Provide an overview and introduction
 21 | 
 22 |     Start the documentation by providing a brief overview and introduction to the module or framework.
 23 |     Explain the importance and relevance of the module or framework in the context of the problem it solves.
 24 |     Highlight any key concepts or terminology that will be used throughout the documentation.
 25 |     Step 3: Provide a class or function definition
 26 | 
 27 |     Provide the class or function definition for the module or framework.
 28 |     Include the parameters that need to be passed to the class or function and provide a brief description of each parameter.
 29 |     Specify the data types and default values for each parameter.
 30 |     Step 4: Explain the functionality and usage
 31 | 
 32 |     Provide a detailed explanation of how the module or framework works and what it does.
 33 |     Describe the steps involved in using the module or framework, including any specific requirements or considerations.
 34 |     Provide code examples to demonstrate the usage of the module or framework.
 35 |     Explain the expected inputs and outputs for each operation or function.
 36 |     Step 5: Provide additional information and tips
 37 | 
 38 |     Provide any additional information or tips that may be useful for using the module or framework effectively.
 39 |     Address any common issues or challenges that developers may encounter and provide recommendations or workarounds.
 40 |     Step 6: Include references and resources
 41 | 
 42 |     Include references to any external resources or research papers that provide further information or background on the module or framework.
 43 |     Provide links to relevant documentation or websites for further exploration.
 44 |     Example Template for the given documentation:
 45 | 
 46 |     # Module/Function Name: MultiheadAttention
 47 | 
 48 |     class torch.nn.MultiheadAttention(embed_dim, num_heads, dropout=0.0, bias=True, add_bias_kv=False, add_zero_attn=False, kdim=None, vdim=None, batch_first=False, device=None, dtype=None):
 49 |         ```
 50 |         Creates a multi-head attention module for joint information representation from the different subspaces.
 51 | 
 52 |         Parameters:
 53 |         - embed_dim (int): Total dimension of the model.
 54 |         - num_heads (int): Number of parallel attention heads. The embed_dim will be split across num_heads.
 55 |         - dropout (float): Dropout probability on attn_output_weights. Default: 0.0 (no dropout).
 56 |         - bias (bool): If specified, adds bias to input/output projection layers. Default: True.
 57 |         - add_bias_kv (bool): If specified, adds bias to the key and value sequences at dim=0. Default: False.
 58 |         - add_zero_attn (bool): If specified, adds a new batch of zeros to the key and value sequences at dim=1. Default: False.
 59 |         - kdim (int): Total number of features for keys. Default: None (uses kdim=embed_dim).
 60 |         - vdim (int): Total number of features for values. Default: None (uses vdim=embed_dim).
 61 |         - batch_first (bool): If True, the input and output tensors are provided as (batch, seq, feature). Default: False.
 62 |         - device (torch.device): If specified, the tensors will be moved to the specified device.
 63 |         - dtype (torch.dtype): If specified, the tensors will have the specified dtype.
 64 |         ```
 65 | 
 66 |         def forward(query, key, value, key_padding_mask=None, need_weights=True, attn_mask=None, average_attn_weights=True, is_causal=False):
 67 |             ```
 68 |             Forward pass of the multi-head attention module.
 69 | 
 70 |             Parameters:
 71 |             - query (Tensor): Query embeddings of shape (L, E_q) for unbatched input, (L, N, E_q) when batch_first=False, or (N, L, E_q) when batch_first=True.
 72 |             - key (Tensor): Key embeddings of shape (S, E_k) for unbatched input, (S, N, E_k) when batch_first=False, or (N, S, E_k) when batch_first=True.
 73 |             - value (Tensor): Value embeddings of shape (S, E_v) for unbatched input, (S, N, E_v) when batch_first=False, or (N, S, E_v) when batch_first=True.
 74 |             - key_padding_mask (Optional[Tensor]): If specified, a mask indicating elements to be ignored in key for attention computation.
 75 |             - need_weights (bool): If specified, returns attention weights in addition to attention outputs. Default: True.
 76 |             - attn_mask (Optional[Tensor]): If specified, a mask preventing attention to certain positions.
 77 |             - average_attn_weights (bool): If true, returns averaged attention weights per head. Otherwise, returns attention weights separately per head. Note that this flag only has an effect when need_weights=True. Default: True.
 78 |             - is_causal (bool): If specified, applies a causal mask as the attention mask. Default: False.
 79 | 
 80 |             Returns:
 81 |             Tuple[Tensor, Optional[Tensor]]:
 82 |             - attn_output (Tensor): Attention outputs of shape (L, E) for unbatched input, (L, N, E) when batch_first=False, or (N, L, E) when batch_first=True.
 83 |             - attn_output_weights (Optional[Tensor]): Attention weights of shape (L, S) when unbatched or (N, L, S) when batched. Optional, only returned when need_weights=True.
 84 |             ```
 85 | 
 86 |             # Implementation of the forward pass of the attention module goes here
 87 | 
 88 |             return attn_output, attn_output_weights
 89 | 
 90 |             ```
 91 |             # Usage example:
 92 | 
 93 |             multihead_attn = nn.MultiheadAttention(embed_dim, num_heads)
 94 |             attn_output, attn_output_weights = multihead_attn(query, key, value)
 95 |             Note:
 96 | 
 97 |             The above template includes the class or function definition, parameters, description, and usage example.
 98 |             To replicate the documentation for any other module or framework, follow the same structure and provide the specific details for that module or framework.
 99 | 
100 | 
101 |             ############# DOCUMENT THE FOLLOWING CODE ########
102 |             {task}
103 |             """
104 |     return documentation
105 | 
106 | 
107 | def TEST_WRITER_SOP_PROMPT(
108 |     task: str, module: str, path: str, *args, **kwargs
109 | ):
110 |     TESTS_PROMPT = f"""
111 | 
112 |    Create 5,000 lines of extensive and thorough tests for the code below using the guide, do not worry about your limits you do not have any
113 |    just write the best tests possible, the module is {module}, the file path is {path}
114 | 
115 | 
116 |    ######### TESTING GUIDE #############
117 | 
118 |    # **Guide to Creating Extensive, Thorough, and Production-Ready Tests using `pytest`**
119 | 
120 |    1. **Preparation**:
121 |       - Install pytest: `pip install pytest`.
122 |       - Structure your project so that tests are in a separate `tests/` directory.
123 |       - Name your test files with the prefix `test_` for pytest to recognize them.
124 | 
125 |    2. **Writing Basic Tests**:
126 |       - Use clear function names prefixed with `test_` (e.g., `test_check_value()`).
127 |       - Use assert statements to validate results.
128 | 
129 |    3. **Utilize Fixtures**:
130 |       - Fixtures are a powerful feature to set up preconditions for your tests.
131 |       - Use `@pytest.fixture` decorator to define a fixture.
132 |       - Pass fixture name as an argument to your test to use it.
133 | 
134 |    4. **Parameterized Testing**:
135 |       - Use `@pytest.mark.parametrize` to run a test multiple times with different inputs.
136 |       - This helps in thorough testing with various input values without writing redundant code.
137 | 
138 |    5. **Use Mocks and Monkeypatching**:
139 |       - Use `monkeypatch` fixture to modify or replace classes/functions during testing.
140 |       - Use `unittest.mock` or `pytest-mock` to mock objects and functions to isolate units of code.
141 | 
142 |    6. **Exception Testing**:
143 |       - Test for expected exceptions using `pytest.raises(ExceptionType)`.
144 | 
145 |    7. **Test Coverage**:
146 |       - Install pytest-cov: `pip install pytest-cov`.
147 |       - Run tests with `pytest --cov=my_module` to get a coverage report.
148 | 
149 |    8. **Environment Variables and Secret Handling**:
150 |       - Store secrets and configurations in environment variables.
151 |       - Use libraries like `python-decouple` or `python-dotenv` to load environment variables.
152 |       - For tests, mock or set environment variables temporarily within the test environment.
153 | 
154 |    9. **Grouping and Marking Tests**:
155 |       - Use `@pytest.mark` decorator to mark tests (e.g., `@pytest.mark.slow`).
156 |       - This allows for selectively running certain groups of tests.
157 | 
158 |    10. **Use Plugins**:
159 |       - Utilize the rich ecosystem of pytest plugins (e.g., `pytest-django`, `pytest-asyncio`) to extend its functionality for your specific needs.
160 | 
161 |    11. **Continuous Integration (CI)**:
162 |       - Integrate your tests with CI platforms like Jenkins, Travis CI, or GitHub Actions.
163 |       - Ensure tests are run automatically with every code push or pull request.
164 | 
165 |    12. **Logging and Reporting**:
166 |       - Use `pytest`'s inbuilt logging.
167 |       - Integrate with tools like `Allure` for more comprehensive reporting.
168 | 
169 |    13. **Database and State Handling**:
170 |       - If testing with databases, use database fixtures or factories to create a known state before tests.
171 |       - Clean up and reset state post-tests to maintain consistency.
172 | 
173 |    14. **Concurrency Issues**:
174 |       - Consider using `pytest-xdist` for parallel test execution.
175 |       - Always be cautious when testing concurrent code to avoid race conditions.
176 | 
177 |    15. **Clean Code Practices**:
178 |       - Ensure tests are readable and maintainable.
179 |       - Avoid testing implementation details; focus on functionality and expected behavior.
180 | 
181 |    16. **Regular Maintenance**:
182 |       - Periodically review and update tests.
183 |       - Ensure that tests stay relevant as your codebase grows and changes.
184 | 
185 |    17. **Documentation**:
186 |       - Document test cases, especially for complex functionalities.
187 |       - Ensure that other developers can understand the purpose and context of each test.
188 | 
189 |    18. **Feedback Loop**:
190 |       - Use test failures as feedback for development.
191 |       - Continuously refine tests based on code changes, bug discoveries, and additional requirements.
192 | 
193 |    By following this guide, your tests will be thorough, maintainable, and production-ready. Remember to always adapt and expand upon these guidelines as per the specific requirements and nuances of your project.
194 | 
195 | 
196 |    ######### CREATE TESTS FOR THIS CODE: #######
197 |    {task}
198 | 
199 |    """
200 | 
201 |     return TESTS_PROMPT
202 | 


--------------------------------------------------------------------------------
/scripts/auto_tests_docs/mkdocs_handler.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | 
 3 | 
 4 | def generate_file_list(directory, output_file):
 5 |     """
 6 |     Generate a list of files in a directory in the specified format and write it to a file.
 7 | 
 8 |     Args:
 9 |     directory (str): The directory to list the files from.
10 |     output_file (str): The file to write the output to.
11 |     """
12 |     with open(output_file, "w") as f:
13 |         for root, dirs, files in os.walk(directory):
14 |             for file in files:
15 |                 if file.endswith(".md"):
16 |                     # Remove the directory from the file path and replace slashes with dots
17 |                     file_path = (
18 |                         os.path.join(root, file)
19 |                         .replace(directory + "/", "")
20 |                         .replace("/", ".")
21 |                     )
22 |                     # Remove the file extension
23 |                     file_name, _ = os.path.splitext(file)
24 |                     # Write the file name and path to the output file
25 |                     f.write(
26 |                         f'- {file_name}: "swarms/utils/{file_path}"\n'
27 |                     )
28 | 
29 | 
30 | # Use the function to generate the file list
31 | generate_file_list("docs/swarms/structs", "file_list.txt")
32 | 


--------------------------------------------------------------------------------
/scripts/auto_tests_docs/update_mkdocs.py:
--------------------------------------------------------------------------------
 1 | import yaml
 2 | 
 3 | 
 4 | def update_mkdocs(
 5 |     class_names,
 6 |     base_path="docs/zeta/nn/modules",
 7 |     mkdocs_file="mkdocs.yml",
 8 | ):
 9 |     """
10 |     Update the mkdocs.yml file with new documentation links.
11 | 
12 |     Args:
13 |     - class_names: A list of class names for which documentation is generated.
14 |     - base_path: The base path where documentation Markdown files are stored.
15 |     - mkdocs_file: The path to the mkdocs.yml file.
16 |     """
17 |     with open(mkdocs_file) as file:
18 |         mkdocs_config = yaml.safe_load(file)
19 | 
20 |     # Find or create the 'zeta.nn.modules' section in 'nav'
21 |     zeta_modules_section = None
22 |     for section in mkdocs_config.get("nav", []):
23 |         if "zeta.nn.modules" in section:
24 |             zeta_modules_section = section["zeta.nn.modules"]
25 |             break
26 | 
27 |     if zeta_modules_section is None:
28 |         zeta_modules_section = {}
29 |         mkdocs_config["nav"].append(
30 |             {"zeta.nn.modules": zeta_modules_section}
31 |         )
32 | 
33 |     # Add the documentation paths to the 'zeta.nn.modules' section
34 |     for class_name in class_names:
35 |         doc_path = f"{base_path}/{class_name.lower()}.md"
36 |         zeta_modules_section[class_name] = doc_path
37 | 
38 |     # Write the updated content back to mkdocs.yml
39 |     with open(mkdocs_file, "w") as file:
40 |         yaml.safe_dump(mkdocs_config, file, sort_keys=False)
41 | 
42 | 
43 | # Example usage
44 | classes = [
45 |     "DenseBlock",
46 |     "HighwayLayer",
47 |     "MultiScaleBlock",
48 |     "FeedbackBlock",
49 |     "DualPathBlock",
50 |     "RecursiveBlock",
51 |     "PytorchGELUTanh",
52 |     "NewGELUActivation",
53 |     "GELUActivation",
54 |     "FastGELUActivation",
55 |     "QuickGELUActivation",
56 |     "ClippedGELUActivation",
57 |     "AccurateGELUActivation",
58 |     "MishActivation",
59 |     "LinearActivation",
60 |     "LaplaceActivation",
61 |     "ReLUSquaredActivation",
62 | ]
63 | 
64 | update_mkdocs(classes)
65 | 


--------------------------------------------------------------------------------
/scripts/code_quality.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Navigate to the directory containing the 'tests' folder
 4 | # cd /path/to/your/code/directory
 5 | 
 6 | # Run autopep8 with max aggressiveness (-aaa) and in-place modification (-i)
 7 | # on all Python files (*.py) under the 'tests' directory.
 8 | autopep8 --in-place --aggressive --aggressive --recursive --experimental --list-fixes zeta/
 9 | 
10 | # Run black with default settings, since black does not have an aggressiveness level.
11 | # Black will format all Python files it finds in the 'tests' directory.
12 | black --experimental-string-processing zeta/
13 | 
14 | # Run ruff on the 'tests' directory.
15 | # Add any additional flags if needed according to your version of ruff.
16 | ruff zeta/ --fix
17 | 
18 | # YAPF
19 | yapf --recursive --in-place --verbose --style=google --parallel tests
20 | 


--------------------------------------------------------------------------------
/scripts/del_pycache.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | # Find and delete all __pycache__ directories
4 | find . -type d -name "__pycache__" -exec rm -r {} +
5 | 
6 | # Find and delete all .pyc files
7 | find . -type f -name "*.pyc" -delete


--------------------------------------------------------------------------------
/scripts/get_package_requirements.py:
--------------------------------------------------------------------------------
 1 | import pkg_resources
 2 | 
 3 | 
 4 | def get_package_versions(requirements_path, output_path):
 5 |     try:
 6 |         with open(requirements_path) as file:
 7 |             requirements = file.readlines()
 8 |     except FileNotFoundError:
 9 |         print(f"Error: The file '{requirements_path}' was not found.")
10 |         return
11 | 
12 |     package_versions = []
13 | 
14 |     for requirement in requirements:
15 |         # Skip empty lines and comments
16 |         if (
17 |             requirement.strip() == ""
18 |             or requirement.strip().startswith("#")
19 |         ):
20 |             continue
21 | 
22 |         # Extract package name
23 |         package_name = requirement.split("==")[0].strip()
24 |         try:
25 |             version = pkg_resources.get_distribution(
26 |                 package_name
27 |             ).version
28 |             package_versions.append(f"{package_name}=={version}")
29 |         except pkg_resources.DistributionNotFound:
30 |             package_versions.append(f"{package_name}: not installed")
31 | 
32 |     with open(output_path, "w") as file:
33 |         for package_version in package_versions:
34 |             file.write(package_version + "\n")
35 |     print(f"Versions written to {output_path}")
36 | 
37 | 
38 | # Usage
39 | get_package_versions("requirements.txt", "installed_versions.txt")
40 | 


--------------------------------------------------------------------------------
/scripts/log_cleanup.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import shutil
 3 | 
 4 | # Create a new directory for the log files if it doesn't exist
 5 | if not os.path.exists("artifacts1"):
 6 |     os.makedirs("artifacts1")
 7 | 
 8 | # Walk through the current directory
 9 | for dirpath, dirnames, filenames in os.walk("."):
10 |     for filename in filenames:
11 |         # If the file is a log file
12 |         if filename.endswith(".log"):
13 |             # Construct the full file path
14 |             file_path = os.path.join(dirpath, filename)
15 |             # Move the log file to the 'artifacts' directory
16 |             shutil.move(file_path, "artifacts")
17 | 
18 | print(
19 |     "Moved all log files into the 'artifacts' directory and deleted"
20 |     " their original location."
21 | )
22 | 


--------------------------------------------------------------------------------
/scripts/playground_to_examples.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Define the directory to search
 4 | dir="playground"
 5 | 
 6 | # Check if the directory exists
 7 | if [ -d "$dir" ]
 8 | then
 9 |     # Use find to locate all .py files in the directory and its subdirectories
10 |     for file in $(find $dir -name "*.py")
11 |     do
12 |         # Extract the file name and directory
13 |         base=$(basename $file .py)
14 |         dir=$(dirname $file)
15 | 
16 |         # Check if the file name already contains _example
17 |         if [[ $base == *_example ]]
18 |         then
19 |             echo "Skipping $file as it already contains _example"
20 |             continue
21 |         fi
22 | 
23 |         # Append _example to the file name
24 |         newname="${base}_example.py"
25 | 
26 |         # Rename the file
27 |         mv $file $dir/$newname
28 | 
29 |         echo "Renamed $file to $dir/$newname"
30 |     done
31 | else
32 |     echo "Directory $dir does not exist."
33 | fi


--------------------------------------------------------------------------------
/scripts/requirementstxt_to_pyproject.py:
--------------------------------------------------------------------------------
 1 | import pkg_resources
 2 | import toml
 3 | 
 4 | 
 5 | def update_pyproject_versions(pyproject_path):
 6 |     try:
 7 |         with open(pyproject_path) as file:
 8 |             data = toml.load(file)
 9 |     except FileNotFoundError:
10 |         print(f"Error: The file '{pyproject_path}' was not found.")
11 |         return
12 |     except toml.TomlDecodeError:
13 |         print(
14 |             f"Error: The file '{pyproject_path}' is not a valid TOML"
15 |             " file."
16 |         )
17 |         return
18 | 
19 |     dependencies = (
20 |         data.get("tool", {}).get("poetry", {}).get("dependencies", {})
21 |     )
22 | 
23 |     for package in dependencies:
24 |         if package.lower() == "python":
25 |             continue  # Skip the Python version dependency
26 | 
27 |         try:
28 |             version = pkg_resources.get_distribution(package).version
29 |             dependencies[package] = version
30 |         except pkg_resources.DistributionNotFound:
31 |             print(f"Warning: Package '{package}' not installed.")
32 | 
33 |     with open(pyproject_path, "w") as file:
34 |         toml.dump(data, file)
35 | 
36 |     print(f"Updated versions written to {pyproject_path}")
37 | 
38 | 
39 | # Usage
40 | update_pyproject_versions("pyproject.toml")
41 | 


--------------------------------------------------------------------------------
/scripts/run_examples.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Define a file to keep track of successfully executed scripts
 4 | SUCCESS_LOG="successful_runs.log"
 5 | 
 6 | for f in /swarms/playground/examples/example_*.py; do
 7 |     # Check if the script has been logged as successful
 8 |     if grep -Fxq "$f" "$SUCCESS_LOG"; then
 9 |         echo "Skipping ${f} as it ran successfully in a previous run."
10 |     else
11 |         # Run the script if not previously successful
12 |         if /home/kye/miniconda3/envs/swarms/bin/python "$f" 2>>errors.txt; then
13 |             echo "(${f}) ran successfully without errors."
14 |             # Log the successful script execution
15 |             echo "$f" >> "$SUCCESS_LOG"
16 |         else
17 |             echo "Error encountered in ${f}. Check errors.txt for details."
18 |             break
19 |         fi
20 |     fi
21 |     echo "##############################################################################"
22 | done
23 | 


--------------------------------------------------------------------------------
/scripts/test_name.sh:
--------------------------------------------------------------------------------
1 | find ./tests -name "*.py" -type f | while read file
2 | do
3 |   filename=$(basename "$file")
4 |   dir=$(dirname "$file")
5 |   if [[ $filename != test_* ]]; then
6 |     mv "$file" "$dir/test_$filename"
7 |     printf "\e[1;34mRenamed: \e[0m$file \e[1;32mto\e[0m $dir/test_$filename\n"
8 |   fi
9 | done


--------------------------------------------------------------------------------
/scripts/tests.sh:
--------------------------------------------------------------------------------
1 | find ./tests -name '*.py' -exec pytest {} \;


--------------------------------------------------------------------------------