[ { "path": ".gitignore", "content": "# Byte-compiled / optimized / DLL files\n__pycache__/\n*.py[cod]\n*$py.class\n\n# C extensions\n*.so\n\n# Distribution / packaging\n.Python\nbuild/\ndevelop-eggs/\ndist/\ndownloads/\neggs/\n.eggs/\nlib/\nlib64/\nparts/\nsdist/\nvar/\nwheels/\nshare/python-wheels/\n*.egg-info/\n.installed.cfg\n*.egg\nMANIFEST\n\n# PyInstaller\n# Usually these files are written by a python script from a template\n# before PyInstaller builds the exe, so as to inject date/other infos into it.\n*.manifest\n*.spec\ntec.md\n.cursor\n\n# Installer logs\npip-log.txt\npip-delete-this-directory.txt\n\n# Unit test / coverage reports\nhtmlcov/\n.tox/\n.nox/\n.coverage\n.coverage.*\n.cache\nnosetests.xml\ncoverage.xml\n*.cover\n*.py,cover\n.hypothesis/\n.pytest_cache/\ncover/\n\n# Translations\n*.mo\n*.pot\n\n# Django stuff:\n*.log\nlocal_settings.py\ndb.sqlite3\ndb.sqlite3-journal\n\n# Flask stuff:\ninstance/\n.webassets-cache\n\n# Scrapy stuff:\n.scrapy\n\n# Sphinx documentation\ndocs/_build/\n\n# PyBuilder\n.pybuilder/\ntarget/\n\n# Jupyter Notebook\n.ipynb_checkpoints\n\n# IPython\nprofile_default/\nipython_config.py\n\n# pyenv\n# For a library or package, you might want to ignore these files since the code is\n# intended to run in multiple environments; otherwise, check them in:\n# .python-version\n\n# pipenv\n# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.\n# However, in case of collaboration, if having platform-specific dependencies or dependencies\n# having no cross-platform support, pipenv may install dependencies that don't work, or not\n# install all needed dependencies.\n#Pipfile.lock\n\n# UV\n# Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.\n# This is especially recommended for binary packages to ensure reproducibility, and is more\n# commonly ignored for libraries.\n#uv.lock\n\n# poetry\n# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.\n# This is especially recommended for binary packages to ensure reproducibility, and is more\n# commonly ignored for libraries.\n# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control\n#poetry.lock\n\n# pdm\n# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.\n#pdm.lock\n# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it\n# in version control.\n# https://pdm.fming.dev/latest/usage/project/#working-with-version-control\n.pdm.toml\n.pdm-python\n.pdm-build/\n\n# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm\n__pypackages__/\n\n# Celery stuff\ncelerybeat-schedule\ncelerybeat.pid\n\n# SageMath parsed files\n*.sage.py\n\n# Environments\n.env\n.venv\nenv/\nvenv/\nENV/\nprd.env\nenv.bak/\nvenv.bak/\nconfig.toml\n\n# Spyder project settings\n.spyderproject\n.spyproject\n\n# Rope project settings\n.ropeproject\n\n# mkdocs documentation\n/site\n\n# mypy\n.mypy_cache/\n.dmypy.json\ndmypy.json\n\n# Pyre type checker\n.pyre/\n\n# pytype static type analyzer\n.pytype/\n\n# Cython debug symbols\ncython_debug/\n.project_structure.json\n\n# PyCharm\n# JetBrains specific template is maintained in a separate JetBrains.gitignore that can\n# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore\n# and can be added to the global gitignore or merged into this file. For a more nuclear\n# option (not recommended) you can uncomment the following to ignore the entire idea folder.\n#.idea/\n\n# PyPI configuration file\n.pypirc\n\n# Python\n__pycache__/\n*.pyc\n\n# Environment\n.env\n/scripts\n\n# VSCode\n.vscode/" }, { "path": ".python-version", "content": "3.13\n" }, { "path": "LICENSE", "content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License." }, { "path": "README.md", "content": "# HAGAMEAI\n\nHAGAMEAI is a training framework for AI game evolution. By constructing diverse game scenario components, from strategic confrontations to simulation, it enhances AI's learning mechanisms, decision-making processes, and its ability to collaborate or compete with humans in complex environments, providing foundational AI support for all game-related scenarios.\n\nExperience AviaFlick, an ecological game based on HAGAMEAI, by visiting: [t.me/HAGAMEAI_CHANNEL](https://t.me/HAGAMEAI_CHANNEL)\n\n---\n\n## Architecture & Technology Stack\n\n- **Language:** Python 3.10+\n- **Framework:** FastAPI (async, high performance, Pydantic validation)\n- **Database:** PostgreSQL (with JSONB support)\n- **Async ORM:** SQLAlchemy (async) or Tortoise ORM\n- **Task Queue:** Celery (with Redis or RabbitMQ)\n- **LLM SDKs:** OpenAI, Google AI\n- **Cache:** Redis (for session, rate limit, and caching)\n- **Containerization:** Docker, Docker Compose\n- **Monitoring:** Prometheus, Grafana\n- **Logging:** ELK Stack or Grafana Loki\n- **Dependency Management:** [uv](https://github.com/astral-sh/uv) with `pyproject.toml`\n\n---\n\n## Environment Setup\n\n1. Ensure you have Python 3.10+ installed.\n2. Install dependencies using `uv`:\n\n```bash\nuv pip install -r pyproject.toml\n```\n\n3. Copy `.env.example` to `.env` and fill in your configuration:\n\n```bash\ncp .env.example .env\n```\n\n**Required variables:**\n- `DATABASE_URL`: PostgreSQL async URL (e.g. `postgresql+asyncpg://user:password@localhost:5432/hagame_db`)\n- `SECRET_KEY`: Secret key for JWT\n- `ALGORITHM`: JWT algorithm (default: HS256)\n- `ACCESS_TOKEN_EXPIRE_MINUTES`: JWT expiration in minutes (default: 60)\n\n---\n\n## Running the Application\n\n```bash\nuvicorn main:app --reload\n```\n\nVisit [http://localhost:8000/](http://localhost:8000/) for the health check (`{\"status\": \"ok\"}`) and [http://localhost:8000/docs](http://localhost:8000/docs) for the OpenAPI documentation.\n\n---\n\n## System Modules & API Overview\n\n### 1. User Authentication & Profile Management\n- **Purpose:** Secure user registration, login (JWT), and management of user profiles and cognitive profiles.\n- **Key Endpoints:**\n - `POST /auth/register` — Register a new user\n - `POST /auth/login` — Obtain JWT access token\n - `GET /auth/me` — Retrieve current user info (JWT required)\n - `GET/PUT /users/me/profile` — Get or update user profile\n - `GET/PUT /users/me/cognitive-profile` — Get or update cognitive profile\n- **Features:**\n - JWT-based authentication\n - Pydantic validation\n - Logging of all key actions\n - Consistent error handling\n\n### 2. Game Core Framework\n- **Purpose:** Define, manage, and run game definitions and instances, supporting plugin/strategy patterns for extensibility.\n- **Key Endpoints:**\n - `GET/POST /games/definitions` — List or create game definitions\n - `GET /games/definitions/{game_def_id}` — Get a game definition by ID\n - `POST /games/instances` — Create a new game instance\n - `GET /games/instances/{instance_id}` — Get a game instance by ID\n - `GET /games/my-instances` — List all game instances for the current user\n- **Features:**\n - Async endpoints\n - Pydantic schemas\n - JWT protection\n - Extensible game engine design\n\n### 3. AI Engine\n- **Purpose:** Provide adaptive prediction, cognitive modeling, quantum uncertainty, collective wisdom aggregation, and explainable AI (XAI) services.\n- **Key Endpoints:**\n - `GET /ai-models/` — List all AI models\n - `POST /ai-models/` — Create a new AI model\n - `GET /ai-models/{model_id}` — Get an AI model by ID\n- **Features:**\n - Modular AI engine (prediction, cognitive modeling, XAI, etc.)\n - Integration with LLMs for advanced reasoning and feedback\n\n### 4. LLM Integration Service\n- **Purpose:** Centralized gateway for all LLM API calls (OpenAI, Gemini, etc.), prompt management, and LLM call logging.\n- **Key Endpoints:**\n - `POST /llm/call` — Call an LLM API\n - `GET /llm/logs` — List all LLM call logs for the current user\n- **Features:**\n - Centralized API key management\n - Prompt versioning and management\n - Error handling and retries\n - Caching of LLM responses\n\n### 5. Async Task Processing (Planned)\n- **Purpose:** Offload long-running or resource-intensive operations to background tasks using Celery.\n- **Planned Use Cases:**\n - AI model training and batch predictions\n - Cognitive profile analysis and updates\n - Generating detailed feedback reports\n - Long-running LLM interactions\n - Data aggregation and statistics\n- **Integration:**\n - Celery with Redis or RabbitMQ as broker and backend\n - Task definitions in `tasks.py` (to be implemented)\n\n### 6. Monitoring & Logging\n- **Purpose:** Provide observability, performance monitoring, and structured logging for all modules.\n- **Stack:**\n - **Monitoring:** Prometheus, Grafana\n - **Logging:** ELK Stack (Elasticsearch, Logstash, Kibana) or Grafana Loki\n- **Features:**\n - Structured logging for all key actions and errors\n - Metrics for API performance and background tasks\n\n---\n\n## Data Models\n\nThe backend uses async ORM models (SQLAlchemy/Tortoise) with Pydantic schemas for validation. Key entities include:\n- **User:** Authentication and profile data\n- **CognitiveProfile:** Dynamic user cognitive modeling (JSONB)\n- **GameDefinition:** Game rules, parameters, and configuration (JSONB)\n- **GameInstance:** Game session state, status, and results (JSONB)\n- **AIModel:** AI model configuration and metadata\n- **UserDecisionLog:** User actions and context during games\n- **Feedback:** System- or LLM-generated feedback for users\n\n---\n\n## Future Work\n\nPlanned features and modules (see `docs/roadmap.md` for details):\n- Developer API/SDK\n- Multimodal interaction support\n- Emotion intelligence analysis\n- Advanced AI model integration\n- Federated learning support\n\n---\n\n## References\n- [Project Roadmap](docs/roadmap.md)\n- [OpenAPI Docs](http://localhost:8000/docs)\n\n---\n\n## License\n\nThis project is licensed under the **Apache License 2.0**. You are free to use, modify, and distribute this software under the terms of the license.\n\nSee the [LICENSE](LICENSE) file for the full license text and details.\n\nFor questions or contributions, please refer to the technical documentation and roadmap, and follow the project coding and architectural guidelines strictly.\n\n# HAGAME AI Engine\n\nHAGAME AI Engine is an advanced artificial intelligence system designed for game environments, providing adaptive learning, cognitive modeling, and strategic decision-making capabilities.\n\n## Features\n\n### AI Engine Components\n\n1. **Adaptive Prediction Engine**\n - Real-time prediction of game states and player behavior\n - Adaptive learning from gameplay patterns\n - Multi-model prediction system with confidence scoring\n\n2. **Cognitive Model Builder**\n - Player cognitive profile generation\n - Learning style analysis\n - Skill level assessment and tracking\n - Adaptability measurement\n\n3. **Quantum Uncertainty Generator**\n - Quantum-inspired uncertainty modeling\n - Multi-dimensional uncertainty factors\n - Entanglement-based correlation analysis\n - Dynamic decoherence rate adjustment\n\n4. **Collective Wisdom Aggregator**\n - Pattern recognition across game sessions\n - Strategy effectiveness analysis\n - Meta-learning from collective experiences\n - Trend and anomaly detection\n\n5. **Explainable AI (XAI)**\n - Natural language explanations of AI decisions\n - Feature importance analysis\n - Counterfactual reasoning\n - Confidence level assessment\n\n## Installation\n\n1. Clone the repository:\n```bash\ngit clone https://github.com/hagame/hagamesai.git\ncd hagamesai\n```\n\n2. Create a virtual environment and activate it:\n```bash\npython -m venv .venv\nsource .venv/bin/activate # On Windows: .venv\\Scripts\\activate\n```\n\n3. Install dependencies:\n```bash\npip install -e .\n```\n\n## Configuration\n\n1. Create a `.env` file in the project root with the following variables:\n```env\nDATABASE_URL=postgresql+asyncpg://user:password@localhost/hagame\nREDIS_URL=redis://localhost:6379/0\nSECRET_KEY=your-secret-key\nALGORITHM=HS256\nACCESS_TOKEN_EXPIRE_MINUTES=30\n```\n\n2. Initialize the database:\n```bash\nalembic upgrade head\n```\n\n## Usage\n\n1. Start the API server:\n```bash\nuvicorn main:app --reload\n```\n\n2. Start the Celery worker:\n```bash\ncelery -A core.celery_app worker --loglevel=info\n```\n\n## API Documentation\n\nOnce the server is running, access the API documentation at:\n- Swagger UI: `http://localhost:8000/docs`\n- ReDoc: `http://localhost:8000/redoc`\n\n## Development\n\n### Project Structure\n\n```\nhagamesai/\n├── alembic/ # Database migrations\n├── api/ # API routes and endpoints\n├── core/ # Core functionality\n│ ├── ai_engine/ # AI Engine components\n│ │ ├── base.py # Base AI component class\n│ │ ├── prediction.py # Adaptive Prediction Engine\n│ │ ├── cognitive.py # Cognitive Model Builder\n│ │ ├── quantum.py # Quantum Uncertainty Generator\n│ │ ├── collective.py # Collective Wisdom Aggregator\n│ │ └── xai.py # Explainable AI\n│ ├── auth.py # Authentication\n│ ├── config.py # Configuration\n│ └── database.py # Database setup\n├── crud/ # Database operations\n├── models/ # SQLAlchemy models\n├── schemas/ # Pydantic schemas\n└── tests/ # Test suite\n```\n\n### Running Tests\n\n```bash\npytest\n```\n\n### Contributing\n\n1. Fork the repository\n2. Create a feature branch\n3. Commit your changes\n4. Push to the branch\n5. Create a Pull Request\n\n## License\n\nThis project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.\n\n## Acknowledgments\n\n- The HAGAME Team\n- Contributors and maintainers\n- The open-source community\n\n## Contact\n\n- Email: team@hagame.ai\n- GitHub: [https://github.com/hagame/hagamesai](https://github.com/hagame/hagamesai)\n\n" }, { "path": "alembic/README", "content": "Generic single-database configuration." }, { "path": "alembic/env.py", "content": "from models.user import Base # Import your Base object here\nfrom logging.config import fileConfig\n\nfrom sqlalchemy import engine_from_config\nfrom sqlalchemy import pool\n\nfrom alembic import context\nimport os\nfrom dotenv import load_dotenv\n\n# Load environment variables from .env file\nload_dotenv()\n\n# this is the Alembic Config object, which provides\n# access to the values within the .ini file in use.\nconfig = context.config\n\n# Set the SQLAlchemy URL from environment variable\nconfig.set_main_option(\"sqlalchemy.url\", os.environ.get(\"DATABASE_URL\"))\n\n# Interpret the config file for Python logging.\n# This line sets up loggers basically.\nif config.config_file_name is not None:\n fileConfig(config.config_file_name)\n\n# add your model's MetaData object here\n# for 'autogenerate' support\n# from myapp import mymodel\ntarget_metadata = Base.metadata\n\n# other values from the config, defined by the needs of env.py,\n# can be acquired:\n# my_important_option = config.get_main_option(\"my_important_option\")\n# ... etc.\n\n\ndef run_migrations_offline() -> None:\n \"\"\"Run migrations in 'offline' mode.\n\n This configures the context with just a URL\n and not an Engine, though an Engine is acceptable\n here as well. By skipping the Engine creation\n we don't even need a DBAPI to be available.\n\n Calls to context.execute() here emit the given string to the\n script output.\n\n \"\"\"\n url = config.get_main_option(\"sqlalchemy.url\")\n context.configure(\n url=url,\n target_metadata=target_metadata,\n literal_binds=True,\n dialect_opts={\"paramstyle\": \"named\"},\n )\n\n with context.begin_transaction():\n context.run_migrations()\n\n\ndef run_migrations_online() -> None:\n \"\"\"Run migrations in 'online' mode.\n\n In this scenario we need to create an Engine\n and associate a connection with the context.\n\n \"\"\"\n connectable = engine_from_config(\n config.get_section(config.config_ini_section, {}),\n prefix=\"sqlalchemy.\",\n poolclass=pool.NullPool,\n )\n\n with connectable.connect() as connection:\n context.configure(\n connection=connection, target_metadata=target_metadata\n )\n\n with context.begin_transaction():\n context.run_migrations()\n\n\nif context.is_offline_mode():\n run_migrations_offline()\nelse:\n run_migrations_online()\n" }, { "path": "alembic/script.py.mako", "content": "\"\"\"${message}\n\nRevision ID: ${up_revision}\nRevises: ${down_revision | comma,n}\nCreate Date: ${create_date}\n\n\"\"\"\nfrom typing import Sequence, Union\n\nfrom alembic import op\nimport sqlalchemy as sa\n${imports if imports else \"\"}\n\n# revision identifiers, used by Alembic.\nrevision: str = ${repr(up_revision)}\ndown_revision: Union[str, None] = ${repr(down_revision)}\nbranch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}\ndepends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}\n\n\ndef upgrade() -> None:\n \"\"\"Upgrade schema.\"\"\"\n ${upgrades if upgrades else \"pass\"}\n\n\ndef downgrade() -> None:\n \"\"\"Downgrade schema.\"\"\"\n ${downgrades if downgrades else \"pass\"}\n" }, { "path": "alembic.ini", "content": "# A generic, single database configuration.\n\n[alembic]\n# path to migration scripts\n# Use forward slashes (/) also on windows to provide an os agnostic path\nscript_location = alembic\n\n# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s\n# Uncomment the line below if you want the files to be prepended with date and time\n# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file\n# for all available tokens\n# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s\n\n# sys.path path, will be prepended to sys.path if present.\n# defaults to the current working directory.\nprepend_sys_path = .\n\n# timezone to use when rendering the date within the migration file\n# as well as the filename.\n# If specified, requires the python>=3.9 or backports.zoneinfo library and tzdata library.\n# Any required deps can installed by adding `alembic[tz]` to the pip requirements\n# string value is passed to ZoneInfo()\n# leave blank for localtime\n# timezone =\n\n# max length of characters to apply to the \"slug\" field\n# truncate_slug_length = 40\n\n# set to 'true' to run the environment during\n# the 'revision' command, regardless of autogenerate\n# revision_environment = false\n\n# set to 'true' to allow .pyc and .pyo files without\n# a source .py file to be detected as revisions in the\n# versions/ directory\n# sourceless = false\n\n# version location specification; This defaults\n# to alembic/versions. When using multiple version\n# directories, initial revisions must be specified with --version-path.\n# The path separator used here should be the separator specified by \"version_path_separator\" below.\n# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions\n\n# version path separator; As mentioned above, this is the character used to split\n# version_locations. The default within new alembic.ini files is \"os\", which uses os.pathsep.\n# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.\n# Valid values for version_path_separator are:\n#\n# version_path_separator = :\n# version_path_separator = ;\n# version_path_separator = space\n# version_path_separator = newline\n#\n# Use os.pathsep. Default configuration used for new projects.\nversion_path_separator = os\n\n# set to 'true' to search source files recursively\n# in each \"version_locations\" directory\n# new in Alembic version 1.10\n# recursive_version_locations = false\n\n# the output encoding used when revision files\n# are written from script.py.mako\n# output_encoding = utf-8\n\n# The sqlalchemy.url can be uncommented here, but it will be overridden by env.py\n# sqlalchemy.url = driver://user:pass@localhost/dbname\n\n[post_write_hooks]\n# post_write_hooks defines scripts or Python functions that are run\n# on newly generated revision scripts. See the documentation for further\n# detail and examples\n\n# format using \"black\" - use the console_scripts runner, against the \"black\" entrypoint\n# hooks = black\n# black.type = console_scripts\n# black.entrypoint = black\n# black.options = -l 79 REVISION_SCRIPT_FILENAME\n\n# lint with attempts to fix using \"ruff\" - use the exec runner, execute a binary\n# hooks = ruff\n# ruff.type = exec\n# ruff.executable = %(here)s/.venv/bin/ruff\n# ruff.options = check --fix REVISION_SCRIPT_FILENAME\n\n# Logging configuration\n[loggers]\nkeys = root,sqlalchemy,alembic\n\n[handlers]\nkeys = console\n\n[formatters]\nkeys = generic\n\n[logger_root]\nlevel = WARNING\nhandlers = console\nqualname =\n\n[logger_sqlalchemy]\nlevel = WARNING\nhandlers =\nqualname = sqlalchemy.engine\n\n[logger_alembic]\nlevel = INFO\nhandlers =\nqualname = alembic\n\n[handler_console]\nclass = StreamHandler\nargs = (sys.stderr,)\nlevel = NOTSET\nformatter = generic\n\n[formatter_generic]\nformat = %(levelname)-5.5s [%(name)s] %(message)s\ndatefmt = %H:%M:%S\n" }, { "path": "api/__init__.py", "content": " " }, { "path": "api/ai.py", "content": "from fastapi import APIRouter, Depends, HTTPException\nfrom sqlalchemy.orm import Session\nfrom typing import List, Dict, Any, Optional\n\nfrom schemas.ai_model import AIModelCreate, AIModelRead, AIModelUpdate\nfrom services import AIModelService\nfrom core.database import get_db\nfrom models.cognitive_profile import CognitiveProfile\n\nrouter = APIRouter(prefix=\"/ai_models\", tags=[\"ai_models\"])\n\n\n@router.post(\"/\", response_model=AIModelRead)\nasync def create_model(\n model_data: AIModelCreate,\n db: Session = Depends(get_db)\n):\n \"\"\"Create a new AI model.\"\"\"\n service = AIModelService(db)\n return await service.create_model(model_data)\n\n\n@router.get(\"/{model_id}\", response_model=AIModelRead)\nasync def get_model(\n model_id: int,\n db: Session = Depends(get_db)\n):\n \"\"\"Get AI model by ID.\"\"\"\n service = AIModelService(db)\n model = await service.get_model(model_id)\n if not model:\n raise HTTPException(status_code=404, detail=\"Model not found\")\n return model\n\n\n@router.put(\"/{model_id}\", response_model=AIModelRead)\nasync def update_model(\n model_id: int,\n model_data: AIModelUpdate,\n db: Session = Depends(get_db)\n):\n \"\"\"Update AI model configuration.\"\"\"\n service = AIModelService(db)\n return await service.update_model(model_id, model_data)\n\n\n@router.post(\"/{model_id}/predict\")\nasync def predict(\n model_id: int,\n input_data: Dict[str, Any],\n cognitive_profile: Optional[CognitiveProfile] = None,\n db: Session = Depends(get_db)\n):\n \"\"\"Generate predictions using the AI model.\"\"\"\n service = AIModelService(db)\n return await service.predict(model_id, input_data, cognitive_profile)\n\n\n@router.post(\"/{model_id}/explain\")\nasync def explain(\n model_id: int,\n input_data: Dict[str, Any],\n db: Session = Depends(get_db)\n):\n \"\"\"Generate model explanations.\"\"\"\n service = AIModelService(db)\n return await service.explain(model_id, input_data)\n" }, { "path": "api/auth.py", "content": "from fastapi import APIRouter, Depends, HTTPException, status\nfrom sqlalchemy.ext.asyncio import AsyncSession\nfrom schemas.user import UserCreate, UserLogin, UserRead\nfrom crud.user import get_user_by_email, create_user\nfrom core.database import get_async_session\nfrom core.auth import verify_password, create_access_token, get_current_user\nfrom fastapi.responses import JSONResponse\nfrom core.logging import get_logger\n\nlogger = get_logger(__name__)\n\nrouter = APIRouter(prefix=\"/auth\", tags=[\"auth\"])\n\n\n@router.post(\n \"/register\",\n response_model=UserRead,\n status_code=status.HTTP_201_CREATED,\n summary=\"Register a new user\",\n response_description=\"The newly registered user's information.\",\n responses={\n 201: {\n \"description\": \"User registered successfully.\",\n \"content\": {\n \"application/json\": {\n \"example\": {\n \"id\": \"b3b7c7e2-1c2d-4e2a-8e2b-1c2d4e2a8e2b\",\n \"username\": \"testuser\",\n \"email\": \"test@example.com\",\n \"created_at\": \"2024-06-01T12:00:00Z\",\n \"updated_at\": \"2024-06-01T12:00:00Z\"\n }\n }\n }\n },\n 400: {\"description\": \"Email already registered.\"}\n }\n)\nasync def register_user(user_in: UserCreate, session: AsyncSession = Depends(get_async_session)) -> UserRead:\n \"\"\"\n Register a new user with a unique email and username.\n \"\"\"\n logger.info(f\"Registration attempt for email: {user_in.email}\")\n existing = await get_user_by_email(session, user_in.email)\n if existing:\n logger.warning(\n f\"Registration failed: Email already registered ({user_in.email})\")\n raise HTTPException(\n status_code=400, detail=\"Email already registered.\")\n user = await create_user(session, user_in)\n logger.info(f\"User registered successfully: {user.email}\")\n return UserRead.from_orm(user)\n\n\n@router.post(\n \"/login\",\n summary=\"Authenticate user and return JWT\",\n response_description=\"JWT access token and token type.\",\n responses={\n 200: {\n \"description\": \"Login successful.\",\n \"content\": {\n \"application/json\": {\n \"example\": {\n \"access_token\": \"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...\",\n \"token_type\": \"bearer\"\n }\n }\n }\n },\n 401: {\"description\": \"Invalid credentials.\"}\n }\n)\nasync def login_user(user_in: UserLogin, session: AsyncSession = Depends(get_async_session)):\n \"\"\"\n Authenticate user with email and password. Returns a JWT access token if successful.\n \"\"\"\n logger.info(f\"Login attempt for email: {user_in.email}\")\n user = await get_user_by_email(session, user_in.email)\n if not user or not verify_password(user_in.password, user.hashed_password):\n logger.warning(f\"Login failed for email: {user_in.email}\")\n raise HTTPException(status_code=401, detail=\"Invalid credentials.\")\n token_data = {\"sub\": str(user.id), \"email\": user.email}\n access_token = create_access_token(token_data)\n logger.info(f\"Login successful for email: {user.email}\")\n return {\"access_token\": access_token, \"token_type\": \"bearer\"}\n\n\n@router.get(\n \"/me\",\n response_model=UserRead,\n summary=\"Get current authenticated user's info\",\n response_description=\"The current user's information.\",\n responses={\n 200: {\n \"description\": \"Current user info returned.\",\n \"content\": {\n \"application/json\": {\n \"example\": {\n \"id\": \"b3b7c7e2-1c2d-4e2a-8e2b-1c2d4e2a8e2b\",\n \"username\": \"testuser\",\n \"email\": \"test@example.com\",\n \"created_at\": \"2024-06-01T12:00:00Z\",\n \"updated_at\": \"2024-06-01T12:00:00Z\"\n }\n }\n }\n },\n 401: {\"description\": \"Not authenticated.\"}\n }\n)\nasync def get_me(current_user=Depends(get_current_user)):\n \"\"\"\n Get the current authenticated user's information using the JWT access token.\n \"\"\"\n logger.info(f\"Get current user info: {current_user.email}\")\n return UserRead.from_orm(current_user)\n" }, { "path": "api/games.py", "content": "from fastapi import APIRouter, HTTPException, Depends\nfrom typing import List\n\nfrom crud.game_definition import GameDefinitionCRUD\nfrom crud.game_instance import GameInstanceCRUD\nfrom schemas.game_definition import GameDefinitionCreate, GameDefinitionUpdate, GameDefinition\nfrom schemas.game_instance import GameInstanceCreate, GameInstanceUpdate, GameInstance\n\nrouter = APIRouter()\n\ndef get_game_definition_crud():\n return GameDefinitionCRUD()\n\ndef get_game_instance_crud():\n return GameInstanceCRUD()\n\n@router.post('/game-definitions/', response_model=GameDefinition)\nasync def create_game_definition(game_definition: GameDefinitionCreate, crud: GameDefinitionCRUD = Depends(get_game_definition_crud)):\n return await crud.create(game_definition)\n\n@router.get('/game-definitions/', response_model=List[GameDefinition])\nasync def list_game_definitions(crud: GameDefinitionCRUD = Depends(get_game_definition_crud)):\n return await crud.get_all()\n\n@router.put('/game-definitions/{game_id}', response_model=GameDefinition)\nasync def update_game_definition(game_id: int, game_definition: GameDefinitionUpdate, crud: GameDefinitionCRUD = Depends(get_game_definition_crud)):\n existing_definition = await crud.get(game_id)\n if not existing_definition:\n raise HTTPException(status_code=404, detail='Game definition not found')\n return await crud.update(game_id, game_definition)\n\n@router.delete('/game-definitions/{game_id}', status_code=204)\nasync def delete_game_definition(game_id: int, crud: GameDefinitionCRUD = Depends(get_game_definition_crud)):\n existing_definition = await crud.get(game_id)\n if not existing_definition:\n raise HTTPException(status_code=404, detail='Game definition not found')\n await crud.delete(game_id)\n\n@router.post('/game-instances/', response_model=GameInstance)\nasync def create_game_instance(game_instance: GameInstanceCreate, crud: GameInstanceCRUD = Depends(get_game_instance_crud)):\n return await crud.create(game_instance)\n\n@router.get('/game-instances/', response_model=List[GameInstance])\nasync def list_game_instances(crud: GameInstanceCRUD = Depends(get_game_instance_crud)):\n return await crud.get_all()\n\n@router.put('/game-instances/{instance_id}', response_model=GameInstance)\nasync def update_game_instance(instance_id: int, game_instance: GameInstanceUpdate, crud: GameInstanceCRUD = Depends(get_game_instance_crud)):\n existing_instance = await crud.get(instance_id)\n if not existing_instance:\n raise HTTPException(status_code=404, detail='Game instance not found')\n return await crud.update(instance_id, game_instance)\n\n@router.delete('/game-instances/{instance_id}', status_code=204)\nasync def delete_game_instance(instance_id: int, crud: GameInstanceCRUD = Depends(get_game_instance_crud)):\n existing_instance = await crud.get(instance_id)\n if not existing_instance:\n raise HTTPException(status_code=404, detail='Game instance not found')\n await crud.delete(instance_id)" }, { "path": "api/llm.py", "content": "from fastapi import APIRouter, Depends, HTTPException, status\nfrom sqlalchemy.ext.asyncio import AsyncSession\nfrom llm_service.schemas import LLMCallRequest, LLMCallResponse, LLMCallLogRead\nfrom llm_service.service import LLMIntegrationService\nfrom llm_service.crud import create_log, list_logs_by_user\nfrom core.database import get_async_session\nfrom core.auth import get_current_user\nfrom core.logging import get_logger\nfrom core.tasks import call_llm_task\nfrom schemas.task import TaskStatus\nimport uuid\n\nlogger = get_logger(__name__)\n# llm_service = LLMIntegrationService() # No longer instantiated directly in endpoint\n\nrouter = APIRouter(prefix=\"/llm\", tags=[\"llm\"])\n\n\n@router.post(\"/call\", response_model=TaskStatus, summary=\"Trigger async LLM API call\")\nasync def call_llm_endpoint(\n req: LLMCallRequest,\n current_user=Depends(get_current_user),\n) -> TaskStatus:\n \"\"\"Trigger an asynchronous LLM API call and return the task ID.\"\"\"\n logger.info(\n f\"User {current_user.email} triggering async LLM call: {req.provider}/{req.model}\")\n # Attach user_id to request data for the task\n req_data = req.dict()\n # Pass UUID as string for serialization\n req_data[\"user_id\"] = str(current_user.id)\n\n # Trigger the Celery task\n task = call_llm_task.delay(req_data)\n\n # Return the task status immediately\n return TaskStatus(task_id=task.id, status=task.status)\n\n\n@router.get(\"/logs\", response_model=list[LLMCallLogRead], summary=\"List user's LLM call logs\")\nasync def get_logs(\n session: AsyncSession = Depends(get_async_session),\n current_user=Depends(get_current_user),\n):\n \"\"\"List all LLM call logs for the current user.\"\"\"\n logger.info(f\"Listing LLM call logs for user: {current_user.email}\")\n logs = await list_logs_by_user(session, current_user.id)\n # Ensure orm_mode is True on LLMCallLogRead for serialization\n return [LLMCallLogRead.from_orm(log) for log in logs]\n" }, { "path": "api/llm_service.py", "content": "from fastapi import APIRouter, HTTPException\nfrom pydantic import BaseModel\n\nrouter = APIRouter()\n\nclass LLMRequest(BaseModel):\n prompt: str\n max_tokens: int = 100\n\nclass LLMResponse(BaseModel):\n result: str\n\n@router.post(\"/llm/generate\", response_model=LLMResponse)\nasync def generate_response(request: LLMRequest):\n \"\"\"Generates a response from the LLM based on the given prompt.\"\"\"\n try:\n # Here you would integrate with your LLM service to generate a response\n # For now, we'll simulate a response\n simulated_response = f\"Response to: {request.prompt}\"\n return LLMResponse(result=simulated_response)\n except Exception as e:\n raise HTTPException(status_code=500, detail=str(e))\n\n# Include this router in your main API application\n\n" }, { "path": "api/llm_service_utils.py", "content": "\"\"\"\nUtility functions for LLM service\n\nThis module contains utility functions that assist in the operation\nof the LLM services. These functions are designed to facilitate\ncommon tasks and enhance code reusability.\n\"\"\"\n\nfrom typing import Any, Dict, List\n\n\ndef preprocess_input(input_data: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"\n Preprocess the input data for the LLM.\n \n Parameters:\n - input_data: A dictionary containing input data.\n \n Returns:\n A dictionary with preprocessed data.\n \"\"\"\n # Example preprocessing steps\n processed_data = {\n \"text\": input_data.get(\"text\", \"\").strip(),\n \"parameters\": input_data.get(\"parameters\", {}),\n }\n return processed_data\n\n\ndef format_response(response_data: Any) -> Dict[str, Any]:\n \"\"\"\n Format the response data from the LLM into a standard structure.\n \n Parameters:\n - response_data: The raw response data from the LLM.\n \n Returns:\n A formatted dictionary containing the response.\n \"\"\"\n formatted_response = {\n \"success\": True,\n \"data\": response_data\n }\n return formatted_response\n\n\ndef log_llm_request(request_data: Dict[str, Any]) -> None:\n \"\"\"\n Log the LLM request for auditing purposes.\n \n Parameters:\n - request_data: The data related to the LLM request.\n \"\"\"\n # Here you would implement logging logic, for example:\n # log.info(f\"LLM Request: {request_data}\")\n pass # Replace with actual logging implementation\n\n\ndef handle_error(error: Exception) -> Dict[str, Any]:\n \"\"\"\n Handle errors that occur during LLM operations.\n \n Parameters:\n - error: The exception that was raised.\n \n Returns:\n A dictionary containing error information.\n \"\"\"\n return {\n \"success\": False,\n \"message\": str(error)\n }\n" }, { "path": "api/routers/ai_engine.py", "content": "\"\"\"API router for AI Engine endpoints.\"\"\"\n\nfrom typing import Dict, Any\nfrom fastapi import APIRouter, Depends, HTTPException\nfrom sqlalchemy.ext.asyncio import AsyncSession\n\nfrom core.database import get_db\nfrom core.auth import get_current_user\nfrom core.ai_engine import (\n AIEngine,\n AdaptivePredictionEngine,\n CognitiveModelBuilder,\n QuantumUncertaintyGenerator,\n CollectiveWisdomAggregator,\n ExplainableAI\n)\nfrom schemas.user import User\nfrom schemas.game import GameState\n\nrouter = APIRouter(prefix=\"/ai\", tags=[\"AI Engine\"])\n\n# Initialize AI Engine components\nai_engine = AIEngine()\n\n\n@router.on_event(\"startup\")\nasync def initialize_ai_engine():\n \"\"\"Initialize AI Engine components on startup.\"\"\"\n await ai_engine.initialize_components()\n\n\n@router.post(\"/predict\")\nasync def predict_game_state(\n game_state: GameState,\n current_user: User = Depends(get_current_user),\n db: AsyncSession = Depends(get_db)\n) -> Dict[str, Any]:\n \"\"\"\n Process current game state and make predictions.\n\n This endpoint:\n 1. Generates uncertainty factors\n 2. Updates cognitive model\n 3. Makes predictions\n 4. Aggregates collective wisdom\n 5. Provides explanations\n \"\"\"\n try:\n # Prepare input data\n input_data = {\n \"game_id\": game_state.game_id,\n \"player_id\": current_user.id,\n \"game_state\": game_state.dict(),\n \"player_state\": {\n \"id\": current_user.id,\n \"profile\": current_user.profile.dict() if current_user.profile else {}\n }\n }\n\n # Process game state through AI Engine\n result = await ai_engine.process_game_state(input_data)\n\n return result\n\n except Exception as e:\n raise HTTPException(\n status_code=500,\n detail=f\"Error processing game state: {str(e)}\"\n )\n\n\n@router.post(\"/feedback\")\nasync def provide_feedback(\n feedback: Dict[str, Any],\n current_user: User = Depends(get_current_user),\n db: AsyncSession = Depends(get_db)\n) -> Dict[str, str]:\n \"\"\"\n Provide feedback to update AI models.\n\n This endpoint accepts feedback about:\n - Prediction accuracy\n - Cognitive model accuracy\n - Uncertainty estimation accuracy\n - Collective wisdom relevance\n - Explanation clarity\n \"\"\"\n try:\n # Add user context to feedback\n feedback[\"player_id\"] = current_user.id\n\n # Update AI components with feedback\n await ai_engine.update_components(feedback)\n\n return {\"status\": \"Feedback processed successfully\"}\n\n except Exception as e:\n raise HTTPException(\n status_code=500,\n detail=f\"Error processing feedback: {str(e)}\"\n )\n\n\n@router.get(\"/cognitive-profile/{player_id}\")\nasync def get_cognitive_profile(\n player_id: str,\n current_user: User = Depends(get_current_user),\n db: AsyncSession = Depends(get_db)\n) -> Dict[str, Any]:\n \"\"\"Get cognitive profile for a player.\"\"\"\n try:\n if current_user.id != player_id and not current_user.is_admin:\n raise HTTPException(\n status_code=403,\n detail=\"Not authorized to access this profile\"\n )\n\n cognitive_builder = ai_engine.cognitive_builder\n if not cognitive_builder:\n raise HTTPException(\n status_code=500,\n detail=\"Cognitive Model Builder not initialized\"\n )\n\n profile = cognitive_builder.profiles.get(player_id)\n if not profile:\n raise HTTPException(\n status_code=404,\n detail=\"Cognitive profile not found\"\n )\n\n return profile.dict()\n\n except HTTPException:\n raise\n except Exception as e:\n raise HTTPException(\n status_code=500,\n detail=f\"Error retrieving cognitive profile: {str(e)}\"\n )\n\n\n@router.get(\"/collective-wisdom/{game_id}\")\nasync def get_collective_wisdom(\n game_id: str,\n current_user: User = Depends(get_current_user),\n db: AsyncSession = Depends(get_db)\n) -> Dict[str, Any]:\n \"\"\"Get collective wisdom insights for a game.\"\"\"\n try:\n wisdom_aggregator = ai_engine.wisdom_aggregator\n if not wisdom_aggregator:\n raise HTTPException(\n status_code=500,\n detail=\"Collective Wisdom Aggregator not initialized\"\n )\n\n # Get latest knowledge for the game\n knowledge = next(\n (k for k in reversed(wisdom_aggregator.knowledge_base)\n if k.game_id == game_id),\n None\n )\n\n if not knowledge:\n raise HTTPException(\n status_code=404,\n detail=\"No collective wisdom found for this game\"\n )\n\n return knowledge.dict()\n\n except HTTPException:\n raise\n except Exception as e:\n raise HTTPException(\n status_code=500,\n detail=f\"Error retrieving collective wisdom: {str(e)}\"\n )\n\n\n@router.get(\"/explanations/{game_id}\")\nasync def get_explanations(\n game_id: str,\n current_user: User = Depends(get_current_user),\n db: AsyncSession = Depends(get_db)\n) -> Dict[str, Any]:\n \"\"\"Get AI explanations for a game.\"\"\"\n try:\n xai_system = ai_engine.xai_system\n if not xai_system:\n raise HTTPException(\n status_code=500,\n detail=\"Explainable AI system not initialized\"\n )\n\n # Get latest explanation for the game\n explanation = next(\n (e for e in reversed(xai_system.explanation_history)\n if e.game_id == game_id),\n None\n )\n\n if not explanation:\n raise HTTPException(\n status_code=404,\n detail=\"No explanations found for this game\"\n )\n\n return explanation.dict()\n\n except HTTPException:\n raise\n except Exception as e:\n raise HTTPException(\n status_code=500,\n detail=f\"Error retrieving explanations: {str(e)}\"\n )\n\n\n@router.get(\"/uncertainty/{game_id}\")\nasync def get_uncertainty_factors(\n game_id: str,\n current_user: User = Depends(get_current_user),\n db: AsyncSession = Depends(get_db)\n) -> Dict[str, Any]:\n \"\"\"Get uncertainty factors for a game.\"\"\"\n try:\n uncertainty_generator = ai_engine.quantum_generator\n if not uncertainty_generator:\n raise HTTPException(\n status_code=500,\n detail=\"Quantum Uncertainty Generator not initialized\"\n )\n\n # Get latest uncertainty factors for the game\n factors = next(\n (f for f in reversed(uncertainty_generator.uncertainty_history)\n if f.game_id == game_id),\n None\n )\n\n if not factors:\n raise HTTPException(\n status_code=404,\n detail=\"No uncertainty factors found for this game\"\n )\n\n return factors.dict()\n\n except HTTPException:\n raise\n except Exception as e:\n raise HTTPException(\n status_code=500,\n detail=f\"Error retrieving uncertainty factors: {str(e)}\"\n )\n" }, { "path": "api/tasks.py", "content": "from fastapi import APIRouter, Depends, HTTPException, status\nfrom schemas.task import TaskTrigger, TaskStatus\nfrom core.tasks import example_task\nfrom core.logging import get_logger\nfrom celery.result import AsyncResult\n\nlogger = get_logger(__name__)\n\nrouter = APIRouter(prefix=\"/tasks\", tags=[\"tasks\"])\n\n\n@router.post(\"/example\", response_model=TaskStatus, summary=\"Trigger example async task\")\nasync def trigger_example_task(task_in: TaskTrigger) -> TaskStatus:\n \"\"\"Trigger an example Celery task with a given sleep duration.\"\"\"\n logger.info(\n f\"Triggering example task with {task_in.seconds} seconds sleep\")\n task = example_task.delay(task_in.seconds)\n return TaskStatus(task_id=task.id, status=task.status, result=task.result)\n\n\n@router.get(\"/status/{task_id}\", response_model=TaskStatus, summary=\"Get status of an async task\")\nasync def get_task_status(task_id: str) -> TaskStatus:\n \"\"\"Get the current status and result of a Celery task by ID.\"\"\"\n task_result = AsyncResult(task_id)\n return TaskStatus(task_id=task_result.id, status=task_result.status, result=task_result.result)\n" }, { "path": "api/test_llm.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom api.llm import app\n\n# Create a test client using the FastAPI app\nclient = TestClient(app)\n\n@pytest.fixture(scope=\"module\")\ndef test_client():\n yield client\n\ndef test_llm_endpoint_valid_request(test_client):\n # Test a valid request to the LLM endpoint\n response = test_client.post(\"/llm\", json={\n \"prompt\": \"What is AI?\",\n \"max_tokens\": 50\n })\n assert response.status_code == 200\n assert \"choices\" in response.json()\n\n\ndef test_llm_endpoint_invalid_request(test_client):\n # Test an invalid request to the LLM endpoint\n response = test_client.post(\"/llm\", json={})\n assert response.status_code == 422 # Unprocessable Entity\n assert \"detail\" in response.json()\n\n\ndef test_llm_endpoint_edge_case(test_client):\n # Test an edge case request to the LLM endpoint\n response = test_client.post(\"/llm\", json={\n \"prompt\": \"\"\n })\n assert response.status_code == 400 # Bad Request\n assert \"detail\" in response.json()" }, { "path": "api/users.py", "content": "from fastapi import APIRouter, Depends, HTTPException, status\nfrom sqlalchemy.ext.asyncio import AsyncSession\nfrom schemas.user import UserRead, UserUpdate\nfrom schemas.cognitive_profile import CognitiveProfileRead, CognitiveProfileUpdate\nfrom crud.user import update_user\nfrom crud.cognitive_profile import get_by_user_id, create_profile, update_profile\nfrom core.database import get_async_session\nfrom core.auth import get_current_user\nfrom core.logging import get_logger\n\nlogger = get_logger(__name__)\n\nrouter = APIRouter(prefix=\"/users/me\", tags=[\"users\"])\n\n\n@router.get(\n \"/profile\",\n response_model=UserRead,\n summary=\"Get current user's profile info\",\n response_description=\"The current user's profile information.\",\n responses={\n 200: {\n \"description\": \"Current user profile info returned.\",\n \"content\": {\n \"application/json\": {\n \"example\": {\n \"id\": \"b3b7c7e2-1c2d-4e2a-8e2b-1c2d4e2a8e2b\",\n \"username\": \"testuser\",\n \"email\": \"test@example.com\",\n \"created_at\": \"2024-06-01T12:00:00Z\",\n \"updated_at\": \"2024-06-01T12:00:00Z\"\n }\n }\n }\n },\n 401: {\"description\": \"Not authenticated.\"}\n }\n)\nasync def get_profile(current_user=Depends(get_current_user)):\n \"\"\"\n Get the current user's profile information using the JWT access token.\n \"\"\"\n logger.info(f\"Profile access for user: {current_user.email}\")\n return UserRead.from_orm(current_user)\n\n\n@router.put(\n \"/profile\",\n response_model=UserRead,\n summary=\"Update current user's profile info\",\n response_description=\"The updated user's profile information.\",\n responses={\n 200: {\n \"description\": \"User profile updated successfully.\",\n \"content\": {\n \"application/json\": {\n \"example\": {\n \"id\": \"b3b7c7e2-1c2d-4e2a-8e2b-1c2d4e2a8e2b\",\n \"username\": \"updateduser\",\n \"email\": \"updated@example.com\",\n \"created_at\": \"2024-06-01T12:00:00Z\",\n \"updated_at\": \"2024-06-02T12:00:00Z\"\n }\n }\n }\n },\n 400: {\"description\": \"Invalid update data.\"},\n 401: {\"description\": \"Not authenticated.\"}\n }\n)\nasync def update_profile_info(\n user_update: UserUpdate,\n current_user=Depends(get_current_user),\n session: AsyncSession = Depends(get_async_session),\n):\n \"\"\"\n Update the current user's profile information. Only provided fields will be updated.\n \"\"\"\n logger.info(f\"Profile update attempt for user: {current_user.email}\")\n user = await update_user(session, current_user, user_update)\n logger.info(f\"Profile updated for user: {user.email}\")\n return UserRead.from_orm(user)\n\n\n@router.get(\n \"/cognitive-profile\",\n response_model=CognitiveProfileRead,\n summary=\"Get current user's cognitive profile\",\n response_description=\"The current user's cognitive profile information.\",\n responses={\n 200: {\n \"description\": \"Current user cognitive profile info returned.\",\n \"content\": {\n \"application/json\": {\n \"example\": {\n \"id\": \"c7e2b3b7-1c2d-4e2a-8e2b-1c2d4e2a8e2b\",\n \"user_id\": \"b3b7c7e2-1c2d-4e2a-8e2b-1c2d4e2a8e2b\",\n \"profile_data\": {\"risk_aversion\": 0.7, \"decision_speed\": \"fast\"},\n \"last_updated\": \"2024-06-01T12:00:00Z\"\n }\n }\n }\n },\n 401: {\"description\": \"Not authenticated.\"},\n 404: {\"description\": \"Cognitive profile not found.\"}\n }\n)\nasync def get_cognitive_profile(\n current_user=Depends(get_current_user),\n session: AsyncSession = Depends(get_async_session),\n):\n \"\"\"\n Get the current user's cognitive profile. Returns 404 if not found.\n \"\"\"\n logger.info(f\"Cognitive profile access for user: {current_user.email}\")\n profile = await get_by_user_id(session, current_user.id)\n if not profile:\n logger.warning(\n f\"Cognitive profile not found for user: {current_user.email}\")\n raise HTTPException(\n status_code=404, detail=\"Cognitive profile not found.\")\n return CognitiveProfileRead.from_orm(profile)\n\n\n@router.put(\n \"/cognitive-profile\",\n response_model=CognitiveProfileRead,\n summary=\"Update or create current user's cognitive profile\",\n response_description=\"The updated or newly created cognitive profile information.\",\n responses={\n 200: {\n \"description\": \"Cognitive profile updated or created successfully.\",\n \"content\": {\n \"application/json\": {\n \"example\": {\n \"id\": \"c7e2b3b7-1c2d-4e2a-8e2b-1c2d4e2a8e2b\",\n \"user_id\": \"b3b7c7e2-1c2d-4e2a-8e2b-1c2d4e2a8e2b\",\n \"profile_data\": {\"risk_aversion\": 0.8, \"decision_speed\": \"slow\"},\n \"last_updated\": \"2024-06-02T12:00:00Z\"\n }\n }\n }\n },\n 400: {\"description\": \"Invalid update data.\"},\n 401: {\"description\": \"Not authenticated.\"}\n }\n)\nasync def update_cognitive_profile(\n update_in: CognitiveProfileUpdate,\n current_user=Depends(get_current_user),\n session: AsyncSession = Depends(get_async_session),\n):\n \"\"\"\n Update or create the current user's cognitive profile. If no profile exists, a new one will be created.\n \"\"\"\n logger.info(\n f\"Cognitive profile update attempt for user: {current_user.email}\")\n profile = await get_by_user_id(session, current_user.id)\n if profile:\n profile = await update_profile(session, profile, update_in)\n logger.info(\n f\"Cognitive profile updated for user: {current_user.email}\")\n else:\n profile = await create_profile(session, current_user.id, update_in.profile_data)\n logger.info(\n f\"Cognitive profile created for user: {current_user.email}\")\n return CognitiveProfileRead.from_orm(profile)\n" }, { "path": "core/__init__.py", "content": " " }, { "path": "core/ai_engine/__init__.py", "content": "\"\"\"\nAI Engine Module for HAGAME.\n\nThis module provides the core AI functionality including:\n- Adaptive Prediction Engine\n- Cognitive Model Building System\n- Quantum Uncertainty Generator\n- Collective Wisdom Aggregation\n- Explainable AI (XAI)\n\"\"\"\n\nfrom .base import AIEngine\nfrom .prediction import AdaptivePredictionEngine\nfrom .cognitive import CognitiveModelBuilder\nfrom .quantum import QuantumUncertaintyGenerator\nfrom .collective import CollectiveWisdomAggregator\nfrom .xai import ExplainableAI\n\n__all__ = [\n 'AIEngine',\n 'AdaptivePredictionEngine',\n 'CognitiveModelBuilder',\n 'QuantumUncertaintyGenerator',\n 'CollectiveWisdomAggregator',\n 'ExplainableAI',\n]\n" }, { "path": "core/ai_engine/ai_processing.py", "content": "# ai_processing.py\n\n\"\"\"\nMain processing logic for AI engine.\n\nThis module contains the functions necessary for processing AI tasks,\nincluding cognitive modeling and decision-making processes based on\ninput data. It provides an interface for integrating various AI\nalgorithms and ensures seamless interaction with other components\nof the AI engine.\n\"\"\"\n\nfrom typing import Any, Dict\nimport logging\n\n# Configure logging\nlogging.basicConfig(level=logging.INFO)\nlogger = logging.getLogger(__name__)\n\n\ndef process_ai_task(task_data: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"\n Process an AI task based on provided task data.\n\n Args:\n task_data (Dict[str, Any]): The input data for the AI task.\n\n Returns:\n Dict[str, Any]: The result of the AI task processing.\n \"\"\" \n logger.info(\"Starting AI task processing.\")\n try:\n # Here, you would implement the specific AI processing logic.\n # This is just a placeholder for demonstration purposes.\n result = perform_cognitive_modeling(task_data)\n logger.info(\"AI task processing completed successfully.\")\n return result\n except Exception as e:\n logger.error(f\"Error during AI task processing: {e}\")\n raise\n\n\ndef perform_cognitive_modeling(data: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"\n Placeholder function for cognitive modeling logic.\n\n Args:\n data (Dict[str, Any]): The input data for cognitive modeling.\n\n Returns:\n Dict[str, Any]: The modeled output data.\n \"\"\" \n # Implement actual cognitive modeling logic here\n modeled_output = {\"status\": \"success\", \"data\": data}\n return modeled_output\n\n\nif __name__ == '__main__':\n # Example usage\n example_data = {\"input\": \"sample data\"}\n result = process_ai_task(example_data)\n print(result)" }, { "path": "core/ai_engine/ai_utilities.py", "content": "# ai_utilities.py\n\n\"\"\"\nUtility functions for AI engine processing.\n\nThis module contains helper functions for various AI engine tasks,\nsuch as processing input data, generating responses, and handling\nAI model interactions.\n\"\"\"\n\nfrom typing import Any, Dict, List\nimport logging\n\n# Configure logging for this module\nlogging.basicConfig(level=logging.INFO)\nlogger = logging.getLogger(__name__)\n\n\ndef preprocess_input(data: Any) -> Dict[str, Any]:\n \"\"\"\n Preprocess input data for the AI model.\n\n Parameters:\n data (Any): Raw input data to be processed.\n\n Returns:\n Dict[str, Any]: Processed data ready for AI model.\n \"\"\"\n logger.info(\"Preprocessing input data...\")\n # Add preprocessing logic here (e.g., normalization, encoding)\n processed_data = {} # Example placeholder\n return processed_data\n\n\ndef generate_response(model_output: Any) -> str:\n \"\"\"\n Generate a human-readable response from the model output.\n\n Parameters:\n model_output (Any): Output from the AI model.\n\n Returns:\n str: Human-readable response.\n \"\"\"\n logger.info(\"Generating response from model output...\")\n # Convert model output to a response string\n response = \"\" # Example placeholder\n return response\n\n\ndef log_model_interaction(model_name: str, input_data: Any, output_data: Any) -> None:\n \"\"\"\n Log interaction with the AI model for auditing purposes.\n\n Parameters:\n model_name (str): Name of the AI model being interacted with.\n input_data (Any): Input data sent to the model.\n output_data (Any): Output data received from the model.\n \"\"\"\n logger.info(f\"Model Interaction - {model_name}:\\n Input: {input_data}\\n Output: {output_data}\")\n" }, { "path": "core/ai_engine/base.py", "content": "\"\"\"Base class for the AI Engine components.\"\"\"\n\nfrom typing import Any, Dict, Optional\nfrom abc import ABC, abstractmethod\nimport logging\nfrom pydantic import BaseModel\n\nlogger = logging.getLogger(__name__)\n\n\nclass AIComponent(ABC):\n \"\"\"Abstract base class for all AI components.\"\"\"\n\n @abstractmethod\n async def initialize(self) -> None:\n \"\"\"Initialize the AI component.\"\"\"\n pass\n\n @abstractmethod\n async def process(self, input_data: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"Process input data and return results.\"\"\"\n pass\n\n @abstractmethod\n async def update(self, feedback: Dict[str, Any]) -> None:\n \"\"\"Update the component based on feedback.\"\"\"\n pass\n\n\nclass AIEngine:\n \"\"\"Main AI Engine class that orchestrates all AI components.\"\"\"\n\n def __init__(self):\n self.prediction_engine: Optional['AdaptivePredictionEngine'] = None\n self.cognitive_builder: Optional['CognitiveModelBuilder'] = None\n self.quantum_generator: Optional['QuantumUncertaintyGenerator'] = None\n self.wisdom_aggregator: Optional['CollectiveWisdomAggregator'] = None\n self.xai_system: Optional['ExplainableAI'] = None\n\n async def initialize_components(self) -> None:\n \"\"\"Initialize all AI components.\"\"\"\n from .prediction import AdaptivePredictionEngine\n from .cognitive import CognitiveModelBuilder\n from .quantum import QuantumUncertaintyGenerator\n from .collective import CollectiveWisdomAggregator\n from .xai import ExplainableAI\n\n self.prediction_engine = AdaptivePredictionEngine()\n self.cognitive_builder = CognitiveModelBuilder()\n self.quantum_generator = QuantumUncertaintyGenerator()\n self.wisdom_aggregator = CollectiveWisdomAggregator()\n self.xai_system = ExplainableAI()\n\n await self.prediction_engine.initialize()\n await self.cognitive_builder.initialize()\n await self.quantum_generator.initialize()\n await self.wisdom_aggregator.initialize()\n await self.xai_system.initialize()\n\n logger.info(\"All AI components initialized successfully\")\n\n async def process_game_state(self, game_state: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"Process the current game state through all AI components.\"\"\"\n try:\n # Generate quantum uncertainty factors\n uncertainty = await self.quantum_generator.process(game_state)\n\n # Build/update cognitive model\n cognitive_state = await self.cognitive_builder.process({\n **game_state,\n \"uncertainty\": uncertainty\n })\n\n # Make predictions\n predictions = await self.prediction_engine.process({\n **game_state,\n \"cognitive_state\": cognitive_state,\n \"uncertainty\": uncertainty\n })\n\n # Aggregate collective wisdom\n aggregated_wisdom = await self.wisdom_aggregator.process({\n **game_state,\n \"predictions\": predictions,\n \"cognitive_state\": cognitive_state\n })\n\n # Generate explanations\n explanations = await self.xai_system.process({\n **game_state,\n \"predictions\": predictions,\n \"cognitive_state\": cognitive_state,\n \"aggregated_wisdom\": aggregated_wisdom\n })\n\n return {\n \"predictions\": predictions,\n \"cognitive_state\": cognitive_state,\n \"uncertainty\": uncertainty,\n \"aggregated_wisdom\": aggregated_wisdom,\n \"explanations\": explanations\n }\n\n except Exception as e:\n logger.error(f\"Error processing game state: {str(e)}\")\n raise\n\n async def update_components(self, feedback: Dict[str, Any]) -> None:\n \"\"\"Update all components based on feedback.\"\"\"\n try:\n await self.prediction_engine.update(feedback)\n await self.cognitive_builder.update(feedback)\n await self.quantum_generator.update(feedback)\n await self.wisdom_aggregator.update(feedback)\n await self.xai_system.update(feedback)\n logger.info(\"All AI components updated successfully\")\n except Exception as e:\n logger.error(f\"Error updating AI components: {str(e)}\")\n raise\n" }, { "path": "core/ai_engine/cognitive.py", "content": "\"\"\"Cognitive Model Builder for HAGAME.\"\"\"\n\nfrom typing import Any, Dict, List, Optional\nimport logging\nimport numpy as np\nfrom pydantic import BaseModel\nfrom .base import AIComponent\n\nlogger = logging.getLogger(__name__)\n\n\nclass CognitiveProfile(BaseModel):\n \"\"\"Model for cognitive profile data.\"\"\"\n player_id: str\n learning_style: str\n decision_making: Dict[str, float]\n attention_patterns: Dict[str, float]\n skill_levels: Dict[str, float]\n adaptability: float\n last_updated: float\n\n\nclass CognitiveModelBuilder(AIComponent):\n \"\"\"Component for building and updating cognitive models of players.\"\"\"\n\n def __init__(self):\n self.profiles: Dict[str, CognitiveProfile] = {}\n self.feature_weights: Dict[str, np.ndarray] = {\n \"learning\": np.random.randn(5),\n \"decision\": np.random.randn(4),\n \"attention\": np.random.randn(3),\n \"skill\": np.random.randn(6)\n }\n\n async def initialize(self) -> None:\n \"\"\"Initialize cognitive modeling system.\"\"\"\n logger.info(\"Initializing Cognitive Model Builder\")\n # Initialize base cognitive modeling parameters\n self._initialize_feature_extractors()\n\n def _initialize_feature_extractors(self) -> None:\n \"\"\"Initialize feature extraction components.\"\"\"\n self.extractors = {\n \"learning\": self._create_learning_extractor(),\n \"decision\": self._create_decision_extractor(),\n \"attention\": self._create_attention_extractor(),\n \"skill\": self._create_skill_extractor()\n }\n\n def _create_learning_extractor(self) -> Dict[str, Any]:\n \"\"\"Create extractor for learning style features.\"\"\"\n return {\n \"features\": [\n \"improvement_rate\",\n \"error_correction\",\n \"pattern_recognition\",\n \"knowledge_retention\",\n \"adaptation_speed\"\n ],\n \"weights\": self.feature_weights[\"learning\"]\n }\n\n def _create_decision_extractor(self) -> Dict[str, Any]:\n \"\"\"Create extractor for decision-making features.\"\"\"\n return {\n \"features\": [\n \"reaction_time\",\n \"risk_taking\",\n \"strategic_depth\",\n \"tactical_awareness\"\n ],\n \"weights\": self.feature_weights[\"decision\"]\n }\n\n def _create_attention_extractor(self) -> Dict[str, Any]:\n \"\"\"Create extractor for attention pattern features.\"\"\"\n return {\n \"features\": [\n \"focus_duration\",\n \"distraction_resistance\",\n \"multi_tasking\"\n ],\n \"weights\": self.feature_weights[\"attention\"]\n }\n\n def _create_skill_extractor(self) -> Dict[str, Any]:\n \"\"\"Create extractor for skill level features.\"\"\"\n return {\n \"features\": [\n \"mechanical_skill\",\n \"strategic_planning\",\n \"resource_management\",\n \"spatial_awareness\",\n \"timing_precision\",\n \"coordination\"\n ],\n \"weights\": self.feature_weights[\"skill\"]\n }\n\n async def process(self, input_data: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"Process player data and update cognitive model.\"\"\"\n try:\n player_id = input_data.get(\"player_id\")\n game_state = input_data.get(\"game_state\", {})\n\n # Extract cognitive features\n learning_features = self._extract_learning_features(game_state)\n decision_features = self._extract_decision_features(game_state)\n attention_features = self._extract_attention_features(game_state)\n skill_features = self._extract_skill_features(game_state)\n\n # Update or create cognitive profile\n profile = self._update_cognitive_profile(\n player_id,\n learning_features,\n decision_features,\n attention_features,\n skill_features\n )\n\n return profile.dict()\n\n except Exception as e:\n logger.error(f\"Error in cognitive model processing: {str(e)}\")\n raise\n\n def _extract_learning_features(self, game_state: Dict[str, Any]) -> Dict[str, float]:\n \"\"\"Extract learning-related features from game state.\"\"\"\n features = {}\n extractor = self.extractors[\"learning\"]\n\n for feature in extractor[\"features\"]:\n value = self._calculate_learning_metric(feature, game_state)\n features[feature] = float(value)\n\n return features\n\n def _extract_decision_features(self, game_state: Dict[str, Any]) -> Dict[str, float]:\n \"\"\"Extract decision-making features from game state.\"\"\"\n features = {}\n extractor = self.extractors[\"decision\"]\n\n for feature in extractor[\"features\"]:\n value = self._calculate_decision_metric(feature, game_state)\n features[feature] = float(value)\n\n return features\n\n def _extract_attention_features(self, game_state: Dict[str, Any]) -> Dict[str, float]:\n \"\"\"Extract attention-related features from game state.\"\"\"\n features = {}\n extractor = self.extractors[\"attention\"]\n\n for feature in extractor[\"features\"]:\n value = self._calculate_attention_metric(feature, game_state)\n features[feature] = float(value)\n\n return features\n\n def _extract_skill_features(self, game_state: Dict[str, Any]) -> Dict[str, float]:\n \"\"\"Extract skill-related features from game state.\"\"\"\n features = {}\n extractor = self.extractors[\"skill\"]\n\n for feature in extractor[\"features\"]:\n value = self._calculate_skill_metric(feature, game_state)\n features[feature] = float(value)\n\n return features\n\n def _calculate_learning_metric(self, feature: str, game_state: Dict[str, Any]) -> float:\n \"\"\"Calculate specific learning-related metric.\"\"\"\n metrics = {\n \"improvement_rate\": lambda: self._calc_improvement_rate(game_state),\n \"error_correction\": lambda: self._calc_error_correction(game_state),\n \"pattern_recognition\": lambda: self._calc_pattern_recognition(game_state),\n \"knowledge_retention\": lambda: self._calc_knowledge_retention(game_state),\n \"adaptation_speed\": lambda: self._calc_adaptation_speed(game_state)\n }\n return metrics.get(feature, lambda: 0.0)()\n\n def _calculate_decision_metric(self, feature: str, game_state: Dict[str, Any]) -> float:\n \"\"\"Calculate specific decision-making metric.\"\"\"\n metrics = {\n \"reaction_time\": lambda: self._calc_reaction_time(game_state),\n \"risk_taking\": lambda: self._calc_risk_taking(game_state),\n \"strategic_depth\": lambda: self._calc_strategic_depth(game_state),\n \"tactical_awareness\": lambda: self._calc_tactical_awareness(game_state)\n }\n return metrics.get(feature, lambda: 0.0)()\n\n def _calculate_attention_metric(self, feature: str, game_state: Dict[str, Any]) -> float:\n \"\"\"Calculate specific attention-related metric.\"\"\"\n metrics = {\n \"focus_duration\": lambda: self._calc_focus_duration(game_state),\n \"distraction_resistance\": lambda: self._calc_distraction_resistance(game_state),\n \"multi_tasking\": lambda: self._calc_multi_tasking(game_state)\n }\n return metrics.get(feature, lambda: 0.0)()\n\n def _calculate_skill_metric(self, feature: str, game_state: Dict[str, Any]) -> float:\n \"\"\"Calculate specific skill-related metric.\"\"\"\n metrics = {\n \"mechanical_skill\": lambda: self._calc_mechanical_skill(game_state),\n \"strategic_planning\": lambda: self._calc_strategic_planning(game_state),\n \"resource_management\": lambda: self._calc_resource_management(game_state),\n \"spatial_awareness\": lambda: self._calc_spatial_awareness(game_state),\n \"timing_precision\": lambda: self._calc_timing_precision(game_state),\n \"coordination\": lambda: self._calc_coordination(game_state)\n }\n return metrics.get(feature, lambda: 0.0)()\n\n # Calculation methods for learning metrics\n def _calc_improvement_rate(self, game_state: Dict[str, Any]) -> float:\n return float(game_state.get(\"performance_delta\", 0.0))\n\n def _calc_error_correction(self, game_state: Dict[str, Any]) -> float:\n return float(game_state.get(\"error_correction_rate\", 0.0))\n\n def _calc_pattern_recognition(self, game_state: Dict[str, Any]) -> float:\n return float(game_state.get(\"pattern_recognition_score\", 0.0))\n\n def _calc_knowledge_retention(self, game_state: Dict[str, Any]) -> float:\n return float(game_state.get(\"knowledge_retention_rate\", 0.0))\n\n def _calc_adaptation_speed(self, game_state: Dict[str, Any]) -> float:\n return float(game_state.get(\"adaptation_speed\", 0.0))\n\n # Calculation methods for decision metrics\n def _calc_reaction_time(self, game_state: Dict[str, Any]) -> float:\n return float(game_state.get(\"avg_reaction_time\", 0.0))\n\n def _calc_risk_taking(self, game_state: Dict[str, Any]) -> float:\n return float(game_state.get(\"risk_taking_score\", 0.0))\n\n def _calc_strategic_depth(self, game_state: Dict[str, Any]) -> float:\n return float(game_state.get(\"strategic_depth_score\", 0.0))\n\n def _calc_tactical_awareness(self, game_state: Dict[str, Any]) -> float:\n return float(game_state.get(\"tactical_awareness_score\", 0.0))\n\n # Calculation methods for attention metrics\n def _calc_focus_duration(self, game_state: Dict[str, Any]) -> float:\n return float(game_state.get(\"focus_duration\", 0.0))\n\n def _calc_distraction_resistance(self, game_state: Dict[str, Any]) -> float:\n return float(game_state.get(\"distraction_resistance\", 0.0))\n\n def _calc_multi_tasking(self, game_state: Dict[str, Any]) -> float:\n return float(game_state.get(\"multi_tasking_score\", 0.0))\n\n # Calculation methods for skill metrics\n def _calc_mechanical_skill(self, game_state: Dict[str, Any]) -> float:\n return float(game_state.get(\"mechanical_skill_score\", 0.0))\n\n def _calc_strategic_planning(self, game_state: Dict[str, Any]) -> float:\n return float(game_state.get(\"strategic_planning_score\", 0.0))\n\n def _calc_resource_management(self, game_state: Dict[str, Any]) -> float:\n return float(game_state.get(\"resource_management_score\", 0.0))\n\n def _calc_spatial_awareness(self, game_state: Dict[str, Any]) -> float:\n return float(game_state.get(\"spatial_awareness_score\", 0.0))\n\n def _calc_timing_precision(self, game_state: Dict[str, Any]) -> float:\n return float(game_state.get(\"timing_precision_score\", 0.0))\n\n def _calc_coordination(self, game_state: Dict[str, Any]) -> float:\n return float(game_state.get(\"coordination_score\", 0.0))\n\n def _update_cognitive_profile(\n self,\n player_id: str,\n learning_features: Dict[str, float],\n decision_features: Dict[str, float],\n attention_features: Dict[str, float],\n skill_features: Dict[str, float]\n ) -> CognitiveProfile:\n \"\"\"Update or create cognitive profile for player.\"\"\"\n import time\n\n # Calculate learning style\n learning_style = self._determine_learning_style(learning_features)\n\n # Create or update profile\n profile = CognitiveProfile(\n player_id=player_id,\n learning_style=learning_style,\n decision_making=decision_features,\n attention_patterns=attention_features,\n skill_levels=skill_features,\n adaptability=self._calculate_adaptability(learning_features),\n last_updated=time.time()\n )\n\n self.profiles[player_id] = profile\n return profile\n\n def _determine_learning_style(self, learning_features: Dict[str, float]) -> str:\n \"\"\"Determine player's learning style based on features.\"\"\"\n styles = {\n \"visual\": self._calc_visual_score(learning_features),\n \"kinesthetic\": self._calc_kinesthetic_score(learning_features),\n \"analytical\": self._calc_analytical_score(learning_features)\n }\n return max(styles.items(), key=lambda x: x[1])[0]\n\n def _calc_visual_score(self, features: Dict[str, float]) -> float:\n \"\"\"Calculate score for visual learning style.\"\"\"\n return features.get(\"pattern_recognition\", 0.0) * 0.6 + features.get(\"knowledge_retention\", 0.0) * 0.4\n\n def _calc_kinesthetic_score(self, features: Dict[str, float]) -> float:\n \"\"\"Calculate score for kinesthetic learning style.\"\"\"\n return features.get(\"improvement_rate\", 0.0) * 0.5 + features.get(\"adaptation_speed\", 0.0) * 0.5\n\n def _calc_analytical_score(self, features: Dict[str, float]) -> float:\n \"\"\"Calculate score for analytical learning style.\"\"\"\n return features.get(\"error_correction\", 0.0) * 0.7 + features.get(\"pattern_recognition\", 0.0) * 0.3\n\n def _calculate_adaptability(self, learning_features: Dict[str, float]) -> float:\n \"\"\"Calculate player's adaptability score.\"\"\"\n weights = {\n \"improvement_rate\": 0.3,\n \"adaptation_speed\": 0.4,\n \"error_correction\": 0.3\n }\n\n adaptability = sum(\n learning_features.get(feature, 0.0) * weight\n for feature, weight in weights.items()\n )\n\n return float(max(0.0, min(1.0, adaptability)))\n\n async def update(self, feedback: Dict[str, Any]) -> None:\n \"\"\"Update cognitive model based on feedback.\"\"\"\n try:\n player_id = feedback.get(\"player_id\")\n if player_id not in self.profiles:\n logger.warning(\n f\"No cognitive profile found for player {player_id}\")\n return\n\n # Update feature weights based on feedback\n self._update_feature_weights(feedback)\n\n # Re-initialize feature extractors with updated weights\n self._initialize_feature_extractors()\n\n logger.info(f\"Updated cognitive model for player {player_id}\")\n\n except Exception as e:\n logger.error(f\"Error updating cognitive model: {str(e)}\")\n raise\n\n def _update_feature_weights(self, feedback: Dict[str, Any]) -> None:\n \"\"\"Update feature weights based on feedback.\"\"\"\n learning_rate = 0.01\n\n for feature_type, weights in self.feature_weights.items():\n if f\"{feature_type}_accuracy\" in feedback:\n accuracy = feedback[f\"{feature_type}_accuracy\"]\n gradient = np.array(feedback.get(\n f\"{feature_type}_gradient\", [0] * len(weights)))\n self.feature_weights[feature_type] += learning_rate * \\\n accuracy * gradient\n" }, { "path": "core/ai_engine/cognitive_functions.py", "content": "# cognitive_functions.py\n\n\"\"\"\nModule for implementing cognitive functions for the AI engine.\nThis module contains various cognitive processing capabilities that can be utilized\nby the AI engine to enhance gameplay and decision-making processes.\n\"\"\"\n\nfrom typing import Any, Dict, List\n\n\ndef process_cognitive_input(input_data: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"\n Process the cognitive input data and perform necessary computations.\n\n Args:\n input_data (Dict[str, Any]): The input data containing cognitive parameters.\n\n Returns:\n Dict[str, Any]: Processed output data with cognitive insights.\n \"\"\"\n # Placeholder for cognitive processing logic\n # Here we could apply cognitive models or algorithms\n # For demonstration, we will just return the input data augmented with a result.\n output_data = {\"result\": \"Processed cognitive insights based on input\"}\n output_data.update(input_data) # Augment the output with input data\n return output_data\n\n\ndef cognitive_analysis(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:\n \"\"\"\n Analyze a list of cognitive data entries and return insights.\n\n Args:\n data (List[Dict[str, Any]]): List of cognitive data entries.\n\n Returns:\n List[Dict[str, Any]]: List of processed data with insights.\n \"\"\"\n insights = []\n for entry in data:\n insight = process_cognitive_input(entry)\n insights.append(insight)\n return insights\n\n\n# Example usage:\nif __name__ == '__main__':\n sample_data = [{\"cognitive_param\": 1}, {\"cognitive_param\": 2}]\n results = cognitive_analysis(sample_data)\n print(results) # Outputs processed insights\n" }, { "path": "core/ai_engine/collective.py", "content": "\"\"\"Collective Wisdom Aggregator for HAGAME.\"\"\"\n\nfrom typing import Any, Dict, List, Optional, Tuple\nimport logging\nimport numpy as np\nfrom pydantic import BaseModel\nfrom .base import AIComponent\n\nlogger = logging.getLogger(__name__)\n\n\nclass CollectiveKnowledge(BaseModel):\n \"\"\"Model for collective knowledge data.\"\"\"\n game_id: str\n timestamp: float\n patterns: Dict[str, float]\n strategies: Dict[str, float]\n meta_insights: Dict[str, Any]\n confidence_scores: Dict[str, float]\n\n\nclass CollectiveWisdomAggregator(AIComponent):\n \"\"\"Component for aggregating and analyzing collective game knowledge.\"\"\"\n\n def __init__(self):\n self.knowledge_base: List[CollectiveKnowledge] = []\n self.pattern_weights: Dict[str, np.ndarray] = {}\n self.strategy_weights: Dict[str, np.ndarray] = {}\n self.meta_analyzers: Dict[str, Any] = {}\n self.confidence_threshold: float = 0.7\n\n async def initialize(self) -> None:\n \"\"\"Initialize collective wisdom system.\"\"\"\n logger.info(\"Initializing Collective Wisdom Aggregator\")\n self._initialize_pattern_recognition()\n self._initialize_strategy_analysis()\n self._initialize_meta_analyzers()\n\n def _initialize_pattern_recognition(self) -> None:\n \"\"\"Initialize pattern recognition components.\"\"\"\n self.pattern_weights = {\n \"behavioral\": np.random.randn(5), # Behavioral patterns\n \"temporal\": np.random.randn(4), # Time-based patterns\n \"spatial\": np.random.randn(6), # Spatial patterns\n \"strategic\": np.random.randn(4) # Strategic patterns\n }\n\n def _initialize_strategy_analysis(self) -> None:\n \"\"\"Initialize strategy analysis components.\"\"\"\n self.strategy_weights = {\n \"offensive\": np.random.randn(3), # Offensive strategies\n \"defensive\": np.random.randn(3), # Defensive strategies\n \"resource\": np.random.randn(4), # Resource management strategies\n \"social\": np.random.randn(3) # Social interaction strategies\n }\n\n def _initialize_meta_analyzers(self) -> None:\n \"\"\"Initialize meta-analysis components.\"\"\"\n self.meta_analyzers = {\n \"trend_analyzer\": self._create_trend_analyzer(),\n \"correlation_analyzer\": self._create_correlation_analyzer(),\n \"anomaly_detector\": self._create_anomaly_detector()\n }\n\n def _create_trend_analyzer(self) -> Dict[str, Any]:\n \"\"\"Create trend analysis component.\"\"\"\n return {\n \"window_size\": 10,\n \"weights\": np.random.randn(10),\n \"threshold\": 0.5\n }\n\n def _create_correlation_analyzer(self) -> Dict[str, Any]:\n \"\"\"Create correlation analysis component.\"\"\"\n return {\n \"matrix_size\": 8,\n \"correlation_matrix\": np.random.randn(8, 8),\n \"significance_threshold\": 0.3\n }\n\n def _create_anomaly_detector(self) -> Dict[str, Any]:\n \"\"\"Create anomaly detection component.\"\"\"\n return {\n \"baseline\": np.zeros(5),\n \"variance_threshold\": 2.0,\n \"history_size\": 100\n }\n\n async def process(self, input_data: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"Process game data and aggregate collective wisdom.\"\"\"\n try:\n game_id = input_data.get(\"game_id\")\n game_state = input_data.get(\"game_state\", {})\n predictions = input_data.get(\"predictions\", {})\n cognitive_state = input_data.get(\"cognitive_state\", {})\n\n # Analyze patterns\n patterns = self._analyze_patterns(game_state, predictions)\n\n # Analyze strategies\n strategies = self._analyze_strategies(game_state, cognitive_state)\n\n # Perform meta-analysis\n meta_insights = self._perform_meta_analysis(patterns, strategies)\n\n # Calculate confidence scores\n confidence_scores = self._calculate_confidence_scores(\n patterns,\n strategies,\n meta_insights\n )\n\n # Create collective knowledge model\n import time\n knowledge = CollectiveKnowledge(\n game_id=game_id,\n timestamp=time.time(),\n patterns=patterns,\n strategies=strategies,\n meta_insights=meta_insights,\n confidence_scores=confidence_scores\n )\n\n self.knowledge_base.append(knowledge)\n\n return knowledge.dict()\n\n except Exception as e:\n logger.error(f\"Error in collective wisdom processing: {str(e)}\")\n raise\n\n def _analyze_patterns(\n self,\n game_state: Dict[str, Any],\n predictions: Dict[str, Any]\n ) -> Dict[str, float]:\n \"\"\"Analyze various patterns in game data.\"\"\"\n patterns = {}\n\n # Analyze behavioral patterns\n behavioral = self._analyze_behavioral_patterns(game_state, predictions)\n patterns.update(behavioral)\n\n # Analyze temporal patterns\n temporal = self._analyze_temporal_patterns(game_state)\n patterns.update(temporal)\n\n # Analyze spatial patterns\n spatial = self._analyze_spatial_patterns(game_state)\n patterns.update(spatial)\n\n # Analyze strategic patterns\n strategic = self._analyze_strategic_patterns(game_state, predictions)\n patterns.update(strategic)\n\n return patterns\n\n def _analyze_behavioral_patterns(\n self,\n game_state: Dict[str, Any],\n predictions: Dict[str, Any]\n ) -> Dict[str, float]:\n \"\"\"Analyze behavioral patterns.\"\"\"\n features = self._extract_behavioral_features(game_state, predictions)\n weights = self.pattern_weights[\"behavioral\"]\n scores = np.dot(features, weights)\n\n return {\n \"aggression_pattern\": float(self._sigmoid(scores[0])),\n \"cooperation_pattern\": float(self._sigmoid(scores[1])),\n \"risk_pattern\": float(self._sigmoid(scores[2])),\n \"learning_pattern\": float(self._sigmoid(scores[3])),\n \"adaptation_pattern\": float(self._sigmoid(scores[4]))\n }\n\n def _analyze_temporal_patterns(self, game_state: Dict[str, Any]) -> Dict[str, float]:\n \"\"\"Analyze temporal patterns.\"\"\"\n features = self._extract_temporal_features(game_state)\n weights = self.pattern_weights[\"temporal\"]\n scores = np.dot(features, weights)\n\n return {\n \"cycle_pattern\": float(self._sigmoid(scores[0])),\n \"progression_pattern\": float(self._sigmoid(scores[1])),\n \"timing_pattern\": float(self._sigmoid(scores[2])),\n \"sequence_pattern\": float(self._sigmoid(scores[3]))\n }\n\n def _analyze_spatial_patterns(self, game_state: Dict[str, Any]) -> Dict[str, float]:\n \"\"\"Analyze spatial patterns.\"\"\"\n features = self._extract_spatial_features(game_state)\n weights = self.pattern_weights[\"spatial\"]\n scores = np.dot(features, weights)\n\n return {\n \"clustering_pattern\": float(self._sigmoid(scores[0])),\n \"distribution_pattern\": float(self._sigmoid(scores[1])),\n \"movement_pattern\": float(self._sigmoid(scores[2])),\n \"territory_pattern\": float(self._sigmoid(scores[3])),\n \"position_pattern\": float(self._sigmoid(scores[4])),\n \"formation_pattern\": float(self._sigmoid(scores[5]))\n }\n\n def _analyze_strategic_patterns(\n self,\n game_state: Dict[str, Any],\n predictions: Dict[str, Any]\n ) -> Dict[str, float]:\n \"\"\"Analyze strategic patterns.\"\"\"\n features = self._extract_strategic_features(game_state, predictions)\n weights = self.pattern_weights[\"strategic\"]\n scores = np.dot(features, weights)\n\n return {\n \"resource_pattern\": float(self._sigmoid(scores[0])),\n \"combat_pattern\": float(self._sigmoid(scores[1])),\n \"development_pattern\": float(self._sigmoid(scores[2])),\n \"social_pattern\": float(self._sigmoid(scores[3]))\n }\n\n def _analyze_strategies(\n self,\n game_state: Dict[str, Any],\n cognitive_state: Dict[str, Any]\n ) -> Dict[str, float]:\n \"\"\"Analyze various strategies in game data.\"\"\"\n strategies = {}\n\n # Analyze offensive strategies\n offensive = self._analyze_offensive_strategies(game_state)\n strategies.update(offensive)\n\n # Analyze defensive strategies\n defensive = self._analyze_defensive_strategies(game_state)\n strategies.update(defensive)\n\n # Analyze resource strategies\n resource = self._analyze_resource_strategies(game_state)\n strategies.update(resource)\n\n # Analyze social strategies\n social = self._analyze_social_strategies(game_state, cognitive_state)\n strategies.update(social)\n\n return strategies\n\n def _analyze_offensive_strategies(self, game_state: Dict[str, Any]) -> Dict[str, float]:\n \"\"\"Analyze offensive strategies.\"\"\"\n features = self._extract_offensive_features(game_state)\n weights = self.strategy_weights[\"offensive\"]\n scores = np.dot(features, weights)\n\n return {\n \"aggressive_strategy\": float(self._sigmoid(scores[0])),\n \"tactical_strategy\": float(self._sigmoid(scores[1])),\n \"opportunistic_strategy\": float(self._sigmoid(scores[2]))\n }\n\n def _analyze_defensive_strategies(self, game_state: Dict[str, Any]) -> Dict[str, float]:\n \"\"\"Analyze defensive strategies.\"\"\"\n features = self._extract_defensive_features(game_state)\n weights = self.strategy_weights[\"defensive\"]\n scores = np.dot(features, weights)\n\n return {\n \"protective_strategy\": float(self._sigmoid(scores[0])),\n \"reactive_strategy\": float(self._sigmoid(scores[1])),\n \"preventive_strategy\": float(self._sigmoid(scores[2]))\n }\n\n def _analyze_resource_strategies(self, game_state: Dict[str, Any]) -> Dict[str, float]:\n \"\"\"Analyze resource management strategies.\"\"\"\n features = self._extract_resource_features(game_state)\n weights = self.strategy_weights[\"resource\"]\n scores = np.dot(features, weights)\n\n return {\n \"gathering_strategy\": float(self._sigmoid(scores[0])),\n \"conservation_strategy\": float(self._sigmoid(scores[1])),\n \"investment_strategy\": float(self._sigmoid(scores[2])),\n \"distribution_strategy\": float(self._sigmoid(scores[3]))\n }\n\n def _analyze_social_strategies(\n self,\n game_state: Dict[str, Any],\n cognitive_state: Dict[str, Any]\n ) -> Dict[str, float]:\n \"\"\"Analyze social interaction strategies.\"\"\"\n features = self._extract_social_features(game_state, cognitive_state)\n weights = self.strategy_weights[\"social\"]\n scores = np.dot(features, weights)\n\n return {\n \"cooperative_strategy\": float(self._sigmoid(scores[0])),\n \"competitive_strategy\": float(self._sigmoid(scores[1])),\n \"diplomatic_strategy\": float(self._sigmoid(scores[2]))\n }\n\n def _perform_meta_analysis(\n self,\n patterns: Dict[str, float],\n strategies: Dict[str, float]\n ) -> Dict[str, Any]:\n \"\"\"Perform meta-analysis on patterns and strategies.\"\"\"\n meta_insights = {}\n\n # Analyze trends\n trends = self._analyze_trends(patterns, strategies)\n meta_insights[\"trends\"] = trends\n\n # Analyze correlations\n correlations = self._analyze_correlations(patterns, strategies)\n meta_insights[\"correlations\"] = correlations\n\n # Detect anomalies\n anomalies = self._detect_anomalies(patterns, strategies)\n meta_insights[\"anomalies\"] = anomalies\n\n return meta_insights\n\n def _analyze_trends(\n self,\n patterns: Dict[str, float],\n strategies: Dict[str, float]\n ) -> Dict[str, List[float]]:\n \"\"\"Analyze trends in patterns and strategies.\"\"\"\n analyzer = self.meta_analyzers[\"trend_analyzer\"]\n combined_data = list(patterns.values()) + list(strategies.values())\n\n if len(self.knowledge_base) >= analyzer[\"window_size\"]:\n historical_data = np.array([\n list(k.patterns.values()) + list(k.strategies.values())\n for k in self.knowledge_base[-analyzer[\"window_size\"]:]\n ])\n\n trends = np.mean(\n (historical_data - np.mean(historical_data, axis=0)) *\n analyzer[\"weights\"][:len(combined_data)],\n axis=0\n )\n else:\n trends = np.zeros(len(combined_data))\n\n return {\n \"pattern_trends\": trends[:len(patterns)].tolist(),\n \"strategy_trends\": trends[len(patterns):].tolist()\n }\n\n def _analyze_correlations(\n self,\n patterns: Dict[str, float],\n strategies: Dict[str, float]\n ) -> Dict[str, List[Tuple[str, str, float]]]:\n \"\"\"Analyze correlations between patterns and strategies.\"\"\"\n analyzer = self.meta_analyzers[\"correlation_analyzer\"]\n combined_data = list(patterns.items()) + list(strategies.items())\n significant_correlations = []\n\n for i, (name1, value1) in enumerate(combined_data):\n for j, (name2, value2) in enumerate(combined_data[i+1:], i+1):\n correlation = analyzer[\"correlation_matrix\"][i, j]\n if abs(correlation) > analyzer[\"significance_threshold\"]:\n significant_correlations.append(\n (name1, name2, float(correlation)))\n\n return {\n \"significant_correlations\": significant_correlations\n }\n\n def _detect_anomalies(\n self,\n patterns: Dict[str, float],\n strategies: Dict[str, float]\n ) -> Dict[str, List[str]]:\n \"\"\"Detect anomalies in patterns and strategies.\"\"\"\n analyzer = self.meta_analyzers[\"anomaly_detector\"]\n combined_data = np.array(\n list(patterns.values()) + list(strategies.values()))\n\n # Update baseline if enough history\n if len(self.knowledge_base) > 0:\n historical_data = np.array([\n list(k.patterns.values()) + list(k.strategies.values())\n for k in self.knowledge_base[-analyzer[\"history_size\"]:]\n ])\n analyzer[\"baseline\"] = np.mean(historical_data, axis=0)\n\n # Detect anomalies\n deviations = np.abs(combined_data - analyzer[\"baseline\"])\n anomaly_indices = np.where(\n deviations > analyzer[\"variance_threshold\"])[0]\n\n # Map anomalies to pattern/strategy names\n combined_names = list(patterns.keys()) + list(strategies.keys())\n anomalies = [combined_names[i] for i in anomaly_indices]\n\n return {\n \"detected_anomalies\": anomalies\n }\n\n def _calculate_confidence_scores(\n self,\n patterns: Dict[str, float],\n strategies: Dict[str, float],\n meta_insights: Dict[str, Any]\n ) -> Dict[str, float]:\n \"\"\"Calculate confidence scores for different aspects.\"\"\"\n confidence_scores = {}\n\n # Pattern confidence\n pattern_confidence = np.mean(list(patterns.values()))\n confidence_scores[\"pattern_confidence\"] = float(pattern_confidence)\n\n # Strategy confidence\n strategy_confidence = np.mean(list(strategies.values()))\n confidence_scores[\"strategy_confidence\"] = float(strategy_confidence)\n\n # Trend confidence\n trend_confidence = self._calculate_trend_confidence(\n meta_insights[\"trends\"])\n confidence_scores[\"trend_confidence\"] = float(trend_confidence)\n\n # Correlation confidence\n correlation_confidence = self._calculate_correlation_confidence(\n meta_insights[\"correlations\"]\n )\n confidence_scores[\"correlation_confidence\"] = float(\n correlation_confidence)\n\n # Overall confidence\n confidence_scores[\"overall_confidence\"] = float(np.mean([\n pattern_confidence,\n strategy_confidence,\n trend_confidence,\n correlation_confidence\n ]))\n\n return confidence_scores\n\n def _calculate_trend_confidence(self, trends: Dict[str, List[float]]) -> float:\n \"\"\"Calculate confidence in trend analysis.\"\"\"\n all_trends = trends[\"pattern_trends\"] + trends[\"strategy_trends\"]\n return float(np.mean(np.abs(all_trends)))\n\n def _calculate_correlation_confidence(\n self,\n correlations: Dict[str, List[Tuple[str, str, float]]]\n ) -> float:\n \"\"\"Calculate confidence in correlation analysis.\"\"\"\n if not correlations[\"significant_correlations\"]:\n return 0.0\n return float(np.mean([abs(c[2]) for c in correlations[\"significant_correlations\"]]))\n\n def _extract_behavioral_features(\n self,\n game_state: Dict[str, Any],\n predictions: Dict[str, Any]\n ) -> np.ndarray:\n \"\"\"Extract behavioral features from game state.\"\"\"\n return np.array([\n float(game_state.get(\"aggression_level\", 0.0)),\n float(game_state.get(\"cooperation_level\", 0.0)),\n float(game_state.get(\"risk_level\", 0.0)),\n float(game_state.get(\"learning_rate\", 0.0)),\n float(game_state.get(\"adaptation_rate\", 0.0))\n ])\n\n def _extract_temporal_features(self, game_state: Dict[str, Any]) -> np.ndarray:\n \"\"\"Extract temporal features from game state.\"\"\"\n return np.array([\n float(game_state.get(\"cycle_phase\", 0.0)),\n float(game_state.get(\"progression_rate\", 0.0)),\n float(game_state.get(\"timing_accuracy\", 0.0)),\n float(game_state.get(\"sequence_position\", 0.0))\n ])\n\n def _extract_spatial_features(self, game_state: Dict[str, Any]) -> np.ndarray:\n \"\"\"Extract spatial features from game state.\"\"\"\n return np.array([\n float(game_state.get(\"clustering_density\", 0.0)),\n float(game_state.get(\"distribution_spread\", 0.0)),\n float(game_state.get(\"movement_speed\", 0.0)),\n float(game_state.get(\"territory_control\", 0.0)),\n float(game_state.get(\"position_advantage\", 0.0)),\n float(game_state.get(\"formation_cohesion\", 0.0))\n ])\n\n def _extract_strategic_features(\n self,\n game_state: Dict[str, Any],\n predictions: Dict[str, Any]\n ) -> np.ndarray:\n \"\"\"Extract strategic features from game state.\"\"\"\n return np.array([\n float(game_state.get(\"resource_efficiency\", 0.0)),\n float(game_state.get(\"combat_effectiveness\", 0.0)),\n float(game_state.get(\"development_progress\", 0.0)),\n float(game_state.get(\"social_influence\", 0.0))\n ])\n\n def _extract_offensive_features(self, game_state: Dict[str, Any]) -> np.ndarray:\n \"\"\"Extract offensive strategy features.\"\"\"\n return np.array([\n float(game_state.get(\"attack_frequency\", 0.0)),\n float(game_state.get(\"tactical_advantage\", 0.0)),\n float(game_state.get(\"opportunity_usage\", 0.0))\n ])\n\n def _extract_defensive_features(self, game_state: Dict[str, Any]) -> np.ndarray:\n \"\"\"Extract defensive strategy features.\"\"\"\n return np.array([\n float(game_state.get(\"protection_level\", 0.0)),\n float(game_state.get(\"reaction_speed\", 0.0)),\n float(game_state.get(\"prevention_effectiveness\", 0.0))\n ])\n\n def _extract_resource_features(self, game_state: Dict[str, Any]) -> np.ndarray:\n \"\"\"Extract resource strategy features.\"\"\"\n return np.array([\n float(game_state.get(\"gathering_rate\", 0.0)),\n float(game_state.get(\"conservation_rate\", 0.0)),\n float(game_state.get(\"investment_ratio\", 0.0)),\n float(game_state.get(\"distribution_efficiency\", 0.0))\n ])\n\n def _extract_social_features(\n self,\n game_state: Dict[str, Any],\n cognitive_state: Dict[str, Any]\n ) -> np.ndarray:\n \"\"\"Extract social strategy features.\"\"\"\n return np.array([\n float(game_state.get(\"cooperation_rate\", 0.0)),\n float(game_state.get(\"competition_level\", 0.0)),\n float(game_state.get(\"diplomatic_influence\", 0.0))\n ])\n\n def _sigmoid(self, x: float) -> float:\n \"\"\"Apply sigmoid function to scalar value.\"\"\"\n return 1 / (1 + np.exp(-x))\n\n async def update(self, feedback: Dict[str, Any]) -> None:\n \"\"\"Update collective wisdom model based on feedback.\"\"\"\n try:\n # Update pattern recognition weights\n self._update_pattern_weights(feedback)\n\n # Update strategy analysis weights\n self._update_strategy_weights(feedback)\n\n # Update meta-analyzers\n self._update_meta_analyzers(feedback)\n\n logger.info(\"Updated collective wisdom model\")\n\n except Exception as e:\n logger.error(f\"Error updating collective wisdom model: {str(e)}\")\n raise\n\n def _update_pattern_weights(self, feedback: Dict[str, Any]) -> None:\n \"\"\"Update pattern recognition weights based on feedback.\"\"\"\n learning_rate = 0.01\n\n for pattern_type, weights in self.pattern_weights.items():\n if f\"{pattern_type}_accuracy\" in feedback:\n accuracy = feedback[f\"{pattern_type}_accuracy\"]\n gradient = np.array(feedback.get(\n f\"{pattern_type}_gradient\", [0] * len(weights)))\n self.pattern_weights[pattern_type] += learning_rate * \\\n accuracy * gradient\n\n def _update_strategy_weights(self, feedback: Dict[str, Any]) -> None:\n \"\"\"Update strategy analysis weights based on feedback.\"\"\"\n learning_rate = 0.01\n\n for strategy_type, weights in self.strategy_weights.items():\n if f\"{strategy_type}_accuracy\" in feedback:\n accuracy = feedback[f\"{strategy_type}_accuracy\"]\n gradient = np.array(feedback.get(\n f\"{strategy_type}_gradient\", [0] * len(weights)))\n self.strategy_weights[strategy_type] += learning_rate * \\\n accuracy * gradient\n\n def _update_meta_analyzers(self, feedback: Dict[str, Any]) -> None:\n \"\"\"Update meta-analyzers based on feedback.\"\"\"\n # Update trend analyzer\n if \"trend_accuracy\" in feedback:\n self.meta_analyzers[\"trend_analyzer\"][\"weights\"] *= (\n 1 + 0.1 * (feedback[\"trend_accuracy\"] - 0.5))\n\n # Update correlation analyzer\n if \"correlation_matrix_update\" in feedback:\n update = np.array(feedback[\"correlation_matrix_update\"])\n self.meta_analyzers[\"correlation_analyzer\"][\"correlation_matrix\"] += 0.1 * update\n\n # Update anomaly detector\n if \"anomaly_feedback\" in feedback:\n self.meta_analyzers[\"anomaly_detector\"][\"variance_threshold\"] *= (\n 1 + 0.1 * (feedback[\"anomaly_feedback\"] - 0.5)\n )\n" }, { "path": "core/ai_engine/collective_intelligence.py", "content": "from typing import List, Dict, Any\n\nclass CollectiveIntelligence:\n \"\"\"\n A class to implement collective intelligence features for the AI engine.\n This class includes methods for aggregating knowledge, decision-making, and collaborative learning.\n \"\"\"\n\n def __init__(self):\n self.knowledge_base: List[Dict[str, Any]] = []\n\n def aggregate_knowledge(self, new_knowledge: Dict[str, Any]) -> None:\n \"\"\"\n Aggregates new knowledge into the existing knowledge base.\n :param new_knowledge: A dictionary containing the new knowledge to be added.\n \"\"\"\n self.knowledge_base.append(new_knowledge)\n\n def make_decision(self, criteria: Dict[str, Any]) -> Any:\n \"\"\"\n Makes a decision based on the aggregated knowledge and the provided criteria.\n \n :param criteria: A dictionary containing the criteria for decision-making.\n :return: The decision made based on the criteria.\n \"\"\"\n # Example logic for decision-making (to be implemented as needed)\n for knowledge in self.knowledge_base:\n if all(knowledge.get(key) == value for key, value in criteria.items()):\n return knowledge\n return None # No decision found\n\n def learn_collaboratively(self, external_data: List[Dict[str, Any]]) -> None:\n \"\"\"\n Updates the knowledge base with external data to enhance collective learning.\n :param external_data: A list of dictionaries containing external data.\n \"\"\"\n for data in external_data:\n self.aggregate_knowledge(data)\n\n def get_knowledge_base(self) -> List[Dict[str, Any]]:\n \"\"\"\n Returns the current knowledge base.\n :return: List of knowledge entries.\n \"\"\"\n return self.knowledge_base\n\n# Example usage:\n# ci = CollectiveIntelligence()\n# ci.aggregate_knowledge({'topic': 'AI', 'data': 'New findings in AI research.'})\n# decision = ci.make_decision({'topic': 'AI'})\n# print(decision)\n" }, { "path": "core/ai_engine/llm_utils.py", "content": "import logging\nfrom typing import Any, Dict\n\n# Configure logging\nlogging.basicConfig(level=logging.INFO)\nlogger = logging.getLogger(__name__)\n\n\ndef preprocess_llm_input(user_input: str) -> Dict[str, Any]:\n \"\"\"\n Preprocess the user input for LLM.\n \n Args:\n user_input (str): The raw input from the user.\n \n Returns:\n Dict[str, Any]: A dictionary containing the processed input.\n \"\"\"\n try:\n processed_input = user_input.strip().lower()\n logger.info(\"Input processed successfully.\")\n return {'input': processed_input}\n except Exception as e:\n logger.error(f\"Error processing input: {e}\")\n raise\n\n\ndef format_llm_response(response: Any) -> str:\n \"\"\"\n Format the response from LLM for user display.\n \n Args:\n response (Any): The raw response from LLM.\n \n Returns:\n str: A formatted string for display.\n \"\"\"\n try:\n formatted_response = str(response)\n logger.info(\"Response formatted successfully.\")\n return formatted_response\n except Exception as e:\n logger.error(f\"Error formatting response: {e}\")\n raise\n\n\ndef log_llm_interaction(user_input: str, response: Any) -> None:\n \"\"\"\n Log the interaction between user input and LLM response.\n \n Args:\n user_input (str): The input provided by the user.\n response (Any): The response generated by LLM.\n \"\"\"\n logger.info(f\"User Input: {user_input}\")\n logger.info(f\"LLM Response: {response}\")\n" }, { "path": "core/ai_engine/prediction.py", "content": "\"\"\"Adaptive Prediction Engine for HAGAME.\"\"\"\n\nfrom typing import Any, Dict, List, Optional\nimport logging\nimport numpy as np\nfrom pydantic import BaseModel\nfrom .base import AIComponent\n\nlogger = logging.getLogger(__name__)\n\n\nclass PredictionModel(BaseModel):\n \"\"\"Model for prediction data.\"\"\"\n game_id: str\n player_id: str\n prediction_type: str\n confidence: float\n predicted_values: Dict[str, Any]\n context: Dict[str, Any]\n\n\nclass AdaptivePredictionEngine(AIComponent):\n \"\"\"Component for making adaptive predictions about game states and player behavior.\"\"\"\n\n def __init__(self):\n self.models: Dict[str, Any] = {} # Game-specific prediction models\n self.history: List[PredictionModel] = []\n self.learning_rate: float = 0.01\n\n async def initialize(self) -> None:\n \"\"\"Initialize prediction models and parameters.\"\"\"\n logger.info(\"Initializing Adaptive Prediction Engine\")\n # Initialize base prediction models\n self.models = {\n \"behavior\": self._create_behavior_model(),\n \"outcome\": self._create_outcome_model(),\n \"strategy\": self._create_strategy_model()\n }\n\n def _create_behavior_model(self) -> Dict[str, Any]:\n \"\"\"Create model for predicting player behavior.\"\"\"\n return {\n \"weights\": np.random.randn(10), # Initial random weights\n \"bias\": np.random.randn(),\n \"features\": [\"action_history\", \"cognitive_state\", \"game_context\"]\n }\n\n def _create_outcome_model(self) -> Dict[str, Any]:\n \"\"\"Create model for predicting game outcomes.\"\"\"\n return {\n \"weights\": np.random.randn(8),\n \"bias\": np.random.randn(),\n \"features\": [\"game_state\", \"player_stats\", \"uncertainty\"]\n }\n\n def _create_strategy_model(self) -> Dict[str, Any]:\n \"\"\"Create model for predicting optimal strategies.\"\"\"\n return {\n \"weights\": np.random.randn(12),\n \"bias\": np.random.randn(),\n \"features\": [\"game_state\", \"player_profile\", \"historical_patterns\"]\n }\n\n async def process(self, input_data: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"Process current game state and make predictions.\"\"\"\n try:\n game_id = input_data.get(\"game_id\")\n player_id = input_data.get(\"player_id\")\n game_state = input_data.get(\"game_state\", {})\n cognitive_state = input_data.get(\"cognitive_state\", {})\n uncertainty = input_data.get(\"uncertainty\", {})\n\n # Make different types of predictions\n behavior_pred = self._predict_behavior(game_state, cognitive_state)\n outcome_pred = self._predict_outcome(game_state, uncertainty)\n strategy_pred = self._predict_strategy(game_state, cognitive_state)\n\n prediction = PredictionModel(\n game_id=game_id,\n player_id=player_id,\n prediction_type=\"composite\",\n confidence=self._calculate_confidence(\n behavior_pred, outcome_pred, strategy_pred),\n predicted_values={\n \"behavior\": behavior_pred,\n \"outcome\": outcome_pred,\n \"strategy\": strategy_pred\n },\n context={\n \"game_state\": game_state,\n \"cognitive_state\": cognitive_state,\n \"uncertainty\": uncertainty\n }\n )\n\n self.history.append(prediction)\n\n return prediction.dict()\n\n except Exception as e:\n logger.error(f\"Error in prediction processing: {str(e)}\")\n raise\n\n def _predict_behavior(self, game_state: Dict[str, Any], cognitive_state: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"Predict player behavior based on game state and cognitive state.\"\"\"\n features = self._extract_features(\n game_state, cognitive_state, self.models[\"behavior\"][\"features\"])\n prediction = np.dot(\n features, self.models[\"behavior\"][\"weights\"]) + self.models[\"behavior\"][\"bias\"]\n return {\n \"predicted_actions\": self._normalize_prediction(prediction),\n \"confidence\": float(np.mean(np.abs(prediction)))\n }\n\n def _predict_outcome(self, game_state: Dict[str, Any], uncertainty: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"Predict game outcome based on current state and uncertainty.\"\"\"\n features = self._extract_features(\n game_state, uncertainty, self.models[\"outcome\"][\"features\"])\n prediction = np.dot(\n features, self.models[\"outcome\"][\"weights\"]) + self.models[\"outcome\"][\"bias\"]\n return {\n \"win_probability\": float(self._sigmoid(prediction)),\n \"confidence\": float(self._calculate_outcome_confidence(prediction, uncertainty))\n }\n\n def _predict_strategy(self, game_state: Dict[str, Any], cognitive_state: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"Predict optimal strategy based on game state and cognitive state.\"\"\"\n features = self._extract_features(\n game_state, cognitive_state, self.models[\"strategy\"][\"features\"])\n prediction = np.dot(\n features, self.models[\"strategy\"][\"weights\"]) + self.models[\"strategy\"][\"bias\"]\n return {\n \"recommended_actions\": self._strategy_to_actions(prediction),\n \"confidence\": float(self._calculate_strategy_confidence(prediction, cognitive_state))\n }\n\n def _extract_features(self, state: Dict[str, Any], context: Dict[str, Any], feature_list: List[str]) -> np.ndarray:\n \"\"\"Extract relevant features from state and context.\"\"\"\n features = []\n for feature in feature_list:\n value = state.get(feature, 0) or context.get(feature, 0)\n features.append(float(value) if isinstance(\n value, (int, float)) else 0.0)\n return np.array(features)\n\n def _normalize_prediction(self, prediction: np.ndarray) -> List[float]:\n \"\"\"Normalize prediction values to probabilities.\"\"\"\n exp_pred = np.exp(prediction - np.max(prediction))\n return (exp_pred / exp_pred.sum()).tolist()\n\n def _sigmoid(self, x: float) -> float:\n \"\"\"Apply sigmoid function to scalar value.\"\"\"\n return 1 / (1 + np.exp(-x))\n\n def _calculate_confidence(self, *predictions: Dict[str, Any]) -> float:\n \"\"\"Calculate overall confidence based on individual predictions.\"\"\"\n confidences = [p.get(\"confidence\", 0.0) for p in predictions]\n return float(np.mean(confidences))\n\n def _calculate_outcome_confidence(self, prediction: float, uncertainty: Dict[str, Any]) -> float:\n \"\"\"Calculate confidence in outcome prediction.\"\"\"\n base_confidence = self._sigmoid(abs(prediction))\n uncertainty_factor = uncertainty.get(\"outcome_uncertainty\", 0.5)\n return base_confidence * (1 - uncertainty_factor)\n\n def _calculate_strategy_confidence(self, prediction: float, cognitive_state: Dict[str, Any]) -> float:\n \"\"\"Calculate confidence in strategy prediction.\"\"\"\n base_confidence = self._sigmoid(abs(prediction))\n cognitive_factor = cognitive_state.get(\"certainty\", 0.5)\n return base_confidence * cognitive_factor\n\n def _strategy_to_actions(self, prediction: float) -> List[Dict[str, Any]]:\n \"\"\"Convert strategy prediction to concrete actions.\"\"\"\n return [\n {\n \"action_type\": \"move\",\n \"probability\": self._sigmoid(prediction),\n \"parameters\": {\"direction\": \"optimal\"}\n },\n {\n \"action_type\": \"attack\",\n \"probability\": self._sigmoid(-prediction),\n \"parameters\": {\"target\": \"nearest\"}\n }\n ]\n\n async def update(self, feedback: Dict[str, Any]) -> None:\n \"\"\"Update prediction models based on feedback.\"\"\"\n try:\n actual_outcome = feedback.get(\"actual_outcome\", {})\n predicted_outcome = feedback.get(\"predicted_outcome\", {})\n\n # Calculate prediction error\n error = self._calculate_prediction_error(\n actual_outcome, predicted_outcome)\n\n # Update model weights\n self._update_weights(error, feedback)\n\n # Adjust learning rate based on error\n self._adjust_learning_rate(error)\n\n logger.info(f\"Updated prediction models with error: {error}\")\n\n except Exception as e:\n logger.error(f\"Error updating prediction models: {str(e)}\")\n raise\n\n def _calculate_prediction_error(self, actual: Dict[str, Any], predicted: Dict[str, Any]) -> float:\n \"\"\"Calculate error between actual and predicted outcomes.\"\"\"\n actual_value = actual.get(\"value\", 0.0)\n predicted_value = predicted.get(\"value\", 0.0)\n return float(abs(actual_value - predicted_value))\n\n def _update_weights(self, error: float, feedback: Dict[str, Any]) -> None:\n \"\"\"Update model weights based on prediction error.\"\"\"\n for model_name, model in self.models.items():\n features = self._extract_features(\n feedback.get(\"game_state\", {}),\n feedback.get(\"context\", {}),\n model[\"features\"]\n )\n gradient = error * features\n model[\"weights\"] -= self.learning_rate * gradient\n model[\"bias\"] -= self.learning_rate * error\n\n def _adjust_learning_rate(self, error: float) -> None:\n \"\"\"Adjust learning rate based on prediction error.\"\"\"\n if error > 0.5:\n self.learning_rate *= 0.95 # Decrease learning rate if error is high\n else:\n self.learning_rate *= 1.05 # Increase learning rate if error is low\n # Keep learning rate in reasonable bounds\n self.learning_rate = max(0.001, min(0.1, self.learning_rate))\n" }, { "path": "core/ai_engine/quantum.py", "content": "\"\"\"Quantum Uncertainty Generator for HAGAME.\"\"\"\n\nfrom typing import Any, Dict, List, Optional\nimport logging\nimport numpy as np\nfrom pydantic import BaseModel\nfrom .base import AIComponent\n\nlogger = logging.getLogger(__name__)\n\n\nclass UncertaintyFactors(BaseModel):\n \"\"\"Model for uncertainty factors.\"\"\"\n game_id: str\n timestamp: float\n player_uncertainty: Dict[str, float]\n game_state_uncertainty: Dict[str, float]\n environmental_uncertainty: Dict[str, float]\n composite_uncertainty: float\n\n\nclass QuantumUncertaintyGenerator(AIComponent):\n \"\"\"Component for generating quantum-inspired uncertainty factors.\"\"\"\n\n def __init__(self):\n self.uncertainty_history: List[UncertaintyFactors] = []\n self.quantum_states: Dict[str, np.ndarray] = {}\n self.entanglement_matrix: Optional[np.ndarray] = None\n self.decoherence_rate: float = 0.1\n\n async def initialize(self) -> None:\n \"\"\"Initialize quantum uncertainty system.\"\"\"\n logger.info(\"Initializing Quantum Uncertainty Generator\")\n self._initialize_quantum_states()\n self._initialize_entanglement_matrix()\n\n def _initialize_quantum_states(self) -> None:\n \"\"\"Initialize quantum states for different uncertainty types.\"\"\"\n self.quantum_states = {\n # Player-related uncertainties\n \"player\": self._create_quantum_state(3),\n # Game state uncertainties\n \"game\": self._create_quantum_state(4),\n # Environmental uncertainties\n \"environment\": self._create_quantum_state(2)\n }\n\n def _initialize_entanglement_matrix(self) -> None:\n \"\"\"Initialize entanglement matrix for uncertainty correlations.\"\"\"\n total_states = sum(state.shape[0]\n for state in self.quantum_states.values())\n self.entanglement_matrix = np.random.randn(total_states, total_states)\n # Make it symmetric for realistic entanglement\n self.entanglement_matrix = (\n self.entanglement_matrix + self.entanglement_matrix.T) / 2\n\n def _create_quantum_state(self, dimensions: int) -> np.ndarray:\n \"\"\"Create a normalized quantum state vector.\"\"\"\n state = np.random.randn(dimensions) + 1j * np.random.randn(dimensions)\n return state / np.linalg.norm(state)\n\n async def process(self, input_data: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"Generate uncertainty factors for current game state.\"\"\"\n try:\n game_id = input_data.get(\"game_id\")\n game_state = input_data.get(\"game_state\", {})\n player_state = input_data.get(\"player_state\", {})\n\n # Apply quantum evolution\n self._evolve_quantum_states(game_state)\n\n # Calculate uncertainty factors\n player_uncertainty = self._calculate_player_uncertainty(\n player_state)\n game_uncertainty = self._calculate_game_uncertainty(game_state)\n env_uncertainty = self._calculate_environmental_uncertainty(\n game_state)\n\n # Apply entanglement effects\n self._apply_entanglement_effects(\n player_uncertainty, game_uncertainty, env_uncertainty)\n\n # Calculate composite uncertainty\n composite = self._calculate_composite_uncertainty(\n player_uncertainty,\n game_uncertainty,\n env_uncertainty\n )\n\n # Create uncertainty factors model\n import time\n factors = UncertaintyFactors(\n game_id=game_id,\n timestamp=time.time(),\n player_uncertainty=player_uncertainty,\n game_state_uncertainty=game_uncertainty,\n environmental_uncertainty=env_uncertainty,\n composite_uncertainty=composite\n )\n\n self.uncertainty_history.append(factors)\n\n return factors.dict()\n\n except Exception as e:\n logger.error(f\"Error generating uncertainty factors: {str(e)}\")\n raise\n\n def _evolve_quantum_states(self, game_state: Dict[str, Any]) -> None:\n \"\"\"Evolve quantum states based on game state.\"\"\"\n # Apply unitary evolution\n for state_type, state in self.quantum_states.items():\n evolution_matrix = self._create_evolution_matrix(\n state.shape[0], game_state)\n self.quantum_states[state_type] = evolution_matrix @ state\n # Renormalize\n self.quantum_states[state_type] /= np.linalg.norm(\n self.quantum_states[state_type])\n\n def _create_evolution_matrix(self, size: int, game_state: Dict[str, Any]) -> np.ndarray:\n \"\"\"Create unitary evolution matrix based on game state.\"\"\"\n # Create Hermitian matrix\n h_matrix = np.random.randn(size, size) + \\\n 1j * np.random.randn(size, size)\n h_matrix = (h_matrix + h_matrix.T.conj()) / 2\n\n # Add game state influence\n game_factor = min(1.0, max(0.0, game_state.get(\"complexity\", 0.5)))\n h_matrix *= game_factor\n\n # Convert to unitary matrix using matrix exponential\n from scipy.linalg import expm\n return expm(-1j * h_matrix * self.decoherence_rate)\n\n def _calculate_player_uncertainty(self, player_state: Dict[str, Any]) -> Dict[str, float]:\n \"\"\"Calculate player-related uncertainty factors.\"\"\"\n state = self.quantum_states[\"player\"]\n probabilities = np.abs(state) ** 2\n\n return {\n \"decision_uncertainty\": float(probabilities[0]),\n \"skill_uncertainty\": float(probabilities[1]),\n \"intention_uncertainty\": float(probabilities[2])\n }\n\n def _calculate_game_uncertainty(self, game_state: Dict[str, Any]) -> Dict[str, float]:\n \"\"\"Calculate game state uncertainty factors.\"\"\"\n state = self.quantum_states[\"game\"]\n probabilities = np.abs(state) ** 2\n\n return {\n \"state_uncertainty\": float(probabilities[0]),\n \"outcome_uncertainty\": float(probabilities[1]),\n \"interaction_uncertainty\": float(probabilities[2]),\n \"emergence_uncertainty\": float(probabilities[3])\n }\n\n def _calculate_environmental_uncertainty(self, game_state: Dict[str, Any]) -> Dict[str, float]:\n \"\"\"Calculate environmental uncertainty factors.\"\"\"\n state = self.quantum_states[\"environment\"]\n probabilities = np.abs(state) ** 2\n\n return {\n \"external_uncertainty\": float(probabilities[0]),\n \"context_uncertainty\": float(probabilities[1])\n }\n\n def _apply_entanglement_effects(\n self,\n player_uncertainty: Dict[str, float],\n game_uncertainty: Dict[str, float],\n env_uncertainty: Dict[str, float]\n ) -> None:\n \"\"\"Apply quantum entanglement effects to uncertainty factors.\"\"\"\n # Combine all uncertainties into a vector\n combined = np.array([\n *player_uncertainty.values(),\n *game_uncertainty.values(),\n *env_uncertainty.values()\n ])\n\n # Apply entanglement effects\n entangled = self.entanglement_matrix @ combined\n\n # Normalize and update uncertainties\n entangled = np.abs(entangled) / np.sum(np.abs(entangled))\n\n # Update individual uncertainties\n idx = 0\n for uncertainties in [player_uncertainty, game_uncertainty, env_uncertainty]:\n for key in uncertainties:\n uncertainties[key] = float(entangled[idx])\n idx += 1\n\n def _calculate_composite_uncertainty(\n self,\n player_uncertainty: Dict[str, float],\n game_uncertainty: Dict[str, float],\n env_uncertainty: Dict[str, float]\n ) -> float:\n \"\"\"Calculate composite uncertainty score.\"\"\"\n # Weights for different uncertainty types\n weights = {\n \"player\": 0.4,\n \"game\": 0.4,\n \"environment\": 0.2\n }\n\n # Calculate weighted averages\n player_score = np.mean(\n list(player_uncertainty.values())) * weights[\"player\"]\n game_score = np.mean(list(game_uncertainty.values())) * weights[\"game\"]\n env_score = np.mean(list(env_uncertainty.values())\n ) * weights[\"environment\"]\n\n return float(player_score + game_score + env_score)\n\n async def update(self, feedback: Dict[str, Any]) -> None:\n \"\"\"Update quantum uncertainty model based on feedback.\"\"\"\n try:\n # Update decoherence rate based on feedback\n self._update_decoherence_rate(feedback)\n\n # Update entanglement matrix\n self._update_entanglement_matrix(feedback)\n\n # Re-initialize quantum states with feedback influence\n self._reinitialize_quantum_states(feedback)\n\n logger.info(\"Updated quantum uncertainty model\")\n\n except Exception as e:\n logger.error(f\"Error updating quantum uncertainty model: {str(e)}\")\n raise\n\n def _update_decoherence_rate(self, feedback: Dict[str, Any]) -> None:\n \"\"\"Update decoherence rate based on feedback.\"\"\"\n accuracy = feedback.get(\"uncertainty_accuracy\", 0.5)\n adjustment = 0.1 * (accuracy - 0.5) # Adjust based on accuracy\n self.decoherence_rate = max(\n 0.01, min(0.5, self.decoherence_rate + adjustment))\n\n def _update_entanglement_matrix(self, feedback: Dict[str, Any]) -> None:\n \"\"\"Update entanglement matrix based on feedback.\"\"\"\n if \"correlation_feedback\" in feedback:\n correlation = np.array(feedback[\"correlation_feedback\"])\n # Update entanglement matrix while maintaining symmetry\n update = 0.1 * correlation\n self.entanglement_matrix += update\n self.entanglement_matrix = (\n self.entanglement_matrix + self.entanglement_matrix.T) / 2\n\n def _reinitialize_quantum_states(self, feedback: Dict[str, Any]) -> None:\n \"\"\"Reinitialize quantum states with feedback influence.\"\"\"\n feedback_factor = feedback.get(\"quantum_feedback\", 1.0)\n for state_type in self.quantum_states:\n current_state = self.quantum_states[state_type]\n new_state = self._create_quantum_state(current_state.shape[0])\n # Blend current and new states based on feedback\n self.quantum_states[state_type] = (\n current_state * (1 - feedback_factor) +\n new_state * feedback_factor\n )\n # Renormalize\n self.quantum_states[state_type] /= np.linalg.norm(\n self.quantum_states[state_type])\n" }, { "path": "core/ai_engine/utils.py", "content": "# Utility functions for AI engine processing\n\nfrom typing import Any, Dict, List, Optional\nimport json\n\n\ndef load_json(file_path: str) -> Dict[str, Any]:\n \"\"\"\n Load a JSON file and return its content as a dictionary.\n \n :param file_path: Path to the JSON file.\n :return: Dictionary containing the JSON data.\n :raises FileNotFoundError: If the file does not exist.\n :raises json.JSONDecodeError: If the file cannot be decoded.\n \"\"\"\n with open(file_path, 'r') as f:\n return json.load(f)\n\n\ndef save_json(data: Dict[str, Any], file_path: str) -> None:\n \"\"\"\n Save a dictionary as a JSON file.\n \n :param data: Dictionary to save.\n :param file_path: Destination path for the JSON file.\n \"\"\"\n with open(file_path, 'w') as f:\n json.dump(data, f, indent=4)\n\n\ndef extract_keys(data: List[Dict[str, Any]], keys: List[str]) -> List[Dict[str, Any]]:\n \"\"\"\n Extract specific keys from a list of dictionaries.\n \n :param data: List of dictionaries to extract keys from.\n :param keys: List of keys to extract.\n :return: List of dictionaries containing only the specified keys.\n \"\"\"\n return [{k: d[k] for k in keys if k in d} for d in data]\n\n\ndef validate_input(data: Any, expected_type: type) -> bool:\n \"\"\"\n Validate if the input data is of the expected type.\n \n :param data: The data to validate.\n :param expected_type: The expected type of the data.\n :return: True if data is of expected type, False otherwise.\n \"\"\"\n return isinstance(data, expected_type)\n" }, { "path": "core/ai_engine/xai.py", "content": "\"\"\"Explainable AI (XAI) component for HAGAME.\"\"\"\n\nfrom typing import Any, Dict, List, Optional\nimport logging\nimport numpy as np\nfrom pydantic import BaseModel\nfrom .base import AIComponent\n\nlogger = logging.getLogger(__name__)\n\n\nclass Explanation(BaseModel):\n \"\"\"Model for AI explanation data.\"\"\"\n game_id: str\n timestamp: float\n decision_explanations: Dict[str, str]\n feature_importance: Dict[str, float]\n counterfactuals: List[Dict[str, Any]]\n confidence_levels: Dict[str, float]\n\n\nclass ExplainableAI(AIComponent):\n \"\"\"Component for generating explanations of AI decisions.\"\"\"\n\n def __init__(self):\n self.explanation_history: List[Explanation] = []\n self.feature_weights: Dict[str, np.ndarray] = {\n \"decision\": np.random.randn(5),\n \"outcome\": np.random.randn(4),\n \"strategy\": np.random.randn(6)\n }\n self.explanation_templates: Dict[str,\n str] = self._initialize_templates()\n\n def _initialize_templates(self) -> Dict[str, str]:\n \"\"\"Initialize explanation templates.\"\"\"\n return {\n \"decision\": (\n \"The AI made this decision because {main_factor}, \"\n \"considering {secondary_factor}. \"\n \"This was influenced by {context_factor}.\"\n ),\n \"outcome\": (\n \"The predicted outcome is based on {main_factor}, \"\n \"with {secondary_factor} playing a significant role. \"\n \"Historical data suggests {historical_factor}.\"\n ),\n \"strategy\": (\n \"The recommended strategy focuses on {main_factor}, \"\n \"while accounting for {secondary_factor}. \"\n \"This approach was chosen because {reasoning_factor}.\"\n ),\n \"counterfactual\": (\n \"If {changed_factor} had been {alternative_value}, \"\n \"the outcome would likely have been {alternative_outcome}.\"\n )\n }\n\n async def initialize(self) -> None:\n \"\"\"Initialize XAI system.\"\"\"\n logger.info(\"Initializing Explainable AI component\")\n self._initialize_feature_analyzers()\n\n def _initialize_feature_analyzers(self) -> None:\n \"\"\"Initialize feature analysis components.\"\"\"\n self.analyzers = {\n \"decision\": self._create_decision_analyzer(),\n \"outcome\": self._create_outcome_analyzer(),\n \"strategy\": self._create_strategy_analyzer()\n }\n\n def _create_decision_analyzer(self) -> Dict[str, Any]:\n \"\"\"Create decision analysis component.\"\"\"\n return {\n \"features\": [\n \"player_state\",\n \"game_context\",\n \"historical_actions\",\n \"predicted_outcomes\",\n \"uncertainty_factors\"\n ],\n \"weights\": self.feature_weights[\"decision\"]\n }\n\n def _create_outcome_analyzer(self) -> Dict[str, Any]:\n \"\"\"Create outcome analysis component.\"\"\"\n return {\n \"features\": [\n \"current_state\",\n \"player_performance\",\n \"game_dynamics\",\n \"external_factors\"\n ],\n \"weights\": self.feature_weights[\"outcome\"]\n }\n\n def _create_strategy_analyzer(self) -> Dict[str, Any]:\n \"\"\"Create strategy analysis component.\"\"\"\n return {\n \"features\": [\n \"player_profile\",\n \"game_objectives\",\n \"resource_state\",\n \"opponent_analysis\",\n \"risk_factors\",\n \"temporal_context\"\n ],\n \"weights\": self.feature_weights[\"strategy\"]\n }\n\n async def process(self, input_data: Dict[str, Any]) -> Dict[str, Any]:\n \"\"\"Generate explanations for AI decisions and predictions.\"\"\"\n try:\n game_id = input_data.get(\"game_id\")\n game_state = input_data.get(\"game_state\", {})\n predictions = input_data.get(\"predictions\", {})\n cognitive_state = input_data.get(\"cognitive_state\", {})\n\n # Generate decision explanations\n decision_explanations = self._explain_decisions(\n game_state,\n predictions,\n cognitive_state\n )\n\n # Calculate feature importance\n feature_importance = self._calculate_feature_importance(\n game_state,\n predictions\n )\n\n # Generate counterfactuals\n counterfactuals = self._generate_counterfactuals(\n game_state,\n predictions\n )\n\n # Calculate confidence levels\n confidence_levels = self._calculate_confidence_levels(\n game_state,\n predictions,\n feature_importance\n )\n\n # Create explanation model\n import time\n explanation = Explanation(\n game_id=game_id,\n timestamp=time.time(),\n decision_explanations=decision_explanations,\n feature_importance=feature_importance,\n counterfactuals=counterfactuals,\n confidence_levels=confidence_levels\n )\n\n self.explanation_history.append(explanation)\n\n return explanation.dict()\n\n except Exception as e:\n logger.error(f\"Error generating explanations: {str(e)}\")\n raise\n\n def _explain_decisions(\n self,\n game_state: Dict[str, Any],\n predictions: Dict[str, Any],\n cognitive_state: Dict[str, Any]\n ) -> Dict[str, str]:\n \"\"\"Generate natural language explanations for decisions.\"\"\"\n explanations = {}\n\n # Explain decision making\n decision_factors = self._analyze_decision_factors(\n game_state, predictions)\n explanations[\"decision\"] = self._format_decision_explanation(\n decision_factors)\n\n # Explain outcome predictions\n outcome_factors = self._analyze_outcome_factors(\n game_state, predictions)\n explanations[\"outcome\"] = self._format_outcome_explanation(\n outcome_factors)\n\n # Explain strategy recommendations\n strategy_factors = self._analyze_strategy_factors(\n game_state, cognitive_state)\n explanations[\"strategy\"] = self._format_strategy_explanation(\n strategy_factors)\n\n return explanations\n\n def _analyze_decision_factors(\n self,\n game_state: Dict[str, Any],\n predictions: Dict[str, Any]\n ) -> Dict[str, Any]:\n \"\"\"Analyze factors influencing decisions.\"\"\"\n analyzer = self.analyzers[\"decision\"]\n features = self._extract_decision_features(game_state, predictions)\n importance = features * analyzer[\"weights\"]\n\n return {\n \"main_factor\": self._get_most_important_factor(\n importance,\n analyzer[\"features\"]\n ),\n \"secondary_factor\": self._get_secondary_factor(\n importance,\n analyzer[\"features\"]\n ),\n \"context_factor\": self._get_context_factor(game_state)\n }\n\n def _analyze_outcome_factors(\n self,\n game_state: Dict[str, Any],\n predictions: Dict[str, Any]\n ) -> Dict[str, Any]:\n \"\"\"Analyze factors influencing outcome predictions.\"\"\"\n analyzer = self.analyzers[\"outcome\"]\n features = self._extract_outcome_features(game_state, predictions)\n importance = features * analyzer[\"weights\"]\n\n return {\n \"main_factor\": self._get_most_important_factor(\n importance,\n analyzer[\"features\"]\n ),\n \"secondary_factor\": self._get_secondary_factor(\n importance,\n analyzer[\"features\"]\n ),\n \"historical_factor\": self._get_historical_factor(game_state)\n }\n\n def _analyze_strategy_factors(\n self,\n game_state: Dict[str, Any],\n cognitive_state: Dict[str, Any]\n ) -> Dict[str, Any]:\n \"\"\"Analyze factors influencing strategy recommendations.\"\"\"\n analyzer = self.analyzers[\"strategy\"]\n features = self._extract_strategy_features(game_state, cognitive_state)\n importance = features * analyzer[\"weights\"]\n\n return {\n \"main_factor\": self._get_most_important_factor(\n importance,\n analyzer[\"features\"]\n ),\n \"secondary_factor\": self._get_secondary_factor(\n importance,\n analyzer[\"features\"]\n ),\n \"reasoning_factor\": self._get_reasoning_factor(cognitive_state)\n }\n\n def _calculate_feature_importance(\n self,\n game_state: Dict[str, Any],\n predictions: Dict[str, Any]\n ) -> Dict[str, float]:\n \"\"\"Calculate importance scores for different features.\"\"\"\n importance_scores = {}\n\n # Calculate decision feature importance\n decision_features = self._extract_decision_features(\n game_state, predictions)\n importance_scores.update(self._calculate_feature_scores(\n decision_features,\n self.analyzers[\"decision\"][\"features\"],\n self.feature_weights[\"decision\"]\n ))\n\n # Calculate outcome feature importance\n outcome_features = self._extract_outcome_features(\n game_state, predictions)\n importance_scores.update(self._calculate_feature_scores(\n outcome_features,\n self.analyzers[\"outcome\"][\"features\"],\n self.feature_weights[\"outcome\"]\n ))\n\n # Calculate strategy feature importance\n strategy_features = self._extract_strategy_features(game_state, {})\n importance_scores.update(self._calculate_feature_scores(\n strategy_features,\n self.analyzers[\"strategy\"][\"features\"],\n self.feature_weights[\"strategy\"]\n ))\n\n return importance_scores\n\n def _generate_counterfactuals(\n self,\n game_state: Dict[str, Any],\n predictions: Dict[str, Any]\n ) -> List[Dict[str, Any]]:\n \"\"\"Generate counterfactual explanations.\"\"\"\n counterfactuals = []\n\n # Generate decision counterfactuals\n decision_cf = self._generate_decision_counterfactuals(\n game_state, predictions)\n counterfactuals.extend(decision_cf)\n\n # Generate outcome counterfactuals\n outcome_cf = self._generate_outcome_counterfactuals(\n game_state, predictions)\n counterfactuals.extend(outcome_cf)\n\n # Generate strategy counterfactuals\n strategy_cf = self._generate_strategy_counterfactuals(\n game_state, predictions)\n counterfactuals.extend(strategy_cf)\n\n return counterfactuals\n\n def _calculate_confidence_levels(\n self,\n game_state: Dict[str, Any],\n predictions: Dict[str, Any],\n feature_importance: Dict[str, float]\n ) -> Dict[str, float]:\n \"\"\"Calculate confidence levels for explanations.\"\"\"\n confidence_levels = {}\n\n # Calculate decision explanation confidence\n confidence_levels[\"decision_confidence\"] = self._calculate_decision_confidence(\n game_state,\n predictions,\n feature_importance\n )\n\n # Calculate outcome explanation confidence\n confidence_levels[\"outcome_confidence\"] = self._calculate_outcome_confidence(\n game_state,\n predictions,\n feature_importance\n )\n\n # Calculate strategy explanation confidence\n confidence_levels[\"strategy_confidence\"] = self._calculate_strategy_confidence(\n game_state,\n predictions,\n feature_importance\n )\n\n # Calculate overall explanation confidence\n confidence_levels[\"overall_confidence\"] = np.mean(\n list(confidence_levels.values()))\n\n return confidence_levels\n\n def _extract_decision_features(\n self,\n game_state: Dict[str, Any],\n predictions: Dict[str, Any]\n ) -> np.ndarray:\n \"\"\"Extract features for decision explanation.\"\"\"\n return np.array([\n float(game_state.get(\"player_state_value\", 0.0)),\n float(game_state.get(\"game_context_value\", 0.0)),\n float(game_state.get(\"historical_actions_value\", 0.0)),\n float(predictions.get(\"predicted_outcome_value\", 0.0)),\n float(predictions.get(\"uncertainty_value\", 0.0))\n ])\n\n def _extract_outcome_features(\n self,\n game_state: Dict[str, Any],\n predictions: Dict[str, Any]\n ) -> np.ndarray:\n \"\"\"Extract features for outcome explanation.\"\"\"\n return np.array([\n float(game_state.get(\"current_state_value\", 0.0)),\n float(game_state.get(\"player_performance_value\", 0.0)),\n float(game_state.get(\"game_dynamics_value\", 0.0)),\n float(game_state.get(\"external_factors_value\", 0.0))\n ])\n\n def _extract_strategy_features(\n self,\n game_state: Dict[str, Any],\n cognitive_state: Dict[str, Any]\n ) -> np.ndarray:\n \"\"\"Extract features for strategy explanation.\"\"\"\n return np.array([\n float(game_state.get(\"player_profile_value\", 0.0)),\n float(game_state.get(\"game_objectives_value\", 0.0)),\n float(game_state.get(\"resource_state_value\", 0.0)),\n float(game_state.get(\"opponent_analysis_value\", 0.0)),\n float(game_state.get(\"risk_factors_value\", 0.0)),\n float(game_state.get(\"temporal_context_value\", 0.0))\n ])\n\n async def update(self, feedback: Dict[str, Any]) -> None:\n \"\"\"Update XAI model based on feedback.\"\"\"\n try:\n # Update feature weights\n self._update_feature_weights(feedback)\n\n # Update explanation templates if provided\n self._update_templates(feedback)\n\n # Re-initialize analyzers with updated weights\n self._initialize_feature_analyzers()\n\n logger.info(\"Updated XAI model\")\n\n except Exception as e:\n logger.error(f\"Error updating XAI model: {str(e)}\")\n raise\n\n def _update_feature_weights(self, feedback: Dict[str, Any]) -> None:\n \"\"\"Update feature weights based on feedback.\"\"\"\n learning_rate = 0.01\n\n for feature_type, weights in self.feature_weights.items():\n if f\"{feature_type}_accuracy\" in feedback:\n accuracy = feedback[f\"{feature_type}_accuracy\"]\n gradient = np.array(feedback.get(\n f\"{feature_type}_gradient\", [0] * len(weights)))\n self.feature_weights[feature_type] += learning_rate * \\\n accuracy * gradient\n\n def _update_templates(self, feedback: Dict[str, Any]) -> None:\n \"\"\"Update explanation templates based on feedback.\"\"\"\n if \"template_updates\" in feedback:\n updates = feedback[\"template_updates\"]\n for template_type, new_template in updates.items():\n if template_type in self.explanation_templates:\n self.explanation_templates[template_type] = new_template\n" }, { "path": "core/auth.py", "content": "import os\nfrom datetime import datetime, timedelta\nfrom typing import Any\nfrom jose import jwt, JWTError\nfrom passlib.context import CryptContext\nfrom pydantic import BaseSettings\nfrom fastapi import Depends, HTTPException, status\nfrom fastapi.security import OAuth2PasswordBearer\nfrom sqlalchemy.ext.asyncio import AsyncSession\nfrom core.database import get_async_session\nfrom crud.user import get_user_by_id\nimport uuid\n\n\nclass AuthSettings(BaseSettings):\n SECRET_KEY: str\n ALGORITHM: str = \"HS256\"\n ACCESS_TOKEN_EXPIRE_MINUTES: int = 60\n\n class Config:\n env_file = \".env\"\n\n\nauth_settings = AuthSettings()\n\npwd_context = CryptContext(schemes=[\"bcrypt\"], deprecated=\"auto\")\n\noauth2_scheme = OAuth2PasswordBearer(tokenUrl=\"/auth/login\")\n\n\ndef verify_password(plain_password: str, hashed_password: str) -> bool:\n \"\"\"Verify a plain password against a hash.\"\"\"\n return pwd_context.verify(plain_password, hashed_password)\n\n\ndef get_password_hash(password: str) -> str:\n \"\"\"Hash a password for storage.\"\"\"\n return pwd_context.hash(password)\n\n\ndef create_access_token(data: dict[str, Any], expires_delta: timedelta | None = None) -> str:\n \"\"\"Create a JWT access token.\"\"\"\n to_encode = data.copy()\n expire = datetime.utcnow() + \\\n (expires_delta or timedelta(minutes=auth_settings.ACCESS_TOKEN_EXPIRE_MINUTES))\n to_encode.update({\"exp\": expire})\n encoded_jwt = jwt.encode(\n to_encode, auth_settings.SECRET_KEY, algorithm=auth_settings.ALGORITHM)\n return encoded_jwt\n\n\ndef decode_access_token(token: str) -> dict[str, Any]:\n \"\"\"Decode a JWT access token.\"\"\"\n try:\n payload = jwt.decode(token, auth_settings.SECRET_KEY,\n algorithms=[auth_settings.ALGORITHM])\n return payload\n except JWTError:\n raise ValueError(\"Invalid token\")\n\n\nasync def get_current_user(\n token: str = Depends(oauth2_scheme),\n session: AsyncSession = Depends(get_async_session),\n):\n \"\"\"FastAPI dependency to get the current user from JWT token.\"\"\"\n credentials_exception = HTTPException(\n status_code=status.HTTP_401_UNAUTHORIZED,\n detail=\"Could not validate credentials\",\n headers={\"WWW-Authenticate\": \"Bearer\"},\n )\n try:\n payload = decode_access_token(token)\n user_id: str = payload.get(\"sub\")\n if user_id is None:\n raise credentials_exception\n user_uuid = uuid.UUID(user_id)\n except Exception:\n raise credentials_exception\n user = await get_user_by_id(session, user_uuid)\n if user is None:\n raise credentials_exception\n return user\n" }, { "path": "core/auth_utils.py", "content": "import hashlib\nfrom datetime import datetime, timedelta\nfrom typing import Dict, Any, Optional\n\nclass AuthUtils:\n \"\"\"\n Utility functions for authentication processes.\n \"\"\"\n\n @staticmethod\n def hash_password(password: str) -> str:\n \"\"\"\n Hash a password using SHA-256.\n \n :param password: The plaintext password to be hashed.\n :return: The hashed password as a hexadecimal string.\n \"\"\"\n return hashlib.sha256(password.encode()).hexdigest()\n\n @staticmethod\n def generate_jwt_token(user_id: str, secret: str, expiration_minutes: int = 60) -> str:\n \"\"\"\n Generate a JSON Web Token (JWT) for a user.\n \n :param user_id: The ID of the user.\n :param secret: The secret key used to encode the token.\n :param expiration_minutes: The expiration time of the token in minutes.\n :return: The encoded JWT as a string.\n \"\"\"\n expiration = datetime.utcnow() + timedelta(minutes=expiration_minutes)\n # Normally you would use a library like PyJWT to create the token.\n # Here we would just return a dummy string for demonstration purposes.\n return f\"token-{user_id}-{expiration.timestamp()}\"\n\n @staticmethod\n def validate_jwt_token(token: str, secret: str) -> Optional[Dict[str, Any]]:\n \"\"\"\n Validate the JWT token and return the payload.\n \n :param token: The JWT token to validate.\n :param secret: The secret key used to decode the token.\n :return: The payload if valid, otherwise None.\n \"\"\"\n # Normally you would use a library like PyJWT to decode and validate the token.\n # Here we would just return a dummy payload for demonstration purposes.\n if \"token-\" in token:\n parts = token.split(\"-\")\n return {\"user_id\": parts[1], \"exp\": float(parts[2])}\n return None\n" }, { "path": "core/celery_app.py", "content": "# Celery configuration for HAGAME Backend\n\nimport os\nfrom celery import Celery\n\n# Read Celery configuration from environment variables\nCELERY_BROKER_URL = os.getenv(\"CELERY_BROKER_URL\", \"redis://localhost:6379/0\")\nCELERY_RESULT_BACKEND = os.getenv(\n \"CELERY_RESULT_BACKEND\", \"redis://localhost:6379/0\")\n\ncelery_app = Celery(\n \"hagame_tasks\",\n broker=CELERY_BROKER_URL,\n backend=CELERY_RESULT_BACKEND,\n include=[\"core.tasks\"], # Include task modules here\n)\n\n# Optional: Celery configuration dictionary\n# celery_app.conf.update(\n# task_ignore_result=False,\n# task_track_started=True,\n# )\n" }, { "path": "core/database.py", "content": "import os\nfrom sqlalchemy.ext.asyncio import AsyncSession, create_async_engine, async_sessionmaker\nfrom sqlalchemy.orm import sessionmaker\nfrom pydantic import BaseSettings\nfrom typing import AsyncGenerator\n\n\nclass Settings(BaseSettings):\n \"\"\"Settings for database configuration.\"\"\"\n DATABASE_URL: str\n\n class Config:\n env_file = \".env\"\n\n\nsettings = Settings()\n\nengine = create_async_engine(settings.DATABASE_URL, echo=True, future=True)\nAsyncSessionLocal = async_sessionmaker(\n engine, expire_on_commit=False, class_=AsyncSession)\n\n\nasync def get_async_session() -> AsyncGenerator[AsyncSession, None]:\n \"\"\"FastAPI dependency that provides an async database session.\"\"\"\n async with AsyncSessionLocal() as session:\n yield session\n" }, { "path": "core/llm_processing.py", "content": "import logging\nfrom typing import Any, Dict\n\n# Set up logging\nlogging.basicConfig(level=logging.INFO)\nlogger = logging.getLogger(__name__)\n\nclass LLMProcessor:\n \"\"\"\n A class for processing interactions with the LLM (Large Language Model).\n \"\"\"\n\n def __init__(self, model: str) -> None:\n \"\"\"\n Initialize the LLMProcessor with a specified model.\n \n Args:\n model (str): The name of the LLM model to be used.\n \"\"\"\n self.model = model\n\n def process_input(self, user_input: str) -> Dict[str, Any]:\n \"\"\"\n Process the user input and interact with the LLM.\n \n Args:\n user_input (str): The input text from the user.\n \n Returns:\n Dict[str, Any]: A dictionary containing the LLM's response and any metadata.\n \"\"\"\n logger.info(\"Processing input: %s\", user_input)\n # Placeholder for LLM interaction logic\n response = self._interact_with_llm(user_input)\n return response\n\n def _interact_with_llm(self, user_input: str) -> Dict[str, Any]:\n \"\"\"\n Simulate interaction with the LLM. In a real implementation, this would\n involve calling the LLM API and handling the response.\n \n Args:\n user_input (str): The input text from the user.\n \n Returns:\n Dict[str, Any]: Simulated LLM response.\n \"\"\"\n # Simulate processing logic\n simulated_response = f\"Response to: {user_input}\"\n logger.info(\"Simulated LLM response: %s\", simulated_response)\n return {\n 'response': simulated_response,\n 'model': self.model\n }\n\n# Example usage:\n# if __name__ == '__main__':\n# processor = LLMProcessor(model='GPT-4')\n# result = processor.process_input('Hello, how are you?')\n# print(result)\n" }, { "path": "core/llm_utilities.py", "content": "\"\"\"\nUtility functions for LLM processing.\n\nThis module provides various utility functions that assist in the\nprocessing of LLM requests and responses within the application.\n\"\"\"\n\nfrom typing import Any, Dict, List\n\n\ndef preprocess_input(text: str) -> str:\n \"\"\"\n Preprocess the input text for the LLM.\n\n Args:\n text (str): The input text to preprocess.\n\n Returns:\n str: The preprocessed text.\n \"\"\"\n # Example preprocessing steps\n return text.strip().lower()\n\n\ndef postprocess_output(output: Any) -> str:\n \"\"\"\n Postprocess the output from the LLM.\n\n Args:\n output (Any): The raw output from the LLM.\n\n Returns:\n str: A formatted string representation of the output.\n \"\"\"\n # Example of formatting output\n return str(output)\n\n\ndef extract_entities(data: Dict[str, Any]) -> List[str]:\n \"\"\"\n Extract entities from the LLM response data.\n\n Args:\n data (Dict[str, Any]): The response data from the LLM.\n\n Returns:\n List[str]: A list of extracted entities.\n \"\"\"\n # Placeholder logic for entity extraction\n entities = []\n if 'entities' in data:\n entities = data['entities']\n return entities\n\n\n# Additional utility functions can be added as needed.\n" }, { "path": "core/logging.py", "content": "import logging\n\nLOG_FORMAT = \"%(asctime)s [%(levelname)s] %(name)s: %(message)s\"\nlogging.basicConfig(level=logging.INFO, format=LOG_FORMAT)\n\n\ndef get_logger(name: str) -> logging.Logger:\n \"\"\"Get a logger instance for a given module name.\"\"\"\n return logging.getLogger(name)\n" }, { "path": "core/tasks.py", "content": "import logging\nfrom celery import shared_task\n\n# Configure logging\nlogging.basicConfig(level=logging.INFO)\nlogger = logging.getLogger(__name__)\n\n@shared_task\ndef process_llm_response(response_data):\n \"\"\"\n Process the response data from the LLM.\n This function handles the asynchronous processing of LLM responses,\n including logging and further actions based on the response.\n\n Args:\n response_data (dict): The response data from the LLM containing the results.\n \"\"\"\n try:\n logger.info(\"Starting LLM response processing\")\n # Simulate processing the response data\n # TODO: Implement actual processing logic\n processed_data = response_data # Replace with actual processing code\n logger.info(\"Successfully processed LLM response\")\n return processed_data\n except Exception as e:\n logger.error(f\"Error processing LLM response: {str(e)}\")\n raise\n\n@shared_task\ndef generate_llm_prompt(game_context):\n \"\"\"\n Generate a prompt for the LLM based on the game context.\n This function prepares the input for the LLM based on the current game state.\n\n Args:\n game_context (dict): The current context of the game to generate a prompt.\n \"\"\"\n try:\n logger.info(\"Generating LLM prompt\")\n # TODO: Implement prompt generation logic\n prompt = f\"Generate response based on context: {game_context}\"\n logger.info(\"LLM prompt generated successfully\")\n return prompt\n except Exception as e:\n logger.error(f\"Error generating LLM prompt: {str(e)}\")\n raise\n" }, { "path": "crud/__init__.py", "content": " " }, { "path": "crud/ai_model.py", "content": "import uuid\nfrom sqlalchemy.ext.asyncio import AsyncSession\nfrom sqlalchemy.future import select\nfrom models.ai_model import AIModel\nfrom schemas.ai_model import AIModelCreate\n\n\nasync def get_by_id(session: AsyncSession, id: uuid.UUID) -> AIModel | None:\n \"\"\"Get an AI model by id.\"\"\"\n result = await session.execute(select(AIModel).where(AIModel.id == id))\n return result.scalars().first()\n\n\nasync def create(session: AsyncSession, data: AIModelCreate) -> AIModel:\n \"\"\"Create a new AI model.\"\"\"\n model = AIModel(\n name=data.name,\n type=data.type,\n version=data.version,\n config_params=data.config_params,\n file_path=data.file_path\n )\n session.add(model)\n await session.commit()\n await session.refresh(model)\n return model\n\n\nasync def list_all(session: AsyncSession) -> list[AIModel]:\n \"\"\"List all AI models.\"\"\"\n result = await session.execute(select(AIModel))\n return result.scalars().all()\n" }, { "path": "crud/cognitive_profile.py", "content": "import uuid\nfrom sqlalchemy.ext.asyncio import AsyncSession\nfrom sqlalchemy.future import select\nfrom models.cognitive_profile import CognitiveProfile\nfrom schemas.cognitive_profile import CognitiveProfileUpdate\n\n\nasync def get_by_user_id(session: AsyncSession, user_id: uuid.UUID) -> CognitiveProfile | None:\n \"\"\"Get cognitive profile by user_id.\"\"\"\n result = await session.execute(select(CognitiveProfile).where(CognitiveProfile.user_id == user_id))\n return result.scalars().first()\n\n\nasync def create_profile(session: AsyncSession, user_id: uuid.UUID, profile_data: dict) -> CognitiveProfile:\n \"\"\"Create a new cognitive profile for a user.\"\"\"\n profile = CognitiveProfile(user_id=user_id, profile_data=profile_data)\n session.add(profile)\n await session.commit()\n await session.refresh(profile)\n return profile\n\n\nasync def update_profile(session: AsyncSession, profile: CognitiveProfile, update_in: CognitiveProfileUpdate) -> CognitiveProfile:\n \"\"\"Update cognitive profile data.\"\"\"\n profile.profile_data = update_in.profile_data\n await session.commit()\n await session.refresh(profile)\n return profile\n" }, { "path": "crud/game_definition.py", "content": "import uuid\nfrom sqlalchemy.ext.asyncio import AsyncSession\nfrom sqlalchemy.future import select\nfrom models.game_definition import GameDefinition\nfrom schemas.game_definition import GameDefinitionCreate\n\n\nasync def get_by_id(session: AsyncSession, id: uuid.UUID) -> GameDefinition | None:\n \"\"\"Get a game definition by id.\"\"\"\n result = await session.execute(select(GameDefinition).where(GameDefinition.id == id))\n return result.scalars().first()\n\n\nasync def get_by_name(session: AsyncSession, name: str) -> GameDefinition | None:\n \"\"\"Get a game definition by name.\"\"\"\n result = await session.execute(select(GameDefinition).where(GameDefinition.name == name))\n return result.scalars().first()\n\n\nasync def create(session: AsyncSession, data: GameDefinitionCreate) -> GameDefinition:\n \"\"\"Create a new game definition.\"\"\"\n game_def = GameDefinition(\n name=data.name,\n description=data.description,\n rules_config=data.rules_config,\n version=data.version\n )\n session.add(game_def)\n await session.commit()\n await session.refresh(game_def)\n return game_def\n\n\nasync def list_all(session: AsyncSession) -> list[GameDefinition]:\n \"\"\"List all game definitions.\"\"\"\n result = await session.execute(select(GameDefinition))\n return result.scalars().all()\n" }, { "path": "crud/game_instance.py", "content": "import uuid\nfrom sqlalchemy.ext.asyncio import AsyncSession\nfrom sqlalchemy.future import select\nfrom models.game_instance import GameInstance\nfrom schemas.game_instance import GameInstanceCreate\n\n\nasync def get_by_id(session: AsyncSession, id: uuid.UUID) -> GameInstance | None:\n \"\"\"Get a game instance by id.\"\"\"\n result = await session.execute(select(GameInstance).where(GameInstance.id == id))\n return result.scalars().first()\n\n\nasync def create(session: AsyncSession, data: GameInstanceCreate) -> GameInstance:\n \"\"\"Create a new game instance.\"\"\"\n instance = GameInstance(\n game_definition_id=data.game_definition_id,\n user_id=data.user_id,\n game_state=data.game_state,\n ai_model_id=data.ai_model_id\n )\n session.add(instance)\n await session.commit()\n await session.refresh(instance)\n return instance\n\n\nasync def list_by_user(session: AsyncSession, user_id: uuid.UUID) -> list[GameInstance]:\n \"\"\"List all game instances for a user.\"\"\"\n result = await session.execute(select(GameInstance).where(GameInstance.user_id == user_id))\n return result.scalars().all()\n" }, { "path": "crud/user.py", "content": "import uuid\nfrom sqlalchemy.ext.asyncio import AsyncSession\nfrom sqlalchemy.future import select\nfrom sqlalchemy.exc import NoResultFound\nfrom models.user import User\nfrom schemas.user import UserCreate, UserUpdate\nfrom passlib.context import CryptContext\nfrom core.auth import get_password_hash\n\npwd_context = CryptContext(schemes=[\"bcrypt\"], deprecated=\"auto\")\n\n\nasync def get_user_by_email(session: AsyncSession, email: str) -> User | None:\n \"\"\"Get a user by email.\"\"\"\n result = await session.execute(select(User).where(User.email == email))\n return result.scalars().first()\n\n\nasync def get_user_by_id(session: AsyncSession, user_id: uuid.UUID) -> User | None:\n \"\"\"Get a user by id.\"\"\"\n result = await session.execute(select(User).where(User.id == user_id))\n return result.scalars().first()\n\n\nasync def create_user(session: AsyncSession, user_in: UserCreate) -> User:\n \"\"\"Create a new user with hashed password.\"\"\"\n hashed_password = get_password_hash(user_in.password)\n user = User(\n username=user_in.username,\n email=user_in.email,\n hashed_password=hashed_password\n )\n session.add(user)\n await session.commit()\n await session.refresh(user)\n return user\n\n\nasync def update_user(session: AsyncSession, user: User, user_in: UserUpdate) -> User:\n \"\"\"Update user fields.\"\"\"\n if user_in.username is not None:\n user.username = user_in.username\n if user_in.email is not None:\n user.email = user_in.email\n if user_in.password is not None:\n user.hashed_password = pwd_context.hash(user_in.password)\n await session.commit()\n await session.refresh(user)\n return user\n" }, { "path": "docs/ai_engine.md", "content": "# docs/ai_engine.md\n# AI Engine Module Documentation\n\n## Overview\nThe AI Engine module provides functionality for managing AI models, including:\n- Model creation and configuration\n- Adaptive predictions based on cognitive profiles\n- Explainable AI (XAI) features using SHAP values\n- Model metadata management\n\n## Components\n\n### AIModel\nThe core model class that represents an AI model in the system.\n\n#### Fields:\n- `id`: Unique identifier\n- `name`: Model name\n- `description`: Optional model description\n- `config`: JSON configuration for model parameters\n- `metadata`: Optional JSON metadata\n- `file_path`: Path to the saved model file\n- `created_at`: Creation timestamp\n- `updated_at`: Last update timestamp\n\n### API Endpoints\n\n#### Create Model\n```http\nPOST /ai_models/\n```\nCreates a new AI model with the specified configuration.\n\n#### Get Model\n```http\nGET /ai_models/{model_id}\n```\nRetrieves model details by ID.\n\n#### Update Model\n```http\nPUT /ai_models/{model_id}\n```\nUpdates model configuration and metadata.\n\n#### Predict\n```http\nPOST /ai_models/{model_id}/predict\n```\nGenerates predictions using the model, with optional cognitive profile adaptation.\n\n#### Explain\n```http\nPOST /ai_models/{model_id}/explain\n```\nProvides model explanations using SHAP values.\n\n## Usage Examples\n\n### Creating a New Model\n```python\nmodel_data = {\n \"name\": \"sentiment_classifier\",\n \"description\": \"Sentiment analysis model\",\n \"config\": {\n \"model_type\": \"transformer\",\n \"parameters\": {\n \"max_length\": 512\n }\n }\n}\nresponse = client.post(\"/ai_models/\", json=model_data)\n```\n\n### Making Predictions\n```python\ninput_data = {\n \"text\": \"This is a sample input\"\n}\nresponse = client.post(\"/ai_models/1/predict\", json=input_data)\n```\n\n### Getting Model Explanations\n```python\nresponse = client.post(\"/ai_models/1/explain\", json=input_data)\n```\n\n## Dependencies\n- SHAP: For model explanations\n- joblib: For model serialization\n- numpy: For numerical computations\n\n## Testing\nRun tests using pytest:\n```bash\npytest tests/test_ai_engine/\n```" }, { "path": "docs/ai_engine_integration_guide.md", "content": "# AI Engine Integration Guide\n\nThis document provides a comprehensive guide for integrating AI engine services into your applications using the hagamesai backend. \n\n## Overview\nThe AI engine services are designed to provide advanced functionalities for human-vs-AI gameplay, leveraging large language models (LLMs) and cognitive modeling. This guide will help you understand how to utilize these services effectively.\n\n## Prerequisites\nBefore you begin integration, ensure that you have the following:\n- Access to the hagamesai backend API.\n- An understanding of FastAPI endpoints.\n- Required libraries and dependencies installed, including `httpx` for API requests.\n\n## Integration Steps\n\n### 1. Setting Up Your Environment\nEnsure your development environment is configured. You can use a virtual environment to maintain project dependencies.\n\n```bash\n# Create a virtual environment\npython -m venv venv\n# Activate the virtual environment\nsource venv/bin/activate # On Windows use `venv\\Scripts\\activate`\n# Install required packages\npip install httpx\n```\n\n### 2. Making API Requests to the AI Engine\nUse the following example to make requests to the AI engine service endpoints:\n\n```python\nimport httpx\n\nasync def call_ai_engine(prompt: str):\n url = \"http://localhost:8000/api/llm\"\n payload = {'prompt': prompt}\n async with httpx.AsyncClient() as client:\n response = await client.post(url, json=payload)\n return response.json()\n```\n\n### 3. Handling Responses\nThe AI engine will return a JSON response. You should handle this response appropriately:\n\n```python\nresponse_data = await call_ai_engine(\"Hello AI, how can you assist me today?\")\nif response_data['success']:\n print(\"AI Response:\", response_data['data'])\nelse:\n print(\"Error:\", response_data['error'])\n```\n\n### 4. Error Handling\nImplement error handling to manage potential issues during the API call:\n\n```python\nasync def call_ai_engine(prompt: str):\n url = \"http://localhost:8000/api/llm\"\n payload = {'prompt': prompt}\n try:\n async with httpx.AsyncClient() as client:\n response = await client.post(url, json=payload)\n response.raise_for_status() # Raises an error for bad responses\n return response.json()\n except httpx.HTTPStatusError as e:\n print(f\"HTTP Error: {e.response.status_code} - {e.response.text}\")\n return {'success': False, 'error': str(e)}\n except Exception as e:\n print(\"An error occurred:\", str(e))\n return {'success': False, 'error': str(e)}\n```\n\n## Conclusion\nThis guide provides a starting point for integrating AI engine services with your application. Ensure you adapt the integration to your specific use case and error handling needs. For further details, refer to the API documentation.\n\n## Additional Resources\n- [FastAPI Documentation](https://fastapi.tiangolo.com/)\n- [HTTPX Documentation](https://www.python-httpx.org/)\n\n---\nThis guide is part of the hagamesai project documentation, which aims to support developers in building innovative AI-powered applications." }, { "path": "docs/ai_engine_processing.md", "content": "# AI Engine Processing Documentation\n\nThis documentation outlines the processing logic utilized by the AI engine in the hagamesai project. The AI engine is designed to facilitate human-vs-AI gameplay by leveraging advanced cognitive modeling and large language models (LLMs). This document serves as a guide for developers to understand the core functionality and implementation details of the AI processing modules.\n\n## Overview\n\nThe AI engine processing logic is responsible for:\n- Handling incoming game state data from users.\n- Performing cognitive functions to simulate AI behavior.\n- Generating responses based on the current game context using LLMs.\n\n## Components\n\n### 1. Data Processing\n\nThe AI engine receives data from the game instance, which includes player actions, game state, and other contextual information. This data undergoes the following processing steps:\n- **Input Validation**: Ensures that the incoming data is in the correct format and contains all required fields.\n- **Normalization**: Converts the data into a standardized format suitable for processing by the AI models.\n\n### 2. Cognitive Modeling\n\nThe cognitive modeling component simulates the decision-making process of the AI. It includes:\n- **Predictive Analysis**: Estimates the most likely player actions based on historical data.\n- **Strategy Development**: Generates strategies for the AI to adopt during gameplay.\n\n### 3. Response Generation\n\nOnce the cognitive model has processed the input, the AI generates a response using the following:\n- **LLM Integration**: Utilizes large language models to create dynamic and contextually relevant responses based on the current game state.\n- **Output Formatting**: Prepares the generated response to be sent back to the game interface.\n\n## Usage\n\nDevelopers can interact with the AI engine by calling the `process_game_state` function from the core AI processing module. Here is an example of how to use this function:\n\n```python\nfrom core.ai_engine.ai_processing import process_game_state\n\n# Example game state data\ngame_state = {\n 'player_action': 'move',\n 'current_state': 'waiting',\n 'context': {'level': 1, 'score': 100}\n}\n\n# Processing the game state with AI engine\nai_response = process_game_state(game_state)\nprint(ai_response)\n```\n\n## Conclusion\n\nThe AI engine's processing logic is a critical component of the hagamesai project, enabling engaging and intelligent gameplay experiences. Developers are encouraged to explore the various components and enhance the AI capabilities further.\n\n## References\n- [Core AI Processing Module](../core/ai_engine/ai_processing.py)\n\n---\n\nFor further information, please refer to the project's README or the API documentation." }, { "path": "docs/ai_engine_utils.md", "content": "# AI Engine Utility Functions Documentation\n\nThis document provides an overview of the utility functions used in the AI engine module of the hagamesai project. The utility functions are designed to facilitate various operations related to cognitive modeling and AI processing.\n\n## Overview\n\nThe AI engine utility functions are responsible for supporting core functionalities such as data preprocessing, model evaluation, and cognitive processing. These functions are utilized across different components of the AI engine to ensure modularity and reusability.\n\n## Utility Functions\n\n### 1. Data Normalization\n\n```python\ndef normalize_data(data: List[float]) -> List[float]:\n \"\"\"\n Normalize the input data to a range between 0 and 1.\n\n Parameters:\n - data (List[float]): A list of float values to be normalized.\n\n Returns:\n - List[float]: A list of normalized float values.\n \"\"\"\n min_val = min(data)\n max_val = max(data)\n return [(x - min_val) / (max_val - min_val) for x in data]\n```\n\n### 2. Cognitive Load Calculation\n\n```python\ndef calculate_cognitive_load(task_difficulty: float, user_expertise: float) -> float:\n \"\"\"\n Calculate the cognitive load based on task difficulty and user expertise.\n\n Parameters:\n - task_difficulty (float): The difficulty level of the task.\n - user_expertise (float): The expertise level of the user.\n\n Returns:\n - float: The calculated cognitive load.\n \"\"\"\n return task_difficulty / (user_expertise + 1e-5) # Prevent division by zero\n```\n\n### 3. Performance Evaluation\n\n```python\ndef evaluate_performance(predictions: List[float], actuals: List[float]) -> float:\n \"\"\"\n Evaluate the performance of the AI model using Mean Squared Error (MSE).\n\n Parameters:\n - predictions (List[float]): The predictions made by the model.\n - actuals (List[float]): The actual values.\n\n Returns:\n - float: The calculated Mean Squared Error.\n \"\"\"\n return sum((p - a) ** 2 for p, a in zip(predictions, actuals)) / len(actuals)\n```\n\n## Usage\n\nThese utility functions can be imported and utilized in various components of the AI engine. Ensure to handle exceptions and edge cases appropriately when using these functions in production.\n\n## Conclusion\n\nThe utility functions outlined in this document play a vital role in the functionality of the AI engine. By maintaining a modular approach, we can enhance, test, and maintain these functions independently as the project evolves.\n\nFor further information, refer to the source code and related documentation." }, { "path": "docs/api_overview.md", "content": "# API Overview\n\nThis document provides a detailed overview of the API endpoints available in the `hagamesai` project. The API is built using FastAPI and offers various functionalities to support human-vs-AI game scenarios, advanced cognitive modeling, and LLM-powered services.\n\n## Base URL\nThe base URL for all the API endpoints is:\n```\nhttp:///api\n```\n\n## Authentication\nMost endpoints require user authentication. You can obtain a JWT token by using the `/auth/login` endpoint after registering a user via `/auth/register`.\n\n## Endpoints\n\n### User Endpoints\n\n1. **Register User** \n - **Endpoint:** `/auth/register` \n - **Method:** `POST` \n - **Request Body:**\n ```json\n {\n \"username\": \"\",\n \"password\": \"\"\n }\n ```\n - **Response:** \n - **201 Created** on successful registration.\n - **400 Bad Request** if the input data is invalid.\n\n2. **Login User** \n - **Endpoint:** `/auth/login` \n - **Method:** `POST` \n - **Request Body:**\n ```json\n {\n \"username\": \"\",\n \"password\": \"\"\n }\n ```\n - **Response:** \n - **200 OK** with JWT token on successful login.\n - **401 Unauthorized** if credentials are invalid.\n\n### Game Management Endpoints\n\n1. **Get Game Definitions** \n - **Endpoint:** `/games/definitions` \n - **Method:** `GET` \n - **Response:** \n - **200 OK** with a list of game definitions.\n\n2. **Create Game Instance** \n - **Endpoint:** `/games/instances` \n - **Method:** `POST` \n - **Request Body:**\n ```json\n {\n \"game_id\": \"\",\n \"user_id\": \"\"\n }\n ```\n - **Response:** \n - **201 Created** on successful creation.\n - **400 Bad Request** if the input data is invalid.\n\n### AI Services Endpoints\n\n1. **AI Engine Prediction** \n - **Endpoint:** `/llm/predict` \n - **Method:** `POST` \n - **Request Body:**\n ```json\n {\n \"input_data\": \"\"\n }\n ```\n - **Response:** \n - **200 OK** with AI prediction result.\n\n## Error Handling\nAll API responses include a status code and a message. Common status codes include:\n- **200 OK:** Successful request.\n- **201 Created:** Resource successfully created.\n- **400 Bad Request:** Invalid input data.\n- **401 Unauthorized:** Authentication error.\n- **404 Not Found:** Resource not found.\n- **500 Internal Server Error:** An unexpected error occurred.\n\n## Conclusion\nThis overview provides a high-level understanding of the available API endpoints in the `hagamesai` project. For more detailed information about specific endpoints, refer to the endpoint documentation in the respective modules." }, { "path": "docs/api_reference.md", "content": "# API Reference for hagamesai\n\nThis document serves as a detailed API reference for the endpoints available in the hagamesai project. Each endpoint is described with its functionality, required parameters, and response structure.\n\n## Authentication\n\n### POST /auth/login\n- **Description:** Authenticate a user and return a JWT token.\n- **Request Body:**\n - `email` (string): The user's email address.\n - `password` (string): The user's password.\n- **Response:**\n - **200 OK** \n - `access_token` (string): JWT token for authorized access.\n - `token_type` (string): Type of token (usually \"bearer\").\n - **401 Unauthorized** \n - Error message indicating invalid credentials.\n\n\n### POST /auth/register\n- **Description:** Register a new user.\n- **Request Body:**\n - `email` (string): The new user's email address.\n - `password` (string): The new user's password.\n - `name` (string): The user's name.\n- **Response:**\n - **201 Created** \n - `user_id` (integer): ID of the newly created user.\n - **400 Bad Request** \n - Error message indicating validation issues.\n\n\n## Game Management\n\n### GET /games\n- **Description:** Retrieve a list of all games.\n- **Response:**\n - **200 OK** \n - `games` (array): Array of game objects containing details such as ID, name, and description.\n\n\n### POST /games\n- **Description:** Create a new game definition.\n- **Request Body:**\n - `name` (string): Name of the game.\n - `description` (string): Description of the game.\n- **Response:**\n - **201 Created** \n - `game_id` (integer): ID of the newly created game.\n - **400 Bad Request** \n - Error message indicating validation issues.\n\n\n## AI Services\n\n### POST /llm/predict\n- **Description:** Get predictions from the LLM based on input data.\n- **Request Body:**\n - `input` (string): The input data for the prediction.\n- **Response:**\n - **200 OK** \n - `prediction` (string): Predicted output from the LLM.\n - **400 Bad Request** \n - Error message indicating invalid input.\n\n\n## Error Handling\n\nAll endpoints will return appropriate HTTP status codes and error messages for any failures. Common error responses include:\n- **400 Bad Request:** The request was invalid.\n- **401 Unauthorized:** Authentication is required or failed.\n- **404 Not Found:** The requested resource was not found.\n- **500 Internal Server Error:** An unexpected error occurred on the server side.\n\n## Conclusion\n\nThis API reference provides a comprehensive overview of the endpoints available for the hagamesai project. For further assistance, please consult the project's documentation or contact the development team." }, { "path": "docs/game_management.md", "content": "# Game Management Documentation\n\n## Overview\nThe game management feature provides the functionality to create, manage, and interact with game definitions and instances. This is integral to the backend for the human-vs-AI gaming scenarios facilitated by the application.\n\n## Features\n- **Create Game Definitions**: Allows the creation of new game types with defined rules and settings.\n- **Manage Game Instances**: Enables the initiation and management of game sessions for users.\n- **User Interaction**: Facilitates user interactions with the game instances through API endpoints.\n\n## API Endpoints\n\n### 1. Create Game Definition\n- **Endpoint**: `POST /api/games`\n- **Description**: Create a new game definition.\n- **Request Body**:\n ```json\n {\n \"name\": \"string\",\n \"description\": \"string\",\n \"rules\": \"string\",\n \"settings\": {\n \"max_players\": \"integer\",\n \"game_type\": \"string\"\n }\n }\n ```\n- **Response**:\n - **Success**: Returns the created game definition object.\n - **Error**: Returns an error message if the creation fails.\n\n### 2. Get Game Definitions\n- **Endpoint**: `GET /api/games`\n- **Description**: Retrieve all game definitions.\n- **Response**:\n - Returns a list of game definitions.\n\n### 3. Start Game Instance\n- **Endpoint**: `POST /api/games/start`\n- **Description**: Start a new game instance based on a game definition.\n- **Request Body**:\n ```json\n {\n \"game_id\": \"string\",\n \"players\": [\"string\"]\n }\n ```\n- **Response**:\n - **Success**: Returns the created game instance object.\n - **Error**: Returns an error message if the instance creation fails.\n\n### 4. Get Game Instance\n- **Endpoint**: `GET /api/games/{instance_id}`\n- **Description**: Retrieve a specific game instance by its ID.\n- **Response**:\n - Returns the game instance details, including its current state and players.\n\n## Conclusion\nThe game management feature is designed to provide a comprehensive interface for managing games within the application, ensuring that users can easily create and engage in various game scenarios. This documentation will be updated as the feature evolves and further functionalities are added." }, { "path": "docs/llm_api_documentation.md", "content": "# LLM API Documentation\n\n## Overview\nThis document provides detailed information about the LLM (Large Language Model) API endpoints available in the hagamesai project. The LLM API is designed to facilitate communication with the AI engine for various functionalities including natural language processing, cognitive modeling, and game interactions.\n\n## Base URL\nThe base URL for all LLM API requests is:\n```\nhttp:///api/llm\n```\n\n## Endpoints\n\n### 1. Generate Text\n- **Endpoint:** `/generate`\n- **Method:** `POST`\n- **Description:** Generates text based on the provided prompt.\n- **Request Body:**\n - `prompt`: (string) The input text to generate a response from.\n - `max_length`: (integer) The maximum length of the generated response.\n\n Example:\n ```json\n {\n \"prompt\": \"Once upon a time\",\n \"max_length\": 100\n }\n ```\n- **Response:**\n - `200 OK`\n ```json\n {\n \"generated_text\": \"Once upon a time, in a land far away...\"\n }\n ```\n - `400 Bad Request`\n ```json\n {\n \"error\": \"Invalid input\"\n }\n ```\n\n### 2. Analyze Sentiment\n- **Endpoint:** `/analyze/sentiment`\n- **Method:** `POST`\n- **Description:** Analyzes the sentiment of the provided text.\n- **Request Body:**\n - `text`: (string) The input text for sentiment analysis.\n\n Example:\n ```json\n {\n \"text\": \"I love playing games!\"\n }\n ```\n- **Response:**\n - `200 OK`\n ```json\n {\n \"sentiment\": \"positive\"\n }\n ```\n - `400 Bad Request`\n ```json\n {\n \"error\": \"Invalid input\"\n }\n ```\n\n### 3. Cognitive Task\n- **Endpoint:** `/cognitive/task`\n- **Method:** `POST`\n- **Description:** Executes a cognitive task based on the input data.\n- **Request Body:**\n - `task_data`: (object) The data required to perform the cognitive task.\n\n Example:\n ```json\n {\n \"task_data\": {\n \"question\": \"What is the capital of France?\"\n }\n }\n ```\n- **Response:**\n - `200 OK`\n ```json\n {\n \"answer\": \"Paris\"\n }\n ```\n - `400 Bad Request`\n ```json\n {\n \"error\": \"Invalid input\"\n }\n ```\n\n## Error Handling\nAll error responses will include an error message indicating the nature of the issue. Ensure to handle error responses appropriately in client applications.\n\n## Conclusion\nThis documentation serves as a comprehensive guide to the LLM API endpoints. For further details on implementation and usage, please refer to the source code and additional documentation available in the project.\n" }, { "path": "docs/llm_integration_guide.md", "content": "# LLM Integration Guide\n\nThis document provides guidance on integrating LLM (Large Language Model) services into the hagamesai backend. This integration is crucial for enhancing the AI capabilities in human-vs-AI gameplay and cognitive modeling.\n\n## Prerequisites\n\nBefore integrating LLM services, ensure you have the following:\n- Python 3.10+\n- FastAPI\n- Required libraries for LLM integration (e.g., `transformers`, `torch`, etc.)\n\n## Setting Up the LLM Service\n\n1. **Install Required Packages**:\n \n You need to install the necessary libraries via pip:\n ```bash\n pip install transformers torch\n ```\n\n2. **Configure the LLM Service**:\n \n In the `llm_service/service.py` file, set up the LLM model and tokenizer:\n ```python\n from transformers import AutoModelForCausalLM, AutoTokenizer\n\n class LLMService:\n def __init__(self, model_name: str):\n self.tokenizer = AutoTokenizer.from_pretrained(model_name)\n self.model = AutoModelForCausalLM.from_pretrained(model_name)\n\n def generate_text(self, prompt: str, max_length: int = 50):\n inputs = self.tokenizer(prompt, return_tensors=\"pt\")\n outputs = self.model.generate(**inputs, max_length=max_length)\n return self.tokenizer.decode(outputs[0], skip_special_tokens=True)\n ```\n\n3. **Integrate with FastAPI**:\n \n Create an API endpoint to utilize the LLM service in `api/llm.py`:\n ```python\n from fastapi import APIRouter, HTTPException\n from llm_service.service import LLMService\n\n llm_router = APIRouter()\n llm_service = LLMService(\"gpt2\") # Example model\n\n @llm_router.post(\"/generate\")\n async def generate_text(prompt: str):\n try:\n return llm_service.generate_text(prompt)\n except Exception as e:\n raise HTTPException(status_code=500, detail=str(e))\n ```\n\n4. **Testing the Integration**:\n \n Ensure to create unit and integration tests for the new LLM functionalities. Tests should cover:\n - Valid input generation\n - Error handling for invalid inputs\n\n## Conclusion\n\nThis guide outlines the steps necessary for integrating LLM services into the hagamesai project. Ensure to refer to the official documentation of the libraries used for any advanced configurations and optimizations.\n\nFor further assistance, consult the project's documentation or reach out to the development team." }, { "path": "docs/llm_service.md", "content": "# LLM Service Integration Documentation\n\n## Overview\nThe LLM (Large Language Model) service provides advanced AI capabilities for human-vs-AI gameplay within the hagamesai application. This documentation outlines the integration points, usage, and configuration of the LLM service, which is built using FastAPI.\n\n## Features\n- **AI-Powered Gameplay**: Leverages LLMs to create intelligent behaviors in non-playable characters (NPCs).\n- **Cognitive Modeling**: Supports advanced decision-making processes and cognitive profiles for game entities.\n\n## Integration Points\nThe LLM service is integrated through the following components:\n\n- **API Endpoints**: LLM service exposes several API endpoints that can be consumed by the frontend or other services.\n- **Background Tasks**: Utilizes Celery for asynchronous processing of LLM requests and responses.\n\n## Configuration\nTo configure the LLM service, ensure that the following environment variables are set:\n\n| Environment Variable | Description |\n|----------------------|-------------|\n| `LLM_SERVICE_URL` | The URL of the LLM service endpoint. |\n| `LLM_API_KEY` | API key for authenticating requests to the LLM service. |\n\n## Usage\n### API Endpoints\nThe LLM service provides the following endpoints:\n\n1. **Generate Response** \n `POST /api/llm/generate` \n - **Request Body**: \n ```json\n {\n \"input\": \"string\"\n }\n ``` \n - **Response**: \n ```json\n {\n \"output\": \"string\"\n }\n ``` \n - **Description**: This endpoint generates a response based on the provided input string.\n\n### Background Tasks\nThe processing of requests to the LLM service is handled asynchronously. Ensure that your Celery workers are running to process LLM tasks.\n\n## Error Handling\nThe LLM service implements standard error handling. Common HTTP status codes include:\n- `200 OK`: The request was successful.\n- `400 Bad Request`: The request was invalid.\n- `500 Internal Server Error`: An unexpected error occurred.\n\n## Conclusion\nIntegrating the LLM service within the hagamesai project enhances the gaming experience by providing intelligent and responsive AI capabilities. Ensure that the necessary configurations are set up properly and that the API endpoints are utilized as intended.\n\nFor further updates, please refer to the project's [roadmap](roadmap.md) and API overview documentation." }, { "path": "docs/roadmap.md", "content": "# project roadmap\n\n## Technical Requirements\n- Python 3.10+\n- FastAPI (async, high performance, Pydantic validation)\n- PostgreSQL (with JSONB support)\n- Async ORM: SQLAlchemy (async) or Tortoise ORM\n- Celery (with Redis or RabbitMQ)\n- LLM SDKs: OpenAI, Google AI\n- Redis (cache, session, rate limit)\n- Docker, Docker Compose, Kubernetes (for deployment)\n- Monitoring: Prometheus, Grafana\n- Logging: ELK Stack or Grafana Loki\n- Git for version control\n\n## System Architecture\n- API Server (FastAPI)\n- User Authentication & Profile Management\n- Game Core Framework\n- AI Engine (Prediction, Cognitive Modeling, XAI, etc.)\n- LLM Integration Service\n- Data Persistence & Management\n- Async Task Queue (Celery)\n- Monitoring & Logging\n\n## Planned Modules & Implementation Sequence\n1. User Authentication & Profile Management\n - User registration, login, JWT/OAuth2, profile CRUD\n - CognitiveProfile management\n2. Game Core Framework\n - Game definition, instance management, state engine\n - Game lifecycle, plugin/strategy pattern\n3. AI Engine\n - Adaptive Prediction Engine\n - Cognitive Model Builder\n - Quantum Uncertainty Generator\n - Collective Wisdom Aggregation\n - Explainable AI (XAI)\n4. LLM Integration Service\n - Centralized LLM API gateway\n - Prompt management, error handling, caching\n5. Data Persistence & Management\n - Async ORM models for all entities\n - CRUD utilities, session management\n6. API Routers & Endpoints\n - RESTful API for all modules\n - Pydantic schemas, status codes, error handling\n7. Async Task Processing\n - Celery task definitions, idempotency, error handling\n8. Monitoring & Logging\n - Structured logging, Prometheus metrics\n\n## To Be Implemented\n- Developer API/SDK\n- Multimodal interaction support\n- Emotion intelligence analysis\n- Advanced AI model integration\n- Federated learning support\n\n---\n\n**After each module is implemented, update this roadmap to reflect progress and next steps.**" }, { "path": "docs/usage_guide.md", "content": "# Usage Guide for API Endpoints\n\nThis guide provides examples of how to use the API endpoints in the `hagamesai` backend service. Each section outlines the request format, required parameters, and example responses for common API functionalities.\n\n## User Authentication\n\n### Register a New User\n**Endpoint:** `POST /api/auth/register`\n\n**Request Body:**\n```json\n{\n \"username\": \"example_user\",\n \"password\": \"securepassword\",\n \"email\": \"user@example.com\"\n}\n```\n\n**Response:**\n- **201 Created** on success:\n```json\n{\n \"message\": \"User registered successfully.\"\n}\n```\n- **400 Bad Request** on validation error:\n```json\n{\n \"detail\": \"Username already exists.\"\n}\n```\n\n### User Login\n**Endpoint:** `POST /api/auth/login`\n\n**Request Body:**\n```json\n{\n \"username\": \"example_user\",\n \"password\": \"securepassword\"\n}\n```\n\n**Response:**\n- **200 OK** on success:\n```json\n{\n \"access_token\": \"your_jwt_token\",\n \"token_type\": \"bearer\"\n}\n```\n- **401 Unauthorized** if credentials are invalid:\n```json\n{\n \"detail\": \"Invalid username or password.\"\n}\n```\n\n## Game Management\n\n### Create a New Game\n**Endpoint:** `POST /api/games`\n\n**Request Body:**\n```json\n{\n \"game_name\": \"Chess\",\n \"description\": \"A strategic board game for two players.\"\n}\n```\n\n**Response:**\n- **201 Created** on success:\n```json\n{\n \"game_id\": \"123\",\n \"message\": \"Game created successfully.\"\n}\n```\n\n### Get Game Details\n**Endpoint:** `GET /api/games/{game_id}`\n\n**Response:**\n- **200 OK** on success:\n```json\n{\n \"game_id\": \"123\",\n \"game_name\": \"Chess\",\n \"description\": \"A strategic board game for two players.\"\n}\n```\n- **404 Not Found** if the game does not exist:\n```json\n{\n \"detail\": \"Game not found.\"\n}\n```\n\n## AI Engine Services\n\n### Request AI Service\n**Endpoint:** `POST /api/llm/request`\n\n**Request Body:**\n```json\n{\n \"input_text\": \"What is the capital of France?\"\n}\n```\n\n**Response:**\n- **200 OK** on success:\n```json\n{\n \"response\": \"The capital of France is Paris.\"\n}\n```\n- **500 Internal Server Error** if the AI service fails:\n```json\n{\n \"detail\": \"Error processing request.\"\n}\n```\n\n## Conclusion\n\nThis usage guide serves as a reference for interacting with the API endpoints of `hagamesai`. Always ensure to handle responses properly, especially error cases, to provide a smooth user experience." }, { "path": "docs/user_management_guide.md", "content": "# User Management Guide\n\nThis guide provides an overview of the user management features available in the hagamesai project. The user management system includes functionalities for user registration, authentication, and profile management. It is designed to ensure secure interactions and ease of use for end users.\n\n## Features\n\n### User Registration\n- **Endpoint**: `POST /api/auth/register`\n- **Description**: Allows new users to create an account.\n- **Request Body**:\n - `username`: A unique identifier for the user.\n - `password`: A secure password for account access.\n - `email`: The user's email address for account verification.\n\n- **Response**:\n - `201 Created`: User successfully registered.\n - `400 Bad Request`: Validation errors or username already taken.\n\n### User Login\n- **Endpoint**: `POST /api/auth/login`\n- **Description**: Authenticates a user and provides a JWT token.\n- **Request Body**:\n - `username`: The user's unique identifier.\n - `password`: The user's password.\n\n- **Response**:\n - `200 OK`: JWT token is returned for further authenticated requests.\n - `401 Unauthorized`: Invalid credentials.\n\n### User Profile Management\n- **Endpoints**:\n - `GET /api/users/me`: Retrieves the currently authenticated user's profile.\n - `PUT /api/users/me`: Updates the user's profile information.\n- **Request Body for Update**:\n - `email`: Updated email address.\n - `password`: Updated password (optional).\n\n- **Response**:\n - `200 OK`: User profile updated successfully.\n - `404 Not Found`: User does not exist.\n\n## Security Considerations\n- Passwords must be hashed before storage.\n- Implement measures to prevent brute force attacks on login endpoints.\n- Consider implementing two-factor authentication for added security.\n\n## Conclusion\nThis guide provides the essential information for developers and users regarding the user management features of hagamesai. For further details, please refer to the API documentation and the source code in the `api/auth.py` and `core/auth.py` files." }, { "path": "docs/user_profile_management.md", "content": "# User Profile Management API Documentation\n\n## Overview\nThe User Profile Management API allows for the creation, retrieval, updating, and deletion of user profiles. This API provides endpoints for managing user-specific information and preferences, enabling personalized user experiences within the application.\n\n## Base URL\n```plaintext\nhttp://{host}:{port}/api/users/\n```\n\n## Endpoints\n\n### 1. Create User Profile\n- **Endpoint:** `/profiles`\n- **Method:** `POST`\n- **Description:** Create a new user profile.\n- **Request Body:**\n ```json\n {\n \"username\": \"string\",\n \"email\": \"string\",\n \"preferences\": {\n \"theme\": \"string\",\n \"notifications\": \"boolean\"\n }\n }\n ```\n- **Response:**\n - **Status 201:** Profile created successfully.\n - **Status 400:** Invalid request data.\n\n### 2. Retrieve User Profile\n- **Endpoint:** `/profiles/{user_id}`\n- **Method:** `GET`\n- **Description:** Retrieve a user profile by ID.\n- **Response:**\n - **Status 200:** Returns user profile data.\n - **Status 404:** Profile not found.\n\n### 3. Update User Profile\n- **Endpoint:** `/profiles/{user_id}`\n- **Method:** `PUT`\n- **Description:** Update an existing user profile.\n- **Request Body:**\n ```json\n {\n \"email\": \"string\",\n \"preferences\": {\n \"theme\": \"string\",\n \"notifications\": \"boolean\"\n }\n }\n ```\n- **Response:**\n - **Status 200:** Profile updated successfully.\n - **Status 404:** Profile not found.\n - **Status 400:** Invalid request data.\n\n### 4. Delete User Profile\n- **Endpoint:** `/profiles/{user_id}`\n- **Method:** `DELETE`\n- **Description:** Delete a user profile.\n- **Response:**\n - **Status 204:** Profile deleted successfully.\n - **Status 404:** Profile not found.\n\n## Error Handling\nThe API uses standard HTTP status codes to indicate the outcome of API requests. All error responses will include a JSON object containing an error message.\n\n## Conclusion\nThis documentation provides an overview of the User Profile Management API, including its endpoints, request and response formats, and error handling mechanisms. This API is essential for maintaining user information and enhancing user experience in the application.\n\nFor further details, please refer to the API overview documentation or contact the API support team." }, { "path": "llm_service/README.md", "content": "# LLM Service Overview\n\nThe LLM (Large Language Model) Service is a crucial component of the hagamesai project, enabling advanced AI capabilities to facilitate human-vs-AI gameplay. This service provides endpoints that allow for interactions with the LLM, handling requests and responses efficiently.\n\n## Purpose\nThe LLM Service is designed to:\n- Provide a seamless interface for integrating LLM functionalities into game scenarios.\n- Support various cognitive tasks such as conversation, problem-solving, and decision-making.\n- Offer robust processing capabilities to handle multiple user requests simultaneously.\n\n## Usage Instructions\nTo utilize the LLM Service, ensure that the service is running and follow the steps below:\n\n### 1. Setup\nMake sure to install the required dependencies. If you are using a virtual environment, activate it and run:\n```bash\npip install -r requirements.txt\n```\n\n### 2. Running the Service\nYou can start the LLM Service by running the following command in your terminal:\n```bash\nuvicorn llm_service.service:app --host 0.0.0.0 --port 8000\n```\n\n### 3. API Endpoints\nThe LLM Service exposes several API endpoints that you can use to interact with the model:\n\n- **POST /llm/request**: This endpoint allows you to send a request to the LLM.\n - **Request Body**:\n ```json\n {\n \"prompt\": \"Your input text here\",\n \"parameters\": {\n \"max_tokens\": 100,\n \"temperature\": 0.7\n }\n }\n ```\n - **Response**:\n ```json\n {\n \"response\": \"Generated response from LLM\"\n }\n ```\n\n### 4. Example Request\nHere is an example of how to make a request to the LLM endpoint using `curl`:\n```bash\ncurl -X POST \"http://localhost:8000/llm/request\" -H \"Content-Type: application/json\" -d '{\"prompt\":\"What is the capital of France?\",\"parameters\":{\"max_tokens\":10}}'\n```\n\n## Conclusion\nThis LLM Service is a key building block for enhancing gameplay experiences in hagamesai by leveraging advanced AI technologies. For further integration details and examples, please refer to the API documentation.\n\n## License\nThis project is licensed under the MIT License - see the [LICENSE](../../LICENSE) file for details." }, { "path": "llm_service/__init__.py", "content": "" }, { "path": "llm_service/architecture.md", "content": "# LLM Service Architecture Overview\n\n## Introduction\nThe LLM Service (Large Language Model Service) is designed to facilitate human-vs-AI interactions in the game scenarios provided by the hagamesai backend. This document outlines the architecture of the LLM Service, detailing its major components, interactions, and data flow.\n\n## Core Components\nThe architecture of the LLM Service can be broken down into the following core components:\n\n1. **API Layer** \n The API layer serves as the entry point for all client requests related to LLM functionalities. It handles incoming HTTP requests and routes them to the appropriate service handlers.\n - **Endpoints:** \n - `/llm/generate` - Generates a response based on user input. \n - `/llm/configure` - Configures model parameters for specific game scenarios.\n\n2. **Service Layer** \n This layer contains the core business logic of the LLM Service. It processes requests from the API layer, orchestrating interactions with the underlying models and managing responses.\n - **Key Functions:** \n - `generate_response(user_input: str) -> str` \n Generates a response based on user input using the LLM. \n - `configure_model(params: Dict[str, Any]) -> None` \n Configures the model with specified parameters for optimal performance.\n\n3. **Model Layer** \n The Model layer is responsible for interacting with the Large Language Model, executing the necessary computations to generate responses. This layer abstracts the complexities of model interactions, providing a clean interface for the service layer.\n - **Key Models:** \n - Transformer-based models optimized for dialogue generation and multi-turn conversations.\n\n4. **Database Layer** \n This layer includes all database interactions required for storing user profiles, game states, and any other persistent data necessary for the LLM Service.\n - **Database Technology:** \n - PostgreSQL for structured data storage.\n\n5. **Caching Layer** \n To improve performance and reduce latency, we utilize Redis as a caching layer to store frequently accessed data, such as user sessions and previous interactions.\n\n## Data Flow\nThe interaction flow within the LLM Service can be summarized as follows:\n1. A user sends a request through the API layer.\n2. The API layer forwards the request to the service layer.\n3. The service layer processes the request, potentially querying the database or caching layer for necessary data.\n4. The service layer invokes the model layer to generate a response.\n5. The response is then formatted and returned to the user via the API layer.\n\n## Conclusion\nThis architecture is designed to ensure scalability, performance, and maintainability. The separation of concerns allows for easier updates and enhancements to individual components without affecting the overall system.\n\n## Future Considerations\nAs the project evolves, further enhancements may include:\n- Advanced error handling strategies for API requests.\n- Implementation of additional caching strategies to support more complex queries.\n- Exploration of multi-model setups for improved response accuracy and diversity.\n\n---" }, { "path": "llm_service/configuration.md", "content": "# LLM Service Configuration Options\n\nThis document outlines the configuration options available for the LLM (Large Language Model) service within the hagamesai project. Proper configuration is crucial for optimizing the performance and capabilities of our AI engine services. \n\n## Configuration Parameters\n\n### 1. LLM Endpoint\n- **Description:** The endpoint to access the LLM service.\n- **Default:** `http://localhost:8000/llm`\n\n### 2. API Key\n- **Description:** The API key for authenticating requests to the LLM service.\n- **Default:** `None` (must be provided for production).\n\n### 3. Timeout\n- **Description:** The maximum time to wait for a response from the LLM service, in seconds.\n- **Default:** `30`\n\n### 4. Max Tokens\n- **Description:** The maximum number of tokens to generate in the response.\n- **Default:** `150`\n\n### 5. Temperature\n- **Description:** Controls the randomness of the output. Lower values make the output more focused and deterministic. Higher values increase creativity and randomness.\n- **Default:** `0.7`\n\n### 6. Top P\n- **Description:** The cumulative probability for token selection. This can be used to restrict the output to a certain subset of tokens, enhancing quality.\n- **Default:** `1.0` (no restrictions)\n\n## Example Configuration\n```json\n{\n \"llm_endpoint\": \"http://localhost:8000/llm\",\n \"api_key\": \"your_api_key_here\",\n \"timeout\": 30,\n \"max_tokens\": 150,\n \"temperature\": 0.7,\n \"top_p\": 1.0\n}\n```\n\n## Conclusion\n\nThis configuration file allows you to customize various aspects of the LLM service to better fit your application needs. Ensure that you adjust these settings based on your requirements and the environment in which the service is deployed." }, { "path": "llm_service/crud.py", "content": "import uuid\nfrom sqlalchemy.ext.asyncio import AsyncSession\nfrom sqlalchemy.future import select\nfrom llm_service.models import LLMCallLog\nfrom llm_service.schemas import LLMCallRequest\n\n\nasync def create_log(session: AsyncSession, req: LLMCallRequest, response: str, status: str) -> LLMCallLog:\n \"\"\"Create a new LLM call log entry.\"\"\"\n log = LLMCallLog(\n user_id=req.user_id,\n provider=req.provider,\n model=req.model,\n prompt=req.prompt,\n response=response,\n status=status\n )\n session.add(log)\n await session.commit()\n await session.refresh(log)\n return log\n\n\nasync def list_logs_by_user(session: AsyncSession, user_id: uuid.UUID) -> list[LLMCallLog]:\n \"\"\"List all LLM call logs for a user.\"\"\"\n result = await session.execute(select(LLMCallLog).where(LLMCallLog.user_id == user_id))\n return result.scalars().all()\n" }, { "path": "llm_service/faq.md", "content": "# Frequently Asked Questions (FAQ) about LLM Service\n\n## What is the LLM Service?\nThe LLM (Large Language Model) Service is a component of the hagamesai project that provides advanced AI capabilities for human-vs-AI gameplay. It utilizes state-of-the-art machine learning techniques to enhance the gaming experience.\n\n## How do I integrate the LLM Service with my application?\nTo integrate the LLM Service, you can use the API endpoints provided in the `llm.py` file located in the `api` directory. Make sure to refer to the API documentation for detailed instructions on how to make requests and handle responses.\n\n## What kind of functionalities does the LLM Service provide?\nThe LLM Service offers various functionalities, including:\n- Natural language understanding\n- Text generation\n- Sentiment analysis\n- Customizable AI behavior based on user interactions\n\n## Is there a limit on the number of requests I can make to the LLM Service?\nYes, there may be rate limits imposed on the API to ensure fair usage and maintain service quality. Please check the API documentation for specific rate limits and guidelines.\n\n## How can I report issues or provide feedback about the LLM Service?\nFeedback and issues can be reported through the project's GitHub repository. Please open an issue and provide as much detail as possible regarding the problem or suggestion.\n\n## Where can I find more information about the AI models used in the LLM Service?\nYou can find more information about the AI models in the `llm_service` directory, specifically within the `models.py` and `schemas.py` files. These files contain the definitions and structures of the models utilized by the service.\n\n## Who can I contact for support?\nFor support, please reach out to the project maintainers through the GitHub repository's contact options. You can also check the existing issues for similar queries." }, { "path": "llm_service/models.py", "content": "import uuid\nfrom datetime import datetime\nfrom sqlalchemy import String, Text, DateTime, ForeignKey\nfrom sqlalchemy.orm import Mapped, mapped_column\nfrom sqlalchemy.dialects.postgresql import UUID\nfrom models.user import Base\n\n\nclass LLMCallLog(Base):\n \"\"\"LLMCallLog model for logging LLM API calls and responses.\"\"\"\n __tablename__ = \"llm_call_logs\"\n\n id: Mapped[uuid.UUID] = mapped_column(\n UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)\n user_id: Mapped[uuid.UUID | None] = mapped_column(\n UUID(as_uuid=True), ForeignKey(\"users.id\"), nullable=True)\n provider: Mapped[str] = mapped_column(String(50), nullable=False)\n model: Mapped[str] = mapped_column(String(100), nullable=False)\n prompt: Mapped[str] = mapped_column(Text, nullable=False)\n response: Mapped[str] = mapped_column(Text, nullable=True)\n status: Mapped[str] = mapped_column(String(20), nullable=False)\n created_at: Mapped[datetime] = mapped_column(\n DateTime, default=datetime.utcnow, nullable=False)\n" }, { "path": "llm_service/schemas.py", "content": "import uuid\nfrom datetime import datetime\nfrom pydantic import BaseModel, Field\n\n\nclass LLMCallRequest(BaseModel):\n \"\"\"Schema for making an LLM call.\"\"\"\n provider: str = Field(..., max_length=50)\n model: str = Field(..., max_length=100)\n prompt: str\n user_id: uuid.UUID | None = None\n\n\nclass LLMCallResponse(BaseModel):\n \"\"\"Schema for LLM call response.\"\"\"\n response: str\n status: str\n\n\nclass LLMCallLogRead(BaseModel):\n \"\"\"Schema for reading LLM call log info.\"\"\"\n id: uuid.UUID\n user_id: uuid.UUID | None\n provider: str\n model: str\n prompt: str\n response: str | None\n status: str\n created_at: datetime\n\n class Config:\n orm_mode = True\n" }, { "path": "llm_service/service.py", "content": "import requests\nimport logging\n\nclass LLMService:\n \"\"\"\n A service class to handle integration with the LLM (Large Language Model) API.\n \"\"\"\n def __init__(self, api_key: str, api_url: str):\n \"\"\"\n Initialize the LLM service with API key and URL.\n \"\"\"\n self.api_key = api_key\n self.api_url = api_url\n self.logger = logging.getLogger(__name__)\n\n def generate_response(self, prompt: str) -> str:\n \"\"\"\n Generate a response from the LLM based on the provided prompt.\n :param prompt: The input prompt for the LLM.\n :return: The generated response from the LLM.\n \"\"\"\n headers = {\n 'Authorization': f'Bearer {self.api_key}',\n 'Content-Type': 'application/json'\n }\n data = {\n 'prompt': prompt,\n 'max_tokens': 150\n }\n try:\n response = requests.post(self.api_url, headers=headers, json=data)\n response.raise_for_status() # Raise an error for bad responses\n response_data = response.json()\n return response_data.get('choices')[0].get('text').strip()\n except requests.exceptions.HTTPError as http_err:\n self.logger.error(f'HTTP error occurred: {http_err}')\n except Exception as err:\n self.logger.error(f'An error occurred: {err}')\n return \"\" # Return empty string in case of error\n\n# Example usage:\n# llm_service = LLMService(api_key='your_api_key', api_url='https://api.llmprovider.com/v1/generate')\n# response = llm_service.generate_response('What is the capital of France?')\n# print(response)" }, { "path": "llm_service/test_ai_engine_service.py", "content": "import pytest\nfrom llm_service.service import AIEngineService\n\n\nclass TestAIEngineService:\n @pytest.fixture(scope=\"class\")\n def service(self):\n \"\"\"Fixture to initialize the AIEngineService for testing.\"\"\"\n return AIEngineService()\n\n def test_initialization(self, service):\n \"\"\"Test the initialization of the AIEngineService.\"\"\"\n assert service is not None, \"Service should be initialized\"\n\n def test_method_1(self, service):\n \"\"\"Test method 1 of AIEngineService.\"\"\"\n result = service.method_1() # Replace with actual method\n assert result == expected_value, \"Method 1 should return expected value\"\n\n def test_method_2(self, service):\n \"\"\"Test method 2 of AIEngineService.\"\"\"\n result = service.method_2(arg1, arg2) # Replace with actual method and arguments\n assert result == expected_value, \"Method 2 should return expected value\"\n\n def test_method_3(self, service):\n \"\"\"Test method 3 of AIEngineService with edge case.\"\"\"\n result = service.method_3(edge_case_arg) # Replace with actual method and edge case argument\n assert result == expected_value, \"Method 3 should handle edge case correctly\"\n\n # Add more tests for additional methods as necessary\n" }, { "path": "llm_service/test_llm_service.py", "content": "import unittest\nfrom llm_service.service import LLMService\n\nclass TestLLMService(unittest.TestCase):\n \"\"\"Unit tests for LLM service functionality.\"\"\"\n\n def setUp(self):\n \"\"\"Set up test fixtures, if any.\"\"\"\n self.llm_service = LLMService()\n\n def test_generate_response(self):\n \"\"\"Test the response generation from LLM service.\"\"\"\n input_text = \"What is the capital of France?\"\n expected_output = \"Paris\" # This should match the expected output based on the service logic\n response = self.llm_service.generate_response(input_text)\n self.assertEqual(response, expected_output,\n f\"Expected '{expected_output}' but got '{response}'\")\n\n def test_invalid_input(self):\n \"\"\"Test LLM service with invalid input.\"\"\"\n input_text = \"\"\n with self.assertRaises(ValueError):\n self.llm_service.generate_response(input_text)\n\n def test_performance(self):\n \"\"\"Test the performance of the LLM service.\"\"\"\n import time\n input_text = \"Tell me a joke\"\n start_time = time.time()\n self.llm_service.generate_response(input_text)\n duration = time.time() - start_time\n self.assertLess(duration, 1,\n \"Response time should be less than 1 second\")\n\nif __name__ == '__main__':\n unittest.main()" }, { "path": "llm_service/test_llm_service_integration.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom llm_service.service import app\n\n@pytest.fixture(scope=\"module\")\ndef test_client():\n \"\"\"Fixture to create a test client for the FastAPI app.\"\"\"\n client = TestClient(app)\n yield client\n\n\ndef test_llm_service_integration(test_client):\n \"\"\"Integration tests for LLM service with external APIs.\"\"\"\n # Example test case for LLM service\n response = test_client.post(\"/llm_service/endpoint\", json={\n \"input_data\": \"Test input\"\n })\n assert response.status_code == 200\n assert \"output_data\" in response.json()\n assert response.json()[\"output_data\"] == \"Expected output\" # Replace with actual expected output\n\n # Additional tests can be added here to cover more scenarios\n\n \ndef test_llm_service_error_handling(test_client):\n \"\"\"Test error handling in LLM service.\"\"\"\n response = test_client.post(\"/llm_service/endpoint\", json={\n \"input_data\": \"Invalid data\"\n })\n assert response.status_code == 400\n assert \"error\" in response.json() # Ensure response has error key\n" }, { "path": "llm_service/test_service.py", "content": "import pytest\nfrom llm_service.service import LLMService\n\n\n@pytest.fixture\ndef llm_service():\n \"\"\"Fixture for LLMService instance.\"\"\"\n return LLMService()\n\n\ndef test_llm_service_integration(llm_service):\n \"\"\"Test LLM service integration with valid input.\"\"\"\n response = llm_service.process_request({\n 'input_data': 'Test input for LLM',\n 'parameters': {'max_tokens': 50}\n })\n assert response is not None, \"Expected a response from LLM service\"\n assert 'output_data' in response, \"Response should contain 'output_data' key\"\n\n\ndef test_llm_service_error_handling(llm_service):\n \"\"\"Test LLM service integration with invalid input.\"\"\"\n with pytest.raises(ValueError):\n llm_service.process_request({\n 'input_data': '', # Invalid input\n 'parameters': {'max_tokens': 50}\n })\n\n\n@pytest.mark.parametrize('input_data, expected_output', [\n ('Hello, world!', 'Expected output for Hello'),\n ('Goodbye!', 'Expected output for Goodbye')\n])\ndef test_llm_service_multiple_cases(llm_service, input_data, expected_output):\n \"\"\"Test LLM service with multiple input cases.\"\"\"\n response = llm_service.process_request({\n 'input_data': input_data,\n 'parameters': {'max_tokens': 50}\n })\n assert response['output_data'] == expected_output,\n f\"Expected {expected_output} but got {response['output_data']}\"" }, { "path": "llm_service/usage_examples.md", "content": "# Usage Examples for LLM Service Endpoints\n\nThis document provides examples of how to use the LLM (Large Language Model) service endpoints exposed by the API. The LLM service is designed to facilitate interactions with advanced AI functionalities, including text generation, summarization, and more.\n\n## Endpoint: Generate Text\n\n### Request\nTo generate text using the LLM service, send a POST request to the following endpoint:\n\n```http\nPOST /api/llm/generate\n```\n\n### Sample Request Body\n```json\n{\n \"prompt\": \"Once upon a time in a distant galaxy...\",\n \"max_tokens\": 150,\n \"temperature\": 0.7\n}\n```\n\n### Example using Python's `requests` library\n```python\nimport requests\n\nurl = \"http://localhost:8000/api/llm/generate\"\nheaders = {\"Content-Type\": \"application/json\"}\n\npayload = {\n \"prompt\": \"Once upon a time in a distant galaxy...\",\n \"max_tokens\": 150,\n \"temperature\": 0.7\n}\n\nresponse = requests.post(url, json=payload, headers=headers)\n\nif response.status_code == 200:\n result = response.json()\n print(\"Generated Text:\", result['text'])\nelse:\n print(\"Error:\", response.status_code, response.text)\n```\n\n## Endpoint: Summarize Text\n\n### Request\nTo summarize a given text, send a POST request to:\n\n```http\nPOST /api/llm/summarize\n```\n\n### Sample Request Body\n```json\n{\n \"text\": \"The quick brown fox jumps over the lazy dog. This sentence is often used as a pangram in English, demonstrating the usage of every letter in the alphabet.\",\n \"max_tokens\": 50\n}\n```\n\n### Example using Python's `requests` library\n```python\nimport requests\n\nurl = \"http://localhost:8000/api/llm/summarize\"\nheaders = {\"Content-Type\": \"application/json\"}\n\npayload = {\n \"text\": \"The quick brown fox jumps over the lazy dog. This sentence is often used as a pangram in English, demonstrating the usage of every letter in the alphabet.\",\n \"max_tokens\": 50\n}\n\nresponse = requests.post(url, json=payload, headers=headers)\n\nif response.status_code == 200:\n result = response.json()\n print(\"Summary:\", result['summary'])\nelse:\n print(\"Error:\", response.status_code, response.text)\n```\n\n## Conclusion\nThese examples demonstrate how to effectively interact with the LLM service endpoints. Ensure that the API is running and accessible at the specified URL before making requests. Adjust the `max_tokens` and `temperature` parameters as needed to tailor the output to your specific requirements." }, { "path": "main.py", "content": "\"\"\"Main application module for HAGAME AI Engine.\"\"\"\n\nfrom fastapi import FastAPI\nfrom fastapi.middleware.cors import CORSMiddleware\nimport uvicorn\nimport logging\n\nfrom api.routers import auth, users, games, ai_engine\nfrom core.config import settings\n\n# Configure logging\nlogging.basicConfig(\n level=logging.INFO,\n format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'\n)\nlogger = logging.getLogger(__name__)\n\napp = FastAPI(\n title=\"HAGAME AI Engine\",\n description=\"Advanced AI system for game environments\",\n version=\"0.1.0\"\n)\n\n# Configure CORS\napp.add_middleware(\n CORSMiddleware,\n allow_origins=settings.CORS_ORIGINS,\n allow_credentials=True,\n allow_methods=[\"*\"],\n allow_headers=[\"*\"],\n)\n\n# Include routers\napp.include_router(auth.router)\napp.include_router(users.router)\napp.include_router(games.router)\napp.include_router(ai_engine.router)\n\n\n@app.on_event(\"startup\")\nasync def startup_event():\n \"\"\"Initialize services on application startup.\"\"\"\n logger.info(\"Starting HAGAME AI Engine\")\n\n\n@app.on_event(\"shutdown\")\nasync def shutdown_event():\n \"\"\"Cleanup on application shutdown.\"\"\"\n logger.info(\"Shutting down HAGAME AI Engine\")\n\n\n@app.get(\"/\")\nasync def root():\n \"\"\"Root endpoint.\"\"\"\n return {\n \"name\": \"HAGAME AI Engine\",\n \"version\": \"0.1.0\",\n \"status\": \"running\"\n }\n\nif __name__ == \"__main__\":\n uvicorn.run(\n \"main:app\",\n host=settings.HOST,\n port=settings.PORT,\n reload=settings.DEBUG\n )\n" }, { "path": "models/__init__.py", "content": " " }, { "path": "models/ai_model.py", "content": "import uuid\nfrom sqlalchemy import String, Text, Column, Integer, JSON\nfrom sqlalchemy.orm import Mapped, mapped_column\nfrom sqlalchemy.dialects.postgresql import UUID, JSONB\nfrom models.user import Base\n\n\nclass AIModel(Base):\n \"\"\"AIModel model for storing AI model configuration and metadata.\"\"\"\n __tablename__ = \"ai_models\"\n\n id = Column(Integer, primary_key=True, index=True)\n name = Column(String, nullable=False, unique=True)\n description = Column(String, nullable=True)\n config = Column(JSON, nullable=False)\n metadata = Column(JSON, nullable=True)\n file_path = Column(String, nullable=True)\n created_at = Column(String, nullable=False)\n updated_at = Column(String, nullable=True)\n" }, { "path": "models/cognitive_profile.py", "content": "import uuid\nfrom datetime import datetime\nfrom sqlalchemy import DateTime, ForeignKey\nfrom sqlalchemy.orm import Mapped, mapped_column\nfrom sqlalchemy.dialects.postgresql import UUID, JSONB\nfrom models.user import Base\n\n\nclass CognitiveProfile(Base):\n \"\"\"CognitiveProfile model for storing user cognitive data.\"\"\"\n __tablename__ = \"cognitive_profiles\"\n\n id: Mapped[uuid.UUID] = mapped_column(\n UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)\n user_id: Mapped[uuid.UUID] = mapped_column(\n UUID(as_uuid=True), ForeignKey(\"users.id\"), unique=True, nullable=False)\n profile_data: Mapped[dict] = mapped_column(\n JSONB, nullable=False, default=dict)\n last_updated: Mapped[datetime] = mapped_column(\n DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)\n" }, { "path": "models/game_definition.py", "content": "import uuid\nfrom sqlalchemy import String, Text\nfrom sqlalchemy.orm import Mapped, mapped_column\nfrom sqlalchemy.dialects.postgresql import UUID, JSONB\nfrom models.user import Base\n\n\nclass GameDefinition(Base):\n \"\"\"GameDefinition model for storing game metadata and rules.\"\"\"\n __tablename__ = \"game_definitions\"\n\n id: Mapped[uuid.UUID] = mapped_column(\n UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)\n name: Mapped[str] = mapped_column(\n String(100), unique=True, nullable=False, index=True)\n description: Mapped[str] = mapped_column(Text, nullable=False)\n rules_config: Mapped[dict] = mapped_column(\n JSONB, nullable=False, default=dict)\n version: Mapped[str] = mapped_column(String(20), nullable=False)\n" }, { "path": "models/game_instance.py", "content": "import uuid\nfrom datetime import datetime\nfrom sqlalchemy import String, Integer, DateTime, ForeignKey\nfrom sqlalchemy.orm import Mapped, mapped_column\nfrom sqlalchemy.dialects.postgresql import UUID, JSONB\nfrom models.user import Base\n\n\nclass GameInstance(Base):\n \"\"\"GameInstance model for storing game session data.\"\"\"\n __tablename__ = \"game_instances\"\n\n id: Mapped[uuid.UUID] = mapped_column(\n UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)\n game_definition_id: Mapped[uuid.UUID] = mapped_column(\n UUID(as_uuid=True), ForeignKey(\"game_definitions.id\"), nullable=False)\n user_id: Mapped[uuid.UUID | None] = mapped_column(\n UUID(as_uuid=True), ForeignKey(\"users.id\"), nullable=True)\n status: Mapped[str] = mapped_column(\n String(20), nullable=False, default=\"pending\")\n game_state: Mapped[dict] = mapped_column(\n JSONB, nullable=False, default=dict)\n start_time: Mapped[datetime] = mapped_column(\n DateTime, default=datetime.utcnow, nullable=False)\n end_time: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)\n score: Mapped[int | None] = mapped_column(Integer, nullable=True)\n ai_model_id: Mapped[uuid.UUID | None] = mapped_column(\n UUID(as_uuid=True), nullable=True)\n" }, { "path": "models/user.py", "content": "import uuid\nfrom datetime import datetime\nfrom sqlalchemy import String, DateTime\nfrom sqlalchemy.orm import Mapped, mapped_column, declarative_base\nfrom sqlalchemy.dialects.postgresql import UUID\n\nBase = declarative_base()\n\n\nclass User(Base):\n \"\"\"User model for authentication and profile management.\"\"\"\n __tablename__ = \"users\"\n\n id: Mapped[uuid.UUID] = mapped_column(\n UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)\n username: Mapped[str] = mapped_column(\n String(50), unique=True, nullable=False, index=True)\n email: Mapped[str] = mapped_column(\n String(255), unique=True, nullable=False, index=True)\n hashed_password: Mapped[str] = mapped_column(String(255), nullable=False)\n created_at: Mapped[datetime] = mapped_column(\n DateTime, default=datetime.utcnow, nullable=False)\n updated_at: Mapped[datetime] = mapped_column(\n DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)\n" }, { "path": "pyproject.toml", "content": "[project]\nname = \"hagamesai\"\nversion = \"0.1.0\"\ndescription = \"HAGAME AI Engine - An advanced game AI system\"\nauthors = [{ name = \"HAGAME Team\", email = \"team@hagame.ai\" }]\ndependencies = [\n \"fastapi>=0.68.0\",\n \"uvicorn>=0.15.0\",\n \"sqlalchemy>=1.4.23\",\n \"alembic>=1.7.1\",\n \"pydantic>=1.8.2\",\n \"python-jose[cryptography]>=3.3.0\",\n \"passlib[bcrypt]>=1.7.4\",\n \"python-multipart>=0.0.5\",\n \"numpy>=1.21.2\",\n \"scipy>=1.7.1\",\n \"scikit-learn>=0.24.2\",\n \"pandas>=1.3.2\",\n \"celery>=5.1.2\",\n \"redis>=3.5.3\",\n \"python-dotenv>=0.19.0\",\n \"structlog>=21.1.0\",\n \"psycopg2-binary>=2.9.1\",\n \"asyncpg>=0.24.0\",\n \"aiohttp>=3.7.4\",\n \"httpx>=0.18.2\",\n \"pyyaml>=6.0.2\",\n]\nrequires-python = \">=3.10\"\nreadme = \"README.md\"\nlicense = { file = \"LICENSE\" }\n\n[build-system]\nrequires = [\"pdm-backend\"]\nbuild-backend = \"pdm.backend\"\n\n[tool.pdm.dev-dependencies]\ntest = [\"pytest>=6.2.5\", \"pytest-asyncio>=0.15.1\", \"pytest-cov>=2.12.1\", \"httpx>=0.18.2\"]\n\n[tool.pytest.ini_options]\nasyncio_mode = \"auto\"\ntestpaths = [\"tests\"]\npython_files = [\"test_*.py\", \"*_test.py\"]\n\n[tool.black]\nline-length = 88\ntarget-version = [\"py310\"]\ninclude = '\\.pyi?$'\n\n[tool.isort]\nprofile = \"black\"\nmulti_line_output = 3\n" }, { "path": "schemas/__init__.py", "content": " " }, { "path": "schemas/ai_engine.py", "content": "\"\"\"Pydantic schemas for AI Engine data models.\"\"\"\n\nfrom typing import Dict, List, Any, Optional\nfrom pydantic import BaseModel, Field\nfrom datetime import datetime\n\n\nclass GameState(BaseModel):\n \"\"\"Schema for game state data.\"\"\"\n game_id: str\n state_type: str = Field(...,\n description=\"Type of game state (e.g., 'in_progress', 'completed')\")\n player_states: Dict[str, Dict[str, Any]\n ] = Field(..., description=\"States of all players\")\n game_variables: Dict[str,\n Any] = Field(..., description=\"Game-specific variables\")\n timestamp: datetime = Field(default_factory=datetime.utcnow)\n metadata: Optional[Dict[str, Any]] = Field(\n default=None, description=\"Additional metadata\")\n\n\nclass PredictionRequest(BaseModel):\n \"\"\"Schema for prediction request.\"\"\"\n game_state: GameState\n context: Optional[Dict[str, Any]] = Field(\n default=None, description=\"Additional context\")\n\n\nclass PredictionResponse(BaseModel):\n \"\"\"Schema for prediction response.\"\"\"\n predictions: Dict[str, Any] = Field(...,\n description=\"Predicted outcomes and actions\")\n cognitive_state: Dict[str,\n Any] = Field(..., description=\"Current cognitive model state\")\n uncertainty: Dict[str, Any] = Field(..., description=\"Uncertainty factors\")\n collective_wisdom: Dict[str,\n Any] = Field(..., description=\"Aggregated insights\")\n explanations: Dict[str, str] = Field(...,\n description=\"Natural language explanations\")\n confidence_scores: Dict[str,\n float] = Field(..., description=\"Confidence levels\")\n timestamp: datetime = Field(default_factory=datetime.utcnow)\n\n\nclass FeedbackRequest(BaseModel):\n \"\"\"Schema for feedback data.\"\"\"\n game_id: str\n prediction_accuracy: Dict[str,\n float] = Field(..., description=\"Accuracy of predictions\")\n cognitive_accuracy: Dict[str,\n float] = Field(..., description=\"Accuracy of cognitive model\")\n uncertainty_accuracy: Dict[str, float] = Field(\n ..., description=\"Accuracy of uncertainty estimates\")\n wisdom_relevance: Dict[str, float] = Field(\n ..., description=\"Relevance of collective insights\")\n explanation_clarity: Dict[str,\n float] = Field(..., description=\"Clarity of explanations\")\n context: Optional[Dict[str, Any]] = Field(\n default=None, description=\"Additional context\")\n\n\nclass CognitiveProfile(BaseModel):\n \"\"\"Schema for cognitive profile data.\"\"\"\n player_id: str\n learning_style: str = Field(..., description=\"Identified learning style\")\n decision_making: Dict[str,\n float] = Field(..., description=\"Decision-making metrics\")\n attention_patterns: Dict[str,\n float] = Field(..., description=\"Attention-related metrics\")\n skill_levels: Dict[str,\n float] = Field(..., description=\"Various skill measurements\")\n adaptability: float = Field(..., description=\"Overall adaptability score\")\n last_updated: datetime = Field(default_factory=datetime.utcnow)\n metadata: Optional[Dict[str, Any]] = Field(\n default=None, description=\"Additional metadata\")\n\n\nclass CollectiveKnowledge(BaseModel):\n \"\"\"Schema for collective wisdom data.\"\"\"\n game_id: str\n patterns: Dict[str, float] = Field(..., description=\"Identified patterns\")\n strategies: Dict[str,\n float] = Field(..., description=\"Effective strategies\")\n meta_insights: Dict[str,\n Any] = Field(..., description=\"Meta-level insights\")\n confidence_scores: Dict[str,\n float] = Field(..., description=\"Confidence in insights\")\n timestamp: datetime = Field(default_factory=datetime.utcnow)\n\n\nclass UncertaintyFactors(BaseModel):\n \"\"\"Schema for uncertainty data.\"\"\"\n game_id: str\n player_uncertainty: Dict[str, float] = Field(\n ..., description=\"Player-related uncertainties\")\n game_state_uncertainty: Dict[str, float] = Field(\n ..., description=\"Game state uncertainties\")\n environmental_uncertainty: Dict[str, float] = Field(\n ..., description=\"Environmental uncertainties\")\n composite_uncertainty: float = Field(...,\n description=\"Overall uncertainty score\")\n timestamp: datetime = Field(default_factory=datetime.utcnow)\n\n\nclass Explanation(BaseModel):\n \"\"\"Schema for AI explanations.\"\"\"\n game_id: str\n decision_explanations: Dict[str,\n str] = Field(..., description=\"Decision explanations\")\n feature_importance: Dict[str,\n float] = Field(..., description=\"Feature importance scores\")\n counterfactuals: List[Dict[str, Any]\n ] = Field(..., description=\"Counterfactual scenarios\")\n confidence_levels: Dict[str,\n float] = Field(..., description=\"Confidence in explanations\")\n timestamp: datetime = Field(default_factory=datetime.utcnow)\n\n# Response models for API endpoints\n\n\nclass CognitiveProfileResponse(BaseModel):\n \"\"\"Response model for cognitive profile endpoint.\"\"\"\n profile: CognitiveProfile\n metadata: Optional[Dict[str, Any]] = None\n\n\nclass CollectiveWisdomResponse(BaseModel):\n \"\"\"Response model for collective wisdom endpoint.\"\"\"\n knowledge: CollectiveKnowledge\n metadata: Optional[Dict[str, Any]] = None\n\n\nclass UncertaintyResponse(BaseModel):\n \"\"\"Response model for uncertainty factors endpoint.\"\"\"\n factors: UncertaintyFactors\n metadata: Optional[Dict[str, Any]] = None\n\n\nclass ExplanationResponse(BaseModel):\n \"\"\"Response model for explanations endpoint.\"\"\"\n explanation: Explanation\n metadata: Optional[Dict[str, Any]] = None\n" }, { "path": "schemas/ai_model.py", "content": "import uuid\nfrom pydantic import BaseModel, Field\nfrom typing import Optional, Dict, Any\nfrom datetime import datetime\n\n\nclass AIModelBase(BaseModel):\n name: str\n description: Optional[str] = None\n config: Dict[str, Any]\n metadata: Optional[Dict[str, Any]] = None\n file_path: Optional[str] = None\n\n\nclass AIModelCreate(AIModelBase):\n \"\"\"Schema for creating a new AI model.\"\"\"\n type: str = Field(..., max_length=50)\n version: str = Field(..., max_length=20)\n\n\nclass AIModelUpdate(BaseModel):\n name: Optional[str] = None\n description: Optional[str] = None\n config: Optional[Dict[str, Any]] = None\n metadata: Optional[Dict[str, Any]] = None\n file_path: Optional[str] = None\n\n\nclass AIModelRead(AIModelBase):\n \"\"\"Schema for reading AI model info.\"\"\"\n id: int\n created_at: datetime\n updated_at: Optional[datetime] = None\n\n class Config:\n from_attributes = True\n" }, { "path": "schemas/cognitive_profile.py", "content": "import uuid\nfrom datetime import datetime\nfrom pydantic import BaseModel, Field\n\n\nclass CognitiveProfileRead(BaseModel):\n \"\"\"Schema for reading cognitive profile info.\"\"\"\n id: uuid.UUID\n user_id: uuid.UUID\n profile_data: dict\n last_updated: datetime\n\n\nclass CognitiveProfileUpdate(BaseModel):\n \"\"\"Schema for updating cognitive profile info.\"\"\"\n profile_data: dict = Field(...)\n" }, { "path": "schemas/game_definition.py", "content": "from pydantic import BaseModel, Field\nfrom typing import List, Optional\n\nclass GameDefinition(BaseModel):\n id: int = Field(..., description=\"Unique identifier for the game definition\")\n name: str = Field(..., description=\"Name of the game\")\n description: Optional[str] = Field(None, description=\"Description of the game\")\n rules: str = Field(..., description=\"Rules of the game\")\n created_at: str = Field(..., description=\"Timestamp of when the game was created\")\n updated_at: str = Field(..., description=\"Timestamp of when the game was last updated\")\n\nclass GameDefinitionCreate(BaseModel):\n name: str = Field(..., description=\"Name of the game\")\n description: Optional[str] = Field(None, description=\"Description of the game\")\n rules: str = Field(..., description=\"Rules of the game\")\n\nclass GameDefinitionUpdate(BaseModel):\n name: Optional[str] = Field(None, description=\"Name of the game\")\n description: Optional[str] = Field(None, description=\"Description of the game\")\n rules: Optional[str] = Field(None, description=\"Rules of the game\")\n\nclass GameDefinitionResponse(BaseModel):\n id: int\n name: str\n description: Optional[str]\n rules: str\n created_at: str\n updated_at: str\n\n class Config:\n orm_mode = True\n" }, { "path": "schemas/game_instance.py", "content": "from pydantic import BaseModel, Field\nfrom typing import Optional\n\nclass GameInstance(BaseModel):\n id: int = Field(..., description=\"Unique identifier for the game instance\")\n game_id: int = Field(..., description=\"Identifier for the associated game\")\n user_id: int = Field(..., description=\"Identifier for the user playing this game instance\")\n status: str = Field(..., description=\"Current status of the game instance (e.g., 'in_progress', 'completed')\")\n created_at: str = Field(..., description=\"Timestamp when the game instance was created\")\n updated_at: Optional[str] = Field(None, description=\"Timestamp when the game instance was last updated\")\n\n class Config:\n schema_extra = {\n \"example\": {\n \"id\": 1,\n \"game_id\": 101,\n \"user_id\": 201,\n \"status\": \"in_progress\",\n \"created_at\": \"2023-01-01T12:00:00Z\",\n \"updated_at\": \"2023-01-01T12:30:00Z\"\n }\n }\n" }, { "path": "schemas/llm_request.py", "content": "from pydantic import BaseModel, Field\nfrom typing import Optional\n\nclass LLMRequest(BaseModel):\n prompt: str = Field(..., description=\"The input prompt for the LLM.\")\n model: str = Field(..., description=\"The name of the LLM model to use.\")\n max_tokens: Optional[int] = Field(100, ge=1, description=\"The maximum number of tokens to generate.\")\n temperature: Optional[float] = Field(0.7, ge=0.0, le=1.0, description=\"Sampling temperature for the model.\")\n top_p: Optional[float] = Field(1.0, ge=0.0, le=1.0, description=\"Cumulative probability for top-p sampling.\")\n stop: Optional[list] = Field(None, description=\"List of stop sequences for the LLM.\")\n\n class Config:\n schema_extra = {\n \"example\": {\n \"prompt\": \"What is the capital of France?\",\n \"model\": \"gpt-3.5-turbo\",\n \"max_tokens\": 50,\n \"temperature\": 0.5,\n \"top_p\": 1.0,\n \"stop\": [\"\\n\"]\n }\n }\n" }, { "path": "schemas/llm_response.py", "content": "from pydantic import BaseModel, Field\nfrom typing import Any, List, Optional\n\nclass LLMResponse(BaseModel):\n id: str = Field(..., description=\"The unique identifier for the response\")\n prompt: str = Field(..., description=\"The input prompt given to the LLM\")\n response: str = Field(..., description=\"The generated response from the LLM\")\n tokens_used: int = Field(..., description=\"The number of tokens used in the response\")\n completion_time: float = Field(..., description=\"Time taken to generate the response in seconds\")\n metadata: Optional[dict[str, Any]] = Field(None, description=\"Optional metadata related to the response\")\n\nclass LLMResponseList(BaseModel):\n responses: List[LLMResponse] = Field(..., description=\"List of LLM responses\")\n" }, { "path": "schemas/task.py", "content": "from pydantic import BaseModel\n\n\nclass TaskTrigger(BaseModel):\n \"\"\"Schema for triggering an example task.\"\"\"\n seconds: int\n\n\nclass TaskStatus(BaseModel):\n \"\"\"Schema for returning task status.\"\"\"\n task_id: str\n status: str\n result: str | None = None\n" }, { "path": "schemas/user.py", "content": "import uuid\nfrom datetime import datetime\nfrom pydantic import BaseModel, EmailStr, Field\n\n\nclass UserCreate(BaseModel):\n \"\"\"Schema for user registration.\"\"\"\n username: str = Field(..., max_length=50)\n email: EmailStr\n password: str = Field(..., min_length=8)\n\n\nclass UserLogin(BaseModel):\n \"\"\"Schema for user login.\"\"\"\n email: EmailStr\n password: str\n\n\nclass UserRead(BaseModel):\n \"\"\"Schema for reading user info.\"\"\"\n id: uuid.UUID\n username: str\n email: EmailStr\n created_at: datetime\n updated_at: datetime\n\n class Config:\n orm_mode = True\n\n\nclass UserUpdate(BaseModel):\n \"\"\"Schema for updating user info.\"\"\"\n username: str | None = None\n email: EmailStr | None = None\n password: str | None = Field(default=None, min_length=8)\n" }, { "path": "schemas/user_profile.py", "content": "from pydantic import BaseModel, EmailStr\nfrom typing import Optional\n\nclass UserProfile(BaseModel):\n id: int\n user_id: int # Foreign key to associate with User\n display_name: str\n bio: Optional[str] = None\n email: Optional[EmailStr] = None # Email validation\n profile_picture: Optional[str] = None # URL to profile picture\n\n class Config:\n orm_mode = True # Allows compatibility with ORM\n\nclass UserProfileCreate(BaseModel):\n user_id: int\n display_name: str\n bio: Optional[str] = None\n email: Optional[EmailStr] = None\n profile_picture: Optional[str] = None\n\nclass UserProfileUpdate(BaseModel):\n display_name: Optional[str] = None\n bio: Optional[str] = None\n email: Optional[EmailStr] = None\n profile_picture: Optional[str] = None\n" }, { "path": "tests/integration/test_ai_engine.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom llm_service.service import app\n\n# Initialize the test client\nclient = TestClient(app)\n\n@pytest.fixture\ndef sample_data():\n # Sample input data for the AI engine services\n return {\n 'input': 'sample input',\n 'parameters': {'param1': 'value1', 'param2': 'value2'}\n }\n\ndef test_ai_engine_service_integration(sample_data):\n # Test for the AI engine service integration\n response = client.post('/api/ai/engine', json=sample_data)\n assert response.status_code == 200\n assert 'output' in response.json()\n\ndef test_ai_engine_service_error_handling():\n # Test for error handling in the AI engine service\n response = client.post('/api/ai/engine', json={}) # Missing required data\n assert response.status_code == 422 # Unprocessable Entity\n assert 'detail' in response.json()\n\n# Additional tests can be added here to cover more scenarios\n" }, { "path": "tests/integration/test_ai_engine_integration.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom core.ai_engine import app # Assuming your FastAPI app is in core/ai_engine.py\n\n@pytest.fixture\ndef client():\n \"\"\"Create a test client for the FastAPI app.\"\"\"\n return TestClient(app)\n\n\ndef test_ai_engine_integration(client):\n \"\"\"Test integration of AI engine with valid input.\"\"\"\n response = client.post(\"/api/llm/engine\", json={\n \"input_data\": \"Sample input for AI engine\"\n })\n assert response.status_code == 200\n assert \"output_data\" in response.json()\n\n\ndef test_ai_engine_integration_invalid_data(client):\n \"\"\"Test integration of AI engine with invalid input.\"\"\"\n response = client.post(\"/api/llm/engine\", json={\n \"input_data\": \"\"\n })\n assert response.status_code == 422 # Unprocessable Entity\n assert \"detail\" in response.json()\n\n\ndef test_ai_engine_integration_error_handling(client):\n \"\"\"Test AI engine's error handling with incorrect endpoint.\"\"\"\n response = client.post(\"/api/llm/non_existing_endpoint\", json={\n \"input_data\": \"Sample input\"\n })\n assert response.status_code == 404 # Not Found\n assert \"detail\" in response.json()" }, { "path": "tests/integration/test_auth.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom api.auth import app\n\n# Test client for the FastAPI app\nclient = TestClient(app)\n\n@pytest.mark.parametrize(\"username, password, expected_status\", [\n (\"testuser\", \"testpass\", 200), # Successful login\n (\"invaliduser\", \"testpass\", 401), # Invalid user\n (\"testuser\", \"wrongpass\", 401), # Invalid password\n])\ndef test_login(username, password, expected_status):\n response = client.post(\"/auth/login\", json={\n \"username\": username,\n \"password\": password\n })\n assert response.status_code == expected_status\n\n\ndef test_register():\n response = client.post(\"/auth/register\", json={\n \"username\": \"newuser\",\n \"password\": \"newpass\",\n \"email\": \"newuser@example.com\"\n })\n assert response.status_code == 201\n assert \"access_token\" in response.json()\n\n\ndef test_register_existing_user():\n response = client.post(\"/auth/register\", json={\n \"username\": \"testuser\",\n \"password\": \"testpass\",\n \"email\": \"testuser@example.com\"\n })\n assert response.status_code == 400 # User already exists\n\n" }, { "path": "tests/integration/test_auth_integration.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom api.auth import app\n\n@pytest.fixture\ndef client():\n return TestClient(app)\n\n@pytest.fixture\ndef create_user(client):\n response = client.post('/auth/register', json={\n 'username': 'test_user',\n 'password': 'test_pass',\n 'email': 'test_user@example.com'\n })\n return response.json()\n\n@pytest.fixture\ndef login_user(client, create_user):\n response = client.post('/auth/login', json={\n 'username': 'test_user',\n 'password': 'test_pass'\n })\n return response.json()\n\ndef test_user_registration(client):\n response = client.post('/auth/register', json={\n 'username': 'new_user',\n 'password': 'new_pass',\n 'email': 'new_user@example.com'\n })\n assert response.status_code == 201\n assert 'access_token' in response.json()\n\n\ndef test_user_login(client, create_user):\n response = client.post('/auth/login', json={\n 'username': 'test_user',\n 'password': 'test_pass'\n })\n assert response.status_code == 200\n assert 'access_token' in response.json()\n\n\ndef test_login_with_invalid_credentials(client):\n response = client.post('/auth/login', json={\n 'username': 'wrong_user',\n 'password': 'wrong_pass'\n })\n assert response.status_code == 401\n assert 'detail' in response.json()\n\n\ndef test_login_without_password(client):\n response = client.post('/auth/login', json={\n 'username': 'test_user'\n })\n assert response.status_code == 422\n assert 'detail' in response.json()\n\n\ndef test_registration_with_existing_username(client):\n client.post('/auth/register', json={\n 'username': 'existing_user',\n 'password': 'pass',\n 'email': 'existing_user@example.com'\n }) # Register first time\n response = client.post('/auth/register', json={\n 'username': 'existing_user',\n 'password': 'pass',\n 'email': 'existing_user2@example.com'\n })\n assert response.status_code == 400\n assert 'detail' in response.json()" }, { "path": "tests/integration/test_game_integration.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom main import app\n\n# Create a test client using the FastAPI app\nclient = TestClient(app)\n\n\n@pytest.fixture\ndef create_game():\n # Sample payload for creating a game\n payload = {\n \"name\": \"Test Game\",\n \"description\": \"A game for testing purposes\",\n \"rules\": \"Test rules for the game.\"\n }\n response = client.post(\"/games/\", json=payload)\n assert response.status_code == 201\n return response.json()\n\n\ndef test_create_game(create_game):\n game = create_game\n assert \"id\" in game\n assert game[\"name\"] == \"Test Game\"\n assert game[\"description\"] == \"A game for testing purposes\"\n\n\ndef test_get_game(create_game):\n game_id = create_game[\"id\"]\n response = client.get(f\"/games/{game_id}\")\n assert response.status_code == 200\n game = response.json()\n assert game[\"id\"] == game_id\n assert game[\"name\"] == \"Test Game\"\n\n\ndef test_update_game(create_game):\n game_id = create_game[\"id\"]\n update_payload = {\n \"name\": \"Updated Game\",\n \"description\": \"An updated description for the game.\"\n }\n response = client.put(f\"/games/{game_id}\", json=update_payload)\n assert response.status_code == 200\n updated_game = response.json()\n assert updated_game[\"name\"] == \"Updated Game\"\n\n\ndef test_delete_game(create_game):\n game_id = create_game[\"id\"]\n response = client.delete(f\"/games/{game_id}\")\n assert response.status_code == 204\n # Ensure the game was deleted\n response = client.get(f\"/games/{game_id}\")\n assert response.status_code == 404\n" }, { "path": "tests/integration/test_game_management_integration.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom main import app\n\n# Initialize the test client\nclient = TestClient(app)\n\n@pytest.fixture\ndef game_data():\n return {\n \"name\": \"Test Game\",\n \"description\": \"A game for testing purposes\",\n \"rules\": \"Test rules for the game\",\n \"max_players\": 4\n }\n\ndef test_create_game(game_data):\n response = client.post(\"/games/\", json=game_data)\n assert response.status_code == 201\n data = response.json()\n assert data[\"name\"] == game_data[\"name\"]\n assert \"id\" in data\n\n\ndef test_get_game(game_data):\n # First, create a game to retrieve\n create_response = client.post(\"/games/\", json=game_data)\n game_id = create_response.json()[\"id\"]\n\n # Now retrieve the created game\n response = client.get(f\"/games/{game_id}\")\n assert response.status_code == 200\n data = response.json()\n assert data[\"id\"] == game_id\n assert data[\"name\"] == game_data[\"name\"]\n\n\ndef test_update_game(game_data):\n # First, create a game to update\n create_response = client.post(\"/games/\", json=game_data)\n game_id = create_response.json()[\"id\"]\n updated_data = {\"name\": \"Updated Game\", \"description\": \"Updated description\"}\n\n # Now update the created game\n response = client.put(f\"/games/{game_id}\", json=updated_data)\n assert response.status_code == 200\n data = response.json()\n assert data[\"name\"] == updated_data[\"name\"]\n\n\ndef test_delete_game(game_data):\n # First, create a game to delete\n create_response = client.post(\"/games/\", json=game_data)\n game_id = create_response.json()[\"id\"]\n\n # Now delete the created game\n response = client.delete(f\"/games/{game_id}\")\n assert response.status_code == 204\n\n # Ensure the game no longer exists\n response = client.get(f\"/games/{game_id}\")\n assert response.status_code == 404\n" }, { "path": "tests/integration/test_games.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom api.games import app\n\n# Initialize the test client\nclient = TestClient(app)\n\n@pytest.mark.parametrize(\"game_data\", [\n {\"name\": \"Chess\", \"description\": \"A classic strategy game.\"},\n {\"name\": \"Checkers\", \"description\": \"A classic board game for two players.\"},\n])\ndef test_create_game(game_data):\n response = client.post(\"/games/\", json=game_data)\n assert response.status_code == 201\n assert \"id\" in response.json()\n assert response.json()[\"name\"] == game_data[\"name\"]\n\n\ndef test_get_all_games():\n response = client.get(\"/games/\")\n assert response.status_code == 200\n assert isinstance(response.json(), list)\n\n\ndef test_get_game_by_id():\n game_id = 1 # assuming a game with ID 1 exists\n response = client.get(f\"/games/{game_id}\")\n assert response.status_code == 200\n assert \"name\" in response.json()\n\n\ndef test_update_game():\n game_id = 1 # assuming a game with ID 1 exists\n updated_data = {\"name\": \"Updated Chess\", \"description\": \"An updated description for the chess game.\"}\n response = client.put(f\"/games/{game_id}\", json=updated_data)\n assert response.status_code == 200\n assert response.json()[\"name\"] == updated_data[\"name\"]\n\n\ndef test_delete_game():\n game_id = 1 # assuming a game with ID 1 exists\n response = client.delete(f\"/games/{game_id}\")\n assert response.status_code == 204\n # Check if game is deleted\n response = client.get(f\"/games/{game_id}\")\n assert response.status_code == 404\n" }, { "path": "tests/integration/test_llm.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom api.llm import app\n\n@pytest.fixture(scope=\"module\")\ndef test_client():\n \"\"\"Fixture to create a test client for the FastAPI app.\"\"\"\n client = TestClient(app)\n return client\n\n\ndef test_llm_endpoint(client):\n \"\"\"Test the LLM service API endpoint.\"\"\"\n response = client.post(\"/llm/endpoint\", json={\n \"input\": \"Test input data\"\n })\n assert response.status_code == 200,\n assert \"output\" in response.json(),\n assert response.json()[\"output\"] == \"Expected output\" # Replace with expected output\n\n\ndef test_llm_invalid_input(client):\n \"\"\"Test LLM service API with invalid input.\"\"\"\n response = client.post(\"/llm/endpoint\", json={\n \"input\": 12345 # Invalid input type\n })\n assert response.status_code == 422,\n assert \"detail\" in response.json(),\n assert response.json()[\"detail\"] == \"Input validation error\" # Replace with actual error message\n" }, { "path": "tests/integration/test_llm_integration.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom api.llm import app\n\n# Initialize the test client for the FastAPI app\nclient = TestClient(app)\n\n@pytest.fixture(scope=\"module\")\ndef setup_module():\n # Code to run before tests in this module (e.g., setup database)\n yield # This will run after tests in this module\n # Code to run after tests in this module (e.g., teardown database)\n\n\ndef test_llm_integration_setup(setup_module):\n \"\"\"Test the LLM API setup and basic connectivity\"\"\"\n response = client.get(\"/llm/\")\n assert response.status_code == 200\n assert \"message\" in response.json()\n\n\ndef test_llm_integration_prediction(setup_module):\n \"\"\"Test LLM prediction endpoint\"\"\"\n payload = {\"input_text\": \"What is AI?\"}\n response = client.post(\"/llm/predict\", json=payload)\n assert response.status_code == 200\n assert \"prediction\" in response.json()\n\n\ndef test_llm_integration_error_handling(setup_module):\n \"\"\"Test LLM prediction endpoint with invalid input\"\"\"\n payload = {\"input_text\": \"\"}\n response = client.post(\"/llm/predict\", json=payload)\n assert response.status_code == 422 # Unprocessable Entity\n assert \"detail\" in response.json() # Validate error response\n\n\ndef test_llm_integration_performance(setup_module):\n \"\"\"Test LLM prediction performance\"\"\"\n import time\n payload = {\"input_text\": \"Explain quantum computing.\"}\n start_time = time.time()\n response = client.post(\"/llm/predict\", json=payload)\n end_time = time.time()\n assert response.status_code == 200\n assert (end_time - start_time) < 2 # Ensure response time is under 2 seconds\n" }, { "path": "tests/integration/test_llm_service.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom llm_service.service import app\n\n# Test client for the FastAPI application\nclient = TestClient(app)\n\n@pytest.mark.parametrize(\"input_data, expected_status\", [\n ({\"prompt\": \"What is AI?\"}, 200),\n ({\"prompt\": \"\"}, 422), # Invalid input case\n])\ndef test_llm_service(input_data, expected_status):\n response = client.post(\"/llm/service\", json=input_data)\n assert response.status_code == expected_status\n\n# Add more tests to cover different scenarios\n\ndef test_llm_service_response_format():\n input_data = {\"prompt\": \"Explain quantum computing.\"}\n response = client.post(\"/llm/service\", json=input_data)\n assert response.status_code == 200\n assert \"response\" in response.json() # Check if response key exists\n assert isinstance(response.json()[\"response\"], str) # Ensure the response is a string\n\n\ndef test_llm_service_invalid_method():\n response = client.get(\"/llm/service\") # Using GET instead of POST\n assert response.status_code == 405 # Method not allowed\n\n# Further tests can be implemented to validate specific LLM outputs based on known inputs\n" }, { "path": "tests/integration/test_llm_service_integration.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom llm_service.service import app\n\n# Create a TestClient for the FastAPI app\nclient = TestClient(app)\n\n@pytest.mark.parametrize(\"input_data, expected_response_code\", [\n (\"{\\\"prompt\\\": \\\"Hello, AI!\\\"}\", 200),\n (\"{\\\"prompt\\\": \\\"What is the capital of France?\\\"}\", 200),\n (\"{\\\"prompt\\\": \\\"Tell me a joke.\\\"}\", 200),\n (\"{\\\"prompt\\\": \\\"\\\"}\", 400) # Testing with empty prompt\n])\ndef test_llm_response(input_data, expected_response_code):\n response = client.post(\"/llm/respond\", json=input_data)\n assert response.status_code == expected_response_code\n\n# Additional tests for LLM service integration\n\ndef test_llm_service_integration():\n # Test a valid request\n response = client.post(\"/llm/respond\", json={\"prompt\": \"What is AI?\"})\n assert response.status_code == 200\n assert \"response\" in response.json()\n\n # Test invalid request\n response = client.post(\"/llm/respond\", json={}) # No prompt\n assert response.status_code == 400\n assert response.json() == {\"detail\": \"Prompt is required.\"}\n\n # Test LLM service with unexpected input\n response = client.post(\"/llm/respond\", json={\"prompt\": 12345})\n assert response.status_code == 422 # Unprocessable Entity\n assert \"detail\" in response.json()" }, { "path": "tests/integration/test_user_management.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom api.auth import app\n\nclient = TestClient(app)\n\n@pytest.fixture(scope=\"module\")\ndef setup_module():\n # Setup for the tests, if needed (e.g., create a test user)\n yield\n # Teardown if needed\n\n\ndef test_user_registration(setup_module):\n response = client.post(\"/api/auth/register\", json={\n \"username\": \"testuser\",\n \"password\": \"testpassword\",\n \"email\": \"testuser@example.com\"\n })\n assert response.status_code == 201\n assert response.json()[\"username\"] == \"testuser\"\n\n\ndef test_user_login(setup_module):\n response = client.post(\"/api/auth/login\", json={\n \"username\": \"testuser\",\n \"password\": \"testpassword\"\n })\n assert response.status_code == 200\n assert \"access_token\" in response.json()\n\n\ndef test_user_profile_retrieval(setup_module):\n login_response = client.post(\"/api/auth/login\", json={\n \"username\": \"testuser\",\n \"password\": \"testpassword\"\n })\n access_token = login_response.json()[\"access_token\"]\n headers = {\"Authorization\": f\"Bearer {access_token}\"}\n profile_response = client.get(\"/api/users/me\", headers=headers)\n assert profile_response.status_code == 200\n assert profile_response.json()[\"username\"] == \"testuser\"\n\n\ndef test_user_profile_update(setup_module):\n login_response = client.post(\"/api/auth/login\", json={\n \"username\": \"testuser\",\n \"password\": \"testpassword\"\n })\n access_token = login_response.json()[\"access_token\"]\n headers = {\"Authorization\": f\"Bearer {access_token}\"}\n update_response = client.put(\"/api/users/me\", headers=headers, json={\n \"email\": \"updateduser@example.com\"\n })\n assert update_response.status_code == 200\n assert update_response.json()[\"email\"] == \"updateduser@example.com\"" }, { "path": "tests/integration/test_user_management_integration.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom api.auth import app\nfrom crud.user import UserCRUD\n\n@pytest.fixture(scope=\"module\")\ndef test_client():\n client = TestClient(app)\n return client\n\n@pytest.fixture(scope=\"module\")\ndef setup_user():\n # Create a test user\n user_data = {\n \"username\": \"testuser\",\n \"email\": \"testuser@example.com\",\n \"password\": \"securepassword\"\n }\n user = UserCRUD.create_user(user_data)\n yield user # This is where the tests will run\n # Teardown logic goes here if needed\n UserCRUD.delete_user(user.id)\n\n\ndef test_user_registration(test_client):\n response = test_client.post(\"/auth/register\", json={\n \"username\": \"testuser\",\n \"email\": \"testuser@example.com\",\n \"password\": \"securepassword\"\n })\n assert response.status_code == 201\n assert \"access_token\" in response.json()\n\n\ndef test_user_login(test_client, setup_user):\n response = test_client.post(\"/auth/login\", json={\n \"username\": setup_user.username,\n \"password\": \"securepassword\"\n })\n assert response.status_code == 200\n assert \"access_token\" in response.json()\n\n\ndef test_user_profile_retrieval(test_client, setup_user):\n # Simulate login to get access token\n login_response = test_client.post(\"/auth/login\", json={\n \"username\": setup_user.username,\n \"password\": \"securepassword\"\n })\n access_token = login_response.json()[\"access_token\"]\n headers = {\n \"Authorization\": f\"Bearer {access_token}\"\n }\n\n response = test_client.get(f\"/users/{setup_user.id}\", headers=headers)\n assert response.status_code == 200\n assert response.json()[\"username\"] == setup_user.username\n\n\ndef test_user_profile_update(test_client, setup_user):\n login_response = test_client.post(\"/auth/login\", json={\n \"username\": setup_user.username,\n \"password\": \"securepassword\"\n })\n access_token = login_response.json()[\"access_token\"]\n headers = {\n \"Authorization\": f\"Bearer {access_token}\"\n }\n\n updated_data = {\n \"username\": \"updateduser\",\n \"email\": \"updated@example.com\"\n }\n response = test_client.put(f\"/users/{setup_user.id}\", json=updated_data, headers=headers)\n assert response.status_code == 200\n assert response.json()[\"username\"] == \"updateduser\"\n" }, { "path": "tests/unit/test_ai_engine.py", "content": "import pytest\nfrom core.ai_engine import cognitive, collective, prediction\n\n\ndef test_cognitive_functionality():\n # Test cognitive processing logic\n input_data = {'some_key': 'some_value'}\n result = cognitive.process(input_data)\n assert result is not None\n # Add more assertions as necessary\n\n\ndef test_collective_functionality():\n # Test collective intelligence features\n participants = ['user1', 'user2']\n result = collective.analyze(participants)\n assert isinstance(result, dict)\n assert 'analysis' in result\n\n\ndef test_prediction_algorithm():\n # Test prediction algorithm\n historical_data = {'past_events': [1, 2, 3]}\n future_prediction = prediction.forecast(historical_data)\n assert future_prediction is not None\n assert isinstance(future_prediction, float) # Assuming a float return type\n\n\n@pytest.fixture\ndef setup_data():\n # Setup any necessary data for tests\n return {'test_key': 'test_value'}\n\n\ndef test_prediction_with_setup(setup_data):\n # Test prediction algorithm with setup data\n future_prediction = prediction.forecast(setup_data)\n assert future_prediction is not None\n assert isinstance(future_prediction, float) # Assuming a float return type\n" }, { "path": "tests/unit/test_ai_engine_model.py", "content": "import pytest\nfrom core.ai_engine.base import AIModel # Adjust path based on actual model location\n\n\n@pytest.fixture\ndef sample_ai_model():\n return AIModel(name=\"Test Model\", version=\"1.0\")\n\n\ndef test_ai_model_initialization(sample_ai_model):\n assert sample_ai_model.name == \"Test Model\"\n assert sample_ai_model.version == \"1.0\"\n\n\ndef test_ai_model_prediction(sample_ai_model):\n input_data = [1, 2, 3]\n prediction = sample_ai_model.predict(input_data)\n assert prediction is not None # Assuming predict should return some output\n\n\ndef test_ai_model_update(sample_ai_model):\n new_version = \"1.1\"\n sample_ai_model.update_version(new_version)\n assert sample_ai_model.version == new_version\n\n\ndef test_ai_model_invalid_prediction(sample_ai_model):\n with pytest.raises(ValueError):\n sample_ai_model.predict(None) # Assuming it raises an error on invalid input\n\n" }, { "path": "tests/unit/test_ai_engine_service.py", "content": "import pytest\nfrom llm_service.service import AIEngineService\n\n\n@pytest.fixture\ndef ai_engine_service():\n # Setup AIEngineService instance for testing\n service = AIEngineService()\n return service\n\n\ndef test_ai_engine_service_prediction(ai_engine_service):\n # Test the prediction method with a sample input\n input_data = {'user_input': 'Tell me a joke'}\n expected_output = 'Why did the scarecrow win an award? Because he was outstanding in his field!'\n\n # Call the prediction method\n result = ai_engine_service.predict(input_data)\n\n # Assert the expected output\n assert result == expected_output, f\"Expected {expected_output}, but got {result}\"\n\n\ndef test_ai_engine_service_error_handling(ai_engine_service):\n # Test error handling in the prediction method\n input_data = {'invalid_key': 'Some input'}\n\n # Call the prediction method and validate error handling\n with pytest.raises(ValueError):\n ai_engine_service.predict(input_data)\n" }, { "path": "tests/unit/test_ai_processing.py", "content": "import pytest\nfrom core.ai_engine.ai_processing import process_data, some_other_function\n\nclass TestAIProcessing:\n def test_process_data_valid_input(self):\n # Test with valid input\n input_data = {'key': 'value'}\n expected_output = {'processed_key': 'processed_value'} # Expected output should be defined\n assert process_data(input_data) == expected_output\n\n def test_process_data_invalid_input(self):\n # Test with invalid input\n input_data = None\n with pytest.raises(ValueError):\n process_data(input_data)\n\n def test_some_other_function(self):\n # Test another function from ai_processing\n input_value = 10\n expected_result = 20 # Expected result should be defined\n assert some_other_function(input_value) == expected_result\n\n def test_some_other_function_invalid(self):\n # Test function with invalid input\n input_value = -1\n with pytest.raises(ValueError):\n some_other_function(input_value)" }, { "path": "tests/unit/test_auth.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom api.auth import app\n\n@pytest.fixture()\ndef client():\n \"\"\"Create a test client for the FastAPI application.\"\"\"\n return TestClient(app)\n\n\ndef test_user_registration(client):\n \"\"\"Test user registration endpoint.\"\"\"\n response = client.post(\"/auth/register\", json={\n \"username\": \"testuser\",\n \"password\": \"testpass\"\n })\n assert response.status_code == 201\n assert response.json() == {\"msg\": \"User created successfully\"}\n\n\ndef test_user_login(client):\n \"\"\"Test user login endpoint.\"\"\"\n response = client.post(\"/auth/login\", json={\n \"username\": \"testuser\",\n \"password\": \"testpass\"\n })\n assert response.status_code == 200\n assert \"access_token\" in response.json()\n assert \"token_type\" in response.json()\n\n\ndef test_invalid_login(client):\n \"\"\"Test login with invalid credentials.\"\"\"\n response = client.post(\"/auth/login\", json={\n \"username\": \"wronguser\",\n \"password\": \"wrongpass\"\n })\n assert response.status_code == 401\n assert response.json() == {\"detail\": \"Invalid credentials\"}" }, { "path": "tests/unit/test_cognitive_profile.py", "content": "import pytest\nfrom models.cognitive_profile import CognitiveProfile\n\n\ndef test_cognitive_profile_initialization():\n \"\"\"\n Test the initialization of the CognitiveProfile class.\n \"\"\"\n profile = CognitiveProfile(name=\"Test Profile\", attributes={\"intelligence\": 100})\n assert profile.name == \"Test Profile\"\n assert profile.attributes == {\"intelligence\": 100}\n\n\ndef test_cognitive_profile_add_attribute():\n \"\"\"\n Test adding an attribute to the CognitiveProfile.\n \"\"\"\n profile = CognitiveProfile(name=\"Test Profile\", attributes={})\n profile.add_attribute(\"creativity\", 85)\n assert profile.attributes[\"creativity\"] == 85\n\n\ndef test_cognitive_profile_remove_attribute():\n \"\"\"\n Test removing an attribute from the CognitiveProfile.\n \"\"\"\n profile = CognitiveProfile(name=\"Test Profile\", attributes={\"intelligence\": 100})\n profile.remove_attribute(\"intelligence\")\n assert \"intelligence\" not in profile.attributes\n\n\ndef test_cognitive_profile_update_attribute():\n \"\"\"\n Test updating an existing attribute in the CognitiveProfile.\n \"\"\"\n profile = CognitiveProfile(name=\"Test Profile\", attributes={\"intelligence\": 100})\n profile.update_attribute(\"intelligence\", 120)\n assert profile.attributes[\"intelligence\"] == 120\n" }, { "path": "tests/unit/test_game_definition.py", "content": "import pytest\nfrom crud.game_definition import GameDefinition\n\n\ndef test_create_game_definition():\n \"\"\"\n Test the creation of a game definition.\n \"\"\"\n game_def = GameDefinition(name=\"Test Game\", description=\"A test game\")\n assert game_def.name == \"Test Game\"\n assert game_def.description == \"A test game\"\n\n\ndef test_update_game_definition():\n \"\"\"\n Test the updating of a game definition.\n \"\"\"\n game_def = GameDefinition(name=\"Test Game\", description=\"A test game\")\n game_def.update(name=\"Updated Game\")\n assert game_def.name == \"Updated Game\"\n\n\ndef test_delete_game_definition():\n \"\"\"\n Test the deletion of a game definition.\n \"\"\"\n game_def = GameDefinition(name=\"Test Game\", description=\"A test game\")\n game_def.delete()\n assert game_def.is_deleted() is True\n\n\ndef test_game_definition_repr():\n \"\"\"\n Test the string representation of a game definition.\n \"\"\"\n game_def = GameDefinition(name=\"Test Game\", description=\"A test game\")\n assert repr(game_def) == \"GameDefinition(name='Test Game', description='A test game')\"" }, { "path": "tests/unit/test_game_instance.py", "content": "import pytest\nfrom crud.game_instance import GameInstanceCRUD # Import your CRUD operations\nfrom models.game_instance import GameInstance # Import your GameInstance model\n\n\n@pytest.fixture\ndef game_instance_data():\n return {\n \"name\": \"Test Game\",\n \"description\": \"A game for testing purposes\",\n \"status\": \"active\"\n }\n\n\ndef test_create_game_instance(game_instance_data):\n instance = GameInstanceCRUD.create(**game_instance_data)\n assert instance.id is not None\n assert instance.name == game_instance_data['name']\n assert instance.description == game_instance_data['description']\n assert instance.status == game_instance_data['status']\n\n\ndef test_read_game_instance(game_instance_data):\n instance = GameInstanceCRUD.create(**game_instance_data)\n fetched_instance = GameInstanceCRUD.read(instance.id)\n assert fetched_instance.id == instance.id\n assert fetched_instance.name == instance.name\n\n\ndef test_update_game_instance(game_instance_data):\n instance = GameInstanceCRUD.create(**game_instance_data)\n updated_data = {\"name\": \"Updated Game\"}\n updated_instance = GameInstanceCRUD.update(instance.id, **updated_data)\n assert updated_instance.name == updated_data['name']\n\n\ndef test_delete_game_instance(game_instance_data):\n instance = GameInstanceCRUD.create(**game_instance_data)\n GameInstanceCRUD.delete(instance.id)\n fetched_instance = GameInstanceCRUD.read(instance.id)\n assert fetched_instance is None # Assuming None is returned when not found\n" }, { "path": "tests/unit/test_game_management.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom api.games import app\nfrom crud.game_definition import GameDefinitionCRUD\n\n@pytest.fixture(scope=\"module\")\ndef test_client():\n client = TestClient(app)\n yield client\n\n@pytest.fixture(scope=\"module\")\ndef setup_game_definition():\n # Sample game definition to be used in tests\n game_definition = {\n \"name\": \"Sample Game\",\n \"description\": \"A sample game for testing.\",\n \"rules\": \"Sample rules\"\n }\n # Assuming there is a method to create a game definition in the CRUD\n GameDefinitionCRUD.create(game_definition)\n yield game_definition # Yield the created game definition for tests\n # Cleanup can be performed here if needed\n\n\ndef test_create_game(test_client, setup_game_definition):\n response = test_client.post(\"/games/\", json=setup_game_definition)\n assert response.status_code == 201\n assert response.json()[\"name\"] == setup_game_definition[\"name\"]\n\n\ndef test_get_games(test_client):\n response = test_client.get(\"/games/\")\n assert response.status_code == 200\n assert isinstance(response.json(), list) # Ensure it returns a list\n\n\ndef test_update_game(test_client, setup_game_definition):\n updated_game = {\"name\": \"Updated Game\", \"description\": \"Updated description\", \"rules\": \"Updated rules\"}\n response = test_client.put(f\"/games/{setup_game_definition['id']}/\", json=updated_game)\n assert response.status_code == 200\n assert response.json()[\"name\"] == updated_game[\"name\"]\n\n\ndef test_delete_game(test_client, setup_game_definition):\n response = test_client.delete(f\"/games/{setup_game_definition['id']}/\")\n assert response.status_code == 204 # No content response for successful deletion\n\n # Verify that the game no longer exists\n response = test_client.get(f\"/games/{setup_game_definition['id']}/\")\n assert response.status_code == 404 # Should return 404 Not Found after deletion" }, { "path": "tests/unit/test_game_model.py", "content": "import pytest\nfrom models.game_definition import GameDefinition # Import the GameDefinition model to be tested\n\n\ndef test_game_definition_creation():\n \"\"\"\n Test the creation of a GameDefinition object.\n \"\"\"\n game = GameDefinition(name=\"Chess\", description=\"A strategic board game.\")\n assert game.name == \"Chess\"\n assert game.description == \"A strategic board game.\"\n\n\ndef test_game_definition_str():\n \"\"\"\n Test the string representation of the GameDefinition object.\n \"\"\"\n game = GameDefinition(name=\"Checkers\", description=\"A game played on an 8x8 board.\")\n assert str(game) == \"Checkers: A game played on an 8x8 board.\"\n\n\ndef test_game_definition_update():\n \"\"\"\n Test updating the GameDefinition attributes.\n \"\"\"\n game = GameDefinition(name=\"Tic Tac Toe\", description=\"A simple game.\")\n game.name = \"Tic Tac Toe Updated\"\n game.description = \"An updated description.\"\n assert game.name == \"Tic Tac Toe Updated\"\n assert game.description == \"An updated description.\"\n\n\ndef test_game_definition_invalid_name():\n \"\"\"\n Test creating a GameDefinition with an invalid name (e.g., empty string).\n \"\"\"\n with pytest.raises(ValueError):\n GameDefinition(name=\"\", description=\"Invalid game definition.\")\n\n\ndef test_game_definition_invalid_description():\n \"\"\"\n Test creating a GameDefinition with an invalid description (e.g., none).\n \"\"\"\n with pytest.raises(ValueError):\n GameDefinition(name=\"Valid Game\", description=None) \n" }, { "path": "tests/unit/test_games.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom api.games import app\n\n# Initialize the TestClient with the FastAPI app\nclient = TestClient(app)\n\n# Test cases for game management\nclass TestGameManagement:\n @pytest.fixture\n def create_game(self):\n # Helper function to create a game\n response = client.post(\"/games/\", json={\n \"name\": \"Test Game\",\n \"description\": \"A game for testing purposes.\"\n })\n return response.json()\n\n def test_create_game(self, create_game):\n assert create_game['name'] == \"Test Game\"\n assert create_game['description'] == \"A game for testing purposes.\"\n\n def test_get_game(self, create_game):\n game_id = create_game['id']\n response = client.get(f\"/games/{game_id}\")\n assert response.status_code == 200\n assert response.json()['name'] == \"Test Game\"\n\n def test_update_game(self, create_game):\n game_id = create_game['id']\n response = client.put(f\"/games/{game_id}\", json={\n \"name\": \"Updated Game\",\n \"description\": \"An updated game for testing purposes.\"\n })\n assert response.status_code == 200\n assert response.json()['name'] == \"Updated Game\"\n\n def test_delete_game(self, create_game):\n game_id = create_game['id']\n response = client.delete(f\"/games/{game_id}\")\n assert response.status_code == 204\n # Ensure the game is deleted\n response = client.get(f\"/games/{game_id}\")\n assert response.status_code == 404\n" }, { "path": "tests/unit/test_llm.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom api.llm import app\n\n# Create a test client using the FastAPI app\nclient = TestClient(app)\n\n\n# Test cases for LLM API endpoints\nclass TestLLMAPI:\n\n def test_llm_endpoint(self):\n # Test the LLM API endpoint with a sample request payload\n payload = {\n \"input_text\": \"Hello, AI!\",\n \"model\": \"gpt-3.5-turbo\"\n }\n response = client.post(\"/llm/generate\", json=payload)\n assert response.status_code == 200\n data = response.json()\n assert \"output_text\" in data\n assert isinstance(data[\"output_text\"], str)\n\n def test_llm_endpoint_invalid_model(self):\n # Test the LLM API endpoint with an invalid model\n payload = {\n \"input_text\": \"Hello, AI!\",\n \"model\": \"invalid-model\"\n }\n response = client.post(\"/llm/generate\", json=payload)\n assert response.status_code == 400\n assert \"error\" in response.json()\n\n def test_llm_endpoint_missing_fields(self):\n # Test the LLM API endpoint with missing fields\n payload = {\"input_text\": \"Hello, AI!\"}\n response = client.post(\"/llm/generate\", json=payload)\n assert response.status_code == 422\n assert \"detail\" in response.json()\n\n def test_llm_endpoint_empty_input(self):\n # Test the LLM API endpoint with empty input text\n payload = {\n \"input_text\": \"\",\n \"model\": \"gpt-3.5-turbo\"\n }\n response = client.post(\"/llm/generate\", json=payload)\n assert response.status_code == 400\n assert \"error\" in response.json()" }, { "path": "tests/unit/test_llm_processing.py", "content": "import unittest\nfrom core.llm_processing import process_llm_request\n\nclass TestLLMProcessing(unittest.TestCase):\n def test_process_llm_request_valid_input(self):\n # Test with valid input\n input_data = {'prompt': 'Hello, AI!', 'max_tokens': 50}\n expected_output = {'response': 'AI response here...'} # Update with expected response\n result = process_llm_request(input_data)\n self.assertEqual(result, expected_output)\n\n def test_process_llm_request_empty_prompt(self):\n # Test with empty prompt\n input_data = {'prompt': '', 'max_tokens': 50}\n with self.assertRaises(ValueError):\n process_llm_request(input_data)\n\n def test_process_llm_request_invalid_max_tokens(self):\n # Test with invalid max_tokens\n input_data = {'prompt': 'Hello, AI!', 'max_tokens': -1}\n with self.assertRaises(ValueError):\n process_llm_request(input_data)\n\n def test_process_llm_request_missing_keys(self):\n # Test with missing keys\n input_data = {'prompt': 'Hello, AI!'} # Missing max_tokens\n with self.assertRaises(KeyError):\n process_llm_request(input_data)\n\nif __name__ == '__main__':\n unittest.main()" }, { "path": "tests/unit/test_llm_response.py", "content": "import pytest\nfrom schemas.llm_response import LLMResponse\n\n\ndef test_llm_response_initialization():\n \"\"\"\n Test the initialization of LLMResponse schema.\n \"\"\"\n response_data = {\n 'id': '123',\n 'status': 'success',\n 'data': {'message': 'Hello, world!'}\n }\n llm_response = LLMResponse(**response_data)\n assert llm_response.id == '123'\n assert llm_response.status == 'success'\n assert llm_response.data['message'] == 'Hello, world!'\n\n\ndef test_llm_response_invalid_data():\n \"\"\"\n Test LLMResponse initialization with invalid data.\n \"\"\"\n with pytest.raises(ValueError):\n LLMResponse(id='123', status='success', data='Invalid data')\n\n\ndef test_llm_response_missing_fields():\n \"\"\"\n Test LLMResponse initialization with missing required fields.\n \"\"\"\n with pytest.raises(TypeError):\n LLMResponse(status='success')\n\n\ndef test_llm_response_empty_data():\n \"\"\"\n Test LLMResponse with empty data field.\n \"\"\"\n response_data = {\n 'id': '124',\n 'status': 'success',\n 'data': {}\n }\n llm_response = LLMResponse(**response_data)\n assert llm_response.data == {}\n\n\nif __name__ == '__main__':\n pytest.main()" }, { "path": "tests/unit/test_llm_schema.py", "content": "import pytest\nfrom pydantic import ValidationError\nfrom schemas.llm_request import LLMRequestSchema\nfrom schemas.llm_response import LLMResponseSchema\n\n\ndef test_llm_request_schema_valid():\n # Test valid LLM request schema\n valid_data = {\n 'prompt': 'What is the capital of France?',\n 'max_tokens': 50,\n 'temperature': 0.7,\n }\n schema = LLMRequestSchema(**valid_data)\n assert schema.prompt == valid_data['prompt']\n assert schema.max_tokens == valid_data['max_tokens']\n assert schema.temperature == valid_data['temperature']\n\n\ndef test_llm_request_schema_invalid():\n # Test invalid LLM request schema\n invalid_data = {\n 'prompt': 12345, # Invalid type for prompt\n 'max_tokens': -10, # Invalid value for max_tokens\n 'temperature': 2.0, # Invalid value for temperature\n }\n with pytest.raises(ValidationError):\n LLMRequestSchema(**invalid_data)\n\n\ndef test_llm_response_schema_valid():\n # Test valid LLM response schema\n valid_response_data = {\n 'id': 'response_123',\n 'choices': [{'text': 'Paris', 'index': 0}]\n }\n schema = LLMResponseSchema(**valid_response_data)\n assert schema.id == valid_response_data['id']\n assert len(schema.choices) == len(valid_response_data['choices'])\n\n\ndef test_llm_response_schema_invalid():\n # Test invalid LLM response schema\n invalid_response_data = {\n 'id': 'response_123',\n 'choices': [{'text': 12345}] # Invalid type for text\n }\n with pytest.raises(ValidationError):\n LLMResponseSchema(**invalid_response_data)" }, { "path": "tests/unit/test_llm_service.py", "content": "import pytest\nfrom llm_service.service import LLMService\n\n\n@pytest.fixture\ndef llm_service():\n \"\"\"\n Fixture to create an instance of `LLMService` for testing.\n \"\"\"\n return LLMService()\n\n\ndef test_service_initialization(llm_service):\n \"\"\"\n Test that the LLMService initializes correctly.\n \"\"\"\n assert llm_service is not None\n\n\ndef test_process_request_valid(llm_service):\n \"\"\"\n Test processing a valid request.\n \"\"\"\n request_data = {'input': 'Hello, AI!'}\n response = llm_service.process_request(request_data)\n assert response is not None\n assert 'output' in response\n assert response['output'] == 'Hello, AI! processed' # Example expected behavior\n\n\ndef test_process_request_invalid(llm_service):\n \"\"\"\n Test processing an invalid request.\n \"\"\"\n request_data = {'wrong_key': 'Invalid data'}\n with pytest.raises(ValueError, match='Invalid request format'):\n llm_service.process_request(request_data)\n\n\ndef test_service_response_format(llm_service):\n \"\"\"\n Test that the response format is correct.\n \"\"\"\n request_data = {'input': 'Test response format.'}\n response = llm_service.process_request(request_data)\n assert isinstance(response, dict)\n assert 'output' in response\n assert isinstance(response['output'], str)" }, { "path": "tests/unit/test_llm_service_integration.py", "content": "import pytest\nfrom llm_service.service import LLMService\n\nclass TestLLMServiceIntegration:\n @pytest.fixture(scope=\"class\")\n def llm_service(self):\n \"\"\"Fixture to provide an instance of LLMService for testing.\"\"\"\n service = LLMService()\n yield service\n\n def test_llm_service_initialization(self, llm_service):\n \"\"\"Test initialization of the LLM service.\"\"\"\n assert llm_service is not None, \"LLM Service should be initialized\"\n\n def test_llm_service_functionality(self, llm_service):\n \"\"\"Test a sample functionality of the LLM service.\"\"\"\n # Assuming LLMService has a method called `process_request`\n sample_request = {'input': 'Sample input for LLM'}\n response = llm_service.process_request(sample_request)\n assert response is not None, \"Response should not be None\"\n assert 'output' in response, \"Response should contain output key\"\n\n def test_llm_service_error_handling(self, llm_service):\n \"\"\"Test error handling of the LLM service.\"\"\"\n invalid_request = {'wrong_key': 'Sample input'}\n with pytest.raises(ValueError):\n llm_service.process_request(invalid_request)\n" }, { "path": "tests/unit/test_user_management.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom api.auth import app\nfrom crud.user import UserCRUD\n\n@pytest.fixture\ndef client():\n return TestClient(app)\n\n@pytest.fixture\ndef user_data():\n return {\n \"username\": \"testuser\",\n \"password\": \"testpassword\",\n \"email\": \"testuser@example.com\"\n }\n\n@pytest.fixture\ndef create_user(client, user_data):\n response = client.post('/auth/register', json=user_data)\n return response\n\ndef test_user_registration(client, user_data):\n response = client.post('/auth/register', json=user_data)\n assert response.status_code == 201\n assert \"access_token\" in response.json()\n assert response.json()[\"user\"]['username'] == user_data['username']\n\ndef test_user_login(client, create_user, user_data):\n response = client.post('/auth/login', json={\n \"username\": user_data['username'],\n \"password\": user_data['password']\n })\n assert response.status_code == 200\n assert \"access_token\" in response.json()\n\ndef test_user_login_with_incorrect_password(client, create_user, user_data):\n response = client.post('/auth/login', json={\n \"username\": user_data['username'],\n \"password\": \"wrongpassword\"\n })\n assert response.status_code == 401\n assert \"detail\" in response.json()\n assert response.json()[\"detail\"] == \"Incorrect username or password\"\n\ndef test_user_profile(client, create_user):\n response = client.get('/auth/profile')\n assert response.status_code == 200\n assert \"username\" in response.json()\n" }, { "path": "tests/unit/test_user_model.py", "content": "import pytest\nfrom models.user import User\n\n\ndef test_user_creation():\n \"\"\"Test the creation of a User instance.\"\"\"\n user = User(username='test_user', email='test@example.com')\n assert user.username == 'test_user'\n assert user.email == 'test@example.com'\n\n\ndef test_user_str():\n \"\"\"Test the string representation of a User instance.\"\"\"\n user = User(username='test_user', email='test@example.com')\n assert str(user) == 'User(test_user, test@example.com)'\n\n\ndef test_user_email_validation():\n \"\"\"Test email validation for User instance.\"\"\"\n with pytest.raises(ValueError):\n User(username='test_user', email='invalid_email')\n\n\ndef test_user_update():\n \"\"\"Test updating user details.\"\"\"\n user = User(username='test_user', email='test@example.com')\n user.update(username='new_user', email='new@example.com')\n assert user.username == 'new_user'\n assert user.email == 'new@example.com'\n\n\ndef test_user_profile_link():\n \"\"\"Test the link to the user profile.\"\"\"\n user = User(username='test_user', email='test@example.com')\n assert user.get_profile_link() == '/profiles/test_user'" }, { "path": "tests/unit/test_user_profile.py", "content": "import pytest\nfrom fastapi.testclient import TestClient\nfrom api.auth import app # Adjust the import based on your project structure\n\n# Create a test client using the FastAPI app\nclient = TestClient(app)\n\n@pytest.fixture\ndef create_user():\n \"\"\"Fixture to create a user for testing\"\"\"\n response = client.post(\"/auth/register\", json={\n \"username\": \"testuser\",\n \"password\": \"testpassword\",\n \"email\": \"testuser@example.com\"\n })\n return response.json()\n\n\ndef test_user_profile_creation(create_user):\n \"\"\"Test user profile creation\"\"\"\n response = client.post(\"/users/profile\", json={\n \"bio\": \"This is a test user profile.\"\n }, headers={\n \"Authorization\": f\"Bearer {create_user['access_token']}\"\n })\n assert response.status_code == 201\n assert \"profile_id\" in response.json()\n\n\ndef test_get_user_profile(create_user):\n \"\"\"Test fetching user profile\"\"\"\n response = client.get(\"/users/profile\", headers={\n \"Authorization\": f\"Bearer {create_user['access_token']}\"\n })\n assert response.status_code == 200\n assert \"bio\" in response.json()\n\n\ndef test_update_user_profile(create_user):\n \"\"\"Test updating user profile\"\"\"\n response = client.put(\"/users/profile\", json={\n \"bio\": \"Updated test user profile.\"\n }, headers={\n \"Authorization\": f\"Bearer {create_user['access_token']}\"\n })\n assert response.status_code == 200\n assert response.json()[\"bio\"] == \"Updated test user profile.\"\n\n\ndef test_delete_user_profile(create_user):\n \"\"\"Test deleting user profile\"\"\"\n response = client.delete(\"/users/profile\", headers={\n \"Authorization\": f\"Bearer {create_user['access_token']}\"\n })\n assert response.status_code == 204\n\n # Verify profile is deleted\n response = client.get(\"/users/profile\", headers={\n \"Authorization\": f\"Bearer {create_user['access_token']}\"\n })\n assert response.status_code == 404\n" } ]