.eslintignore

@@ -1,3 +1,3 @@
 **/node_modules
-build/
+**/build/
 *.d.ts

.eslintrc.js

@@ -22,7 +22,7 @@ module.exports = {
   ],
   root: true,
 
-  plugins: ['jest', 'no-for-of-loops', 'no-function-declare-after-return', 'react', '@typescript-eslint'],
+  plugins: ['jest', 'no-function-declare-after-return', 'react', '@typescript-eslint'],
 
   parser: '@typescript-eslint/parser',
   parserOptions: {
@@ -56,8 +56,8 @@ module.exports = {
     'comma-dangle': ['error', 'only-multiline'],
 
     'no-constant-condition': 'off',
-    'no-for-of-loops/no-for-of-loops': 'error',
     'no-function-declare-after-return/no-function-declare-after-return': 'error',
+    '@typescript-eslint/ban-ts-comment': 'warn'
   },
   globals: {
     isDev: true,

.gitee/ISSUE_TEMPLATE_CN.md

@@ -0,0 +1,24 @@
+---
+name: 模板名称，在新建issue时候能看到
+about: 模板描述，对应的issue模板卡片展示时候能看到，介绍模板
+---
+
+**标题:** [请在此处填写 issue 标题]
+
+**问题描述:** [请描述问题背景、可能的原因、如何重现问题以及相关解决方案]
+
+**关联的 Issues:** [请列出与此问题相关的 issue 编号]
+
+**检查项:**
+
+- [ ]  该问题的存在已经确认
+- [ ]  这个问题的重要性和紧迫性已经确认
+- [ ]  该问题的责任人已经确认
+- [ ]  该问题的解决方案已经确认
+- [ ]  该问题的测试方法已经确认
+
+**标签:** [请为该问题添加合适的标签]
+
+**责任人:** [请为该问题分配责任人]
+
+**优先级:** [请给出该问题的优先级]

.gitee/ISSUE_TEMPLATE_EN.md

@@ -0,0 +1,24 @@
+---
+name: The template name can be seen when creating a new issue
+about: Template description, which can be seen when displaying the corresponding issue template card
+---
+
+**Title:** [Please fill in the issue title here]
+
+**Description:** [Please describe the background, possible causes, how to reproduce the issue, and any necessary solutions]
+
+**Related Issues:** [List the issue numbers related to this issue]
+
+**Checklist:**
+
+- [ ]  The existence of this issue has been confirmed
+- [ ]  The importance and urgency of this issue have been confirmed
+- [ ]  The responsible person for this issue has been confirmed
+- [ ]  The solution for this issue has been confirmed
+- [ ]  The testing method for this issue has been confirmed
+
+**Labels:** [Add appropriate labels]
+
+**Assignees:** [Assign the responsible person for this issue]
+
+**Priority:** [Set the priority for this issue]

.gitee/PULL_REQUEST_TEMPLATE_CN.md

@@ -0,0 +1,12 @@
+**PR 描述:** [请描述提交此 PR 的背景、目的、所做的更改以及如何测试此 PR]
+
+**关联的 Issues:** [请列出与此 PR 相关的 issue 编号]
+
+**检查项（无需修改，提交后界面上可勾选）:**
+- [ ]  代码已经被审查
+- [ ]  代码符合项目的代码标准和最佳实践
+- [ ]  代码已经通过所有测试用例
+- [ ]  代码不影响现有功能的正常使用
+- [ ]  文档已经同步更新
+
+**截图（可选）:** [提供相关的截图或 gif 动画]

.gitee/PULL_REQUEST_TEMPLATE_EN.md

@@ -0,0 +1,12 @@
+**Description:** [Please describe the background, purpose, changes made, and how to test this PR]
+
+**Related Issues:** [List the issue numbers related to this PR]
+
+**Checklist:**
+- [ ]  Code has been reviewed
+- [ ]  Code complies with the project's code standards and best practices
+- [ ]  Code has passed all tests
+- [ ]  Code does not affect the normal use of existing features
+- [ ]  Documentation has been updated
+
+**Screenshots(optional):** [Provide relevant screenshots or GIF animations]

.gitignore

@@ -4,3 +4,7 @@
 package-lock.json
 pnpm-lock.yaml
 /packages/**/node_modules
+/packages/inula-cli/lib
+build
+/packages/inula-router/connectRouter
+/packages/inula-router/router

.husky/commit-msg

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npm run commitlint

.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npm run lint-commit

.prettierignore

@@ -0,0 +1,3 @@
+**/build
+*.md
+*.html

.prettierrc.js

@@ -16,17 +16,17 @@
 'use strict';
 
 module.exports = {
-  printWidth: 120, // 一行120字符数，如果超过会进行换行
-  tabWidth: 2, // tab等2个空格
-  useTabs: false, // 用空格缩进行
-  semi: true, // 行尾使用分号
-  singleQuote: true, // 字符串使用单引号
-  quoteProps: 'as-needed', // 仅在需要时在对象属性添加引号
-  jsxSingleQuote: false, // 在JSX中使用双引号
-  trailingComma: 'es5', // 使用尾逗号(对象、数组等)
-  bracketSpacing: true, // 对象的括号间增加空格
-  bracketSameLine: false, // 将多行JSX元素的>放在最后一行的末尾
-  arrowParens: 'avoid', // 在唯一的arrow函数参数周围省略括号
-  vueIndentScriptAndStyle: false, // 不缩进Vue文件中的<script>和<style>标记内的代码
-  endOfLine: 'lf', // 仅限换行（\n）
+  printWidth: 120, // 一行120字符数，如果超过会进行换行
+  tabWidth: 2, // tab等2个空格
+  useTabs: false, // 用空格缩进行
+  semi: true, // 行尾使用分号
+  singleQuote: true, // 字符串使用单引号
+  quoteProps: 'as-needed', // 仅在需要时在对象属性添加引号
+  jsxSingleQuote: false, // 在JSX中使用双引号
+  trailingComma: 'es5', // 使用尾逗号(对象、数组等)
+  bracketSpacing: true, // 对象的括号间增加空格
+  bracketSameLine: false, // 将多行JSX元素的>放在最后一行的末尾
+  arrowParens: 'avoid', // 在唯一的arrow函数参数周围省略括号
+  vueIndentScriptAndStyle: false, // 不缩进Vue文件中的<script>和<style>标记内的代码
+  endOfLine: 'auto', // 仅限换行（\n）
 };

.workflow/branch-pipeline.yml

@@ -0,0 +1,51 @@
+version: '1.0'
+name: branch-pipeline
+displayName: BranchPipeline
+stages:
+  - stage: 
+    name: compile
+    displayName: 编译
+    steps:
+      - step: build@nodejs
+        name: build_nodejs
+        displayName: Nodejs 构建
+        # 支持8.16.2、10.17.0、12.16.1、14.16.0、15.12.0五个版本
+        nodeVersion: 14.16.0
+        # 构建命令：安装依赖 -> 清除上次打包产物残留 -> 执行构建 【请根据项目实际产出进行填写】
+        commands:
+          - npm install && rm -rf ./dist && npm run build
+        # 非必填字段，开启后表示将构建产物暂存，但不会上传到制品库中，7天后自动清除
+        artifacts:
+            # 构建产物名字，作为产物的唯一标识可向下传递，支持自定义，默认为BUILD_ARTIFACT。在下游可以通过${BUILD_ARTIFACT}方式引用来获取构建物地址
+          - name: BUILD_ARTIFACT
+            # 构建产物获取路径，是指代码编译完毕之后构建物的所在路径
+            path:
+              - ./dist
+      - step: publish@general_artifacts
+        name: publish_general_artifacts
+        displayName: 上传制品
+        # 上游构建任务定义的产物名，默认BUILD_ARTIFACT
+        dependArtifact: BUILD_ARTIFACT
+        # 上传到制品库时的制品命名，默认output
+        artifactName: output
+        dependsOn: build_nodejs
+  - stage: 
+    name: release
+    displayName: 发布
+    steps:
+      - step: publish@release_artifacts
+        name: publish_release_artifacts
+        displayName: '发布'
+        # 上游上传制品任务的产出
+        dependArtifact: output
+        # 发布制品版本号
+        version: '1.0.0.0'
+        # 是否开启版本号自增，默认开启
+        autoIncrement: true
+triggers:
+  push:
+    branches:
+      exclude:
+        - master
+      include:
+        - .*

.workflow/master-pipeline.yml

@@ -0,0 +1,49 @@
+version: '1.0'
+name: master-pipeline
+displayName: MasterPipeline
+stages:
+  - stage: 
+    name: compile
+    displayName: 编译
+    steps:
+      - step: build@nodejs
+        name: build_nodejs
+        displayName: Nodejs 构建
+        # 支持8.16.2、10.17.0、12.16.1、14.16.0、15.12.0五个版本
+        nodeVersion: 14.16.0
+        # 构建命令：安装依赖 -> 清除上次打包产物残留 -> 执行构建 【请根据项目实际产出进行填写】
+        commands:
+          - npm install && rm -rf ./dist && npm run build
+        # 非必填字段，开启后表示将构建产物暂存，但不会上传到制品库中，7天后自动清除
+        artifacts:
+            # 构建产物名字，作为产物的唯一标识可向下传递，支持自定义，默认为BUILD_ARTIFACT。在下游可以通过${BUILD_ARTIFACT}方式引用来获取构建物地址
+          - name: BUILD_ARTIFACT
+            # 构建产物获取路径，是指代码编译完毕之后构建物的所在路径
+            path:
+              - ./dist
+      - step: publish@general_artifacts
+        name: publish_general_artifacts
+        displayName: 上传制品
+        # 上游构建任务定义的产物名，默认BUILD_ARTIFACT
+        dependArtifact: BUILD_ARTIFACT
+        # 上传到制品库时的制品命名，默认output
+        artifactName: output
+        dependsOn: build_nodejs
+  - stage: 
+    name: release
+    displayName: 发布
+    steps:
+      - step: publish@release_artifacts
+        name: publish_release_artifacts
+        displayName: '发布'
+        # 上游上传制品任务的产出
+        dependArtifact: output
+        # 发布制品版本号
+        version: '1.0.0.0'
+        # 是否开启版本号自增，默认开启
+        autoIncrement: true
+triggers:
+  push:
+    branches:
+      include:
+        - master

.workflow/pr-pipeline.yml

@@ -0,0 +1,36 @@
+version: '1.0'
+name: pr-pipeline
+displayName: PRPipeline
+stages:
+  - stage: 
+    name: compile
+    displayName: 编译
+    steps:
+      - step: build@nodejs
+        name: build_nodejs
+        displayName: Nodejs 构建
+        # 支持8.16.2、10.17.0、12.16.1、14.16.0、15.12.0五个版本
+        nodeVersion: 14.16.0
+        # 构建命令：安装依赖 -> 清除上次打包产物残留 -> 执行构建 【请根据项目实际产出进行填写】
+        commands:
+          - npm install && rm -rf ./dist && npm run build
+        # 非必填字段，开启后表示将构建产物暂存，但不会上传到制品库中，7天后自动清除
+        artifacts:
+            # 构建产物名字，作为产物的唯一标识可向下传递，支持自定义，默认为BUILD_ARTIFACT。在下游可以通过${BUILD_ARTIFACT}方式引用来获取构建物地址
+          - name: BUILD_ARTIFACT
+            # 构建产物获取路径，是指代码编译完毕之后构建物的所在路径
+            path:
+              - ./dist
+      - step: publish@general_artifacts
+        name: publish_general_artifacts
+        displayName: 上传制品
+        # 上游构建任务定义的产物名，默认BUILD_ARTIFACT
+        dependArtifact: BUILD_ARTIFACT
+        # 上传到制品库时的制品命名，默认output
+        artifactName: output
+        dependsOn: build_nodejs
+triggers:
+  pr:
+    branches:
+      include:
+        - master

CONTRIBUTING.md

@@ -0,0 +1,3 @@
+# Inula Contributing Guide
+
+查看[贡献指南](https://docs.openinula.net/docs/%E8%B4%A1%E7%8C%AE%E6%8C%87%E5%8D%97)获取完整指南。

LICENSE

@@ -0,0 +1,127 @@
+                     木兰宽松许可证, 第2版
+
+   木兰宽松许可证， 第2版 
+   2020年1月 http://license.coscl.org.cn/MulanPSL2
+
+
+   您对“软件”的复制、使用、修改及分发受木兰宽松许可证，第2版（“本许可证”）的如下条款的约束：
+
+   0. 定义
+
+      “软件”是指由“贡献”构成的许可在“本许可证”下的程序和相关文档的集合。
+
+      “贡献”是指由任一“贡献者”许可在“本许可证”下的受版权法保护的作品。
+
+      “贡献者”是指将受版权法保护的作品许可在“本许可证”下的自然人或“法人实体”。
+
+      “法人实体”是指提交贡献的机构及其“关联实体”。
+
+      “关联实体”是指，对“本许可证”下的行为方而言，控制、受控制或与其共同受控制的机构，此处的控制是指有受控方或共同受控方至少50%直接或间接的投票权、资金或其他有价证券。
+
+   1. 授予版权许可
+
+      每个“贡献者”根据“本许可证”授予您永久性的、全球性的、免费的、非独占的、不可撤销的版权许可，您可以复制、使用、修改、分发其“贡献”，不论修改与否。
+
+   2. 授予专利许可
+
+      每个“贡献者”根据“本许可证”授予您永久性的、全球性的、免费的、非独占的、不可撤销的（根据本条规定撤销除外）专利许可，供您制造、委托制造、使用、许诺销售、销售、进口其“贡献”或以其他方式转移其“贡献”。前述专利许可仅限于“贡献者”现在或将来拥有或控制的其“贡献”本身或其“贡献”与许可“贡献”时的“软件”结合而将必然会侵犯的专利权利要求，不包括对“贡献”的修改或包含“贡献”的其他结合。如果您或您的“关联实体”直接或间接地，就“软件”或其中的“贡献”对任何人发起专利侵权诉讼（包括反诉或交叉诉讼）或其他专利维权行动，指控其侵犯专利权，则“本许可证”授予您对“软件”的专利许可自您提起诉讼或发起维权行动之日终止。
+
+   3. 无商标许可
+
+      “本许可证”不提供对“贡献者”的商品名称、商标、服务标志或产品名称的商标许可，但您为满足第4条规定的声明义务而必须使用除外。
+
+   4. 分发限制
+
+      您可以在任何媒介中将“软件”以源程序形式或可执行形式重新分发，不论修改与否，但您必须向接收者提供“本许可证”的副本，并保留“软件”中的版权、商标、专利及免责声明。
+
+   5. 免责声明与责任限制
+
+      “软件”及其中的“贡献”在提供时不带任何明示或默示的担保。在任何情况下，“贡献者”或版权所有者不对任何人因使用“软件”或其中的“贡献”而引发的任何直接或间接损失承担责任，不论因何种原因导致或者基于何种法律理论，即使其曾被建议有此种损失的可能性。 
+
+   6. 语言
+      “本许可证”以中英文双语表述，中英文版本具有同等法律效力。如果中英文版本存在任何冲突不一致，以中文版为准。
+
+   条款结束 
+
+   如何将木兰宽松许可证，第2版，应用到您的软件
+   
+   如果您希望将木兰宽松许可证，第2版，应用到您的新软件，为了方便接收者查阅，建议您完成如下三步：
+
+      1， 请您补充如下声明中的空白，包括软件名、软件的首次发表年份以及您作为版权人的名字；
+
+      2， 请您在软件包的一级目录下创建以“LICENSE”为名的文件，将整个许可证文本放入该文件中；
+
+      3， 请将如下声明文本放入每个源文件的头部注释中。
+
+   Copyright (c) [Year] [name of copyright holder]
+   [Software Name] is licensed under Mulan PSL v2.
+   You can use this software according to the terms and conditions of the Mulan PSL v2. 
+   You may obtain a copy of Mulan PSL v2 at:
+            http://license.coscl.org.cn/MulanPSL2 
+   THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.  
+   See the Mulan PSL v2 for more details.  
+
+
+                     Mulan Permissive Software License，Version 2
+
+   Mulan Permissive Software License，Version 2 (Mulan PSL v2)
+   January 2020 http://license.coscl.org.cn/MulanPSL2
+
+   Your reproduction, use, modification and distribution of the Software shall be subject to Mulan PSL v2 (this License) with the following terms and conditions: 
+   
+   0. Definition
+   
+      Software means the program and related documents which are licensed under this License and comprise all Contribution(s). 
+   
+      Contribution means the copyrightable work licensed by a particular Contributor under this License.
+   
+      Contributor means the Individual or Legal Entity who licenses its copyrightable work under this License.
+   
+      Legal Entity means the entity making a Contribution and all its Affiliates.
+   
+      Affiliates means entities that control, are controlled by, or are under common control with the acting entity under this License, ‘control’ means direct or indirect ownership of at least fifty percent (50%) of the voting power, capital or other securities of controlled or commonly controlled entity.
+
+   1. Grant of Copyright License
+
+      Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable copyright license to reproduce, use, modify, or distribute its Contribution, with modification or not.
+
+   2. Grant of Patent License 
+
+      Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable (except for revocation under this Section) patent license to make, have made, use, offer for sale, sell, import or otherwise transfer its Contribution, where such patent license is only limited to the patent claims owned or controlled by such Contributor now or in future which will be necessarily infringed by its Contribution alone, or by combination of the Contribution with the Software to which the Contribution was contributed. The patent license shall not apply to any modification of the Contribution, and any other combination which includes the Contribution. If you or your Affiliates directly or indirectly institute patent litigation (including a cross claim or counterclaim in a litigation) or other patent enforcement activities against any individual or entity by alleging that the Software or any Contribution in it infringes patents, then any patent license granted to you under this License for the Software shall terminate as of the date such litigation or activity is filed or taken.
+
+   3. No Trademark License
+
+      No trademark license is granted to use the trade names, trademarks, service marks, or product names of Contributor, except as required to fulfill notice requirements in Section 4.
+
+   4. Distribution Restriction
+
+      You may distribute the Software in any medium with or without modification, whether in source or executable forms, provided that you provide recipients with a copy of this License and retain copyright, patent, trademark and disclaimer statements in the Software.
+
+   5. Disclaimer of Warranty and Limitation of Liability
+
+      THE SOFTWARE AND CONTRIBUTION IN IT ARE PROVIDED WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED. IN NO EVENT SHALL ANY CONTRIBUTOR OR COPYRIGHT HOLDER BE LIABLE TO YOU FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO ANY DIRECT, OR INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING FROM YOUR USE OR INABILITY TO USE THE SOFTWARE OR THE CONTRIBUTION IN IT, NO MATTER HOW IT’S CAUSED OR BASED ON WHICH LEGAL THEORY, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+   6. Language
+
+      THIS LICENSE IS WRITTEN IN BOTH CHINESE AND ENGLISH, AND THE CHINESE VERSION AND ENGLISH VERSION SHALL HAVE THE SAME LEGAL EFFECT. IN THE CASE OF DIVERGENCE BETWEEN THE CHINESE AND ENGLISH VERSIONS, THE CHINESE VERSION SHALL PREVAIL.
+
+   END OF THE TERMS AND CONDITIONS
+
+   How to Apply the Mulan Permissive Software License，Version 2 (Mulan PSL v2) to Your Software
+
+      To apply the Mulan PSL v2 to your work, for easy identification by recipients, you are suggested to complete following three steps:
+
+      i Fill in the blanks in following statement, including insert your software name, the year of the first publication of your software, and your name identified as the copyright owner; 
+
+      ii Create a file named “LICENSE” which contains the whole context of this License in the first directory of your software package;
+
+      iii Attach the statement to the appropriate annotated syntax at the beginning of each source file.
+
+
+   Copyright (c) [Year] [name of copyright holder]
+   [Software Name] is licensed under Mulan PSL v2.
+   You can use this software according to the terms and conditions of the Mulan PSL v2. 
+   You may obtain a copy of Mulan PSL v2 at:
+               http://license.coscl.org.cn/MulanPSL2 
+   THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.  
+   See the Mulan PSL v2 for more details.  

Licenses/Third Party Open Source Software Notice.docx

@@ -0,0 +1,498 @@
+THIRD PARTY OPEN SOURCE SOFTWARE NOTICE
+Please note we provide an open source software notice for the third party open source software along with this software and/or this software component contributed by Huawei (in the following just “this SOFTWARE”). The open source software licenses are granted by the respective right holders. 
+
+Warranty Disclaimer 
+The open source software in this software is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY, without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the applicable licenses for more details.
+
+Copyright Notice and License Texts 
+Software: glob 10.3.4
+Copyright notice: Isaac Z. Schlueter <i@izs.me> (https://blog.izs.me/)
+License: ISC License
+ISC License
+
+Copyright <YEAR> <OWNER>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+Software: inquirer 8.2.6
+Copyright notice: Simon Boudrias <admin@simonboudrias.com>
+License: MIT License
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: mkdirp 3.0.1
+License: MIT License
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: yargs-parser 21.1.1
+Copyright notice: Ben Coe <ben@npmjs.com>
+License: ISC License
+ISC LICENSE
+
+COPYRIGHT <YEAR> <OWNER>
+
+PERMISSION TO USE, COPY, MODIFY, AND/OR DISTRIBUTE THIS SOFTWARE FOR ANY PURPOSE WITH OR WITHOUT FEE IS HEREBY GRANTED, PROVIDED THAT THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE APPEAR IN ALL COPIES.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+Software: yeoman-environment 3.19.3
+Copyright notice: Yeoman
+License: BSD-2-Clause
+Copyright <YEAR> <COPYRIGHT HOLDER>
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Software: yeoman-generator 5.9.0
+Copyright notice: Yeoman
+License: BSD-2-Clause
+COPYRIGHT <YEAR> <COPYRIGHT HOLDER>
+
+REDISTRIBUTION AND USE IN SOURCE AND BINARY FORMS, WITH OR WITHOUT MODIFICATION, ARE PERMITTED PROVIDED THAT THE FOLLOWING CONDITIONS ARE MET:
+
+1. REDISTRIBUTIONS OF SOURCE CODE MUST RETAIN THE ABOVE COPYRIGHT NOTICE, THIS LIST OF CONDITIONS AND THE FOLLOWING DISCLAIMER.
+
+2. REDISTRIBUTIONS IN BINARY FORM MUST REPRODUCE THE ABOVE COPYRIGHT NOTICE, THIS LIST OF CONDITIONS AND THE FOLLOWING DISCLAIMER IN THE DOCUMENTATION AND/OR OTHER MATERIALS PROVIDED WITH THE DISTRIBUTION.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Software: @babel/runtime 7.22.15
+Copyright notice: The Babel Team (https://babel.dev/team)
+License: MIT License   
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: babel-eslint 10.1.0
+Copyright notice: Sebastian McKenzie <sebmck@gmail.com>
+License: MIT License   
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: chalk 4.1.2
+License: MIT License   
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: chokidar 3.5.3
+Copyright notice: Paul Miller (https://paulmillr.com)
+License: MIT License   
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: crequire 1.8.1
+Copyright notice: army8735 <army8735@qq.com>
+License: MIT License   
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: deepmerge 4.3.1
+License: MIT License   
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: dotenv 16.3.1
+License: BSD-2-Clause
+COPYRIGHT <YEAR> <COPYRIGHT HOLDER>
+
+REDISTRIBUTION AND USE IN SOURCE AND BINARY FORMS, WITH OR WITHOUT MODIFICATION, ARE PERMITTED PROVIDED THAT THE FOLLOWING CONDITIONS ARE MET:
+
+1. REDISTRIBUTIONS OF SOURCE CODE MUST RETAIN THE ABOVE COPYRIGHT NOTICE, THIS LIST OF CONDITIONS AND THE FOLLOWING DISCLAIMER.
+
+2. REDISTRIBUTIONS IN BINARY FORM MUST REPRODUCE THE ABOVE COPYRIGHT NOTICE, THIS LIST OF CONDITIONS AND THE FOLLOWING DISCLAIMER IN THE DOCUMENTATION AND/OR OTHER MATERIALS PROVIDED WITH THE DISTRIBUTION.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Software: esbuild 0.18.20
+License: MIT License   
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: express 4.18.2
+Copyright notice: TJ Holowaychuk <tj@vision-media.ca>
+License: MIT License   
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: http-proxy-middleware 2.0.6
+Copyright notice: Steven Chim
+License: MIT License   
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: install 0.13.0
+Copyright notice: Ben Newman < bn@cs.stanford.edu>
+License: MIT License   
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: jest 29.7.0
+License: MIT License   
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: lodash 4.17.21
+Copyright notice: John-David Dalton <john.david.dalton@gmail.com>
+License: MIT License   
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: resolve 1.22.6
+Copyright notice: James Halliday<mail@substack.net>(http://substack.net)
+License: MIT License   
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: ts-jest 29.1.1
+Copyright notice: Kulshekhar Kabra <kulshekhar@users.noreply.github.com> (https://github.com/kulshekhar)
+License: MIT License   
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: ts-node 10.9.1
+Copyright notice: Blake Embrey <hello@blakeembrey.com>(http://blakeembrey.me)
+License: MIT License   
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: vite 4.4.2
+Copyright notice: Evan You
+License: MIT License   
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: webpack 5.88.2
+Copyright notice: Tobias Koppers @sokra
+License: MIT License   
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+Software: webpack-dev-server 4.15.1
+Copyright notice: Tobias Koppers @sokra
+License: MIT License   
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,87 @@
+# openInula 开源项目
+
+## 项目介绍
+
+单词 Inula（发音为：[ˈɪnjʊlə]），意为一类旋覆花属菊科的植物。openInula 是一款用于构建用户界面的 JavaScript 库，提供响应式 API 帮助开发者简单高效构建 Web 页面，比传统虚拟 DOM 方式渲染效率提升30%以上！同时 openInula 提供与 React 保持一致的 API，并且提供5大常用功能组件：状态管理器、路由、国际化、请求组件、应用脚手架，以便开发者高效、高质量的构筑基于 openInula 的前端产品。
+
+## 技术架构
+
+![](https://openinula-website.obs.ap-southeast-1.myhuaweicloud.com/misc/structure.png)
+
+## 核心能力
+
+### 响应式API
+
+openInula 通过监听状态变量的变化，以细粒度的依赖追踪机制来实现响应式更新，避免了虚拟 DOM 的开销。通过最小化重新渲染的范围，从而进行高效的UI渲染。无需用户过度关注性能优化。
+
+>（实验性功能，可在 `reactive` 分支查看代码或使用 npm 仓中 experimental 版本体验）
+
+### 兼容 React API
+
+提供与 React 一致的 API，完全支持 React 生态，可将 React 应用可零修改切换至 openInula。
+
+### openInula 配套组件
+
+#### 状态管理器 inula-X
+
+inula-X 是 openInula 默认提供的状态管理器。无需额外引入三方库，就可以简单实现跨组件/页面共享状态。
+
+inula-X 与 Redux 相比，可创建多个 Store，不需要在 Reducer 中返回 state 并且简化了 Action 和 Reducer 的创建步骤，原生支持异步能力，组件能做到精准重渲染。inula-X 均可使用函数组件、class 组件，能提供 redux 的适配接口及支持响应式的特点。
+
+#### 路由 inula-router
+
+inula-router 为 openInula 提供前端路由的能力，是构建大型应用必要组件，涵盖 react-router、history、connect-react-router 的功能。
+
+#### 请求 inula-request
+
+inula-request 是 openInula 的网络请求组件，不仅涵盖常见的网络请求方式，还提供动态轮询钩子函数给用户更便捷的定制化请求体验。
+
+#### 国际化 inula-intl
+
+inula-intl 是基于 openInula 的国际化组件，涵盖了基本的国际化组件和钩子函数，允许用户更方便地构建国际化能力。
+
+#### 调试工具 inula-dev-tools
+
+inula-dev-tools 是一个为 openInula 开发者提供的强大工具集，能够方便地查看和编辑组件树、管理应用状态以及进行性能分析，极大提高了开发效率和诊断问题的便捷性。
+
+#### 脚手架 create-inula
+
+create-inula 是一套用于创建 openInula 项目的脚手架工具。它预置了一系列项目模板，允许开发者通过命令行按需快速生成可运行的项目代码。
+
+## 参与贡献
+
+我们鼓励开发者以各种方式参与代码贡献、生态拓展或文档反馈，献您的原创内容，详细请参考[贡献指南](https://docs.openinula.net/docs/%E8%B4%A1%E7%8C%AE%E6%8C%87%E5%8D%97)。
+
+### 官方链接
+
+欢迎访问 openInula 官网与文档仓库，参与 openInula 开发者文档开源项目，与我们一起完善开发者文档。
+
+* openInula 官网：[https://www.openinula.net/](https://www.openinula.net/)
+* openInula 文档：[https://docs.openinula.net/](https://docs.openinula.net/)
+* openInula 仓库地址：[https://gitee.com/openinula/inula](https://gitee.com/openinula/inula)
+* openInula 社提案备忘录（RFC）：[https://gitee.com/openInula/rfcs](https://gitee.com/openInula/rfcs)
+
+### 社区贡献者案例
+
+**[`umi-inula`](https://gitee.com/congxiaochen/inula)**
+
+基于 umijs 与 openInula 的开发框架，集成官方组件与UI、AIGC等功能，开箱即用。
+
+**[`VoerkaI18n`](https://github.com/zhangfisher/voerka-i18n/)**
+
+适用于多框架的 JavaScript 国际化解决方案，提供对 openInula 的适配。
+
+- [适配示例](https://gitee.com/link?target=https%3A%2F%2Fgithub.com%2Fzhangfisher%2Fvoerka-i18n%2Ftree%2Fmaster%2Fexamples%2Fopeninula)
+- [适配文档](https://gitee.com/link?target=https%3A%2F%2Fzhangfisher.github.io%2Fvoerka-i18n%2F%23%2Fzh%2Fguide%2Fintegration%2Fopeninula)
+
+## 许可协议
+
+openInula 主要遵循 [Mulan Permissive Software License v2](http://license.coscl.org.cn/MulanPSL2) 协议，详情请参考各代码仓 LICENSE 声明。
+
+## 联系方式
+
+* 官方邮箱: [team@inulajs.org](mailto:team@inulajs.org)
+
+* 微信公众号:
+
+![](https://www.openinula.net/assets/qrcode.inula-02f99d58.jpg)

RELEASE-NOTES.md

@@ -1,3 +1,28 @@
+# 0.0.2 版本
+
+## 新特性
+
+- **inula-request** 新增响应体中获取完整 URL 能力。
+
+## API变更
+
+无
+
+## Bug修复
+
+- **inula** 解决事件卸载失败问题。
+- **inula** 解决 mouseover 重复触发 mouseEnter 事件问题。
+- **inula** 大数组合并使用 concat。
+- **inula** 事件支持 defaultPrevented 属性
+
+## CVE漏洞修复
+
+无
+
+## 已知问题
+
+无
+
 # 0.0.1 版本
 
 ## 新特性

commitlint.config.js

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2024 Huawei Technologies Co.,Ltd.
+ *
+ * openInula is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *          http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+module.exports = {
+  extends: ['@commitlint/config-conventional'],
+  'type-enum': ['build', 'chore', 'ci', 'docs', 'feat', 'fix', 'perf', 'refactor', 'revert', 'style', 'test', 'types'],
+};

package.json

@@ -1,69 +1,90 @@
 {
-  "name": "inulajs",
-  "description": "InulaJS is a JavaScript framework library.",
+  "name": "inula",
+  "description": "OpenInula is a JavaScript framework library.",
   "version": "0.0.1",
   "private": true,
   "scripts": {
     "lint": "eslint . --ext .ts --fix",
-    "prettier": "prettier -w libs/**/*.ts",
-    "build:inula": "pnpm -F inulajs build",
-    "test:inula": "pnpm -F inulajs test",
+    "lint-commit": "lint-staged",
+    "prettier": "prettier .prettierrc.js -w packages/**/*.{ts,tsx,js,jsx}",
+    "build:inula": "pnpm -F openinula build",
+    "test:inula": "pnpm -F openinula test",
+    "test:inula-intl": "pnpm -F inula-intl test",
+    "test:inula-request": "pnpm -F inula-request test",
+    "test:inula-router": "pnpm -F inula-router test",
     "build:inula-cli": "pnpm -F inula-cli build",
-    "build:inula-intl": "pnpm -F inula-intl rollup-build",
+    "build:inula-intl": "pnpm -F inula-intl build",
     "build:inula-request": "pnpm -F inula-request build",
-    "build:inula-router": "pnpm -F inula-router build"
+    "build:inula-router": "pnpm -F inula-router build",
+    "commitlint": "commitlint --config commitlint.config.js -e",
+    "postinstall": "husky install"
+  },
+  "lint-staged": {
+    "*.{js,jsx,ts,tsx}": [
+      "prettier .prettierrc.js -w"
+    ]
   },
   "devDependencies": {
-    "@babel/core": "7.16.7",
-    "@babel/plugin-proposal-class-properties": "7.16.7",
-    "@babel/plugin-proposal-nullish-coalescing-operator": "7.16.7",
-    "@babel/plugin-proposal-object-rest-spread": "7.16.7",
-    "@babel/plugin-proposal-optional-chaining": "7.16.7",
-    "@babel/plugin-proposal-private-methods": "7.16.7",
-    "@babel/plugin-proposal-private-property-in-object": "7.16.7",
-    "@babel/plugin-syntax-jsx": "7.16.7",
-    "@babel/plugin-transform-arrow-functions": "7.16.7",
-    "@babel/plugin-transform-block-scoped-functions": "7.16.7",
-    "@babel/plugin-transform-block-scoping": "7.16.7",
-    "@babel/plugin-transform-classes": "7.16.7",
-    "@babel/plugin-transform-computed-properties": "7.16.7",
-    "@babel/plugin-transform-destructuring": "7.16.7",
-    "@babel/plugin-transform-for-of": "7.16.7",
-    "@babel/plugin-transform-literals": "7.16.7",
-    "@babel/plugin-transform-object-assign": "7.16.7",
-    "@babel/plugin-transform-object-super": "7.16.7",
-    "@babel/plugin-transform-parameters": "7.16.7",
-    "@babel/plugin-transform-react-jsx": "7.16.7",
-    "@babel/plugin-transform-react-jsx-source": "^7.16.7",
-    "@babel/plugin-transform-runtime": "7.16.7",
-    "@babel/plugin-transform-shorthand-properties": "7.16.7",
-    "@babel/plugin-transform-spread": "7.16.7",
-    "@babel/plugin-transform-template-literals": "7.16.7",
-    "@babel/preset-env": "7.16.7",
-    "@babel/preset-typescript": "7.16.7",
-    "@babel/runtime": "7.16.7",
-    "@rollup/plugin-babel": "^5.3.1",
-    "@rollup/plugin-node-resolve": "^13.3.0",
+    "@babel/core": "7.23.7",
+    "@babel/plugin-proposal-class-properties": "7.18.6",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "7.18.6",
+    "@babel/plugin-proposal-object-rest-spread": "7.20.7",
+    "@babel/plugin-proposal-optional-chaining": "7.21.0",
+    "@babel/plugin-proposal-private-methods": "7.18.6",
+    "@babel/plugin-proposal-private-property-in-object": "7.21.11",
+    "@babel/plugin-syntax-jsx": "7.23.3",
+    "@babel/plugin-transform-arrow-functions": "7.23.3",
+    "@babel/plugin-transform-block-scoped-functions": "7.23.3",
+    "@babel/plugin-transform-block-scoping": "7.23.4",
+    "@babel/plugin-transform-classes": "7.23.8",
+    "@babel/plugin-transform-computed-properties": "7.23.3",
+    "@babel/plugin-transform-destructuring": "7.23.3",
+    "@babel/plugin-transform-for-of": "7.23.6",
+    "@babel/plugin-transform-literals": "7.23.3",
+    "@babel/plugin-transform-object-assign": "7.23.3",
+    "@babel/plugin-transform-object-super": "7.23.3",
+    "@babel/plugin-transform-parameters": "7.23.3",
+    "@babel/plugin-transform-react-jsx": "7.23.4",
+    "@babel/plugin-transform-react-jsx-source": "^7.23.3",
+    "@babel/plugin-transform-runtime": "7.23.7",
+    "@babel/plugin-transform-shorthand-properties": "7.23.3",
+    "@babel/plugin-transform-spread": "7.23.3",
+    "@babel/plugin-transform-template-literals": "7.23.3",
+    "@babel/preset-env": "7.23.8",
+    "@babel/preset-typescript": "7.23.3",
+    "@babel/runtime": "7.23.8",
+    "@commitlint/cli": "^17.8.1",
+    "@commitlint/config-conventional": "^17.8.1",
+    "@rollup/plugin-babel": "^6.0.4",
+    "@rollup/plugin-node-resolve": "^15.2.3",
     "@rollup/plugin-replace": "^4.0.0",
-    "@types/jest": "^26.0.24",
+    "@types/jest": "^29.5.11",
     "@types/node": "^17.0.18",
-    "@typescript-eslint/eslint-plugin": "4.8.0",
-    "@typescript-eslint/parser": "4.8.0",
-    "babel-jest": "^27.5.1",
+    "@typescript-eslint/eslint-plugin": "^6.18.1",
+    "@typescript-eslint/parser": "6.18.1",
+    "@babel/parser": "^7.24.7",
+    "magic-string": "^0.30.10",
+    "babel-jest": "^29.7.0",
     "ejs": "^3.1.8",
-    "eslint": "7.13.0",
+    "eslint": "^8.56.0",
     "eslint-config-prettier": "^6.9.0",
     "eslint-plugin-jest": "^22.15.0",
-    "eslint-plugin-no-for-of-loops": "^1.0.0",
     "eslint-plugin-no-function-declare-after-return": "^1.0.0",
     "eslint-plugin-react": "7.14.3",
-    "jest": "^25.5.4",
-    "jest-environment-jsdom-sixteen": "^1.0.3",
-    "prettier": "2.6.2",
-    "rollup": "^2.75.5",
+    "husky": "^8.0.3",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "lint-staged": "^15.2.0",
+    "openinula": "workspace:*",
+    "prettier": "^3.1.1",
+    "rollup": "^2.79.1",
+    "rollup-plugin-dts": "^6.1.0",
     "rollup-plugin-execute": "^1.1.1",
     "rollup-plugin-terser": "^7.0.2",
-    "typescript": "4.2.3"
+    "rollup-plugin-esbuild": "^6.1.1",
+    "rollup-plugin-polyfill-node": "^0.13.0",
+    "ts-jest": "^29.1.1",
+    "typescript": "^4.9.5"
   },
   "engines": {
     "node": ">=10.x",

packages/create-inula/.prettierrc.js

@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2023 Huawei Technologies Co.,Ltd.
- *
- * openInula is licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *
- *          http://license.coscl.org.cn/MulanPSL2
- *
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- */
-
-'use strict';
-
-module.exports = {
-  printWidth: 120, // 一行120字符数，如果超过会进行换行
-  tabWidth: 2, // tab等2个空格
-  useTabs: false, // 用空格缩进行
-  semi: true, // 行尾使用分号
-  singleQuote: true, // 字符串使用单引号
-  quoteProps: 'as-needed', // 仅在需要时在对象属性添加引号
-  jsxSingleQuote: false, // 在JSX中使用双引号
-  trailingComma: 'es5', // 使用尾逗号(对象、数组等)
-  bracketSpacing: true, // 对象的括号间增加空格
-  bracketSameLine: false, // 将多行JSX元素的>放在最后一行的末尾
-  arrowParens: 'avoid', // 在唯一的arrow函数参数周围省略括号
-  vueIndentScriptAndStyle: false, // 不缩进Vue文件中的<script>和<style>标记内的代码
-  endOfLine: 'lf', // 仅限换行（\n）
-};

packages/create-inula/lib/BasicGenerator.js

@@ -128,9 +128,9 @@ class BasicGenerator extends Generator {
         if (fs.existsSync(fullpath)) {
           this.traverseDirCapture(fullpath, dirCallback, fileCallback);
         }
-        continue;
+      } else {
+        fileCallback(fullpath);
       }
-      fileCallback(fullpath);
     }
   }
 
@@ -140,9 +140,9 @@ class BasicGenerator extends Generator {
       if (fs.lstatSync(fullpath).isDirectory()) {
         this.traverseDirBubble(fullpath, dirCallback, fileCallback);
         dirCallback(fullpath);
-        continue;
+      } else {
+        fileCallback(fullpath);
       }
-      fileCallback(fullpath);
     }
   }
 

packages/create-inula/lib/generators/Simple-app/templates/vite/package.json

@@ -11,7 +11,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "inulajs": "^0.0.11"
+    "openinula": "^0.1.1"
   },
   "devDependencies": {
     "@babel/core": "^7.21.4",

packages/create-inula/lib/generators/Simple-app/templates/vite/src/index.jsx

@@ -13,7 +13,7 @@
  * See the Mulan PSL v2 for more details.
  */
 
-import Inula from 'inulajs';
+import Inula from 'openinula';
 import './index.css';
 
 function App() {
@@ -34,7 +34,9 @@ function App() {
           <h2>了解更多</h2>
           <p>
             要了解 Inula，查看{' '}
-            <a href="https://openinula.com/" target="_blank">Inula 官网</a>
+            <a href="https://openinula.net/" target="_blank">
+              Inula 官网
+            </a>
           </p>
         </div>
       </div>

packages/create-inula/lib/generators/Simple-app/templates/vite/vite.config.js

@@ -16,9 +16,9 @@
 import react from '@vitejs/plugin-react';
 
 let alias = {
-  react: 'inulajs', // 新增
-  'react-dom': 'inulajs', // 新增
-  'react/jsx-dev-runtime': 'inulajs/jsx-dev-runtime',
+  react: 'openinula', // 新增
+  'react-dom': 'openinula', // 新增
+  'react/jsx-dev-runtime': 'openinula/jsx-dev-runtime',
 };
 
 export default {

packages/create-inula/lib/generators/Simple-app/templates/webpack/package.json

@@ -10,7 +10,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "inulajs": "^0.0.11"
+    "openinula": "^0.1.1"
   },
   "devDependencies": {
     "@babel/core": "^7.21.4",

packages/create-inula/lib/generators/Simple-app/templates/webpack/src/App.js

@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 2023 Huawei Technologies Co.,Ltd.
- *
- * openInula is licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *
- *          http://license.coscl.org.cn/MulanPSL2
- *
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- */
-
-import Inula from 'inulajs';
-import './styles.css';
-
-class App extends Inula.Component {
-  render() {
-    return (
-      <div class="container">
-        <div class="hero">
-          <h1 class="hero-title animate__animated animate__bounceInDown">欢迎来到 Inula 项目!</h1>
-          <p class="hero-subtitle animate__animated animate__bounceInUp">你已成功创建你的第一个 Inula 项目</p>
-        </div>
-        <div class="content">
-          <div class="card animate__animated animate__zoomIn">
-            <h2>开始吧</h2>
-            <p>
-              编辑 <code>src/App.js</code> 并保存以重新加载。
-            </p>
-          </div>
-          <div class="card animate__animated animate__zoomIn">
-            <h2>了解更多</h2>
-          <p>
-            要了解 Inula，查看{' '}
-            <a href="https://inulajs.org" target="_blank">Inula 官网</a>
-          </p>
-          </div>
-        </div>
-      </div>
-    );
-  }
-}
-
-export default App;

packages/create-inula/lib/generators/Simple-app/templates/webpack/src/index.js

@@ -1,19 +0,0 @@
-/*
- * Copyright (c) 2023 Huawei Technologies Co.,Ltd.
- *
- * openInula is licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *
- *          http://license.coscl.org.cn/MulanPSL2
- *
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- */
-
-import Inula from 'inulajs';
-import App from './App';
-
-Inula.render(<App />, document.getElementById('root'));

packages/create-inula/lib/generators/Simple-app/templates/webpack/webpack.config.js

@@ -17,7 +17,7 @@ const path = require('path');
 const HtmlWebpackPlugin = require('html-webpack-plugin');
 
 module.exports = {
-  entry: './src/index.js',
+  entry: './src/index.jsx',
   output: {
     path: path.resolve(__dirname, 'dist'),
     filename: 'bundle.js',
@@ -36,7 +36,7 @@ module.exports = {
                 '@babel/preset-react',
                 {
                   runtime: 'automatic', // 新增
-                  importSource: 'inulajs', // 新增
+                  importSource: 'openinula', // 新增
                 },
               ],
             ],
@@ -78,4 +78,7 @@ module.exports = {
     port: 9000,
     open: true,
   },
+  resolve: {
+    extensions: ['.mjs', '.js', '.mts', '.ts', '.jsx', '.tsx', '.json'],
+  },
 };

packages/create-inula/lib/run.js

@@ -32,8 +32,8 @@ const generatorType = fs
   });
 
 const runGenerator = async (templatePath, { name = '', cwd = process.cwd(), args = {} }) => {
+  let currentPath;
   return new Promise(resolve => {
-    let currentPath;
     if (name) {
       mkdirp.sync(name);
       currentPath = path.join(cwd, name);
@@ -46,7 +46,7 @@ const runGenerator = async (templatePath, { name = '', cwd = process.cwd(), args
     const generator = new Generator({
       name,
       env,
-      resolved: path.join(__dirname, templatePath),
+      resolved: require.resolve(templatePath),
       args,
     });
     return generator.run(() => {
@@ -62,7 +62,17 @@ const run = async config => {
   }
   process.emit('message', { type: 'prompt' });
 
-  let { type } = config;
+  let { type, name } = config;
+  if (!name) {
+    const answers = await inquirer.prompt([
+      {
+        name: 'projectName',
+        message: 'Project name',
+        type: 'input',
+      },
+    ]);
+    config.name = answers.projectName;
+  }
   if (!type) {
     const answers = await inquirer.prompt([
       {

packages/create-inula/package.json

@@ -1,11 +1,14 @@
 {
   "name": "create-inula",
-  "version": "1.0.22",
+  "version": "0.0.8",
   "description": "",
   "main": "index.js",
   "bin": {
     "create-inula": "bin/cli.js"
   },
+  "engines": {
+    "node": ">= 18.0.0"
+  },
   "files": [
     "bin",
     "lib",
@@ -13,17 +16,17 @@
     "package.json"
   ],
   "author": "",
-  "license": "ISC",
+  "license": "MulanPSL2",
   "dependencies": {
     "glob": "^10.3.3",
     "inquirer": "^8.0.0",
     "mkdirp": "^3.0.1",
     "yargs-parser": "^21.1.1",
     "yeoman-environment": "^3.15.0",
-    "yeoman-generator": "^5.8.0"
+    "yeoman-generator": "^5.8.0",
+    "chalk": "^4.1.2"
   },
   "devDependencies": {
-    "chalk": "^4.1.2",
     "lodash": "^4.17.21"
   }
 }

packages/inula-cli/.eslintrc.cjs

@@ -1,55 +0,0 @@
-/*
- * Copyright (c) 2023 Huawei Technologies Co.,Ltd.
- *
- * openInula is licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *
- *          http://license.coscl.org.cn/MulanPSL2
- *
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- */
-
-module.exports = {
-  'parser': 'babel-eslint',
-  'env': {
-    'amd': true,
-    'es6': true,
-    'browser': true,
-    'node': false
-  },
-  'parserOptions': {
-    'ecmaVersion': 6,
-    'sourceType': 'module',
-    'ecmaFeatures': {
-      'jsx': true
-    }
-  },
-  'ignorePatterns': [
-    "src/template"
-  ],
-  'rules': {
-    'indent': [
-      'error',
-      4,
-      {
-        SwitchCase: 1,
-        flatTernaryExpressions: true
-      }
-    ],
-    'no-unused-vars': 'off',  // 允许变量声明后未使用
-    'no-debugger': process.env.NODE_ENV === 'production' ? 'error' : 'off',
-    "no-underscore-dangle": ["off", "always"],  // 允许私有变量 _xxx的变量命名方式
-    'filenames/match-exported': 0,
-    'consistent-return': 0,
-    "comma-dangle": [2, "never"], //  组和对象键值对最后一个逗号， never参数：不能带末尾的逗号, always参数：必须带末尾的逗号
-    'global-require': 0, // 允许require语句不出现在顶层中
-    'no-nested-ternary': 0, //  允许嵌套三元表达式
-    'no-unused-expressions': 0, // 允许使用未执行的表达式。比如fn是一个函数，允许 fn && fn()
-    'no-throw-literal': 0, // 允许throw抛出对象格式
-    '@typescript-eslint/member-ordering': 0 // 禁用TypeScript声明规范
-  }
-}

packages/inula-cli/.prettierignore

@@ -1,3 +0,0 @@
-node_modules/
-webpack/
-public/

packages/inula-cli/.prettierrc.js

@@ -1,30 +0,0 @@
-/*
- * Copyright (c) 2023 Huawei Technologies Co.,Ltd.
- *
- * openInula is licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *
- *          http://license.coscl.org.cn/MulanPSL2
- *
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- */
-
-export default {
-  printWidth: 120, // 一行120字符数，如果超过会进行换行
-  tabWidth: 2, // tab等2个空格
-  useTabs: false, // 用空格缩进行
-  semi: true, // 行尾使用分号
-  singleQuote: true, // 字符串使用单引号
-  quoteProps: 'as-needed', // 仅在需要时在对象属性添加引号
-  jsxSingleQuote: false, // 在JSX中使用双引号
-  trailingComma: 'es5', // 使用尾逗号(对象、数组等)
-  bracketSpacing: true, // 对象的括号间增加空格
-  jsxBracketSameLine: false, // 将多行JSX元素的>放在最后一行的末尾
-  arrowParens: 'avoid', // 在唯一的arrow函数参数周围省略括号
-  vueIndentScriptAndStyle: false, // 不缩进Vue文件中的<script>和<style>标记内的代码
-  endOfLine: 'lf', // 仅限换行（\n）
-};

packages/inula-cli/README.md

@@ -2,23 +2,23 @@
 
 ## 一、安装使用
 
-### 安装Nodejs
+### 安装Node.js
 
-inula-cli的运行需要依赖Nodejs，使用前请确保您的电脑已安装Nodejs，并且版本在16以上。您可以通过在控制台执行以下命令来确认您的版本。
+inula-cli的运行需要依赖Node.js，使用前请确保您的电脑已安装Node.js，并且版本在16以上。您可以通过在控制台执行以下命令来确认您的版本。
 
-```
+```shell
 >node -v
 
 v16.4.0
 ```
 
-如果您没有安装Nodejs，或者Nodejs版本不满足条件，推荐使用nvm工具安装和管理Nodejs版本。
+如果您没有安装Node.js，或者Node.js版本不满足条件，推荐使用nvm工具安装和管理Node.js版本。
 
 nvm最新版本下载: [https://github.com/coreybutler/nvm-windows/releases](https://links.jianshu.com/go?to=https%3A%2F%2Fgithub.com%2Fcoreybutler%2Fnvm-windows%2Freleases)
 
-安装nvm之后，可以通过如下命令安装Nodejs:
+安装nvm之后，可以通过如下命令安装Node.js:
 
-```
+```shell
 >node install 16
 
 >node use 16
@@ -28,15 +28,15 @@ nvm最新版本下载: [https://github.com/coreybutler/nvm-windows/releases](htt
 
 ### 安装inula-cli
 
-为了方便使用inula-cli的功能，推荐您全局安装inula-cli。Nodejs安装会自带npm工具用于管理模块，您可以直接运行如下命令：
+为了方便使用inula-cli的功能，推荐您全局安装inula-cli。Node.js安装会自带npm工具用于管理模块，您可以直接运行如下命令：
 
-```
+```shell
 >npm install -g inula-cli
 ```
 
 安装完成后，使用inula-cli version命令确认安装是否完成。
 
-```
+```shell
 >inula-cli version
 1.1.0
 ```
@@ -93,7 +93,7 @@ inula-cli支持用户通过项目根目录下的.inula.ts或者.inula.js文件
 
 在配置文件中，您需要默认导出一个配置，以下为一个简单的配置文件示例：
 
-```
+```typescript
 // .inula.ts
 
 export default {
@@ -113,7 +113,7 @@ export default {
 
 对于TypeScript类型，我们也提供了类型定义以供开发时自动补全：
 
-```
+```typescript
 // .inula.ts
 
 import { defineConfig } from "inula-cli"
@@ -164,8 +164,8 @@ inula-cli的所有功能都围绕插件展开，插件可以很方便地让用
 
 内置插件在inula-cli运行时会自动加载，用户可以直接调用这些内置命令，当前支持的内置插件功能如下：
 
-| 序号 | 插件功能                 | 触发命令            |
-| ---- | :----------------------- | ------------------- |
+| 序号 | 插件功能                 | 触发命令          |
+| ---- | :----------------------- | ----------------- |
 | 1、  | 本地开发构建             | inula-cli dev     |
 | 2、  | 生产构建                 | inula-cli build   |
 | 3、  | 接口mock能力             | inula-cli dev     |
@@ -180,13 +180,13 @@ inula-cli支持用户集成已发布在npm仓库的插件，用户可以按需
 
 安装可以通过npm安装，这里以插件@inula/add为例：
 
-```
+```shell
 npm i --save-dev @inula/add
 ```
 
 如果需要运行插件，需要在配置文件中配置对应的插件路径
 
-```
+```typescript
 // .inula.ts
 
 export default {
@@ -205,7 +205,7 @@ export default {
 
 1、编写命令插件文件，这里我们自定义了一个conf命令用于展示当前项目的配置信息。
 
-```
+```typescript
 // conf.ts
 
 import { API } from "inula-cli";
@@ -224,7 +224,7 @@ export default (api: API) => {
 
 2、在配置文件中加入对插件的引用
 
-```
+```typescript
 // .inula.ts
 
 export default  {
@@ -232,9 +232,9 @@ export default  {
 }
 ```
 
-3、在项目根目录下执行inula-cli conf即可触发插件运行。
+3、在项目根目录下执行`inula-cli conf`即可触发插件运行。
 
-```
+```shell
 > inula-cli conf
 current user config is: {
   plugins: [ './conf', './showConf' ],
@@ -247,7 +247,7 @@ inula-cli提供了hook机制可以让开发者在执行命令时实现事件监
 
 1、使用插件注册hook
 
-```
+```typescript
 // modifyConfig.ts
 
 import { API } from "inula-cli";
@@ -267,7 +267,7 @@ export default (api: API) => {
 
 2、在插件中触发hook
 
-```
+```typescript
 // conf.ts
 
 import { API } from "inula-cli";
@@ -287,7 +287,7 @@ export default (api: API) => {
 
 3、在配置文件中加入插件
 
-```
+```typescript
 // .inula.ts
 
 export default  {
@@ -297,7 +297,7 @@ export default  {
 
 4、触发命令
 
-```
+```shell
 > inula-cli conf
 current user config is: {
   plugins: [ './conf', './showConf' ],
@@ -327,7 +327,7 @@ current user config is: {
 
 registerCommand方法允许用户自定义inula-cli的执行命令，
 
-```
+```typescript
  api.registerCommand({
         name: string,
         description?: string,
@@ -343,15 +343,15 @@ registerCommand方法允许用户自定义inula-cli的执行命令，
 
 使用示例：
 
-```
+```typescript
 import { API } from "inula-cli";
 
 export default (api: API) => {
     api.registerCommand({
         name: "conf",
         description: "show user config",
-        initalState: api.userConfig,
-        fn: async function (args: any, config: any) {
+        initialState: api.userConfig,
+        fn: async function (args: any, state: any) {
             console.log("current user config is: ", state);
         }
     })
@@ -374,7 +374,7 @@ api.registerHook({
 
 使用示例：
 
-```
+```typescript
 import { API } from "inula-cli";
 
 export default (api: API) => {
@@ -403,7 +403,7 @@ applyHook(name: string, value?: any})
 
 使用示例：
 
-```
+```typescript
 import { API } from "inula-cli";
 
 export default (api: API) => {
@@ -427,7 +427,7 @@ export default (api: API) => {
 
 inula-cli默认集成生产构建能力，用户可以通过在.inula.ts中配置buildConfig字段启用功能。配置示例如下：
 
-```
+```typescript
 // .inula.ts
 
 // 使用webpack构建
@@ -460,7 +460,7 @@ export default {
 
 生产构建支持传入多个配置文件路径，使用webpack构建还支持配置文件以函数方式导出，inula-cli会将配置中的env和args作为参数传递到函数中执行以获取最后的构建配置。
 
-```
+```typescript
 // webpack.config.js
 
 module.exports = function (env, argv) {
@@ -497,7 +497,7 @@ export default {
 
 inula-cli默认也支持项目本地构建，用户可以通过在.inula.ts中配置devBuildConfig字段启用功能。配置示例如下：
 
-```
+```typescript
 // .inula.ts
 
 // 使用webpack构建
@@ -552,7 +552,7 @@ inula-cli自动将项目根路径里/Mock目录下所有文件视为mock文件
 
 如果您想修改Mock目录位置，可以在配置文件中修改mockPath。如果不配置该参数，默认使用"./mock"。
 
-```
+```typescript
 // .inula.ts
 export default {
     ...
@@ -569,7 +569,7 @@ export default {
 
 Mock文件需要默认导出一个对象，key为"请求方式 接口名"，值为接口实现。示例如下：
 
-```
+```typescript
 export default {
     "GET /api/user": (req, res) => {
         res.status(200).json("admin")
@@ -579,7 +579,7 @@ export default {
 
 如果想要一次mock多个接口，可以在导出对象中设置多个key，例如：
 
-```
+```typescript
 export default {
     "GET /api/user": (req, res) => {
         res.status(200).json("admin");
@@ -597,7 +597,7 @@ export default {
 
 Mock文件默认导出一个数组，数组每一个成员示例如下：
 
-```
+```typescript
 export default [
   {
     url: '/api/get',
@@ -654,7 +654,7 @@ export default [
 
 在框架配置文件中，开发者需要配置远端服务器地址以及编写自定义的matcher函数提供给框架：
 
-```
+```typescript
 // .inula.ts
 
 const matcher = (pathname, request) => {
@@ -689,7 +689,7 @@ export default  {
 
 用户可以在.inula.ts中配置remoteProxy字段开启远端静态接口代理能力，完成配置后，使用后执行inula-cli proxy启动该功能。
 
-```
+```typescript
 // .inula.ts
 
 export default {
@@ -710,6 +710,3 @@ export default {
   }
 }
 ```
-
-
-

packages/inula-cli/bin/start.js

@@ -17,4 +17,4 @@
 
 import run from '../lib/cli/cli.js';
 
-run();
+run();

packages/inula-cli/externals.d.ts

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2023 Huawei Technologies Co.,Ltd.
+ *
+ * openInula is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *          http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+declare module 'crequire';

packages/inula-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inula-cli",
-  "version": "0.0.1",
+  "version": "0.0.4",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -14,10 +14,11 @@
     "lib",
     "template",
     "package.json",
-    "tsconfig.json"
+    "tsconfig.json",
+    "README.md"
   ],
   "author": "",
-  "license": "ISC",
+  "license": "MulanPSL2",
   "type": "module",
   "devDependencies": {
     "@types/body-parser": "^1.19.2",

packages/inula-cli/src/builtInPlugins/command/build/build.ts

@@ -1,51 +0,0 @@
-/*
- * Copyright (c) 2023 Huawei Technologies Co.,Ltd.
- *
- * openInula is licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *
- *          http://license.coscl.org.cn/MulanPSL2
- *
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
- * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
- * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v2 for more details.
- */
-
-import webpack from 'webpack';
-import { build } from 'vite';
-
-export default (api: any) => {
-  api.registerCommand({
-    name: 'build',
-    description: 'build application for production',
-    initialState: api.buildConfig,
-    fn: async function (args: any, state: any) {
-      switch (api.compileMode) {
-        case 'webpack':
-          if (state) {
-            api.applyHook({ name: 'beforeCompile', args: state });
-            state.forEach((s: any) => {
-              webpack(s.config, (err: any, stats: any) => {
-                if (err || stats.hasErrors()) {
-                  api.logger.error(`Build failed.err: ${err}, stats:${stats}`);
-                }
-              });
-            });
-          } else {
-            api.logger.error(`Build failed. Can't find build config.`);
-          }
-          break;
-        case 'vite':
-          if (state) {
-            api.applyHook({ name: 'beforeCompile' });
-            build(state);
-          } else {
-            api.logger.error(`Build failed. Can't find build config.`);
-          }
-          break;
-      }
-    },
-  });
-};

packages/inula-cli/src/builtInPlugins/command/dev/buildDev.ts

@@ -19,7 +19,6 @@ import { createServer } from 'vite';
 import { API } from '../../../types/types';
 import setupProxy from '../../../utils/setupProxy.js';
 
-
 export default (api: API) => {
   api.registerCommand({
     name: 'dev',
@@ -46,7 +45,7 @@ export default (api: API) => {
             if (api.userConfig.devBuildConfig.devProxy) {
               devServerOptions.onBeforeSetupMiddleware = (devServer: WebpackDevServer) => {
                 setupProxy(devServer.app, api);
-              }
+              };
             }
 
             api.applyHook({
@@ -58,7 +57,7 @@ export default (api: API) => {
               api.applyHook({ name: 'afterStartDevServer' });
             });
           } else {
-            api.logger.error('Can\'t find config');
+            api.logger.error("Can't find config");
           }
           break;
         case 'vite':
@@ -71,7 +70,7 @@ export default (api: API) => {
                 server.printUrls();
               });
           } else {
-            api.logger.error('Can\'t find config');
+            api.logger.error("Can't find config");
           }
           break;
         default:

packages/inula-cli/src/builtInPlugins/command/generate/generate.ts

@@ -39,9 +39,11 @@ export default (api: API) => {
 
       switch (args._[0]) {
         case 'jest':
-          args._.shift();
-          const isESM = api.packageJson['type'] === 'module';
-          await generateJest(args, api.cwd, isESM);
+          {
+            args._.shift();
+            const isESM = api.packageJson['type'] === 'module';
+            await generateJest(args, api.cwd, isESM);
+          }
           break;
         default:
       }
@@ -50,7 +52,7 @@ export default (api: API) => {
 };
 
 const generateJest = async (args: yargsParser.Arguments, cwd: string, isESM: boolean) => {
-  let isTs: boolean = false;
+  let isTs = false;
   if (args['ts']) {
     isTs = true;
   } else {

packages/inula-cli/src/builtInPlugins/command/proxy/proxy.ts

@@ -25,7 +25,7 @@ export default (api: any) => {
     initialState: api.userConfig.remoteProxy,
     fn: async function (args: any, state: any) {
       if (!state) {
-        api.logger.error(`Invalid proxy config!`);
+        api.logger.error('Invalid proxy config!');
         return;
       }
       const app = express();

packages/inula-cli/src/cli/cli.ts

@@ -46,7 +46,7 @@ export default async function run() {
   initializeEnv();
 
   if (command === 'version' || command === 'help') {
-    process.env.INNER_COMMAND = "true"
+    process.env.INNER_COMMAND = 'true';
   }
 
   switch (command) {
@@ -61,9 +61,9 @@ export default async function run() {
       break;
   }
 
-  let enableDebug: boolean = false;
+  let enableDebug = false;
 
-  if (process.env.DEBUG === "true") {
+  if (process.env.DEBUG === 'true') {
     enableDebug = true;
   }
 

packages/inula-cli/src/config/Config.ts

@@ -89,7 +89,7 @@ export default class Config {
 
   getConfigFile(): string | null {
     const configFileList: string[] = DEFAULT_CONFIG_FILES.map(f => join(this.cwd, f));
-    for (let configFile of configFileList) {
+    for (const configFile of configFileList) {
       if (existsSync(configFile)) {
         return configFile;
       }

packages/inula-cli/src/core/Hub.ts

@@ -46,11 +46,11 @@ export default class Hub {
   userConfig: UserConfig = {};
   packageJson: PackageJSON;
   stage: ServiceStage = ServiceStage.uninitialized;
-  buildConfig: {name:string, config: object}[] = [];
+  buildConfig: { name: string; config: Record<string, unknown> }[] = [];
   pluginManager: Plugin;
   buildConfigPath: BuildConfig[] = [];
-  devBuildConfig: object = {};
-  compileMode: string = '';
+  devBuildConfig: Record<string, unknown> = {};
+  compileMode = '';
   builtInPlugins: string[] = [];
   pluginPaths: string[] = [];
   devProxy: DevProxy | null = null;
@@ -95,7 +95,7 @@ export default class Hub {
     this.userConfig = await this.configManager.getUserConfig();
 
     // 设置编译模式
-    this.setCompileMode()
+    this.setCompileMode();
 
     // 获取编译配置
     await this.analyzeBuildConfig();
@@ -135,8 +135,8 @@ export default class Hub {
         : this.pluginManager.commands[command];
 
     if (commands === undefined) {
-      this.logger.error(`Invalid command ${command}`)
-      return
+      this.logger.error(`Invalid command ${command}`);
+      return;
     }
     const { fn } = commands as ICommand;
 
@@ -150,21 +150,22 @@ export default class Hub {
 
   async analyzeBuildConfig() {
     if (this.userConfig.devBuildConfig) {
-      let { name, path, env } = this.userConfig.devBuildConfig;
+      let { path } = this.userConfig.devBuildConfig;
+      const { env } = this.userConfig.devBuildConfig;
       path = isAbsolute(path) ? path : join(process.cwd(), path);
       if (!existsSync(path)) {
         this.logger.warn(`Cant't find dev build config. Path is ${path}`);
         return;
       }
       this.logger.debug(`Find dev build config. Path is ${path}`);
-      let bc = await loadModule<object | Function>(path);
+      const bc = await loadModule<Record<string, unknown> | ((...args: any[]) => any)>(path);
       if (bc == undefined) {
         return;
       }
 
       let finalBc = {};
       if (typeof bc === 'function') {
-        finalBc = bc(env)
+        finalBc = bc(env);
         this.devBuildConfig = finalBc;
         return;
       }
@@ -175,55 +176,54 @@ export default class Hub {
       }
     }
 
-
-
     if (!this.userConfig.buildConfig) {
       switch (this.compileMode) {
         case 'webpack':
-          this.buildConfigPath.push({name:'default', path:'./webpack.config.js'})
+          this.buildConfigPath.push({ name: 'default', path: './webpack.config.js' });
           break;
         case 'vite':
-          this.buildConfigPath.push({name:'default', path:'./vite.config.js'})
+          this.buildConfigPath.push({ name: 'default', path: './vite.config.js' });
           break;
         default:
           this.logger.warn(`Unknown compile mode ${this.compileMode}`);
           break;
       }
     } else {
-      this.userConfig.buildConfig.forEach((userBuildConfig) => {
+      this.userConfig.buildConfig.forEach(userBuildConfig => {
         if (typeof userBuildConfig === 'object') {
           this.buildConfigPath.push(userBuildConfig);
         }
-      })
+      });
     }
 
-    this.buildConfigPath.forEach(async (config) => {
-      let {name, path} = config;
+    this.buildConfigPath.forEach(async config => {
+      let { path } = config;
+      const { name } = config;
       path = isAbsolute(path) ? path : join(process.cwd(), path);
       if (!existsSync(path)) {
         this.logger.debug(`Cant't find build config. Path is ${path}`);
         return;
       }
       this.logger.debug(`Find build config. Path is ${path}`);
-      let bc = await loadModule<object | Function >(path);
+      const bc = await loadModule<Record<string, unknown> | ((...args: any[]) => any)>(path);
       if (bc == undefined) {
         return;
       }
 
       let finalBc = {};
       if (typeof bc === 'function') {
-        finalBc = bc(config.env)
-        this.buildConfig.push({name: name, config: finalBc});
+        finalBc = bc(config.env);
+        this.buildConfig.push({ name: name, config: finalBc });
         return;
       }
-      this.buildConfig.push({name: name, config: bc});
-    })
+      this.buildConfig.push({ name: name, config: bc });
+    });
   }
 
   getConfigName(name: string): string {
     name = name.replace('webpack.', '');
     name = name.replace('.js', '');
     name = name.replace('.ts', '');
-    return name
+    return name;
   }
 }

packages/inula-cli/src/plugin/Plugin.ts

@@ -36,7 +36,7 @@ export interface IPlugin {
   id: string;
   key: string;
   path: string;
-  apply: Function;
+  apply: (...args: any[]) => any;
 }
 
 export default class Plugin {
@@ -57,7 +57,7 @@ export default class Plugin {
   } = {};
   hub: Hub;
   logger: Logger;
-  registerFunction: Function[] = [];
+  registerFunction: ((...args: any[]) => any)[] = [];
   // 解决调用this[props]时ts提示属性未知
   [key: string]: any;
 
@@ -110,7 +110,7 @@ export default class Plugin {
     });
 
     for (const obj of objs) {
-      const module: Function | undefined = await loadModule(obj.path);
+      const module: ((...args: any[]) => any) | undefined = await loadModule(obj.path);
       if (module) {
         try {
           module(obj.api);
@@ -135,15 +135,11 @@ export default class Plugin {
     return new Proxy(pluginAPI, {
       get: (target: PluginAPI, prop: string) => {
         if (['userConfig', 'devBuildConfig', 'buildConfig', 'compileMode', 'packageJson', 'cwd'].includes(prop)) {
-          return typeof this.hub[prop] === 'function'
-            ? this.hub[prop].bind(this.hub)
-            : this.hub[prop];
+          return typeof this.hub[prop] === 'function' ? this.hub[prop].bind(this.hub) : this.hub[prop];
         }
 
         if (['setStore', 'logger', 'commands'].includes(prop)) {
-          return typeof this[prop] === 'function'
-            ? this[prop].bind(this)
-            : this[prop];
+          return typeof this[prop] === 'function' ? this[prop].bind(this) : this[prop];
         }
 
         return target[prop];

packages/inula-cli/src/plugin/PluginAPI.ts

@@ -55,11 +55,11 @@ export default class PluginAPI {
     this.register(hook);
   }
 
-  registerMethod(fn: Function) {
+  registerMethod(fn: (...args: any[]) => any) {
     this.manager.registerFunction.push(fn);
   }
 
-  async applyHook(name: string, args?: any ) {
+  async applyHook(name: string, args?: any) {
     const hooks: IHook[] = this.manager.hooks[name] || [];
     let config: any = undefined;
     for (const hook of hooks) {

packages/inula-cli/src/types/types.ts

@@ -19,11 +19,8 @@ import { Logger } from '../utils/logger.js';
 import type * as http from 'http';
 import type * as express from 'express';
 
-
-interface Request extends express.Request {
-}
-interface Response extends express.Response {
-}
+type Request = express.Request;
+type Response = express.Response;
 
 export interface IDep {
   [name: string]: string;
@@ -40,7 +37,7 @@ export interface IPlugin {
   id: string;
   key: string;
   path: string;
-  apply: Function;
+  apply: (...args: any[]) => any;
 
   config?: IPluginConfig;
   isPreset?: boolean;
@@ -48,7 +45,7 @@ export interface IPlugin {
 
 export interface IPluginConfig {
   default?: any;
-  onChange?: string | Function;
+  onChange?: string | ((...args: any[]) => any);
 }
 
 export interface IHook {
@@ -97,8 +94,8 @@ export interface API {
     (hook: IHook): void;
   };
   registerMethod: {
-    (method: Function): void;
-  }
+    (method: (...args: any[]) => any): void;
+  };
   applyHook: {
     (opts: applyHookConfig): void;
   };
@@ -136,22 +133,22 @@ export interface MockConfig {
 export interface DevBuildConfig {
   name: string;
   path: string;
-  args?: object;
-  env?: object;
+  args?: Record<string, unknown>;
+  env?: Record<string, unknown>;
   devProxy?: DevProxy;
 }
 
 export interface DevProxy {
   target: string;
-  matcher: ((pathname: string, req: Request) => boolean);
+  matcher: (pathname: string, req: Request) => boolean;
   onProxyRes: (proxyRes: http.IncomingMessage, req: Request, res: Response) => void;
 }
 
 export interface BuildConfig {
   name: string;
   path: string;
-  args?: object;
-  env?: object;
+  args?: Record<string, unknown>;
+  env?: Record<string, unknown>;
 }
 
 export type ExportUserConfig = UserConfig | Promise<UserConfig>;
@@ -165,4 +162,3 @@ export interface Arguments {
   '--'?: Array<string | number>;
   [argName: string]: any;
 }
-

packages/inula-cli/src/utils/build.ts

@@ -52,7 +52,7 @@ const buildConfig = async (fileName: string, format: 'esm' | 'cjs' = 'esm'): Pro
 
         return {
           loader: args.path.endsWith('.ts') ? 'ts' : 'js',
-          contents: contents
+          contents: contents,
         };
       });
     },

packages/inula-cli/src/utils/loadModule.ts

@@ -27,7 +27,6 @@ export async function loadModule<T>(filePath: string): Promise<T | undefined> {
   const isTsFile: boolean = filePath.endsWith('ts');
   const isJsFile: boolean = filePath.endsWith('js');
 
-
   let content: T | undefined;
 
   // js文件，可以直接通过import引用

packages/inula-cli/src/utils/logger.ts

@@ -15,8 +15,8 @@
 
 export enum LogLevel {
   DEBUG = 0,
-  INFO  = 1,
-  WARN  = 2,
+  INFO = 1,
+  WARN = 2,
   ERROR = 3,
 }
 

packages/inula-cli/src/utils/mockServer.ts

@@ -15,7 +15,7 @@
 
 import chokidar from 'chokidar';
 import bodyParser from 'body-parser';
-import {globSync} from 'glob';
+import { globSync } from 'glob';
 import { join } from 'path';
 
 import { createRequire } from 'module';
@@ -38,13 +38,15 @@ function getMocksFile() {
   const mockFiles = globSync('**/*.js', {
     cwd: mockDir,
   });
-  let ret = mockFiles.reduce((mocks: any, mockFile: string) => {
+  const ret = mockFiles.reduce((mocks: any, mockFile: string) => {
     if (!mockFile.startsWith('_')) {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const file = require(join(mockDir, mockFile));
       mocks = {
         ...mocks,
-        ...require(join(mockDir, mockFile)),
+        ...file,
       };
-      console.log('mockFile', require(join(mockDir, mockFile)));
+      console.log('mockFile', file);
     }
 
     return mocks;
@@ -54,8 +56,8 @@ function getMocksFile() {
 }
 
 function generateRoutes(app: any) {
-  let mockStartIndex = app._router.stack.length,
-    mocks: Mock = {};
+  const mockStartIndex = app._router.stack.length;
+  let mocks: Mock = {};
 
   try {
     mocks = getMocksFile();
@@ -93,8 +95,8 @@ function generateRoutes(app: any) {
           respond instanceof Function
             ? respond
             : (_req: any, res: { send: (arg0: any) => void }) => {
-              res.send(respond);
-            }
+                res.send(respond);
+              }
         );
       } catch (error) {
         console.error(error);

packages/inula-cli/src/utils/setupProxy.ts

@@ -17,12 +17,14 @@ import { createProxyMiddleware } from 'http-proxy-middleware';
 import { API } from '../types/types';
 
 export default (app: any, api: API) => {
-    const { devProxy } = api.userConfig.devBuildConfig;
-    app.use(createProxyMiddleware(devProxy.matcher, {
-        target: devProxy.target,
-        secure: false,
-        changeOrigin: true,
-        ws: false,
-        onProxyRes: devProxy.onProxyRes
-    }));
-}
+  const { devProxy } = api.userConfig.devBuildConfig;
+  app.use(
+    createProxyMiddleware(devProxy.matcher, {
+      target: devProxy.target,
+      secure: false,
+      changeOrigin: true,
+      ws: false,
+      onProxyRes: devProxy.onProxyRes,
+    })
+  );
+};

packages/inula-cli/src/utils/util.ts

@@ -16,8 +16,7 @@
 import { dirname } from 'path';
 import { readFileSync, writeFileSync } from 'fs';
 import resolve from 'resolve';
-// @ts-ignore
-import crequire from 'crequire'
+import crequire from 'crequire';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 

packages/inula-cli/tsconfig.json

@@ -11,9 +11,16 @@
     "moduleResolution": "node",
     "esModuleInterop": true,
   },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "**/*.spec.ts", "./src/template/**/*"],
+  "include": [
+    "src/**/*",
+    "./externals.d.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "**/*.spec.ts",
+    "./src/template/**/*"
+  ],
   "ts-node": {
     "esm": true,
   },
-}
+}

packages/inula-code-generator/.gitignore

@@ -0,0 +1,11 @@
+
+# 视觉模型
+YOLOv8_cs/runs
+
+# 前端
+inula-code-generator-web/frontend/node_modules
+
+# 后端
+**/__pycache__
+
+node_modules

packages/inula-code-generator/README.md

@@ -0,0 +1,78 @@
+<div align="center">  <a href="https://gitee.com/openInula" align="center">
+    <img src="https://foruda.gitee.com/avatar/1695115915614709704/12142544_inula-js_1695115915.png!avatar100" alt="Logo" width="80" height="80">
+  </a></div>
+
+<p align="center">
+    <img alt="stars" src="https://gitee.com/openInula/inula-code-generator/badge/star.svg?theme=dark">
+    <img alt="forks" src="https://gitee.com/openInula/inula-code-generator/badge/fork.svg?theme=dark">
+</p>
+
+<h3 align="center">OpenInula Code Generator Platform</h3>
+
+<p align="center">
+    AI视觉模型生成前端代码
+    <br />
+    <a href="https://gitee.com/openInula/inula-code-generator"><strong>Explore the repos »</strong></a>
+    <a href="https://gitee.com/openInula/inula-code-generator/issues/new?issue">Request Feature</a>
+  </p>
+
+
+<!-- ABOUT THE PROJECT -->
+
+## 项目介绍
+
+**openInula AI 代码生成工具** 是一个结合大语言模型能力和视觉识别技术，生成基于 openInula 生态和特定 UI 组件库应用页面代码的工具。
+
+### 项目特点
+
+1. **多模态输入**: 支持使用网页设计稿或图片作为输入，生成相应的代码。
+2. **openInula 生态适配**: 生成的代码基于 openInula 生态，确保与其框架和规范兼容。
+3. **实时编辑与渲染**: 开发者可以手动编辑生成的代码，并实时查看渲染效果。
+4. **交互式修改**: 开发者可以向 AI 提出修改需求，AI 将根据当前代码生成修改后的版本。
+5. **版本控制**: 支持多版本管理，便于开发者进行代码迭代与回溯。
+6. **生态友好**: 大语言模型可根据需要替换，提高工具的灵活性与适应性。
+7. **渐进式生成**: 支持分步生成代码，让开发者逐步完善和优化页面。
+8. **代码导出**: 允许开发者下载生成的代码，方便后续集成与部署。
+
+### 后端运行
+
+* 进入后端
+
+  ```sh
+  cd inula-code-generator-web\backend
+  ```
+* 下载环境配置
+
+  ```sh
+  pip install -r requirements.txt
+  ```
+* 启动后端
+
+  ```sh
+   python manage.py runserver 0.0.0.0:9090  
+  ```
+
+### 前端运行
+
+* 进入前端
+
+  ```sh
+  cd inula-code-generator-web\frontend
+  ```
+
+* 下载依赖
+
+  ```sh
+  npm install
+  ```
+* 启动前端
+
+  ```sh
+  npm run dev
+  ```
+
+## 联系方式
+
+Renlirong - email@renlirong@foxmail.com
+
+Project Link: [inula-code-generator](https://gitee.com/openInula/inula-code-generator)

packages/inula-code-generator/YOLOv10_cs/.gitignore

@@ -0,0 +1,166 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other info into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+mlruns/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# Profiling
+*.pclprof
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+.idea
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# VSCode project settings
+.vscode/
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+mkdocs_github_authors.yaml
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# datasets and projects
+datasets/
+runs/
+wandb/
+tests/
+.DS_Store
+
+# Neural Network weights -----------------------------------------------------------------------------------------------
+weights/
+*.weights
+*.pt
+*.pb
+*.onnx
+*.engine
+*.mlmodel
+*.mlpackage
+*.torchscript
+*.tflite
+*.h5
+*_saved_model/
+*_web_model/
+*_openvino_model/
+*_paddle_model/
+pnnx*
+
+# Autogenerated files for tests
+/ultralytics/assets/

packages/inula-code-generator/YOLOv10_cs/.pre-commit-config.yaml

@@ -0,0 +1,86 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Pre-commit hooks. For more information see https://github.com/pre-commit/pre-commit-hooks/blob/main/README.md
+# Optionally remove from local hooks with 'rm .git/hooks/pre-commit'
+
+# Define bot property if installed via https://github.com/marketplace/pre-commit-ci
+ci:
+  autofix_prs: true
+  autoupdate_commit_msg: "[pre-commit.ci] pre-commit suggestions"
+  autoupdate_schedule: monthly
+  submodules: true
+
+# Exclude directories (optional)
+# exclude: 'docs/'
+
+# Define repos to run
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.5.0
+    hooks:
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+      - id: check-case-conflict
+      # - id: check-yaml
+      - id: check-docstring-first
+      - id: detect-private-key
+
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v3.15.0
+    hooks:
+      - id: pyupgrade
+        name: Upgrade code
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.1.11
+    hooks:
+      - id: ruff
+        args: [--fix]
+
+  - repo: https://github.com/executablebooks/mdformat
+    rev: 0.7.17
+    hooks:
+      - id: mdformat
+        name: MD formatting
+        additional_dependencies:
+          - mdformat-gfm
+          - mdformat-frontmatter
+          - mdformat-mkdocs
+        args:
+          - --wrap=no
+          - --number
+        exclude: 'docs/.*\.md'
+        # exclude: "README.md|README.zh-CN.md|CONTRIBUTING.md"
+
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.2.6
+    hooks:
+      - id: codespell
+        exclude: "docs/de|docs/fr|docs/pt|docs/es|docs/mkdocs_de.yml"
+        args:
+          - --ignore-words-list=crate,nd,ned,strack,dota,ane,segway,fo,gool,winn,commend,bloc,nam,afterall
+
+  - repo: https://github.com/hadialqattan/pycln
+    rev: v2.4.0
+    hooks:
+      - id: pycln
+        args: [--all]
+#
+#  - repo: https://github.com/PyCQA/docformatter
+#    rev: v1.7.5
+#    hooks:
+#      - id: docformatter
+
+#  - repo: https://github.com/asottile/yesqa
+#    rev: v1.4.0
+#    hooks:
+#      - id: yesqa
+
+#  - repo: https://github.com/asottile/dead
+#    rev: v1.5.0
+#    hooks:
+#    -   id: dead
+
+#  - repo: https://github.com/ultralytics/pre-commit
+#    rev: bd60a414f80a53fb8f593d3bfed4701fc47e4b23
+#    hooks:
+#      - id: capitalize-comments

packages/inula-code-generator/YOLOv10_cs/CONTRIBUTING.md

@@ -0,0 +1,96 @@
+# Contributing to YOLOv8 🚀
+
+We love your input! We want to make contributing to YOLOv8 as easy and transparent as possible, whether it's:
+
+- Reporting a bug
+- Discussing the current state of the code
+- Submitting a fix
+- Proposing a new feature
+- Becoming a maintainer
+
+YOLOv8 works so well due to our combined community effort, and for every small improvement you contribute you will be helping push the frontiers of what's possible in AI 😃!
+
+## Submitting a Pull Request (PR) 🛠️
+
+Submitting a PR is easy! This example shows how to submit a PR for updating `requirements.txt` in 4 steps:
+
+### 1. Select File to Update
+
+Select `requirements.txt` to update by clicking on it in GitHub.
+
+<p align="center"><img width="800" alt="PR_step1" src="https://user-images.githubusercontent.com/26833433/122260847-08be2600-ced4-11eb-828b-8287ace4136c.png"></p>
+
+### 2. Click 'Edit this file'
+
+Button is in top-right corner.
+
+<p align="center"><img width="800" alt="PR_step2" src="https://user-images.githubusercontent.com/26833433/122260844-06f46280-ced4-11eb-9eec-b8a24be519ca.png"></p>
+
+### 3. Make Changes
+
+Change `matplotlib` version from `3.2.2` to `3.3`.
+
+<p align="center"><img width="800" alt="PR_step3" src="https://user-images.githubusercontent.com/26833433/122260853-0a87e980-ced4-11eb-9fd2-3650fb6e0842.png"></p>
+
+### 4. Preview Changes and Submit PR
+
+Click on the **Preview changes** tab to verify your updates. At the bottom of the screen select 'Create a **new branch** for this commit', assign your branch a descriptive name such as `fix/matplotlib_version` and click the green **Propose changes** button. All done, your PR is now submitted to YOLOv8 for review and approval 😃!
+
+<p align="center"><img width="800" alt="PR_step4" src="https://user-images.githubusercontent.com/26833433/122260856-0b208000-ced4-11eb-8e8e-77b6151cbcc3.png"></p>
+
+### PR recommendations
+
+To allow your work to be integrated as seamlessly as possible, we advise you to:
+
+- ✅ Verify your PR is **up-to-date** with `ultralytics/ultralytics` `main` branch. If your PR is behind you can update your code by clicking the 'Update branch' button or by running `git pull` and `git merge main` locally.
+
+<p align="center"><img width="751" alt="PR recommendation 1" src="https://user-images.githubusercontent.com/26833433/187295893-50ed9f44-b2c9-4138-a614-de69bd1753d7.png"></p>
+
+- ✅ Verify all YOLOv8 Continuous Integration (CI) **checks are passing**.
+
+<p align="center"><img width="751" alt="PR recommendation 2" src="https://user-images.githubusercontent.com/26833433/187296922-545c5498-f64a-4d8c-8300-5fa764360da6.png"></p>
+
+- ✅ Reduce changes to the absolute **minimum** required for your bug fix or feature addition. _"It is not daily increase but daily decrease, hack away the unessential. The closer to the source, the less wastage there is."_ — Bruce Lee
+
+### Docstrings
+
+Not all functions or classes require docstrings but when they do, we follow [google-style docstrings format](https://google.github.io/styleguide/pyguide.html#38-comments-and-docstrings). Here is an example:
+
+```python
+"""
+    What the function does. Performs NMS on given detection predictions.
+
+    Args:
+        arg1: The description of the 1st argument
+        arg2: The description of the 2nd argument
+
+    Returns:
+        What the function returns. Empty if nothing is returned.
+
+    Raises:
+        Exception Class: When and why this exception can be raised by the function.
+"""
+```
+
+## Submitting a Bug Report 🐛
+
+If you spot a problem with YOLOv8 please submit a Bug Report!
+
+For us to start investigating a possible problem we need to be able to reproduce it ourselves first. We've created a few short guidelines below to help users provide what we need in order to get started.
+
+When asking a question, people will be better able to provide help if you provide **code** that they can easily understand and use to **reproduce** the problem. This is referred to by community members as creating a [minimum reproducible example](https://docs.ultralytics.com/help/minimum_reproducible_example/). Your code that reproduces the problem should be:
+
+- ✅ **Minimal** – Use as little code as possible that still produces the same problem
+- ✅ **Complete** – Provide **all** parts someone else needs to reproduce your problem in the question itself
+- ✅ **Reproducible** – Test the code you're about to provide to make sure it reproduces the problem
+
+In addition to the above requirements, for [Ultralytics](https://ultralytics.com/) to provide assistance your code should be:
+
+- ✅ **Current** – Verify that your code is up-to-date with current GitHub [main](https://github.com/ultralytics/ultralytics/tree/main) branch, and if necessary `git pull` or `git clone` a new copy to ensure your problem has not already been resolved by previous commits.
+- ✅ **Unmodified** – Your problem must be reproducible without any modifications to the codebase in this repository. [Ultralytics](https://ultralytics.com/) does not provide support for custom code ⚠️.
+
+If you believe your problem meets all of the above criteria, please close this issue and raise a new one using the 🐛 **Bug Report** [template](https://github.com/ultralytics/ultralytics/issues/new/choose) and providing a [minimum reproducible example](https://docs.ultralytics.com/help/minimum_reproducible_example/) to help us better understand and diagnose your problem.
+
+## License
+
+By contributing, you agree that your contributions will be licensed under the [AGPL-3.0 license](https://choosealicense.com/licenses/agpl-3.0/)

packages/inula-code-generator/YOLOv10_cs/LICENSE

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

packages/inula-code-generator/YOLOv10_cs/README.md

@@ -0,0 +1,181 @@
+# [YOLOv10: Real-Time End-to-End Object Detection](https://arxiv.org/abs/2405.14458)
+
+
+Official PyTorch implementation of **YOLOv10**.
+
+<p align="center">
+  <img src="figures/latency.svg" width=48%>
+  <img src="figures/params.svg" width=48%> <br>
+  Comparisons with others in terms of latency-accuracy (left) and size-accuracy (right) trade-offs.
+</p>
+
+[YOLOv10: Real-Time End-to-End Object Detection](https://arxiv.org/abs/2405.14458).\
+Ao Wang, Hui Chen, Lihao Liu, Kai Chen, Zijia Lin, Jungong Han, and Guiguang Ding\
+[![arXiv](https://img.shields.io/badge/arXiv-2405.14458-b31b1b.svg)](https://arxiv.org/abs/2405.14458) <a href="https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/train-yolov10-object-detection-on-custom-dataset.ipynb#scrollTo=SaKTSzSWnG7s"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a> [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Models-blue)](https://huggingface.co/collections/jameslahm/yolov10-665b0d90b0b5bb85129460c2) [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/jameslahm/YOLOv10)  [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/kadirnar/Yolov10)  [![Transformers.js Demo](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Transformers.js-blue)](https://huggingface.co/spaces/Xenova/yolov10-web) [![LearnOpenCV](https://img.shields.io/badge/BlogPost-blue?logo=data%3Aimage%2Fpng%3Bbase64%2CiVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAMAAAC67D%2BPAAAALVBMVEX%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F%2F6%2Bfn6%2Bvq3y%2BJ8rOFSne9Jm%2FQcOlr5DJ7GAAAAB3RSTlMAB2LM94H1yMxlvwAAADNJREFUCFtjZGAEAob%2FQMDIyAJl%2FmFkYmEGM%2F%2F%2BYWRmYWYCMv8BmSxYmUgKkLQhGYawAgApySgfFDPqowAAAABJRU5ErkJggg%3D%3D&logoColor=black&labelColor=gray)](https://learnopencv.com/yolov10/) [![Openbayes Demo](https://img.shields.io/static/v1?label=Demo&message=OpenBayes%E8%B4%9D%E5%BC%8F%E8%AE%A1%E7%AE%97&color=green)](https://openbayes.com/console/public/tutorials/im29uYrnIoz) 
+
+
+<details>
+  <summary>
+  <font size="+1">Abstract</font>
+  </summary>
+Over the past years, YOLOs have emerged as the predominant paradigm in the field of real-time object detection owing to their effective balance between computational cost and detection performance. Researchers have explored the architectural designs, optimization objectives, data augmentation strategies, and others for YOLOs, achieving notable progress. However, the reliance on the non-maximum suppression (NMS) for post-processing hampers the end-to-end deployment of YOLOs and adversely impacts the inference latency. Besides, the design of various components in YOLOs lacks the comprehensive and thorough inspection, resulting in noticeable computational redundancy and limiting the model's capability. It renders the suboptimal efficiency, along with considerable potential for performance improvements. In this work, we aim to further advance the performance-efficiency boundary of YOLOs from both the post-processing and the model architecture. To this end, we first present the consistent dual assignments for NMS-free training of YOLOs, which brings the competitive performance and low inference latency simultaneously. Moreover, we introduce the holistic efficiency-accuracy driven model design strategy for YOLOs. We comprehensively optimize various components of YOLOs from both the efficiency and accuracy perspectives, which greatly reduces the computational overhead and enhances the capability. The outcome of our effort is a new generation of YOLO series for real-time end-to-end object detection, dubbed YOLOv10. Extensive experiments show that YOLOv10 achieves the state-of-the-art performance and efficiency across various model scales. For example, our YOLOv10-S is 1.8$\times$ faster than RT-DETR-R18 under the similar AP on COCO, meanwhile enjoying 2.8$\times$ smaller number of parameters and FLOPs. Compared with YOLOv9-C, YOLOv10-B has 46\% less latency and 25\% fewer parameters for the same performance.
+</details>
+
+## Notes
+- 2024/05/31: Please use the [exported format](https://github.com/THU-MIG/yolov10?tab=readme-ov-file#export) for benchmark. In the non-exported format, e.g., pytorch, the speed of YOLOv10 is biased because the unnecessary `cv2` and `cv3` operations in the `v10Detect` are executed during inference.
+- 2024/05/30: We provide [some clarifications and suggestions](https://github.com/THU-MIG/yolov10/issues/136) for detecting smaller objects or objects in the distance with YOLOv10. Thanks to [SkalskiP](https://github.com/SkalskiP)!
+- 2024/05/27: We have updated the [checkpoints](https://huggingface.co/collections/jameslahm/yolov10-665b0d90b0b5bb85129460c2) with class names, for ease of use.
+
+## UPDATES 🔥
+- 2024/06/01: Thanks to [ErlanggaYudiPradana](https://github.com/rlggyp) for the integration with [C++ | OpenVINO | OpenCV](https://github.com/rlggyp/YOLOv10-OpenVINO-CPP-Inference)
+- 2024/06/01: Thanks to [NielsRogge](https://github.com/NielsRogge) and [AK](https://x.com/_akhaliq) for hosting the models on the HuggingFace Hub!
+- 2024/05/31: Build [yolov10-jetson](https://github.com/Seeed-Projects/jetson-examples/blob/main/reComputer/scripts/yolov10/README.md) docker image by [youjiang](https://github.com/yuyoujiang)!
+- 2024/05/31: Thanks to [mohamedsamirx](https://github.com/mohamedsamirx) for the integration with [BoTSORT, DeepOCSORT, OCSORT, HybridSORT, ByteTrack, StrongSORT using BoxMOT library](https://colab.research.google.com/drive/1-QV2TNfqaMsh14w5VxieEyanugVBG14V?usp=sharing)!
+- 2024/05/31: Thanks to [kaylorchen](https://github.com/kaylorchen) for the integration with [rk3588](https://github.com/kaylorchen/rk3588-yolo-demo)!
+- 2024/05/30: Thanks to [eaidova](https://github.com/eaidova) for the integration with [OpenVINO™](https://github.com/openvinotoolkit/openvino_notebooks/blob/0ba3c0211bcd49aa860369feddffdf7273a73c64/notebooks/yolov10-optimization/yolov10-optimization.ipynb)!
+- 2024/05/29: Add the gradio demo for running the models locally. Thanks to [AK](https://x.com/_akhaliq)!
+- 2024/05/27: Thanks to [sujanshresstha](sujanshresstha) for the integration with [DeepSORT](https://github.com/sujanshresstha/YOLOv10_DeepSORT.git)!
+- 2024/05/26: Thanks to [CVHub520](https://github.com/CVHub520) for the integration into [X-AnyLabeling](https://github.com/CVHub520/X-AnyLabeling)!
+- 2024/05/26: Thanks to [DanielSarmiento04](https://github.com/DanielSarmiento04) for integrate in [c++ | ONNX | OPENCV](https://github.com/DanielSarmiento04/yolov10cpp)!
+- 2024/05/25: Add [Transformers.js demo](https://huggingface.co/spaces/Xenova/yolov10-web) and onnx weights(yolov10[n](https://huggingface.co/onnx-community/yolov10n)/[s](https://huggingface.co/onnx-community/yolov10s)/[m](https://huggingface.co/onnx-community/yolov10m)/[b](https://huggingface.co/onnx-community/yolov10b)/[l](https://huggingface.co/onnx-community/yolov10l)/[x](https://huggingface.co/onnx-community/yolov10x)). Thanks to [xenova](https://github.com/xenova)!
+- 2024/05/25: Add [colab demo](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/train-yolov10-object-detection-on-custom-dataset.ipynb#scrollTo=SaKTSzSWnG7s), [HuggingFace Demo](https://huggingface.co/spaces/kadirnar/Yolov10), and [HuggingFace Model Page](https://huggingface.co/kadirnar/Yolov10). Thanks to [SkalskiP](https://github.com/SkalskiP) and [kadirnar](https://github.com/kadirnar)! 
+
+## Performance
+COCO
+
+| Model | Test Size | #Params | FLOPs | AP<sup>val</sup> | Latency |
+|:---------------|:----:|:---:|:--:|:--:|:--:|
+| [YOLOv10-N](https://huggingface.co/jameslahm/yolov10n) |   640  |     2.3M    |   6.7G   |     38.5%     | 1.84ms |
+| [YOLOv10-S](https://huggingface.co/jameslahm/yolov10s) |   640  |     7.2M    |   21.6G  |     46.3%     | 2.49ms |
+| [YOLOv10-M](https://huggingface.co/jameslahm/yolov10m) |   640  |     15.4M   |   59.1G  |     51.1%     | 4.74ms |
+| [YOLOv10-B](https://huggingface.co/jameslahm/yolov10b) |   640  |     19.1M   |  92.0G |     52.5%     | 5.74ms |
+| [YOLOv10-L](https://huggingface.co/jameslahm/yolov10l) |   640  |     24.4M   |  120.3G   |     53.2%     | 7.28ms |
+| [YOLOv10-X](https://huggingface.co/jameslahm/yolov10x) |   640  |     29.5M    |   160.4G   |     54.4%     | 10.70ms |
+
+## Installation
+`conda` virtual environment is recommended. 
+```
+conda create -n yolov10 python=3.9
+conda activate yolov10
+pip install -r requirements.txt
+pip install -e .
+```
+## Demo
+```
+python app.py
+# Please visit http://127.0.0.1:7860
+```
+
+## Validation
+[`yolov10n`](https://huggingface.co/jameslahm/yolov10n)  [`yolov10s`](https://huggingface.co/jameslahm/yolov10s)  [`yolov10m`](https://huggingface.co/jameslahm/yolov10m)  [`yolov10b`](https://huggingface.co/jameslahm/yolov10b)  [`yolov10l`](https://huggingface.co/jameslahm/yolov10l)  [`yolov10x`](https://huggingface.co/jameslahm/yolov10x)  
+```
+yolo val model=jameslahm/yolov10{n/s/m/b/l/x} data=coco.yaml batch=256
+```
+
+Or
+```python
+from ultralytics import YOLOv10
+
+model = YOLOv10.from_pretrained('jameslahm/yolov10{n/s/m/b/l/x}')
+# or
+# wget https://github.com/THU-MIG/yolov10/releases/download/v1.1/yolov10{n/s/m/b/l/x}.pt
+model = YOLOv10('yolov10{n/s/m/b/l/x}.pt')
+
+model.val(data='coco.yaml', batch=256)
+```
+
+
+## Training 
+```
+yolo detect train data=coco.yaml model=yolov10n/s/m/b/l/x.yaml epochs=500 batch=256 imgsz=640 device=0,1,2,3,4,5,6,7
+```
+
+Or
+```python
+from ultralytics import YOLOv10
+
+model = YOLOv10()
+# If you want to finetune the model with pretrained weights, you could load the 
+# pretrained weights like below
+# model = YOLOv10.from_pretrained('jameslahm/yolov10{n/s/m/b/l/x}')
+# or
+# wget https://github.com/THU-MIG/yolov10/releases/download/v1.1/yolov10{n/s/m/b/l/x}.pt
+# model = YOLOv10('yolov10{n/s/m/b/l/x}.pt')
+
+model.train(data='coco.yaml', epochs=500, batch=256, imgsz=640)
+```
+
+## Push to hub to 🤗
+
+Optionally, you can push your fine-tuned model to the [Hugging Face hub](https://huggingface.co/) as a public or private model:
+
+```python
+# let's say you have fine-tuned a model for crop detection
+model.push_to_hub("<your-hf-username-or-organization/yolov10-finetuned-crop-detection")
+
+# you can also pass `private=True` if you don't want everyone to see your model
+model.push_to_hub("<your-hf-username-or-organization/yolov10-finetuned-crop-detection", private=True)
+```
+
+## Prediction
+Note that a smaller confidence threshold can be set to detect smaller objects or objects in the distance. Please refer to [here](https://github.com/THU-MIG/yolov10/issues/136) for details.
+```
+yolo predict model=jameslahm/yolov10{n/s/m/b/l/x}
+```
+
+Or
+```python
+from ultralytics import YOLOv10
+
+model = YOLOv10.from_pretrained('jameslahm/yolov10{n/s/m/b/l/x}')
+# or
+# wget https://github.com/THU-MIG/yolov10/releases/download/v1.1/yolov10{n/s/m/b/l/x}.pt
+model = YOLOv10('yolov10{n/s/m/b/l/x}.pt')
+
+model.predict()
+```
+
+## Export
+```
+# End-to-End ONNX
+yolo export model=jameslahm/yolov10{n/s/m/b/l/x} format=onnx opset=13 simplify
+# Predict with ONNX
+yolo predict model=yolov10n/s/m/b/l/x.onnx
+
+# End-to-End TensorRT
+yolo export model=jameslahm/yolov10{n/s/m/b/l/x} format=engine half=True simplify opset=13 workspace=16
+# or
+trtexec --onnx=yolov10n/s/m/b/l/x.onnx --saveEngine=yolov10n/s/m/b/l/x.engine --fp16
+# Predict with TensorRT
+yolo predict model=yolov10n/s/m/b/l/x.engine
+```
+
+Or
+```python
+from ultralytics import YOLOv10
+
+model = YOLOv10.from_pretrained('jameslahm/yolov10{n/s/m/b/l/x}')
+# or
+# wget https://github.com/THU-MIG/yolov10/releases/download/v1.1/yolov10{n/s/m/b/l/x}.pt
+model = YOLOv10('yolov10{n/s/m/b/l/x}.pt')
+
+model.export(...)
+```
+
+## Acknowledgement
+
+The code base is built with [ultralytics](https://github.com/ultralytics/ultralytics) and [RT-DETR](https://github.com/lyuwenyu/RT-DETR).
+
+Thanks for the great implementations! 
+
+## Citation
+
+If our code or models help your work, please cite our paper:
+```BibTeX
+@article{wang2024yolov10,
+  title={YOLOv10: Real-Time End-to-End Object Detection},
+  author={Wang, Ao and Chen, Hui and Liu, Lihao and Chen, Kai and Lin, Zijia and Han, Jungong and Ding, Guiguang},
+  journal={arXiv preprint arXiv:2405.14458},
+  year={2024}
+}
+```

packages/inula-code-generator/YOLOv10_cs/app.py

@@ -0,0 +1,161 @@
+import gradio as gr
+import cv2
+import tempfile
+from ultralytics import YOLOv10
+
+
+def yolov10_inference(image, video, model_id, image_size, conf_threshold):
+    model = YOLOv10.from_pretrained(f'jameslahm/{model_id}')
+    if image:
+        results = model.predict(source=image, imgsz=image_size, conf=conf_threshold)
+        annotated_image = results[0].plot()
+        return annotated_image[:, :, ::-1], None
+    else:
+        video_path = tempfile.mktemp(suffix=".webm")
+        with open(video_path, "wb") as f:
+            with open(video, "rb") as g:
+                f.write(g.read())
+
+        cap = cv2.VideoCapture(video_path)
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+        output_video_path = tempfile.mktemp(suffix=".webm")
+        out = cv2.VideoWriter(output_video_path, cv2.VideoWriter_fourcc(*'vp80'), fps, (frame_width, frame_height))
+
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            results = model.predict(source=frame, imgsz=image_size, conf=conf_threshold)
+            annotated_frame = results[0].plot()
+            out.write(annotated_frame)
+
+        cap.release()
+        out.release()
+
+        return None, output_video_path
+
+
+def yolov10_inference_for_examples(image, model_path, image_size, conf_threshold):
+    annotated_image, _ = yolov10_inference(image, None, model_path, image_size, conf_threshold)
+    return annotated_image
+
+
+def app():
+    with gr.Blocks():
+        with gr.Row():
+            with gr.Column():
+                image = gr.Image(type="pil", label="Image", visible=True)
+                video = gr.Video(label="Video", visible=False)
+                input_type = gr.Radio(
+                    choices=["Image", "Video"],
+                    value="Image",
+                    label="Input Type",
+                )
+                model_id = gr.Dropdown(
+                    label="Model",
+                    choices=[
+                        "yolov10n",
+                        "yolov10s",
+                        "yolov10m",
+                        "yolov10b",
+                        "yolov10l",
+                        "yolov10x",
+                    ],
+                    value="yolov10m",
+                )
+                image_size = gr.Slider(
+                    label="Image Size",
+                    minimum=320,
+                    maximum=1280,
+                    step=32,
+                    value=640,
+                )
+                conf_threshold = gr.Slider(
+                    label="Confidence Threshold",
+                    minimum=0.0,
+                    maximum=1.0,
+                    step=0.05,
+                    value=0.25,
+                )
+                yolov10_infer = gr.Button(value="Detect Objects")
+
+            with gr.Column():
+                output_image = gr.Image(type="numpy", label="Annotated Image", visible=True)
+                output_video = gr.Video(label="Annotated Video", visible=False)
+
+        def update_visibility(input_type):
+            image = gr.update(visible=True) if input_type == "Image" else gr.update(visible=False)
+            video = gr.update(visible=False) if input_type == "Image" else gr.update(visible=True)
+            output_image = gr.update(visible=True) if input_type == "Image" else gr.update(visible=False)
+            output_video = gr.update(visible=False) if input_type == "Image" else gr.update(visible=True)
+
+            return image, video, output_image, output_video
+
+        input_type.change(
+            fn=update_visibility,
+            inputs=[input_type],
+            outputs=[image, video, output_image, output_video],
+        )
+
+        def run_inference(image, video, model_id, image_size, conf_threshold, input_type):
+            if input_type == "Image":
+                return yolov10_inference(image, None, model_id, image_size, conf_threshold)
+            else:
+                return yolov10_inference(None, video, model_id, image_size, conf_threshold)
+
+
+        yolov10_infer.click(
+            fn=run_inference,
+            inputs=[image, video, model_id, image_size, conf_threshold, input_type],
+            outputs=[output_image, output_video],
+        )
+
+        gr.Examples(
+            examples=[
+                [
+                    "ultralytics/assets/bus.jpg",
+                    "yolov10s",
+                    640,
+                    0.25,
+                ],
+                [
+                    "ultralytics/assets/zidane.jpg",
+                    "yolov10s",
+                    640,
+                    0.25,
+                ],
+            ],
+            fn=yolov10_inference_for_examples,
+            inputs=[
+                image,
+                model_id,
+                image_size,
+                conf_threshold,
+            ],
+            outputs=[output_image],
+            cache_examples='lazy',
+        )
+
+gradio_app = gr.Blocks()
+with gradio_app:
+    gr.HTML(
+        """
+    <h1 style='text-align: center'>
+    YOLOv10: Real-Time End-to-End Object Detection
+    </h1>
+    """)
+    gr.HTML(
+        """
+        <h3 style='text-align: center'>
+        <a href='https://arxiv.org/abs/2405.14458' target='_blank'>arXiv</a> | <a href='https://github.com/THU-MIG/yolov10' target='_blank'>github</a>
+        </h3>
+        """)
+    with gr.Row():
+        with gr.Column():
+            app()
+if __name__ == '__main__':
+    gradio_app.launch()

packages/inula-code-generator/YOLOv10_cs/docker/Dockerfile

@@ -0,0 +1,85 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Builds ultralytics/ultralytics:latest image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
+# Image is CUDA-optimized for YOLOv8 single/multi-GPU training and inference
+
+# Start FROM PyTorch image https://hub.docker.com/r/pytorch/pytorch or nvcr.io/nvidia/pytorch:23.03-py3
+FROM pytorch/pytorch:2.2.0-cuda12.1-cudnn8-runtime
+RUN pip install --no-cache nvidia-tensorrt --index-url https://pypi.ngc.nvidia.com
+
+# Downloads to user config dir
+ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
+    https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
+    /root/.config/Ultralytics/
+
+# Install linux packages
+# g++ required to build 'tflite_support' and 'lap' packages, libusb-1.0-0 required for 'tflite_support' package
+RUN apt update \
+    && apt install --no-install-recommends -y gcc git zip curl htop libgl1 libglib2.0-0 libpython3-dev gnupg g++ libusb-1.0-0 build-essential
+
+# Security updates
+# https://security.snyk.io/vuln/SNYK-UBUNTU1804-OPENSSL-3314796
+RUN apt upgrade --no-install-recommends -y openssl tar
+
+# Create working directory
+WORKDIR /usr/src/ultralytics
+
+# Copy contents
+# COPY . /usr/src/ultralytics  # git permission issues inside container
+RUN git clone https://github.com/ultralytics/ultralytics -b main /usr/src/ultralytics
+ADD https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt /usr/src/ultralytics/
+
+# Install pip packages
+RUN python3 -m pip install --upgrade pip wheel
+RUN pip install --no-cache -e ".[export]" albumentations comet pycocotools
+
+# Run exports to AutoInstall packages
+# Edge TPU export fails the first time so is run twice here
+RUN yolo export model=tmp/yolov8n.pt format=edgetpu imgsz=32 || yolo export model=tmp/yolov8n.pt format=edgetpu imgsz=32
+RUN yolo export model=tmp/yolov8n.pt format=ncnn imgsz=32
+# Requires <= Python 3.10, bug with paddlepaddle==2.5.0 https://github.com/PaddlePaddle/X2Paddle/issues/991
+RUN pip install --no-cache paddlepaddle>=2.6.0 x2paddle
+# Fix error: `np.bool` was a deprecated alias for the builtin `bool` segmentation error in Tests
+RUN pip install --no-cache numpy==1.23.5
+# Remove exported models
+RUN rm -rf tmp
+
+# Set environment variables
+ENV OMP_NUM_THREADS=1
+# Avoid DDP error "MKL_THREADING_LAYER=INTEL is incompatible with libgomp.so.1 library" https://github.com/pytorch/pytorch/issues/37377
+ENV MKL_THREADING_LAYER=GNU
+
+
+# Usage Examples -------------------------------------------------------------------------------------------------------
+
+# Build and Push
+# t=ultralytics/ultralytics:latest && sudo docker build -f docker/Dockerfile -t $t . && sudo docker push $t
+
+# Pull and Run with access to all GPUs
+# t=ultralytics/ultralytics:latest && sudo docker pull $t && sudo docker run -it --ipc=host --gpus all $t
+
+# Pull and Run with access to GPUs 2 and 3 (inside container CUDA devices will appear as 0 and 1)
+# t=ultralytics/ultralytics:latest && sudo docker pull $t && sudo docker run -it --ipc=host --gpus '"device=2,3"' $t
+
+# Pull and Run with local directory access
+# t=ultralytics/ultralytics:latest && sudo docker pull $t && sudo docker run -it --ipc=host --gpus all -v "$(pwd)"/datasets:/usr/src/datasets $t
+
+# Kill all
+# sudo docker kill $(sudo docker ps -q)
+
+# Kill all image-based
+# sudo docker kill $(sudo docker ps -qa --filter ancestor=ultralytics/ultralytics:latest)
+
+# DockerHub tag update
+# t=ultralytics/ultralytics:latest tnew=ultralytics/ultralytics:v6.2 && sudo docker pull $t && sudo docker tag $t $tnew && sudo docker push $tnew
+
+# Clean up
+# sudo docker system prune -a --volumes
+
+# Update Ubuntu drivers
+# https://www.maketecheasier.com/install-nvidia-drivers-ubuntu/
+
+# DDP test
+# python -m torch.distributed.run --nproc_per_node 2 --master_port 1 train.py --epochs 3
+
+# GCP VM from Image
+# docker.io/ultralytics/ultralytics:latest

packages/inula-code-generator/YOLOv10_cs/docker/Dockerfile-arm64

@@ -0,0 +1,51 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Builds ultralytics/ultralytics:latest-arm64 image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
+# Image is aarch64-compatible for Apple M1, M2, M3, Raspberry Pi and other ARM architectures
+
+# Start FROM Ubuntu image https://hub.docker.com/_/ubuntu with "FROM arm64v8/ubuntu:22.04" (deprecated)
+# Start FROM Debian image for arm64v8 https://hub.docker.com/r/arm64v8/debian (new)
+FROM arm64v8/debian:bookworm-slim
+
+# Downloads to user config dir
+ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
+    https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
+    /root/.config/Ultralytics/
+
+# Install linux packages
+# g++ required to build 'tflite_support' and 'lap' packages, libusb-1.0-0 required for 'tflite_support' package
+# cmake and build-essential is needed to build onnxsim when exporting to tflite
+RUN apt update \
+    && apt install --no-install-recommends -y python3-pip git zip curl htop gcc libgl1 libglib2.0-0 libpython3-dev gnupg g++ libusb-1.0-0 build-essential
+
+# Create working directory
+WORKDIR /usr/src/ultralytics
+
+# Copy contents
+# COPY . /usr/src/ultralytics  # git permission issues inside container
+RUN git clone https://github.com/ultralytics/ultralytics -b main /usr/src/ultralytics
+ADD https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt /usr/src/ultralytics/
+
+# Remove python3.11/EXTERNALLY-MANAGED to avoid 'externally-managed-environment' issue, Debian 12 Bookworm error
+RUN rm -rf /usr/lib/python3.11/EXTERNALLY-MANAGED
+
+# Install pip packages
+RUN python3 -m pip install --upgrade pip wheel
+RUN pip install --no-cache -e ".[export]"
+
+# Creates a symbolic link to make 'python' point to 'python3'
+RUN ln -sf /usr/bin/python3 /usr/bin/python
+
+
+# Usage Examples -------------------------------------------------------------------------------------------------------
+
+# Build and Push
+# t=ultralytics/ultralytics:latest-arm64 && sudo docker build --platform linux/arm64 -f docker/Dockerfile-arm64 -t $t . && sudo docker push $t
+
+# Run
+# t=ultralytics/ultralytics:latest-arm64 && sudo docker run -it --ipc=host $t
+
+# Pull and Run
+# t=ultralytics/ultralytics:latest-arm64 && sudo docker pull $t && sudo docker run -it --ipc=host $t
+
+# Pull and Run with local volume mounted
+# t=ultralytics/ultralytics:latest-arm64 && sudo docker pull $t && sudo docker run -it --ipc=host -v "$(pwd)"/datasets:/usr/src/datasets $t

packages/inula-code-generator/YOLOv10_cs/docker/Dockerfile-conda

@@ -0,0 +1,40 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Builds ultralytics/ultralytics:latest-conda image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
+# Image is optimized for Ultralytics Anaconda (https://anaconda.org/conda-forge/ultralytics) installation and usage
+
+# Start FROM miniconda3 image https://hub.docker.com/r/continuumio/miniconda3
+FROM continuumio/miniconda3:latest
+
+# Downloads to user config dir
+ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
+    https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
+    /root/.config/Ultralytics/
+
+# Install linux packages
+RUN apt update \
+    && apt install --no-install-recommends -y libgl1
+
+# Copy contents
+ADD https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt .
+
+# Install conda packages
+# mkl required to fix 'OSError: libmkl_intel_lp64.so.2: cannot open shared object file: No such file or directory'
+RUN conda config --set solver libmamba && \
+    conda install pytorch torchvision pytorch-cuda=11.8 -c pytorch -c nvidia && \
+    conda install -c conda-forge ultralytics mkl
+    # conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics mkl
+
+
+# Usage Examples -------------------------------------------------------------------------------------------------------
+
+# Build and Push
+# t=ultralytics/ultralytics:latest-conda && sudo docker build -f docker/Dockerfile-cpu -t $t . && sudo docker push $t
+
+# Run
+# t=ultralytics/ultralytics:latest-conda && sudo docker run -it --ipc=host $t
+
+# Pull and Run
+# t=ultralytics/ultralytics:latest-conda && sudo docker pull $t && sudo docker run -it --ipc=host $t
+
+# Pull and Run with local volume mounted
+# t=ultralytics/ultralytics:latest-conda && sudo docker pull $t && sudo docker run -it --ipc=host -v "$(pwd)"/datasets:/usr/src/datasets $t

packages/inula-code-generator/YOLOv10_cs/docker/Dockerfile-cpu

@@ -0,0 +1,57 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Builds ultralytics/ultralytics:latest-cpu image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
+# Image is CPU-optimized for ONNX, OpenVINO and PyTorch YOLOv8 deployments
+
+# Start FROM Ubuntu image https://hub.docker.com/_/ubuntu
+FROM ubuntu:23.10
+
+# Downloads to user config dir
+ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
+    https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
+    /root/.config/Ultralytics/
+
+# Install linux packages
+# g++ required to build 'tflite_support' and 'lap' packages, libusb-1.0-0 required for 'tflite_support' package
+RUN apt update \
+    && apt install --no-install-recommends -y python3-pip git zip curl htop libgl1 libglib2.0-0 libpython3-dev gnupg g++ libusb-1.0-0
+
+# Create working directory
+WORKDIR /usr/src/ultralytics
+
+# Copy contents
+# COPY . /usr/src/ultralytics  # git permission issues inside container
+RUN git clone https://github.com/ultralytics/ultralytics -b main /usr/src/ultralytics
+ADD https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt /usr/src/ultralytics/
+
+# Remove python3.11/EXTERNALLY-MANAGED or use 'pip install --break-system-packages' avoid 'externally-managed-environment' Ubuntu nightly error
+RUN rm -rf /usr/lib/python3.11/EXTERNALLY-MANAGED
+
+# Install pip packages
+RUN python3 -m pip install --upgrade pip wheel
+RUN pip install --no-cache -e ".[export]" --extra-index-url https://download.pytorch.org/whl/cpu
+
+# Run exports to AutoInstall packages
+RUN yolo export model=tmp/yolov8n.pt format=edgetpu imgsz=32
+RUN yolo export model=tmp/yolov8n.pt format=ncnn imgsz=32
+# Requires <= Python 3.10, bug with paddlepaddle==2.5.0 https://github.com/PaddlePaddle/X2Paddle/issues/991
+# RUN pip install --no-cache paddlepaddle>=2.6.0 x2paddle
+# Remove exported models
+RUN rm -rf tmp
+
+# Creates a symbolic link to make 'python' point to 'python3'
+RUN ln -sf /usr/bin/python3 /usr/bin/python
+
+
+# Usage Examples -------------------------------------------------------------------------------------------------------
+
+# Build and Push
+# t=ultralytics/ultralytics:latest-cpu && sudo docker build -f docker/Dockerfile-cpu -t $t . && sudo docker push $t
+
+# Run
+# t=ultralytics/ultralytics:latest-cpu && sudo docker run -it --ipc=host --name NAME $t
+
+# Pull and Run
+# t=ultralytics/ultralytics:latest-cpu && sudo docker pull $t && sudo docker run -it --ipc=host --name NAME $t
+
+# Pull and Run with local volume mounted
+# t=ultralytics/ultralytics:latest-cpu && sudo docker pull $t && sudo docker run -it --ipc=host -v "$(pwd)"/datasets:/usr/src/datasets $t

packages/inula-code-generator/YOLOv10_cs/docker/Dockerfile-jetson

@@ -0,0 +1,50 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Builds ultralytics/ultralytics:jetson image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
+# Supports JetPack for YOLOv8 on Jetson Nano, TX1/TX2, Xavier NX, AGX Xavier, AGX Orin, and Orin NX
+
+# Start FROM https://catalog.ngc.nvidia.com/orgs/nvidia/containers/l4t-pytorch
+FROM nvcr.io/nvidia/l4t-pytorch:r35.2.1-pth2.0-py3
+
+# Downloads to user config dir
+ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
+    https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
+    /root/.config/Ultralytics/
+
+# Install linux packages
+# g++ required to build 'tflite_support' and 'lap' packages, libusb-1.0-0 required for 'tflite_support' package
+RUN apt update \
+    && apt install --no-install-recommends -y gcc git zip curl htop libgl1 libglib2.0-0 libpython3-dev gnupg g++ libusb-1.0-0
+
+# Create working directory
+WORKDIR /usr/src/ultralytics
+
+# Copy contents
+# COPY . /usr/src/ultralytics  # git permission issues inside container
+RUN git clone https://github.com/ultralytics/ultralytics -b main /usr/src/ultralytics
+ADD https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt /usr/src/ultralytics/
+
+# Remove opencv-python from Ultralytics dependencies as it conflicts with opencv-python installed in base image
+RUN grep -v "opencv-python" pyproject.toml > temp.toml && mv temp.toml pyproject.toml
+
+# Install pip packages manually for TensorRT compatibility https://github.com/NVIDIA/TensorRT/issues/2567
+RUN python3 -m pip install --upgrade pip wheel
+RUN pip install --no-cache tqdm matplotlib pyyaml psutil pandas onnx "numpy==1.23"
+RUN pip install --no-cache -e .
+
+# Set environment variables
+ENV OMP_NUM_THREADS=1
+
+
+# Usage Examples -------------------------------------------------------------------------------------------------------
+
+# Build and Push
+# t=ultralytics/ultralytics:latest-jetson && sudo docker build --platform linux/arm64 -f docker/Dockerfile-jetson -t $t . && sudo docker push $t
+
+# Run
+# t=ultralytics/ultralytics:latest-jetson && sudo docker run -it --ipc=host $t
+
+# Pull and Run
+# t=ultralytics/ultralytics:latest-jetson && sudo docker pull $t && sudo docker run -it --ipc=host $t
+
+# Pull and Run with NVIDIA runtime
+# t=ultralytics/ultralytics:latest-jetson && sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t

packages/inula-code-generator/YOLOv10_cs/docker/Dockerfile-python

@@ -0,0 +1,54 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Builds ultralytics/ultralytics:latest-cpu image on DockerHub https://hub.docker.com/r/ultralytics/ultralytics
+# Image is CPU-optimized for ONNX, OpenVINO and PyTorch YOLOv8 deployments
+
+# Use the official Python 3.10 slim-bookworm as base image
+FROM python:3.10-slim-bookworm
+
+# Downloads to user config dir
+ADD https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.ttf \
+    https://github.com/ultralytics/assets/releases/download/v0.0.0/Arial.Unicode.ttf \
+    /root/.config/Ultralytics/
+
+# Install linux packages
+# g++ required to build 'tflite_support' and 'lap' packages, libusb-1.0-0 required for 'tflite_support' package
+RUN apt update \
+    && apt install --no-install-recommends -y python3-pip git zip curl htop libgl1 libglib2.0-0 libpython3-dev gnupg g++ libusb-1.0-0
+
+# Create working directory
+WORKDIR /usr/src/ultralytics
+
+# Copy contents
+# COPY . /usr/src/ultralytics  # git permission issues inside container
+RUN git clone https://github.com/ultralytics/ultralytics -b main /usr/src/ultralytics
+ADD https://github.com/ultralytics/assets/releases/download/v8.1.0/yolov8n.pt /usr/src/ultralytics/
+
+# Remove python3.11/EXTERNALLY-MANAGED or use 'pip install --break-system-packages' avoid 'externally-managed-environment' Ubuntu nightly error
+# RUN rm -rf /usr/lib/python3.11/EXTERNALLY-MANAGED
+
+# Install pip packages
+RUN python3 -m pip install --upgrade pip wheel
+RUN pip install --no-cache -e ".[export]" --extra-index-url https://download.pytorch.org/whl/cpu
+
+# Run exports to AutoInstall packages
+RUN yolo export model=tmp/yolov8n.pt format=edgetpu imgsz=32
+RUN yolo export model=tmp/yolov8n.pt format=ncnn imgsz=32
+# Requires <= Python 3.10, bug with paddlepaddle==2.5.0 https://github.com/PaddlePaddle/X2Paddle/issues/991
+RUN pip install --no-cache paddlepaddle>=2.6.0 x2paddle
+# Remove exported models
+RUN rm -rf tmp
+
+
+# Usage Examples -------------------------------------------------------------------------------------------------------
+
+# Build and Push
+# t=ultralytics/ultralytics:latest-python && sudo docker build -f docker/Dockerfile-python -t $t . && sudo docker push $t
+
+# Run
+# t=ultralytics/ultralytics:latest-python && sudo docker run -it --ipc=host $t
+
+# Pull and Run
+# t=ultralytics/ultralytics:latest-python && sudo docker pull $t && sudo docker run -it --ipc=host $t
+
+# Pull and Run with local volume mounted
+# t=ultralytics/ultralytics:latest-python && sudo docker pull $t && sudo docker run -it --ipc=host -v "$(pwd)"/datasets:/usr/src/datasets $t

packages/inula-code-generator/YOLOv10_cs/docker/Dockerfile-runner

@@ -0,0 +1,38 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Builds GitHub actions CI runner image for deployment to DockerHub https://hub.docker.com/r/ultralytics/ultralytics
+# Image is CUDA-optimized for YOLOv8 single/multi-GPU training and inference tests
+
+# Start FROM Ultralytics GPU image
+FROM ultralytics/ultralytics:latest
+
+# Set the working directory
+WORKDIR /actions-runner
+
+# Download and unpack the latest runner from https://github.com/actions/runner
+RUN FILENAME=actions-runner-linux-x64-2.309.0.tar.gz && \
+    curl -o $FILENAME -L https://github.com/actions/runner/releases/download/v2.309.0/$FILENAME && \
+    tar xzf $FILENAME && \
+    rm $FILENAME
+
+# Install runner dependencies
+ENV RUNNER_ALLOW_RUNASROOT=1
+ENV DEBIAN_FRONTEND=noninteractive
+RUN ./bin/installdependencies.sh && \
+    apt-get -y install libicu-dev
+
+# Inline ENTRYPOINT command to configure and start runner with default TOKEN and NAME
+ENTRYPOINT sh -c './config.sh --url https://github.com/ultralytics/ultralytics \
+                              --token ${GITHUB_RUNNER_TOKEN:-TOKEN} \
+                              --name ${GITHUB_RUNNER_NAME:-NAME} \
+                              --labels gpu-latest \
+                              --replace && \
+                  ./run.sh'
+
+
+# Usage Examples -------------------------------------------------------------------------------------------------------
+
+# Build and Push
+# t=ultralytics/ultralytics:latest-runner && sudo docker build -f docker/Dockerfile-runner -t $t . && sudo docker push $t
+
+# Pull and Run in detached mode with access to GPUs 0 and 1
+# t=ultralytics/ultralytics:latest-runner && sudo docker run -d -e GITHUB_RUNNER_TOKEN=TOKEN -e GITHUB_RUNNER_NAME=NAME --ipc=host --gpus '"device=0,1"' $t

packages/inula-code-generator/YOLOv10_cs/docs/README.md

@@ -0,0 +1,140 @@
+<br>
+<img src="https://raw.githubusercontent.com/ultralytics/assets/main/logo/Ultralytics_Logotype_Original.svg" width="320">
+
+# 📚 Ultralytics Docs
+
+Ultralytics Docs are the gateway to understanding and utilizing our cutting-edge machine learning tools. These documents are deployed to [https://docs.ultralytics.com](https://docs.ultralytics.com) for your convenience.
+
+[![pages-build-deployment](https://github.com/ultralytics/docs/actions/workflows/pages/pages-build-deployment/badge.svg)](https://github.com/ultralytics/docs/actions/workflows/pages/pages-build-deployment) [![Check Broken links](https://github.com/ultralytics/docs/actions/workflows/links.yml/badge.svg)](https://github.com/ultralytics/docs/actions/workflows/links.yml) [![Check Domains](https://github.com/ultralytics/docs/actions/workflows/check_domains.yml/badge.svg)](https://github.com/ultralytics/docs/actions/workflows/check_domains.yml) [![Ultralytics Actions](https://github.com/ultralytics/docs/actions/workflows/format.yml/badge.svg)](https://github.com/ultralytics/docs/actions/workflows/format.yml) <a href="https://ultralytics.com/discord"><img alt="Discord" src="https://img.shields.io/discord/1089800235347353640?logo=discord&logoColor=white&label=Discord&color=blue"></a>
+
+## 🛠️ Installation
+
+[![PyPI version](https://badge.fury.io/py/ultralytics.svg)](https://badge.fury.io/py/ultralytics) [![Downloads](https://static.pepy.tech/badge/ultralytics)](https://pepy.tech/project/ultralytics)
+
+To install the ultralytics package in developer mode, ensure you have Git and Python 3 installed on your system. Then, follow these steps:
+
+1. Clone the ultralytics repository to your local machine using Git:
+
+   ```bash
+   git clone https://github.com/ultralytics/ultralytics.git
+   ```
+
+2. Navigate to the cloned repository's root directory:
+
+   ```bash
+   cd ultralytics
+   ```
+
+3. Install the package in developer mode using pip (or pip3 for Python 3):
+
+   ```bash
+   pip install -e '.[dev]'
+   ```
+
+- This command installs the ultralytics package along with all development dependencies, allowing you to modify the package code and have the changes immediately reflected in your Python environment.
+
+## 🚀 Building and Serving Locally
+
+The `mkdocs serve` command builds and serves a local version of your MkDocs documentation, ideal for development and testing:
+
+```bash
+mkdocs serve
+```
+
+- #### Command Breakdown:
+
+  - `mkdocs` is the main MkDocs command-line interface.
+  - `serve` is the subcommand to build and locally serve your documentation.
+
+- 🧐 Note:
+
+  - Grasp changes to the docs in real-time as `mkdocs serve` supports live reloading.
+  - To stop the local server, press `CTRL+C`.
+
+## 🌍 Building and Serving Multi-Language
+
+Supporting multi-language documentation? Follow these steps:
+
+1. Stage all new language \*.md files with Git:
+
+   ```bash
+   git add docs/**/*.md -f
+   ```
+
+2. Build all languages to the `/site` folder, ensuring relevant root-level files are present:
+
+   ```bash
+   # Clear existing /site directory
+   rm -rf site
+
+   # Loop through each language config file and build
+   mkdocs build -f docs/mkdocs.yml
+   for file in docs/mkdocs_*.yml; do
+     echo "Building MkDocs site with $file"
+     mkdocs build -f "$file"
+   done
+   ```
+
+3. To preview your site, initiate a simple HTTP server:
+
+   ```bash
+   cd site
+   python -m http.server
+   # Open in your preferred browser
+   ```
+
+- 🖥️ Access the live site at `http://localhost:8000`.
+
+## 📤 Deploying Your Documentation Site
+
+Choose a hosting provider and deployment method for your MkDocs documentation:
+
+- Configure `mkdocs.yml` with deployment settings.
+- Use `mkdocs deploy` to build and deploy your site.
+
+* ### GitHub Pages Deployment Example:
+  ```bash
+  mkdocs gh-deploy
+  ```
+
+- Update the "Custom domain" in your repository's settings for a personalized URL.
+
+![196814117-fc16e711-d2be-4722-9536-b7c6d78fd167](https://user-images.githubusercontent.com/26833433/210150206-9e86dcd7-10af-43e4-9eb2-9518b3799eac.png)
+
+- For detailed deployment guidance, consult the [MkDocs documentation](https://www.mkdocs.org/user-guide/deploying-your-docs/).
+
+## 💡 Contribute
+
+We cherish the community's input as it drives Ultralytics open-source initiatives. Dive into the [Contributing Guide](https://docs.ultralytics.com/help/contributing) and share your thoughts via our [Survey](https://ultralytics.com/survey?utm_source=github&utm_medium=social&utm_campaign=Survey). A heartfelt thank you 🙏 to each contributor!
+
+<!-- Pictorial representation of our dedicated contributor community -->
+
+![Ultralytics open-source contributors](https://github.com/ultralytics/assets/raw/main/im/image-contributors.png)
+
+## 📜 License
+
+Ultralytics presents two licensing options:
+
+- **AGPL-3.0 License**: Perfect for academia and open collaboration. Details are in the [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) file.
+- **Enterprise License**: Tailored for commercial usage, offering a seamless blend of Ultralytics technology in your products. Learn more at [Ultralytics Licensing](https://ultralytics.com/license).
+
+## ✉️ Contact
+
+For bug reports and feature requests, navigate to [GitHub Issues](https://github.com/ultralytics/docs/issues). Engage with peers and the Ultralytics team on [Discord](https://ultralytics.com/discord) for enriching conversations!
+
+<br>
+<div align="center">
+  <a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="3%" alt="Ultralytics GitHub"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
+  <a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="3%" alt="Ultralytics LinkedIn"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
+  <a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="3%" alt="Ultralytics Twitter"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
+  <a href="https://youtube.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="3%" alt="Ultralytics YouTube"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
+  <a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="3%" alt="Ultralytics TikTok"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
+  <a href="https://www.instagram.com/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-instagram.png" width="3%" alt="Ultralytics Instagram"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
+  <a href="https://ultralytics.com/discord"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="3%" alt="Ultralytics Discord"></a>
+</div>

packages/inula-code-generator/YOLOv10_cs/docs/build_docs.py

@@ -0,0 +1,141 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+"""
+This Python script is designed to automate the building and post-processing of MkDocs documentation, particularly for
+projects with multilingual content. It streamlines the workflow for generating localized versions of the documentation
+and updating HTML links to ensure they are correctly formatted.
+
+Key Features:
+- Automated building of MkDocs documentation: The script compiles both the main documentation and
+  any localized versions specified in separate MkDocs configuration files.
+- Post-processing of generated HTML files: After the documentation is built, the script updates all
+  HTML files to remove the '.md' extension from internal links. This ensures that links in the built
+  HTML documentation correctly point to other HTML pages rather than Markdown files, which is crucial
+  for proper navigation within the web-based documentation.
+
+Usage:
+- Run the script from the root directory of your MkDocs project.
+- Ensure that MkDocs is installed and that all MkDocs configuration files (main and localized versions)
+  are present in the project directory.
+- The script first builds the documentation using MkDocs, then scans the generated HTML files in the 'site'
+  directory to update the internal links.
+- It's ideal for projects where the documentation is written in Markdown and needs to be served as a static website.
+
+Note:
+- This script is built to be run in an environment where Python and MkDocs are installed and properly configured.
+"""
+
+import os
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+from tqdm import tqdm
+
+DOCS = Path(__file__).parent.resolve()
+SITE = DOCS.parent / "site"
+
+
+def build_docs(clone_repos=True):
+    """Build docs using mkdocs."""
+    if SITE.exists():
+        print(f"Removing existing {SITE}")
+        shutil.rmtree(SITE)
+
+    # Get hub-sdk repo
+    if clone_repos:
+        repo = "https://github.com/ultralytics/hub-sdk"
+        local_dir = DOCS.parent / Path(repo).name
+        if not local_dir.exists():
+            os.system(f"git clone {repo} {local_dir}")
+        os.system(f"git -C {local_dir} pull")  # update repo
+        shutil.rmtree(DOCS / "en/hub/sdk", ignore_errors=True)  # delete if exists
+        shutil.copytree(local_dir / "docs", DOCS / "en/hub/sdk")  # for docs
+        shutil.rmtree(DOCS.parent / "hub_sdk", ignore_errors=True)  # delete if exists
+        shutil.copytree(local_dir / "hub_sdk", DOCS.parent / "hub_sdk")  # for mkdocstrings
+        print(f"Cloned/Updated {repo} in {local_dir}")
+
+    # Build the main documentation
+    print(f"Building docs from {DOCS}")
+    subprocess.run(f"mkdocs build -f {DOCS.parent}/mkdocs.yml", check=True, shell=True)
+    print(f"Site built at {SITE}")
+
+
+def update_page_title(file_path: Path, new_title: str):
+    """Update the title of an HTML file."""
+
+    # Read the content of the file
+    with open(file_path, encoding="utf-8") as file:
+        content = file.read()
+
+    # Replace the existing title with the new title
+    updated_content = re.sub(r"<title>.*?</title>", f"<title>{new_title}</title>", content)
+
+    # Write the updated content back to the file
+    with open(file_path, "w", encoding="utf-8") as file:
+        file.write(updated_content)
+
+
+def update_html_head(script=""):
+    """Update the HTML head section of each file."""
+    html_files = Path(SITE).rglob("*.html")
+    for html_file in tqdm(html_files, desc="Processing HTML files"):
+        with html_file.open("r", encoding="utf-8") as file:
+            html_content = file.read()
+
+        if script in html_content:  # script already in HTML file
+            return
+
+        head_end_index = html_content.lower().rfind("</head>")
+        if head_end_index != -1:
+            # Add the specified JavaScript to the HTML file just before the end of the head tag.
+            new_html_content = html_content[:head_end_index] + script + html_content[head_end_index:]
+            with html_file.open("w", encoding="utf-8") as file:
+                file.write(new_html_content)
+
+
+def update_subdir_edit_links(subdir="", docs_url=""):
+    """Update the HTML head section of each file."""
+    from bs4 import BeautifulSoup
+
+    if str(subdir[0]) == "/":
+        subdir = str(subdir[0])[1:]
+    html_files = (SITE / subdir).rglob("*.html")
+    for html_file in tqdm(html_files, desc="Processing subdir files"):
+        with html_file.open("r", encoding="utf-8") as file:
+            soup = BeautifulSoup(file, "html.parser")
+
+        # Find the anchor tag and update its href attribute
+        a_tag = soup.find("a", {"class": "md-content__button md-icon"})
+        if a_tag and a_tag["title"] == "Edit this page":
+            a_tag["href"] = f"{docs_url}{a_tag['href'].split(subdir)[-1]}"
+
+        # Write the updated HTML back to the file
+        with open(html_file, "w", encoding="utf-8") as file:
+            file.write(str(soup))
+
+
+def main():
+    """Builds docs, updates titles and edit links, and prints local server command."""
+    build_docs()
+
+    # Update titles
+    update_page_title(SITE / "404.html", new_title="Ultralytics Docs - Not Found")
+
+    # Update edit links
+    update_subdir_edit_links(
+        subdir="hub/sdk/",  # do not use leading slash
+        docs_url="https://github.com/ultralytics/hub-sdk/tree/develop/docs/",
+    )
+
+    # Update HTML file head section
+    script = ""
+    if any(script):
+        update_html_head(script)
+
+    # Show command to serve built website
+    print('Serve site at http://localhost:8000 with "python -m http.server --directory site"')
+
+
+if __name__ == "__main__":
+    main()

packages/inula-code-generator/YOLOv10_cs/docs/build_reference.py

@@ -0,0 +1,130 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+"""
+Helper file to build Ultralytics Docs reference section. Recursively walks through ultralytics dir and builds an MkDocs
+reference section of *.md files composed of classes and functions, and also creates a nav menu for use in mkdocs.yaml.
+
+Note: Must be run from repository root directory. Do not run from docs directory.
+"""
+
+import re
+from collections import defaultdict
+from pathlib import Path
+
+# Get package root i.e. /Users/glennjocher/PycharmProjects/ultralytics/ultralytics
+from ultralytics.utils import ROOT as PACKAGE_DIR
+
+# Constants
+REFERENCE_DIR = PACKAGE_DIR.parent / "docs/en/reference"
+GITHUB_REPO = "ultralytics/ultralytics"
+
+
+def extract_classes_and_functions(filepath: Path) -> tuple:
+    """Extracts class and function names from a given Python file."""
+    content = filepath.read_text()
+    class_pattern = r"(?:^|\n)class\s(\w+)(?:\(|:)"
+    func_pattern = r"(?:^|\n)def\s(\w+)\("
+
+    classes = re.findall(class_pattern, content)
+    functions = re.findall(func_pattern, content)
+
+    return classes, functions
+
+
+def create_markdown(py_filepath: Path, module_path: str, classes: list, functions: list):
+    """Creates a Markdown file containing the API reference for the given Python module."""
+    md_filepath = py_filepath.with_suffix(".md")
+
+    # Read existing content and keep header content between first two ---
+    header_content = ""
+    if md_filepath.exists():
+        existing_content = md_filepath.read_text()
+        header_parts = existing_content.split("---")
+        for part in header_parts:
+            if "description:" in part or "comments:" in part:
+                header_content += f"---{part}---\n\n"
+
+    module_name = module_path.replace(".__init__", "")
+    module_path = module_path.replace(".", "/")
+    url = f"https://github.com/{GITHUB_REPO}/blob/main/{module_path}.py"
+    edit = f"https://github.com/{GITHUB_REPO}/edit/main/{module_path}.py"
+    title_content = (
+        f"# Reference for `{module_path}.py`\n\n"
+        f"!!! Note\n\n"
+        f"    This file is available at [{url}]({url}). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request]({edit}) 🛠️. Thank you 🙏!\n\n"
+    )
+    md_content = ["<br><br>\n"] + [f"## ::: {module_name}.{class_name}\n\n<br><br>\n" for class_name in classes]
+    md_content.extend(f"## ::: {module_name}.{func_name}\n\n<br><br>\n" for func_name in functions)
+    md_content = header_content + title_content + "\n".join(md_content)
+    if not md_content.endswith("\n"):
+        md_content += "\n"
+
+    md_filepath.parent.mkdir(parents=True, exist_ok=True)
+    md_filepath.write_text(md_content)
+
+    return md_filepath.relative_to(PACKAGE_DIR.parent)
+
+
+def nested_dict() -> defaultdict:
+    """Creates and returns a nested defaultdict."""
+    return defaultdict(nested_dict)
+
+
+def sort_nested_dict(d: dict) -> dict:
+    """Sorts a nested dictionary recursively."""
+    return {key: sort_nested_dict(value) if isinstance(value, dict) else value for key, value in sorted(d.items())}
+
+
+def create_nav_menu_yaml(nav_items: list, save: bool = False):
+    """Creates a YAML file for the navigation menu based on the provided list of items."""
+    nav_tree = nested_dict()
+
+    for item_str in nav_items:
+        item = Path(item_str)
+        parts = item.parts
+        current_level = nav_tree["reference"]
+        for part in parts[2:-1]:  # skip the first two parts (docs and reference) and the last part (filename)
+            current_level = current_level[part]
+
+        md_file_name = parts[-1].replace(".md", "")
+        current_level[md_file_name] = item
+
+    nav_tree_sorted = sort_nested_dict(nav_tree)
+
+    def _dict_to_yaml(d, level=0):
+        """Converts a nested dictionary to a YAML-formatted string with indentation."""
+        yaml_str = ""
+        indent = "  " * level
+        for k, v in d.items():
+            if isinstance(v, dict):
+                yaml_str += f"{indent}- {k}:\n{_dict_to_yaml(v, level + 1)}"
+            else:
+                yaml_str += f"{indent}- {k}: {str(v).replace('docs/en/', '')}\n"
+        return yaml_str
+
+    # Print updated YAML reference section
+    print("Scan complete, new mkdocs.yaml reference section is:\n\n", _dict_to_yaml(nav_tree_sorted))
+
+    # Save new YAML reference section
+    if save:
+        (PACKAGE_DIR.parent / "nav_menu_updated.yml").write_text(_dict_to_yaml(nav_tree_sorted))
+
+
+def main():
+    """Main function to extract class and function names, create Markdown files, and generate a YAML navigation menu."""
+    nav_items = []
+
+    for py_filepath in PACKAGE_DIR.rglob("*.py"):
+        classes, functions = extract_classes_and_functions(py_filepath)
+
+        if classes or functions:
+            py_filepath_rel = py_filepath.relative_to(PACKAGE_DIR)
+            md_filepath = REFERENCE_DIR / py_filepath_rel
+            module_path = f"{PACKAGE_DIR.name}.{py_filepath_rel.with_suffix('').as_posix().replace('/', '.')}"
+            md_rel_filepath = create_markdown(md_filepath, module_path, classes, functions)
+            nav_items.append(str(md_rel_filepath))
+
+    create_nav_menu_yaml(nav_items)
+
+
+if __name__ == "__main__":
+    main()

packages/inula-code-generator/YOLOv10_cs/docs/coming_soon_template.md

@@ -0,0 +1,34 @@
+---
+description: Discover what's next for Ultralytics with our under-construction page, previewing new, groundbreaking AI and ML features coming soon.
+keywords: Ultralytics, coming soon, under construction, new features, AI updates, ML advancements, YOLO, technology preview
+---
+
+# Under Construction 🏗️🌟
+
+Welcome to the Ultralytics "Under Construction" page! Here, we're hard at work developing the next generation of AI and ML innovations. This page serves as a teaser for the exciting updates and new features we're eager to share with you!
+
+## Exciting New Features on the Way 🎉
+
+- **Innovative Breakthroughs:** Get ready for advanced features and services that will transform your AI and ML experience.
+- **New Horizons:** Anticipate novel products that redefine AI and ML capabilities.
+- **Enhanced Services:** We're upgrading our services for greater efficiency and user-friendliness.
+
+## Stay Updated 🚧
+
+This placeholder page is your first stop for upcoming developments. Keep an eye out for:
+
+- **Newsletter:** Subscribe [here](https://ultralytics.com/#newsletter) for the latest news.
+- **Social Media:** Follow us [here](https://www.linkedin.com/company/ultralytics) for updates and teasers.
+- **Blog:** Visit our [blog](https://ultralytics.com/blog) for detailed insights.
+
+## We Value Your Input 🗣️
+
+Your feedback shapes our future releases. Share your thoughts and suggestions [here](https://ultralytics.com/contact).
+
+## Thank You, Community! 🌍
+
+Your [contributions](https://docs.ultralytics.com/help/contributing) inspire our continuous [innovation](https://github.com/ultralytics/ultralytics). Stay tuned for the big reveal of what's next in AI and ML at Ultralytics!
+
+---
+
+Excited for what's coming? Bookmark this page and get ready for a transformative AI and ML journey with Ultralytics! 🛠️🤖

packages/inula-code-generator/YOLOv10_cs/docs/en/CNAME

@@ -0,0 +1 @@
+docs.ultralytics.com

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/azureml-quickstart.md

@@ -0,0 +1,152 @@
+---
+comments: true
+description: Step-by-step Quickstart Guide to Running YOLOv8 Object Detection Models on AzureML for Fast Prototyping and Testing
+keywords: Ultralytics, YOLOv8, Object Detection, Azure Machine Learning, Quickstart Guide, Prototype, Compute Instance, Terminal, Notebook, IPython Kernel, CLI, Python SDK
+---
+
+# YOLOv8 🚀 on AzureML
+
+## What is Azure?
+
+[Azure](https://azure.microsoft.com/) is Microsoft's cloud computing platform, designed to help organizations move their workloads to the cloud from on-premises data centers. With the full spectrum of cloud services including those for computing, databases, analytics, machine learning, and networking, users can pick and choose from these services to develop and scale new applications, or run existing applications, in the public cloud.
+
+## What is Azure Machine Learning (AzureML)?
+
+Azure Machine Learning, commonly referred to as AzureML, is a fully managed cloud service that enables data scientists and developers to efficiently embed predictive analytics into their applications, helping organizations use massive data sets and bring all the benefits of the cloud to machine learning. AzureML offers a variety of services and capabilities aimed at making machine learning accessible, easy to use, and scalable. It provides capabilities like automated machine learning, drag-and-drop model training, as well as a robust Python SDK so that developers can make the most out of their machine learning models.
+
+## How Does AzureML Benefit YOLO Users?
+
+For users of YOLO (You Only Look Once), AzureML provides a robust, scalable, and efficient platform to both train and deploy machine learning models. Whether you are looking to run quick prototypes or scale up to handle more extensive data, AzureML's flexible and user-friendly environment offers various tools and services to fit your needs. You can leverage AzureML to:
+
+- Easily manage large datasets and computational resources for training.
+- Utilize built-in tools for data preprocessing, feature selection, and model training.
+- Collaborate more efficiently with capabilities for MLOps (Machine Learning Operations), including but not limited to monitoring, auditing, and versioning of models and data.
+
+In the subsequent sections, you will find a quickstart guide detailing how to run YOLOv8 object detection models using AzureML, either from a compute terminal or a notebook.
+
+## Prerequisites
+
+Before you can get started, make sure you have access to an AzureML workspace. If you don't have one, you can create a new [AzureML workspace](https://learn.microsoft.com/azure/machine-learning/concept-workspace?view=azureml-api-2) by following Azure's official documentation. This workspace acts as a centralized place to manage all AzureML resources.
+
+## Create a compute instance
+
+From your AzureML workspace, select Compute > Compute instances > New, select the instance with the resources you need.
+
+<p align="center">
+  <img width="1280" src="https://github.com/ouphi/ultralytics/assets/17216799/3e92fcc0-a08e-41a4-af81-d289cfe3b8f2" alt="Create Azure Compute Instance">
+</p>
+
+## Quickstart from Terminal
+
+Start your compute and open a Terminal:
+
+<p align="center">
+  <img width="480" src="https://github.com/ouphi/ultralytics/assets/17216799/635152f1-f4a3-4261-b111-d416cb5ef357" alt="Open Terminal">
+</p>
+
+### Create virtualenv
+
+Create your conda virtualenv and install pip in it:
+
+```bash
+conda create --name yolov8env -y
+conda activate yolov8env
+conda install pip -y
+```
+
+Install the required dependencies:
+
+```bash
+cd ultralytics
+pip install -r requirements.txt
+pip install ultralytics
+pip install onnx>=1.12.0
+```
+
+### Perform YOLOv8 tasks
+
+Predict:
+
+```bash
+yolo predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg'
+```
+
+Train a detection model for 10 epochs with an initial learning_rate of 0.01:
+
+```bash
+yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01
+```
+
+You can find more [instructions to use the Ultralytics CLI here](../quickstart.md#use-ultralytics-with-cli).
+
+## Quickstart from a Notebook
+
+### Create a new IPython kernel
+
+Open the compute Terminal.
+
+<p align="center">
+  <img width="480" src="https://github.com/ouphi/ultralytics/assets/17216799/635152f1-f4a3-4261-b111-d416cb5ef357" alt="Open Terminal">
+</p>
+
+From your compute terminal, you need to create a new ipykernel that will be used by your notebook to manage your dependencies:
+
+```bash
+conda create --name yolov8env -y
+conda activate yolov8env
+conda install pip -y
+conda install ipykernel -y
+python -m ipykernel install --user --name yolov8env --display-name "yolov8env"
+```
+
+Close your terminal and create a new notebook. From your Notebook, you can select the new kernel.
+
+Then you can open a Notebook cell and install the required dependencies:
+
+```bash
+%%bash
+source activate yolov8env
+cd ultralytics
+pip install -r requirements.txt
+pip install ultralytics
+pip install onnx>=1.12.0
+```
+
+Note that we need to use the `source activate yolov8env` for all the %%bash cells, to make sure that the %%bash cell uses environment we want.
+
+Run some predictions using the [Ultralytics CLI](../quickstart.md#use-ultralytics-with-cli):
+
+```bash
+%%bash
+source activate yolov8env
+yolo predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg'
+```
+
+Or with the [Ultralytics Python interface](../quickstart.md#use-ultralytics-with-python), for example to train the model:
+
+```python
+from ultralytics import YOLO
+
+# Load a model
+model = YOLO("yolov8n.pt")  # load an official YOLOv8n model
+
+# Use the model
+model.train(data="coco128.yaml", epochs=3)  # train the model
+metrics = model.val()  # evaluate model performance on the validation set
+results = model("https://ultralytics.com/images/bus.jpg")  # predict on an image
+path = model.export(format="onnx")  # export the model to ONNX format
+```
+
+You can use either the Ultralytics CLI or Python interface for running YOLOv8 tasks, as described in the terminal section above.
+
+By following these steps, you should be able to get YOLOv8 running quickly on AzureML for quick trials. For more advanced uses, you may refer to the full AzureML documentation linked at the beginning of this guide.
+
+## Explore More with AzureML
+
+This guide serves as an introduction to get you up and running with YOLOv8 on AzureML. However, it only scratches the surface of what AzureML can offer. To delve deeper and unlock the full potential of AzureML for your machine learning projects, consider exploring the following resources:
+
+- [Create a Data Asset](https://learn.microsoft.com/azure/machine-learning/how-to-create-data-assets): Learn how to set up and manage your data assets effectively within the AzureML environment.
+- [Initiate an AzureML Job](https://learn.microsoft.com/azure/machine-learning/how-to-train-model): Get a comprehensive understanding of how to kickstart your machine learning training jobs on AzureML.
+- [Register a Model](https://learn.microsoft.com/azure/machine-learning/how-to-manage-models): Familiarize yourself with model management practices including registration, versioning, and deployment.
+- [Train YOLOv8 with AzureML Python SDK](https://medium.com/@ouphi/how-to-train-the-yolov8-model-with-azure-machine-learning-python-sdk-8268696be8ba): Explore a step-by-step guide on using the AzureML Python SDK to train your YOLOv8 models.
+- [Train YOLOv8 with AzureML CLI](https://medium.com/@ouphi/how-to-train-the-yolov8-model-with-azureml-and-the-az-cli-73d3c870ba8e): Discover how to utilize the command-line interface for streamlined training and management of YOLOv8 models on AzureML.

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/conda-quickstart.md

@@ -0,0 +1,132 @@
+---
+comments: true
+description: Comprehensive guide to setting up and using Ultralytics YOLO models in a Conda environment. Learn how to install the package, manage dependencies, and get started with object detection projects.
+keywords: Ultralytics, YOLO, Conda, environment setup, object detection, package installation, deep learning, machine learning, guide
+---
+
+# Conda Quickstart Guide for Ultralytics
+
+<p align="center">
+  <img width="800" src="https://user-images.githubusercontent.com/26833433/266324397-32119e21-8c86-43e5-a00e-79827d303d10.png" alt="Ultralytics Conda Package Visual">
+</p>
+
+This guide provides a comprehensive introduction to setting up a Conda environment for your Ultralytics projects. Conda is an open-source package and environment management system that offers an excellent alternative to pip for installing packages and dependencies. Its isolated environments make it particularly well-suited for data science and machine learning endeavors. For more details, visit the Ultralytics Conda package on [Anaconda](https://anaconda.org/conda-forge/ultralytics) and check out the Ultralytics feedstock repository for package updates on [GitHub](https://github.com/conda-forge/ultralytics-feedstock/).
+
+[![Conda Recipe](https://img.shields.io/badge/recipe-ultralytics-green.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Version](https://img.shields.io/conda/vn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Platforms](https://img.shields.io/conda/pn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics)
+
+## What You Will Learn
+
+- Setting up a Conda environment
+- Installing Ultralytics via Conda
+- Initializing Ultralytics in your environment
+- Using Ultralytics Docker images with Conda
+
+---
+
+## Prerequisites
+
+- You should have Anaconda or Miniconda installed on your system. If not, download and install it from [Anaconda](https://www.anaconda.com/) or [Miniconda](https://docs.conda.io/projects/miniconda/en/latest/).
+
+---
+
+## Setting up a Conda Environment
+
+First, let's create a new Conda environment. Open your terminal and run the following command:
+
+```bash
+conda create --name ultralytics-env python=3.8 -y
+```
+
+Activate the new environment:
+
+```bash
+conda activate ultralytics-env
+```
+
+---
+
+## Installing Ultralytics
+
+You can install the Ultralytics package from the conda-forge channel. Execute the following command:
+
+```bash
+conda install -c conda-forge ultralytics
+```
+
+### Note on CUDA Environment
+
+If you're working in a CUDA-enabled environment, it's a good practice to install `ultralytics`, `pytorch`, and `pytorch-cuda` together to resolve any conflicts:
+
+```bash
+conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics
+```
+
+---
+
+## Using Ultralytics
+
+With Ultralytics installed, you can now start using its robust features for object detection, instance segmentation, and more. For example, to predict an image, you can run:
+
+```python
+from ultralytics import YOLO
+
+model = YOLO('yolov8n.pt')  # initialize model
+results = model('path/to/image.jpg')  # perform inference
+results[0].show()  # display results for the first image
+```
+
+---
+
+## Ultralytics Conda Docker Image
+
+If you prefer using Docker, Ultralytics offers Docker images with a Conda environment included. You can pull these images from [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics).
+
+Pull the latest Ultralytics image:
+
+```bash
+# Set image name as a variable
+t=ultralytics/ultralytics:latest-conda
+
+# Pull the latest Ultralytics image from Docker Hub
+sudo docker pull $t
+```
+
+Run the image:
+
+```bash
+# Run the Ultralytics image in a container with GPU support
+sudo docker run -it --ipc=host --gpus all $t  # all GPUs
+sudo docker run -it --ipc=host --gpus '"device=2,3"' $t  # specify GPUs
+```
+
+---
+
+Certainly, you can include the following section in your Conda guide to inform users about speeding up installation using `libmamba`:
+
+---
+
+## Speeding Up Installation with Libmamba
+
+If you're looking to [speed up the package installation](https://www.anaconda.com/blog/a-faster-conda-for-a-growing-community) process in Conda, you can opt to use `libmamba`, a fast, cross-platform, and dependency-aware package manager that serves as an alternative solver to Conda's default.
+
+### How to Enable Libmamba
+
+To enable `libmamba` as the solver for Conda, you can perform the following steps:
+
+1. First, install the `conda-libmamba-solver` package. This can be skipped if your Conda version is 4.11 or above, as `libmamba` is included by default.
+
+    ```bash
+    conda install conda-libmamba-solver
+    ```
+
+2. Next, configure Conda to use `libmamba` as the solver:
+
+    ```bash
+    conda config --set solver libmamba
+    ```
+
+And that's it! Your Conda installation will now use `libmamba` as the solver, which should result in a faster package installation process.
+
+---
+
+Congratulations! You have successfully set up a Conda environment, installed the Ultralytics package, and are now ready to explore its rich functionalities. Feel free to dive deeper into the [Ultralytics documentation](../index.md) for more advanced tutorials and examples.

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/coral-edge-tpu-on-raspberry-pi.md

@@ -0,0 +1,140 @@
+---
+comments: true
+description: Guide on how to use Ultralytics with a Coral Edge TPU on a Raspberry Pi for increased inference performance.
+keywords: Ultralytics, YOLOv8, Object Detection, Coral, Edge TPU, Raspberry Pi, embedded, edge compute, sbc, accelerator, mobile
+---
+
+# Coral Edge TPU on a Raspberry Pi with Ultralytics YOLOv8 🚀
+
+<p align="center">
+  <img width="800" src="https://images.ctfassets.net/2lpsze4g694w/5XK2dV0w55U0TefijPli1H/bf0d119d77faef9a5d2cc0dad2aa4b42/Edge-TPU-USB-Accelerator-and-Pi.jpg?w=800" alt="Raspberry Pi single board computer with USB Edge TPU accelerator">
+</p>
+
+## What is a Coral Edge TPU?
+
+The Coral Edge TPU is a compact device that adds an Edge TPU coprocessor to your system. It enables low-power, high-performance ML inference for TensorFlow Lite models. Read more at the [Coral Edge TPU home page](https://coral.ai/products/accelerator).
+
+## Boost Raspberry Pi Model Performance with Coral Edge TPU
+
+Many people want to run their models on an embedded or mobile device such as a Raspberry Pi, since they are very power efficient and can be used in many different applications. However, the inference performance on these devices is usually poor even when using formats like [onnx](../integrations/onnx.md) or [openvino](../integrations/openvino.md). The Coral Edge TPU is a great solution to this problem, since it can be used with a Raspberry Pi and accelerate inference performance greatly.
+
+## Edge TPU on Raspberry Pi with TensorFlow Lite (New)⭐
+
+The [existing guide](https://coral.ai/docs/accelerator/get-started/) by Coral on how to use the Edge TPU with a Raspberry Pi is outdated, and the current Coral Edge TPU runtime builds do not work with the current TensorFlow Lite runtime versions anymore. In addition to that, Google seems to have completely abandoned the Coral project, and there have not been any updates between 2021 and 2024. This guide will show you how to get the Edge TPU working with the latest versions of the TensorFlow Lite runtime and an updated Coral Edge TPU runtime on a Raspberry Pi single board computer (SBC).
+
+## Prerequisites
+
+- [Raspberry Pi 4B](https://www.raspberrypi.com/products/raspberry-pi-4-model-b/) (2GB or more recommended) or [Raspberry Pi 5](https://www.raspberrypi.com/products/raspberry-pi-5/) (Recommended)
+- [Raspberry Pi OS](https://www.raspberrypi.com/software/) Bullseye/Bookworm (64-bit) with desktop (Recommended)
+- [Coral USB Accelerator](https://coral.ai/products/accelerator/)
+- A non-ARM based platform for exporting an Ultralytics PyTorch model
+
+## Installation Walkthrough
+
+This guide assumes that you already have a working Raspberry Pi OS install and have installed `ultralytics` and all dependencies. To get `ultralytics` installed, visit the [quickstart guide](../quickstart.md) to get setup before continuing here.
+
+### Installing the Edge TPU runtime
+
+First, we need to install the Edge TPU runtime. There are many different versions available, so you need to choose the right version for your operating system.
+
+| Raspberry Pi OS | High frequency mode | Version to download                        |
+|-----------------|:-------------------:|--------------------------------------------|
+| Bullseye 32bit  |         No          | `libedgetpu1-std_ ... .bullseye_armhf.deb` |
+| Bullseye 64bit  |         No          | `libedgetpu1-std_ ... .bullseye_arm64.deb` |
+| Bullseye 32bit  |         Yes         | `libedgetpu1-max_ ... .bullseye_armhf.deb` |
+| Bullseye 64bit  |         Yes         | `libedgetpu1-max_ ... .bullseye_arm64.deb` |
+| Bookworm 32bit  |         No          | `libedgetpu1-std_ ... .bookworm_armhf.deb` |
+| Bookworm 64bit  |         No          | `libedgetpu1-std_ ... .bookworm_arm64.deb` |
+| Bookworm 32bit  |         Yes         | `libedgetpu1-max_ ... .bookworm_armhf.deb` |
+| Bookworm 64bit  |         Yes         | `libedgetpu1-max_ ... .bookworm_arm64.deb` |
+
+[Download the latest version from here](https://github.com/feranick/libedgetpu/releases).
+
+After downloading the file, you can install it with the following command:
+
+```bash
+sudo dpkg -i path/to/package.deb
+```
+
+After installing the runtime, you need to plug in your Coral Edge TPU into a USB 3.0 port on your Raspberry Pi. This is because, according to the official guide, a new `udev` rule needs to take effect after installation.
+
+???+ warning "Important"
+
+    If you already have the Coral Edge TPU runtime installed, uninstall it using the following command.
+
+    ```bash
+    # If you installed the standard version
+    sudo apt remove libedgetpu1-std 
+
+    # If you installed the high frequency version
+    sudo apt remove libedgetpu1-max 
+    ```
+
+## Export your model to a Edge TPU compatible model
+
+To use the Edge TPU, you need to convert your model into a compatible format. It is recommended that you run export on Google Colab, x86_64 Linux machine, using the official [Ultralytics Docker container](docker-quickstart.md), or using [Ultralytics HUB](../hub/quickstart.md), since the Edge TPU compiler is not available on ARM. See the [Export Mode](../modes/export.md) for the available arguments.
+
+!!! Exporting the model
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO('path/to/model.pt')  # Load a official model or custom model
+
+        # Export the model
+        model.export(format='edgetpu')
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo export model=path/to/model.pt format=edgetpu  # Export a official model or custom model
+        ```
+
+The exported model will be saved in the `<model_name>_saved_model/` folder with the name `<model_name>_full_integer_quant_edgetpu.tflite`.
+
+## Running the model
+
+After exporting your model, you can run inference with it using the following code:
+
+!!! Running the model
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO('path/to/edgetpu_model.tflite')  # Load a official model or custom model
+
+        # Run Prediction
+        model.predict("path/to/source.png")
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo predict model=path/to/edgetpu_model.tflite source=path/to/source.png  # Load a official model or custom model
+        ```
+
+Find comprehensive information on the [Predict](../modes/predict.md) page for full prediction mode details.
+
+???+ warning "Important"
+
+    You should run the model using `tflite-runtime` and not `tensorflow`.
+    If `tensorflow` is installed, uninstall tensorflow with the following command:
+
+    ```bash
+    pip uninstall tensorflow tensorflow-aarch64
+    ```
+
+    Then install/update `tflite-runtime`:
+
+    ```
+    pip install -U tflite-runtime
+    ```
+
+    If you want a `tflite-runtime` wheel for `tensorflow` 2.15.0 download it from [here](https://github.com/feranick/TFlite-builds/releases) and install it using `pip` or your package manager of choice.

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/distance-calculation.md

@@ -0,0 +1,107 @@
+---
+comments: true
+description: Distance Calculation Using Ultralytics YOLOv8
+keywords: Ultralytics, YOLOv8, Object Detection, Distance Calculation, Object Tracking, Notebook, IPython Kernel, CLI, Python SDK
+---
+
+# Distance Calculation using Ultralytics YOLOv8 🚀
+
+## What is Distance Calculation?
+
+Measuring the gap between two objects is known as distance calculation within a specified space. In the case of [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics), the bounding box centroid is employed to calculate the distance for bounding boxes highlighted by the user.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/LE8am1QoVn4"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Distance Calculation using Ultralytics YOLOv8
+</p>
+
+## Visuals
+
+|                                                  Distance Calculation using Ultralytics YOLOv8                                                  |                                                                
+|:-----------------------------------------------------------------------------------------------------------------------------------------------:|
+| ![Ultralytics YOLOv8 Distance Calculation](https://github.com/RizwanMunawar/RizwanMunawar/assets/62513924/6b6b735d-3c49-4b84-a022-2bf6e3c72f8b) |
+
+## Advantages of Distance Calculation?
+
+- **Localization Precision:** Enhances accurate spatial positioning in computer vision tasks.
+- **Size Estimation:** Allows estimation of physical sizes for better contextual understanding.
+- **Scene Understanding:** Contributes to a 3D understanding of the environment for improved decision-making.
+
+???+ tip "Distance Calculation"
+
+    - Click on any two bounding boxes with Left Mouse click for distance calculation
+
+!!! Example "Distance Calculation using YOLOv8 Example"
+
+    === "Video Stream"
+
+        ```python
+        from ultralytics import YOLO
+        from ultralytics.solutions import distance_calculation
+        import cv2
+
+        model = YOLO("yolov8n.pt")
+        names = model.model.names
+
+        cap = cv2.VideoCapture("path/to/video/file.mp4")
+        assert cap.isOpened(), "Error reading video file"
+        w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
+
+        # Video writer
+        video_writer = cv2.VideoWriter("distance_calculation.avi",
+                                       cv2.VideoWriter_fourcc(*'mp4v'),
+                                       fps,
+                                       (w, h))
+
+        # Init distance-calculation obj
+        dist_obj = distance_calculation.DistanceCalculation()
+        dist_obj.set_args(names=names, view_img=True)
+
+        while cap.isOpened():
+            success, im0 = cap.read()
+            if not success:
+                print("Video frame is empty or video processing has been successfully completed.")
+                break
+
+            tracks = model.track(im0, persist=True, show=False)
+            im0 = dist_obj.start_process(im0, tracks)
+            video_writer.write(im0)
+
+        cap.release()
+        video_writer.release()
+        cv2.destroyAllWindows()
+
+        ```
+
+???+ tip "Note"
+
+    - Mouse Right Click will delete all drawn points
+    - Mouse Left Click can be used to draw points
+
+### Optional Arguments `set_args`
+
+| Name             | Type   | Default         | Description                                            |
+|------------------|--------|-----------------|--------------------------------------------------------|
+| `names`          | `dict` | `None`          | Classes names                                          |
+| `view_img`       | `bool` | `False`         | Display frames with counts                             |
+| `line_thickness` | `int`  | `2`             | Increase bounding boxes thickness                      |
+| `line_color`     | `RGB`  | `(255, 255, 0)` | Line Color for centroids mapping on two bounding boxes |
+| `centroid_color` | `RGB`  | `(255, 0, 255)` | Centroid color for each bounding box                   |
+
+### Arguments `model.track`
+
+| Name      | Type    | Default        | Description                                                 |
+|-----------|---------|----------------|-------------------------------------------------------------|
+| `source`  | `im0`   | `None`         | source directory for images or videos                       |
+| `persist` | `bool`  | `False`        | persisting tracks between frames                            |
+| `tracker` | `str`   | `botsort.yaml` | Tracking method 'bytetrack' or 'botsort'                    |
+| `conf`    | `float` | `0.3`          | Confidence Threshold                                        |
+| `iou`     | `float` | `0.5`          | IOU Threshold                                               |
+| `classes` | `list`  | `None`         | filter results by class, i.e. classes=0, or classes=[0,2,3] |
+| `verbose` | `bool`  | `True`         | Display the object tracking results                         |

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/docker-quickstart.md

@@ -0,0 +1,119 @@
+---
+comments: true
+description: Complete guide to setting up and using Ultralytics YOLO models with Docker. Learn how to install Docker, manage GPU support, and run YOLO models in isolated containers.
+keywords: Ultralytics, YOLO, Docker, GPU, containerization, object detection, package installation, deep learning, machine learning, guide
+---
+
+# Docker Quickstart Guide for Ultralytics
+
+<p align="center">
+  <img width="800" src="https://user-images.githubusercontent.com/26833433/270173601-fc7011bd-e67c-452f-a31a-aa047dcd2771.png" alt="Ultralytics Docker Package Visual">
+</p>
+
+This guide serves as a comprehensive introduction to setting up a Docker environment for your Ultralytics projects. [Docker](https://docker.com/) is a platform for developing, shipping, and running applications in containers. It is particularly beneficial for ensuring that the software will always run the same, regardless of where it's deployed. For more details, visit the Ultralytics Docker repository on [Docker Hub](https://hub.docker.com/r/ultralytics/ultralytics).
+
+[![Docker Pulls](https://img.shields.io/docker/pulls/ultralytics/ultralytics?logo=docker)](https://hub.docker.com/r/ultralytics/ultralytics)
+
+## What You Will Learn
+
+- Setting up Docker with NVIDIA support
+- Installing Ultralytics Docker images
+- Running Ultralytics in a Docker container
+- Mounting local directories into the container
+
+---
+
+## Prerequisites
+
+- Make sure Docker is installed on your system. If not, you can download and install it from [Docker's website](https://www.docker.com/products/docker-desktop).
+- Ensure that your system has an NVIDIA GPU and NVIDIA drivers are installed.
+
+---
+
+## Setting up Docker with NVIDIA Support
+
+First, verify that the NVIDIA drivers are properly installed by running:
+
+```bash
+nvidia-smi
+```
+
+### Installing NVIDIA Docker Runtime
+
+Now, let's install the NVIDIA Docker runtime to enable GPU support in Docker containers:
+
+```bash
+# Add NVIDIA package repositories
+curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
+distribution=$(lsb_release -cs)
+curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list
+
+# Install NVIDIA Docker runtime
+sudo apt-get update
+sudo apt-get install -y nvidia-docker2
+
+# Restart Docker service to apply changes
+sudo systemctl restart docker
+```
+
+### Verify NVIDIA Runtime with Docker
+
+Run `docker info | grep -i runtime` to ensure that `nvidia` appears in the list of runtimes:
+
+```bash
+docker info | grep -i runtime
+```
+
+---
+
+## Installing Ultralytics Docker Images
+
+Ultralytics offers several Docker images optimized for various platforms and use-cases:
+
+- **Dockerfile:** GPU image, ideal for training.
+- **Dockerfile-arm64:** For ARM64 architecture, suitable for devices like [Raspberry Pi](raspberry-pi.md).
+- **Dockerfile-cpu:** CPU-only version for inference and non-GPU environments.
+- **Dockerfile-jetson:** Optimized for NVIDIA Jetson devices.
+- **Dockerfile-python:** Minimal Python environment for lightweight applications.
+- **Dockerfile-conda:** Includes [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/) and Ultralytics package installed via Conda.
+
+To pull the latest image:
+
+```bash
+# Set image name as a variable
+t=ultralytics/ultralytics:latest
+
+# Pull the latest Ultralytics image from Docker Hub
+sudo docker pull $t
+```
+
+---
+
+## Running Ultralytics in Docker Container
+
+Here's how to execute the Ultralytics Docker container:
+
+```bash
+# Run with all GPUs
+sudo docker run -it --ipc=host --gpus all $t
+
+# Run specifying which GPUs to use
+sudo docker run -it --ipc=host --gpus '"device=2,3"' $t
+```
+
+The `-it` flag assigns a pseudo-TTY and keeps stdin open, allowing you to interact with the container. The `--ipc=host` flag enables sharing of host's IPC namespace, essential for sharing memory between processes. The `--gpus` flag allows the container to access the host's GPUs.
+
+### Note on File Accessibility
+
+To work with files on your local machine within the container, you can use Docker volumes:
+
+```bash
+# Mount a local directory into the container
+sudo docker run -it --ipc=host --gpus all -v /path/on/host:/path/in/container $t
+```
+
+Replace `/path/on/host` with the directory path on your local machine and `/path/in/container` with the desired path inside the Docker container.
+
+---
+
+Congratulations! You're now set up to use Ultralytics with Docker and ready to take advantage of its powerful capabilities. For alternate installation methods, feel free to explore the [Ultralytics quickstart documentation](../quickstart.md).

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/heatmaps.md

@@ -0,0 +1,301 @@
+---
+comments: true
+description: Advanced Data Visualization with Ultralytics YOLOv8 Heatmaps
+keywords: Ultralytics, YOLOv8, Advanced Data Visualization, Heatmap Technology, Object Detection and Tracking, Jupyter Notebook, Python SDK, Command Line Interface
+---
+
+# Advanced Data Visualization: Heatmaps using Ultralytics YOLOv8 🚀
+
+## Introduction to Heatmaps
+
+A heatmap generated with [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) transforms complex data into a vibrant, color-coded matrix. This visual tool employs a spectrum of colors to represent varying data values, where warmer hues indicate higher intensities and cooler tones signify lower values. Heatmaps excel in visualizing intricate data patterns, correlations, and anomalies, offering an accessible and engaging approach to data interpretation across diverse domains.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/4ezde5-nZZw"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Heatmaps using Ultralytics YOLOv8
+</p>
+
+## Why Choose Heatmaps for Data Analysis?
+
+- **Intuitive Data Distribution Visualization:** Heatmaps simplify the comprehension of data concentration and distribution, converting complex datasets into easy-to-understand visual formats.
+- **Efficient Pattern Detection:** By visualizing data in heatmap format, it becomes easier to spot trends, clusters, and outliers, facilitating quicker analysis and insights.
+- **Enhanced Spatial Analysis and Decision-Making:** Heatmaps are instrumental in illustrating spatial relationships, aiding in decision-making processes in sectors such as business intelligence, environmental studies, and urban planning.
+
+## Real World Applications
+
+|                                                                 Transportation                                                                  |                                                                 Retail                                                                  |
+|:-----------------------------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------------------:|
+| ![Ultralytics YOLOv8 Transportation Heatmap](https://github.com/RizwanMunawar/ultralytics/assets/62513924/288d7053-622b-4452-b4e4-1f41aeb764aa) | ![Ultralytics YOLOv8 Retail Heatmap](https://github.com/RizwanMunawar/ultralytics/assets/62513924/edef75ad-50a7-4c0a-be4a-a66cdfc12802) |
+|                                                    Ultralytics YOLOv8 Transportation Heatmap                                                    |                                                    Ultralytics YOLOv8 Retail Heatmap                                                    |
+
+!!! tip "Heatmap Configuration"
+
+    - `heatmap_alpha`: Ensure this value is within the range (0.0 - 1.0).
+    - `decay_factor`: Used for removing heatmap after an object is no longer in the frame, its value should also be in the range (0.0 - 1.0).
+
+!!! Example "Heatmaps using Ultralytics YOLOv8 Example"
+
+    === "Heatmap"
+
+        ```python
+        from ultralytics import YOLO
+        from ultralytics.solutions import heatmap
+        import cv2
+
+        model = YOLO("yolov8n.pt")
+        cap = cv2.VideoCapture("path/to/video/file.mp4")
+        assert cap.isOpened(), "Error reading video file"
+        w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
+
+        # Video writer
+        video_writer = cv2.VideoWriter("heatmap_output.avi",
+                                       cv2.VideoWriter_fourcc(*'mp4v'),
+                                       fps,
+                                       (w, h))
+
+        # Init heatmap
+        heatmap_obj = heatmap.Heatmap()
+        heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA,
+                             imw=w,
+                             imh=h,
+                             view_img=True,
+                             shape="circle")
+
+        while cap.isOpened():
+            success, im0 = cap.read()
+            if not success:
+                print("Video frame is empty or video processing has been successfully completed.")
+                break
+            tracks = model.track(im0, persist=True, show=False)
+
+            im0 = heatmap_obj.generate_heatmap(im0, tracks)
+            video_writer.write(im0)
+
+        cap.release()
+        video_writer.release()
+        cv2.destroyAllWindows()
+
+        ```
+
+    === "Line Counting"
+
+        ```python
+        from ultralytics import YOLO
+        from ultralytics.solutions import heatmap
+        import cv2
+
+        model = YOLO("yolov8n.pt")
+        cap = cv2.VideoCapture("path/to/video/file.mp4")
+        assert cap.isOpened(), "Error reading video file"
+        w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
+
+        # Video writer
+        video_writer = cv2.VideoWriter("heatmap_output.avi",
+                                       cv2.VideoWriter_fourcc(*'mp4v'),
+                                       fps,
+                                       (w, h))
+
+        line_points = [(20, 400), (1080, 404)]  # line for object counting
+
+        # Init heatmap
+        heatmap_obj = heatmap.Heatmap()
+        heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA,
+                             imw=w,
+                             imh=h,
+                             view_img=True,
+                             shape="circle",
+                             count_reg_pts=line_points)
+
+        while cap.isOpened():
+            success, im0 = cap.read()
+            if not success:
+                print("Video frame is empty or video processing has been successfully completed.")
+                break
+            tracks = model.track(im0, persist=True, show=False)
+
+            im0 = heatmap_obj.generate_heatmap(im0, tracks)
+            video_writer.write(im0)
+
+        cap.release()
+        video_writer.release()
+        cv2.destroyAllWindows()
+        ```
+
+    === "Region Counting"
+
+        ```python
+        from ultralytics import YOLO
+        from ultralytics.solutions import heatmap
+        import cv2
+
+        model = YOLO("yolov8n.pt")
+        cap = cv2.VideoCapture("path/to/video/file.mp4")
+        assert cap.isOpened(), "Error reading video file"
+        w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
+
+        # Video writer
+        video_writer = cv2.VideoWriter("heatmap_output.avi",
+                                       cv2.VideoWriter_fourcc(*'mp4v'),
+                                       fps,
+                                       (w, h))
+
+        # Define region points
+        region_points = [(20, 400), (1080, 404), (1080, 360), (20, 360)]
+
+        # Init heatmap
+        heatmap_obj = heatmap.Heatmap()
+        heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA,
+                             imw=w,
+                             imh=h,
+                             view_img=True,
+                             shape="circle",
+                             count_reg_pts=region_points)
+
+        while cap.isOpened():
+            success, im0 = cap.read()
+            if not success:
+                print("Video frame is empty or video processing has been successfully completed.")
+                break
+            tracks = model.track(im0, persist=True, show=False)
+
+            im0 = heatmap_obj.generate_heatmap(im0, tracks)
+            video_writer.write(im0)
+
+        cap.release()
+        video_writer.release()
+        cv2.destroyAllWindows()
+        ```
+
+    === "Im0"
+
+        ```python
+        from ultralytics import YOLO
+        from ultralytics.solutions import heatmap
+        import cv2
+
+        model = YOLO("yolov8s.pt")   # YOLOv8 custom/pretrained model
+
+        im0 = cv2.imread("path/to/image.png")  # path to image file
+        h, w = im0.shape[:2]  # image height and width
+        
+        # Heatmap Init
+        heatmap_obj = heatmap.Heatmap()
+        heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA,
+                             imw=w,
+                             imh=h,
+                             view_img=True,
+                             shape="circle")
+
+        results = model.track(im0, persist=True)
+        im0 = heatmap_obj.generate_heatmap(im0, tracks=results)
+        cv2.imwrite("ultralytics_output.png", im0)
+        ```
+
+    === "Specific Classes"
+
+        ```python
+        from ultralytics import YOLO
+        from ultralytics.solutions import heatmap
+        import cv2
+
+        model = YOLO("yolov8n.pt")
+        cap = cv2.VideoCapture("path/to/video/file.mp4")
+        assert cap.isOpened(), "Error reading video file"
+        w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
+
+        # Video writer
+        video_writer = cv2.VideoWriter("heatmap_output.avi",
+                                       cv2.VideoWriter_fourcc(*'mp4v'),
+                                       fps,
+                                       (w, h))
+
+        classes_for_heatmap = [0, 2]  # classes for heatmap
+
+        # Init heatmap
+        heatmap_obj = heatmap.Heatmap()
+        heatmap_obj.set_args(colormap=cv2.COLORMAP_PARULA,
+                             imw=w,
+                             imh=h,
+                             view_img=True,
+                             shape="circle")
+
+        while cap.isOpened():
+            success, im0 = cap.read()
+            if not success:
+                print("Video frame is empty or video processing has been successfully completed.")
+                break
+            tracks = model.track(im0, persist=True, show=False,
+                                 classes=classes_for_heatmap)
+
+            im0 = heatmap_obj.generate_heatmap(im0, tracks)
+            video_writer.write(im0)
+
+        cap.release()
+        video_writer.release()
+        cv2.destroyAllWindows()
+        ```
+
+### Arguments `set_args`
+
+| Name                  | Type           | Default           | Description                                               |
+|-----------------------|----------------|-------------------|-----------------------------------------------------------|
+| `view_img`            | `bool`         | `False`           | Display the frame with heatmap                            |
+| `colormap`            | `cv2.COLORMAP` | `None`            | cv2.COLORMAP for heatmap                                  |
+| `imw`                 | `int`          | `None`            | Width of Heatmap                                          |
+| `imh`                 | `int`          | `None`            | Height of Heatmap                                         |
+| `heatmap_alpha`       | `float`        | `0.5`             | Heatmap alpha value                                       |
+| `count_reg_pts`       | `list`         | `None`            | Object counting region points                             |
+| `count_txt_thickness` | `int`          | `2`               | Count values text size                                    |
+| `count_txt_color`     | `RGB Color`    | `(0, 0, 0)`       | Foreground color for Object counts text                   |
+| `count_color`         | `RGB Color`    | `(255, 255, 255)` | Background color for Object counts text                   |
+| `count_reg_color`     | `RGB Color`    | `(255, 0, 255)`   | Counting region color                                     |
+| `region_thickness`    | `int`          | `5`               | Counting region thickness value                           |
+| `decay_factor`        | `float`        | `0.99`            | Decay factor for heatmap area removal after specific time |
+| `shape`               | `str`          | `circle`          | Heatmap shape for display "rect" or "circle" supported    |
+| `line_dist_thresh`    | `int`          | `15`              | Euclidean Distance threshold for line counter             |
+
+### Arguments `model.track`
+
+| Name      | Type    | Default        | Description                                                 |
+|-----------|---------|----------------|-------------------------------------------------------------|
+| `source`  | `im0`   | `None`         | source directory for images or videos                       |
+| `persist` | `bool`  | `False`        | persisting tracks between frames                            |
+| `tracker` | `str`   | `botsort.yaml` | Tracking method 'bytetrack' or 'botsort'                    |
+| `conf`    | `float` | `0.3`          | Confidence Threshold                                        |
+| `iou`     | `float` | `0.5`          | IOU Threshold                                               |
+| `classes` | `list`  | `None`         | filter results by class, i.e. classes=0, or classes=[0,2,3] |
+
+### Heatmap COLORMAPs
+
+| Colormap Name                   | Description                            |
+|---------------------------------|----------------------------------------|
+| `cv::COLORMAP_AUTUMN`           | Autumn color map                       |
+| `cv::COLORMAP_BONE`             | Bone color map                         |
+| `cv::COLORMAP_JET`              | Jet color map                          |
+| `cv::COLORMAP_WINTER`           | Winter color map                       |
+| `cv::COLORMAP_RAINBOW`          | Rainbow color map                      |
+| `cv::COLORMAP_OCEAN`            | Ocean color map                        |
+| `cv::COLORMAP_SUMMER`           | Summer color map                       |
+| `cv::COLORMAP_SPRING`           | Spring color map                       |
+| `cv::COLORMAP_COOL`             | Cool color map                         |
+| `cv::COLORMAP_HSV`              | HSV (Hue, Saturation, Value) color map |
+| `cv::COLORMAP_PINK`             | Pink color map                         |
+| `cv::COLORMAP_HOT`              | Hot color map                          |
+| `cv::COLORMAP_PARULA`           | Parula color map                       |
+| `cv::COLORMAP_MAGMA`            | Magma color map                        |
+| `cv::COLORMAP_INFERNO`          | Inferno color map                      |
+| `cv::COLORMAP_PLASMA`           | Plasma color map                       |
+| `cv::COLORMAP_VIRIDIS`          | Viridis color map                      |
+| `cv::COLORMAP_CIVIDIS`          | Cividis color map                      |
+| `cv::COLORMAP_TWILIGHT`         | Twilight color map                     |
+| `cv::COLORMAP_TWILIGHT_SHIFTED` | Shifted Twilight color map             |
+| `cv::COLORMAP_TURBO`            | Turbo color map                        |
+| `cv::COLORMAP_DEEPGREEN`        | Deep Green color map                   |
+
+These colormaps are commonly used for visualizing data with different color representations.

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/hyperparameter-tuning.md

@@ -0,0 +1,206 @@
+---
+comments: true
+description: Dive into hyperparameter tuning in Ultralytics YOLO models. Learn how to optimize performance using the Tuner class and genetic evolution.
+keywords: Ultralytics, YOLO, Hyperparameter Tuning, Tuner Class, Genetic Evolution, Optimization
+---
+
+# Ultralytics YOLO Hyperparameter Tuning Guide
+
+## Introduction
+
+Hyperparameter tuning is not just a one-time set-up but an iterative process aimed at optimizing the machine learning model's performance metrics, such as accuracy, precision, and recall. In the context of Ultralytics YOLO, these hyperparameters could range from learning rate to architectural details, such as the number of layers or types of activation functions used.
+
+### What are Hyperparameters?
+
+Hyperparameters are high-level, structural settings for the algorithm. They are set prior to the training phase and remain constant during it. Here are some commonly tuned hyperparameters in Ultralytics YOLO:
+
+- **Learning Rate** `lr0`: Determines the step size at each iteration while moving towards a minimum in the loss function.
+- **Batch Size** `batch`: Number of images processed simultaneously in a forward pass.
+- **Number of Epochs** `epochs`: An epoch is one complete forward and backward pass of all the training examples.
+- **Architecture Specifics**: Such as channel counts, number of layers, types of activation functions, etc.
+
+<p align="center">
+  <img width="640" src="https://user-images.githubusercontent.com/26833433/263858934-4f109a2f-82d9-4d08-8bd6-6fd1ff520bcd.png" alt="Hyperparameter Tuning Visual">
+</p>
+
+For a full list of augmentation hyperparameters used in YOLOv8 please refer to the [configurations page](../usage/cfg.md#augmentation-settings).
+
+### Genetic Evolution and Mutation
+
+Ultralytics YOLO uses genetic algorithms to optimize hyperparameters. Genetic algorithms are inspired by the mechanism of natural selection and genetics.
+
+- **Mutation**: In the context of Ultralytics YOLO, mutation helps in locally searching the hyperparameter space by applying small, random changes to existing hyperparameters, producing new candidates for evaluation.
+- **Crossover**: Although crossover is a popular genetic algorithm technique, it is not currently used in Ultralytics YOLO for hyperparameter tuning. The focus is mainly on mutation for generating new hyperparameter sets.
+
+## Preparing for Hyperparameter Tuning
+
+Before you begin the tuning process, it's important to:
+
+1. **Identify the Metrics**: Determine the metrics you will use to evaluate the model's performance. This could be AP50, F1-score, or others.
+2. **Set the Tuning Budget**: Define how much computational resources you're willing to allocate. Hyperparameter tuning can be computationally intensive.
+
+## Steps Involved
+
+### Initialize Hyperparameters
+
+Start with a reasonable set of initial hyperparameters. This could either be the default hyperparameters set by Ultralytics YOLO or something based on your domain knowledge or previous experiments.
+
+### Mutate Hyperparameters
+
+Use the `_mutate` method to produce a new set of hyperparameters based on the existing set.
+
+### Train Model
+
+Training is performed using the mutated set of hyperparameters. The training performance is then assessed.
+
+### Evaluate Model
+
+Use metrics like AP50, F1-score, or custom metrics to evaluate the model's performance.
+
+### Log Results
+
+It's crucial to log both the performance metrics and the corresponding hyperparameters for future reference.
+
+### Repeat
+
+The process is repeated until either the set number of iterations is reached or the performance metric is satisfactory.
+
+## Usage Example
+
+Here's how to use the `model.tune()` method to utilize the `Tuner` class for hyperparameter tuning of YOLOv8n on COCO8 for 30 epochs with an AdamW optimizer and skipping plotting, checkpointing and validation other than on final epoch for faster Tuning.
+
+!!! Example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Initialize the YOLO model
+        model = YOLO('yolov8n.pt')
+
+        # Tune hyperparameters on COCO8 for 30 epochs
+        model.tune(data='coco8.yaml', epochs=30, iterations=300, optimizer='AdamW', plots=False, save=False, val=False)
+        ```
+
+## Results
+
+After you've successfully completed the hyperparameter tuning process, you will obtain several files and directories that encapsulate the results of the tuning. The following describes each:
+
+### File Structure
+
+Here's what the directory structure of the results will look like. Training directories like `train1/` contain individual tuning iterations, i.e. one model trained with one set of hyperparameters. The `tune/` directory contains tuning results from all the individual model trainings:
+
+```plaintext
+runs/
+└── detect/
+    ├── train1/
+    ├── train2/
+    ├── ...
+    └── tune/
+        ├── best_hyperparameters.yaml
+        ├── best_fitness.png
+        ├── tune_results.csv
+        ├── tune_scatter_plots.png
+        └── weights/
+            ├── last.pt
+            └── best.pt
+```
+
+### File Descriptions
+
+#### best_hyperparameters.yaml
+
+This YAML file contains the best-performing hyperparameters found during the tuning process. You can use this file to initialize future trainings with these optimized settings.
+
+- **Format**: YAML
+- **Usage**: Hyperparameter results
+- **Example**:
+    ```yaml
+      # 558/900 iterations complete ✅ (45536.81s)
+      # Results saved to /usr/src/ultralytics/runs/detect/tune
+      # Best fitness=0.64297 observed at iteration 498
+      # Best fitness metrics are {'metrics/precision(B)': 0.87247, 'metrics/recall(B)': 0.71387, 'metrics/mAP50(B)': 0.79106, 'metrics/mAP50-95(B)': 0.62651, 'val/box_loss': 2.79884, 'val/cls_loss': 2.72386, 'val/dfl_loss': 0.68503, 'fitness': 0.64297}
+      # Best fitness model is /usr/src/ultralytics/runs/detect/train498
+      # Best fitness hyperparameters are printed below.
+
+      lr0: 0.00269
+      lrf: 0.00288
+      momentum: 0.73375
+      weight_decay: 0.00015
+      warmup_epochs: 1.22935
+      warmup_momentum: 0.1525
+      box: 18.27875
+      cls: 1.32899
+      dfl: 0.56016
+      hsv_h: 0.01148
+      hsv_s: 0.53554
+      hsv_v: 0.13636
+      degrees: 0.0
+      translate: 0.12431
+      scale: 0.07643
+      shear: 0.0
+      perspective: 0.0
+      flipud: 0.0
+      fliplr: 0.08631
+      mosaic: 0.42551
+      mixup: 0.0
+      copy_paste: 0.0
+    ```
+
+#### best_fitness.png
+
+This is a plot displaying fitness (typically a performance metric like AP50) against the number of iterations. It helps you visualize how well the genetic algorithm performed over time.
+
+- **Format**: PNG
+- **Usage**: Performance visualization
+
+<p align="center">
+  <img width="640" src="https://user-images.githubusercontent.com/26833433/266847423-9d0aea13-d5c4-4771-b06e-0b817a498260.png" alt="Hyperparameter Tuning Fitness vs Iteration">
+</p>
+
+#### tune_results.csv
+
+A CSV file containing detailed results of each iteration during the tuning. Each row in the file represents one iteration, and it includes metrics like fitness score, precision, recall, as well as the hyperparameters used.
+
+- **Format**: CSV
+- **Usage**: Per-iteration results tracking.
+- **Example**:
+    ```csv
+      fitness,lr0,lrf,momentum,weight_decay,warmup_epochs,warmup_momentum,box,cls,dfl,hsv_h,hsv_s,hsv_v,degrees,translate,scale,shear,perspective,flipud,fliplr,mosaic,mixup,copy_paste
+      0.05021,0.01,0.01,0.937,0.0005,3.0,0.8,7.5,0.5,1.5,0.015,0.7,0.4,0.0,0.1,0.5,0.0,0.0,0.0,0.5,1.0,0.0,0.0
+      0.07217,0.01003,0.00967,0.93897,0.00049,2.79757,0.81075,7.5,0.50746,1.44826,0.01503,0.72948,0.40658,0.0,0.0987,0.4922,0.0,0.0,0.0,0.49729,1.0,0.0,0.0
+      0.06584,0.01003,0.00855,0.91009,0.00073,3.42176,0.95,8.64301,0.54594,1.72261,0.01503,0.59179,0.40658,0.0,0.0987,0.46955,0.0,0.0,0.0,0.49729,0.80187,0.0,0.0
+    ```
+
+#### tune_scatter_plots.png
+
+This file contains scatter plots generated from `tune_results.csv`, helping you visualize relationships between different hyperparameters and performance metrics. Note that hyperparameters initialized to 0 will not be tuned, such as `degrees` and `shear` below.
+
+- **Format**: PNG
+- **Usage**: Exploratory data analysis
+
+<p align="center">
+  <img width="1000" src="https://user-images.githubusercontent.com/26833433/266847488-ec382f3d-79bc-4087-a0e0-42fb8b62cad2.png" alt="Hyperparameter Tuning Scatter Plots">
+</p>
+
+#### weights/
+
+This directory contains the saved PyTorch models for the last and the best iterations during the hyperparameter tuning process.
+
+- **`last.pt`**: The last.pt are the weights from the last epoch of training.
+- **`best.pt`**: The best.pt weights for the iteration that achieved the best fitness score.
+
+Using these results, you can make more informed decisions for your future model trainings and analyses. Feel free to consult these artifacts to understand how well your model performed and how you might improve it further.
+
+## Conclusion
+
+The hyperparameter tuning process in Ultralytics YOLO is simplified yet powerful, thanks to its genetic algorithm-based approach focused on mutation. Following the steps outlined in this guide will assist you in systematically tuning your model to achieve better performance.
+
+### Further Reading
+
+1. [Hyperparameter Optimization in Wikipedia](https://en.wikipedia.org/wiki/Hyperparameter_optimization)
+2. [YOLOv5 Hyperparameter Evolution Guide](../yolov5/tutorials/hyperparameter_evolution.md)
+3. [Efficient Hyperparameter Tuning with Ray Tune and YOLOv8](../integrations/ray-tune.md)
+
+For deeper insights, you can explore the `Tuner` class source code and accompanying documentation. Should you have any questions, feature requests, or need further assistance, feel free to reach out to us on [GitHub](https://github.com/ultralytics/ultralytics/issues/new/choose) or [Discord](https://ultralytics.com/discord).

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/index.md

@@ -0,0 +1,65 @@
+---
+comments: true
+description: In-depth exploration of Ultralytics' YOLO. Learn about the YOLO object detection model, how to train it on custom data, multi-GPU training, exporting, predicting, deploying, and more.
+keywords: Ultralytics, YOLO, Deep Learning, Object detection, PyTorch, Tutorial, Multi-GPU training, Custom data training, SAHI, Tiled Inference
+---
+
+# Comprehensive Tutorials to Ultralytics YOLO
+
+Welcome to the Ultralytics' YOLO 🚀 Guides! Our comprehensive tutorials cover various aspects of the YOLO object detection model, ranging from training and prediction to deployment. Built on PyTorch, YOLO stands out for its exceptional speed and accuracy in real-time object detection tasks.
+
+Whether you're a beginner or an expert in deep learning, our tutorials offer valuable insights into the implementation and optimization of YOLO for your computer vision projects. Let's dive in!
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/96NkhsV-W1U"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Ultralytics YOLOv8 Guides Overview
+</p>
+
+## Guides
+
+Here's a compilation of in-depth guides to help you master different aspects of Ultralytics YOLO.
+
+- [YOLO Common Issues](yolo-common-issues.md) ⭐ RECOMMENDED: Practical solutions and troubleshooting tips to the most frequently encountered issues when working with Ultralytics YOLO models.
+- [YOLO Performance Metrics](yolo-performance-metrics.md) ⭐ ESSENTIAL: Understand the key metrics like mAP, IoU, and F1 score used to evaluate the performance of your YOLO models. Includes practical examples and tips on how to improve detection accuracy and speed.
+- [Model Deployment Options](model-deployment-options.md): Overview of YOLO model deployment formats like ONNX, OpenVINO, and TensorRT, with pros and cons for each to inform your deployment strategy.
+- [K-Fold Cross Validation](kfold-cross-validation.md) 🚀 NEW: Learn how to improve model generalization using K-Fold cross-validation technique.
+- [Hyperparameter Tuning](hyperparameter-tuning.md) 🚀 NEW: Discover how to optimize your YOLO models by fine-tuning hyperparameters using the Tuner class and genetic evolution algorithms.
+- [SAHI Tiled Inference](sahi-tiled-inference.md) 🚀 NEW: Comprehensive guide on leveraging SAHI's sliced inference capabilities with YOLOv8 for object detection in high-resolution images.
+- [AzureML Quickstart](azureml-quickstart.md) 🚀 NEW: Get up and running with Ultralytics YOLO models on Microsoft's Azure Machine Learning platform. Learn how to train, deploy, and scale your object detection projects in the cloud.
+- [Conda Quickstart](conda-quickstart.md) 🚀 NEW: Step-by-step guide to setting up a [Conda](https://anaconda.org/conda-forge/ultralytics) environment for Ultralytics. Learn how to install and start using the Ultralytics package efficiently with Conda.
+- [Docker Quickstart](docker-quickstart.md) 🚀 NEW: Complete guide to setting up and using Ultralytics YOLO models with [Docker](https://hub.docker.com/r/ultralytics/ultralytics). Learn how to install Docker, manage GPU support, and run YOLO models in isolated containers for consistent development and deployment.
+- [Raspberry Pi](raspberry-pi.md) 🚀 NEW: Quickstart tutorial to run YOLO models to the latest Raspberry Pi hardware.
+- [Triton Inference Server Integration](triton-inference-server.md) 🚀 NEW: Dive into the integration of Ultralytics YOLOv8 with NVIDIA's Triton Inference Server for scalable and efficient deep learning inference deployments.
+- [YOLO Thread-Safe Inference](yolo-thread-safe-inference.md) 🚀 NEW: Guidelines for performing inference with YOLO models in a thread-safe manner. Learn the importance of thread safety and best practices to prevent race conditions and ensure consistent predictions.
+- [Isolating Segmentation Objects](isolating-segmentation-objects.md) 🚀 NEW: Step-by-step recipe and explanation on how to extract and/or isolate objects from images using Ultralytics Segmentation.
+- [Edge TPU on Raspberry Pi](coral-edge-tpu-on-raspberry-pi.md): [Google Edge TPU](https://coral.ai/products/accelerator) accelerates YOLO inference on [Raspberry Pi](https://www.raspberrypi.com/).
+- [View Inference Images in a Terminal](view-results-in-terminal.md): Use VSCode's integrated terminal to view inference results when using Remote Tunnel or SSH sessions.
+- [OpenVINO Latency vs Throughput Modes](optimizing-openvino-latency-vs-throughput-modes.md) - Learn latency and throughput optimization techniques for peak YOLO inference performance.
+
+## Real-World Projects
+
+- [Object Counting](object-counting.md) 🚀 NEW: Explore the process of real-time object counting with Ultralytics YOLOv8 and acquire the knowledge to effectively count objects in a live video stream.
+- [Object Cropping](object-cropping.md) 🚀 NEW: Explore object cropping using YOLOv8 for precise extraction of objects from images and videos.
+- [Object Blurring](object-blurring.md) 🚀 NEW: Apply object blurring with YOLOv8 for privacy protection in image and video processing.
+- [Workouts Monitoring](workouts-monitoring.md) 🚀 NEW: Discover the comprehensive approach to monitoring workouts with Ultralytics YOLOv8. Acquire the skills and insights necessary to effectively use YOLOv8 for tracking and analyzing various aspects of fitness routines in real time.
+- [Objects Counting in Regions](region-counting.md) 🚀 NEW: Explore counting objects in specific regions with Ultralytics YOLOv8 for precise and efficient object detection in varied areas.
+- [Security Alarm System](security-alarm-system.md) 🚀 NEW: Discover the process of creating a security alarm system with Ultralytics YOLOv8. This system triggers alerts upon detecting new objects in the frame. Subsequently, you can customize the code to align with your specific use case.
+- [Heatmaps](heatmaps.md) 🚀 NEW: Elevate your understanding of data with our Detection Heatmaps! These intuitive visual tools use vibrant color gradients to vividly illustrate the intensity of data values across a matrix. Essential in computer vision, heatmaps are skillfully designed to highlight areas of interest, providing an immediate, impactful way to interpret spatial information.
+- [Instance Segmentation with Object Tracking](instance-segmentation-and-tracking.md) 🚀 NEW: Explore our feature on [Object Segmentation](https://docs.ultralytics.com/tasks/segment/) in Bounding Boxes Shape, providing a visual representation of precise object boundaries for enhanced understanding and analysis.
+- [VisionEye View Objects Mapping](vision-eye.md) 🚀 NEW: This feature aim computers to discern and focus on specific objects, much like the way the human eye observes details from a particular viewpoint.
+- [Speed Estimation](speed-estimation.md) 🚀 NEW: Speed estimation in computer vision relies on analyzing object motion through techniques like [object tracking](https://docs.ultralytics.com/modes/track/), crucial for applications like autonomous vehicles and traffic monitoring.
+- [Distance Calculation](distance-calculation.md) 🚀 NEW: Distance calculation, which involves measuring the separation between two objects within a defined space, is a crucial aspect. In the context of Ultralytics YOLOv8, the method employed for this involves using the bounding box centroid to determine the distance associated with user-highlighted bounding boxes.
+
+## Contribute to Our Guides
+
+We welcome contributions from the community! If you've mastered a particular aspect of Ultralytics YOLO that's not yet covered in our guides, we encourage you to share your expertise. Writing a guide is a great way to give back to the community and help us make our documentation more comprehensive and user-friendly.
+
+To get started, please read our [Contributing Guide](../help/contributing.md) for guidelines on how to open up a Pull Request (PR) 🛠️. We look forward to your contributions!
+
+Let's work together to make the Ultralytics YOLO ecosystem more robust and versatile 🙏!

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/instance-segmentation-and-tracking.md

@@ -0,0 +1,140 @@
+---
+comments: true
+description: Instance Segmentation with Object Tracking using Ultralytics YOLOv8
+keywords: Ultralytics, YOLOv8, Instance Segmentation, Object Detection, Object Tracking, Bounding Box, Computer Vision, Notebook, IPython Kernel, CLI, Python SDK
+---
+
+# Instance Segmentation and Tracking using Ultralytics YOLOv8 🚀
+
+## What is Instance Segmentation?
+
+[Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) instance segmentation involves identifying and outlining individual objects in an image, providing a detailed understanding of spatial distribution. Unlike semantic segmentation, it uniquely labels and precisely delineates each object, crucial for tasks like object detection and medical imaging.
+
+There are two types of instance segmentation tracking available in the Ultralytics package:
+
+- **Instance Segmentation with Class Objects:** Each class object is assigned a unique color for clear visual separation.
+
+- **Instance Segmentation with Object Tracks:** Every track is represented by a distinct color, facilitating easy identification and tracking.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/75G_S1Ngji8"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Instance Segmentation with Object Tracking using Ultralytics YOLOv8
+</p>
+
+## Samples
+
+|                                                          Instance Segmentation                                                          |                                                           Instance Segmentation + Object Tracking                                                            |
+|:---------------------------------------------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------------------------------------------------------------------------------:|
+| ![Ultralytics Instance Segmentation](https://github.com/RizwanMunawar/ultralytics/assets/62513924/d4ad3499-1f33-4871-8fbc-1be0b2643aa2) | ![Ultralytics Instance Segmentation with Object Tracking](https://github.com/RizwanMunawar/ultralytics/assets/62513924/2e5c38cc-fd5c-4145-9682-fa94ae2010a0) |
+|                                                  Ultralytics Instance Segmentation 😍                                                   |                                                  Ultralytics Instance Segmentation with Object Tracking 🔥                                                   |
+
+!!! Example "Instance Segmentation and Tracking"
+
+    === "Instance Segmentation"
+
+        ```python
+        import cv2
+        from ultralytics import YOLO
+        from ultralytics.utils.plotting import Annotator, colors
+
+        model = YOLO("yolov8n-seg.pt")  # segmentation model
+        names = model.model.names
+        cap = cv2.VideoCapture("path/to/video/file.mp4")
+        w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
+
+        out = cv2.VideoWriter('instance-segmentation.avi', cv2.VideoWriter_fourcc(*'MJPG'), fps, (w, h))
+
+        while True:
+            ret, im0 = cap.read()
+            if not ret:
+                print("Video frame is empty or video processing has been successfully completed.")
+                break
+
+            results = model.predict(im0)
+            annotator = Annotator(im0, line_width=2)
+
+            if results[0].masks is not None:
+                clss = results[0].boxes.cls.cpu().tolist()
+                masks = results[0].masks.xy
+                for mask, cls in zip(masks, clss):
+                    annotator.seg_bbox(mask=mask,
+                                       mask_color=colors(int(cls), True),
+                                       det_label=names[int(cls)])
+
+            out.write(im0)
+            cv2.imshow("instance-segmentation", im0)
+
+            if cv2.waitKey(1) & 0xFF == ord('q'):
+                break
+
+        out.release()
+        cap.release()
+        cv2.destroyAllWindows()
+
+        ```
+
+    === "Instance Segmentation with Object Tracking"
+
+        ```python
+        import cv2
+        from ultralytics import YOLO
+        from ultralytics.utils.plotting import Annotator, colors
+
+        from collections import defaultdict
+
+        track_history = defaultdict(lambda: [])
+
+        model = YOLO("yolov8n-seg.pt")   # segmentation model
+        cap = cv2.VideoCapture("path/to/video/file.mp4")
+        w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
+
+        out = cv2.VideoWriter('instance-segmentation-object-tracking.avi', cv2.VideoWriter_fourcc(*'MJPG'), fps, (w, h))
+
+        while True:
+            ret, im0 = cap.read()
+            if not ret:
+                print("Video frame is empty or video processing has been successfully completed.")
+                break
+
+            annotator = Annotator(im0, line_width=2)
+
+            results = model.track(im0, persist=True)
+
+            if results[0].boxes.id is not None and results[0].masks is not None:
+                masks = results[0].masks.xy
+                track_ids = results[0].boxes.id.int().cpu().tolist()
+
+                for mask, track_id in zip(masks, track_ids):
+                    annotator.seg_bbox(mask=mask,
+                                       mask_color=colors(track_id, True),
+                                       track_label=str(track_id))
+
+            out.write(im0)
+            cv2.imshow("instance-segmentation-object-tracking", im0)
+
+            if cv2.waitKey(1) & 0xFF == ord('q'):
+                break
+
+        out.release()
+        cap.release()
+        cv2.destroyAllWindows()
+        ```
+
+### `seg_bbox` Arguments
+
+| Name          | Type    | Default         | Description                            |
+|---------------|---------|-----------------|----------------------------------------|
+| `mask`        | `array` | `None`          | Segmentation mask coordinates          |
+| `mask_color`  | `tuple` | `(255, 0, 255)` | Mask color for every segmented box     |
+| `det_label`   | `str`   | `None`          | Label for segmented object             |
+| `track_label` | `str`   | `None`          | Label for segmented and tracked object |
+
+## Note
+
+For any inquiries, feel free to post your questions in the [Ultralytics Issue Section](https://github.com/ultralytics/ultralytics/issues/new/choose) or the discussion section mentioned below.

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/isolating-segmentation-objects.md

@@ -0,0 +1,325 @@
+---
+comments: true
+description: A concise guide on isolating segmented objects using Ultralytics.
+keywords: Ultralytics, YOLO, segmentation, Python, object detection, inference, dataset, prediction, instance segmentation, contours, binary mask, object mask, image processing
+---
+
+# Isolating Segmentation Objects
+
+After performing the [Segment Task](../tasks/segment.md), it's sometimes desirable to extract the isolated objects from the inference results. This guide provides a generic recipe on how to accomplish this using the Ultralytics [Predict Mode](../modes/predict.md).
+
+<p align="center">
+  <img src="https://github.com/ultralytics/ultralytics/assets/62214284/1787d76b-ad5f-43f9-a39c-d45c9157f38a" alt="Example Isolated Object Segmentation">
+</p>
+
+## Recipe Walk Through
+
+1. Begin with the necessary imports
+
+    ```python
+    from pathlib import Path
+
+    import cv2
+    import numpy as np
+    from ultralytics import YOLO
+    ```
+
+    ???+ tip "Ultralytics Install"
+
+        See the Ultralytics [Quickstart](../quickstart.md/#install-ultralytics) Installation section for a quick walkthrough on installing the required libraries.
+
+    ***
+
+2. Load a model and run `predict()` method on a source.
+
+    ```python
+    from ultralytics import YOLO
+
+    # Load a model
+    model = YOLO('yolov8n-seg.pt')
+
+    # Run inference
+    results = model.predict()
+    ```
+
+    !!! question "No Prediction Arguments?"
+
+        Without specifying a source, the example images from the library will be used:
+
+        ```
+        'ultralytics/assets/bus.jpg'
+        'ultralytics/assets/zidane.jpg'
+        ```
+
+        This is helpful for rapid testing with the `predict()` method.
+
+    For additional information about Segmentation Models, visit the [Segment Task](../tasks/segment.md#models) page. To learn more about `predict()` method, see [Predict Mode](../modes/predict.md) section of the Documentation.
+
+    ***
+
+3. Now iterate over the results and the contours. For workflows that want to save an image to file, the source image `base-name` and the detection `class-label` are retrieved for later use (optional).
+
+    ```{ .py .annotate }
+    # (2) Iterate detection results (helpful for multiple images)
+    for r in res:
+        img = np.copy(r.orig_img)
+        img_name = Path(r.path).stem # source image base-name
+
+        # Iterate each object contour (multiple detections)
+        for ci,c in enumerate(r):
+            # (1) Get detection class name
+            label = c.names[c.boxes.cls.tolist().pop()]
+
+    ```
+
+    1. To learn more about working with detection results, see [Boxes Section for Predict Mode](../modes/predict.md#boxes).
+    2. To learn more about `predict()` results see [Working with Results for Predict Mode](../modes/predict.md#working-with-results)
+
+    ??? info "For-Loop"
+
+        A single image will only iterate the first loop once. A single image with only a single detection will iterate each loop _only_ once.
+
+    ***
+
+4. Start with generating a binary mask from the source image and then draw a filled contour onto the mask. This will allow the object to be isolated from the other parts of the image. An example from `bus.jpg` for one of the detected `person` class objects is shown on the right.
+
+    ![Binary Mask Image](https://github.com/ultralytics/ultralytics/assets/62214284/59bce684-fdda-4b17-8104-0b4b51149aca){ width="240", align="right" }
+
+    ```{ .py .annotate }
+    # Create binary mask
+    b_mask = np.zeros(img.shape[:2], np.uint8)
+
+    # (1) Extract contour result
+    contour = c.masks.xy.pop()
+    # (2) Changing the type
+    contour = contour.astype(np.int32)
+    # (3) Reshaping
+    contour = contour.reshape(-1, 1, 2)
+
+
+    # Draw contour onto mask
+    _ = cv2.drawContours(b_mask,
+                        [contour],
+                        -1,
+                        (255, 255, 255),
+                        cv2.FILLED)
+
+    ```
+
+    1. For more info on `c.masks.xy` see [Masks Section from Predict Mode](../modes/predict.md#masks).
+
+    2. Here, the values are cast into `np.int32` for compatibility with `drawContours()` function from OpenCV.
+
+    3. The OpenCV `drawContours()` function expects contours to have a shape of `[N, 1, 2]` expand section below for more details.
+
+    <details>
+    <summary> Expand to understand what is happening when defining the <code>contour</code> variable.</summary>
+    <p>
+
+    - `c.masks.xy` :: Provides the coordinates of the mask contour points in the format `(x, y)`. For more details, refer to the [Masks Section from Predict Mode](../modes/predict.md#masks).
+
+    - `.pop()` :: As `masks.xy` is a list containing a single element, this element is extracted using the `pop()` method.
+
+    - `.astype(np.int32)` :: Using `masks.xy` will return with a data type of `float32`, but this won't be compatible with the OpenCV `drawContours()` function, so this will change the data type to `int32` for compatibility.
+
+    - `.reshape(-1, 1, 2)` :: Reformats the data into the required shape of `[N, 1, 2]` where `N` is the number of contour points, with each point represented by a single entry `1`, and the entry is composed of `2` values. The `-1` denotes that the number of values along this dimension is flexible.
+
+    </details>
+    <p></p>
+    <details>
+    <summary> Expand for an explanation of the <code>drawContours()</code> configuration.</summary>
+    <p>
+
+    - Encapsulating the `contour` variable within square brackets, `[contour]`, was found to effectively generate the desired contour mask during testing.
+
+    - The value `-1` specified for the `drawContours()` parameter instructs the function to draw all contours present in the image.
+
+    - The `tuple` `(255, 255, 255)` represents the color white, which is the desired color for drawing the contour in this binary mask.
+
+    - The addition of `cv2.FILLED` will color all pixels enclosed by the contour boundary the same, in this case, all enclosed pixels will be white.
+
+    - See [OpenCV Documentation on `drawContours()`](https://docs.opencv.org/4.8.0/d6/d6e/group__imgproc__draw.html#ga746c0625f1781f1ffc9056259103edbc) for more information.
+
+    </details>
+    <p></p>
+
+    ***
+
+5. Next the there are 2 options for how to move forward with the image from this point and a subsequent option for each.
+
+    ### Object Isolation Options
+
+    !!! example ""
+
+        === "Black Background Pixels"
+
+            ```py
+            # Create 3-channel mask
+            mask3ch = cv2.cvtColor(b_mask, cv2.COLOR_GRAY2BGR)
+
+            # Isolate object with binary mask
+            isolated = cv2.bitwise_and(mask3ch, img)
+
+            ```
+
+            ??? question "How does this work?"
+
+                - First, the binary mask is first converted from a single-channel image to a three-channel image. This conversion is necessary for the subsequent step where the mask and the original image are combined. Both images must have the same number of channels to be compatible with the blending operation.
+
+                - The original image and the three-channel binary mask are merged using the OpenCV function `bitwise_and()`. This operation retains <u>only</u> pixel values that are greater than zero `(> 0)` from both images. Since the mask pixels are greater than zero `(> 0)` <u>only</u> within the contour region, the pixels remaining from the original image are those that overlap with the contour.
+
+            ### Isolate with Black Pixels: Sub-options
+
+            ??? info "Full-size Image"
+
+                There are no additional steps required if keeping full size image.
+
+                <figure markdown>
+                    ![Example Full size Isolated Object Image Black Background](https://github.com/ultralytics/ultralytics/assets/62214284/845c00d0-52a6-4b1e-8010-4ba73e011b99){ width=240 }
+                    <figcaption>Example full-size output</figcaption>
+                </figure>
+
+            ??? info "Cropped object Image"
+
+                Additional steps required to crop image to only include object region.
+
+                ![Example Crop Isolated Object Image Black Background](https://github.com/ultralytics/ultralytics/assets/62214284/103dbf90-c169-4f77-b791-76cdf09c6f22){ align="right" }
+                ``` { .py .annotate }
+                # (1) Bounding box coordinates
+                x1, y1, x2, y2 = c.boxes.xyxy.cpu().numpy().squeeze().astype(np.int32)
+                # Crop image to object region
+                iso_crop = isolated[y1:y2, x1:x2]
+
+                ```
+
+                1.  For more information on bounding box results, see [Boxes Section from Predict Mode](../modes/predict.md/#boxes)
+
+                ??? question "What does this code do?"
+
+                    - The `c.boxes.xyxy.cpu().numpy()` call retrieves the bounding boxes as a NumPy array in the `xyxy` format, where `xmin`, `ymin`, `xmax`, and `ymax` represent the coordinates of the bounding box rectangle. See [Boxes Section from Predict Mode](../modes/predict.md/#boxes) for more details.
+
+                    - The `squeeze()` operation removes any unnecessary dimensions from the NumPy array, ensuring it has the expected shape.
+
+                    - Converting the coordinate values using `.astype(np.int32)` changes the box coordinates data type from `float32` to `int32`, making them compatible for image cropping using index slices.
+
+                    - Finally, the bounding box region is cropped from the image using index slicing. The bounds are defined by the `[ymin:ymax, xmin:xmax]` coordinates of the detection bounding box.
+
+        === "Transparent Background Pixels"
+
+            ```py
+            # Isolate object with transparent background (when saved as PNG)
+            isolated = np.dstack([img, b_mask])
+
+            ```
+
+            ??? question "How does this work?"
+
+                - Using the NumPy `dstack()` function (array stacking along depth-axis) in conjunction with the binary mask generated, will create an image with four channels. This allows for all pixels outside of the object contour to be transparent when saving as a `PNG` file.
+
+            ### Isolate with Transparent Pixels: Sub-options
+
+            ??? info "Full-size Image"
+
+                There are no additional steps required if keeping full size image.
+
+                <figure markdown>
+                    ![Example Full size Isolated Object Image No Background](https://github.com/ultralytics/ultralytics/assets/62214284/b1043ee0-369a-4019-941a-9447a9771042){ width=240 }
+                    <figcaption>Example full-size output + transparent background</figcaption>
+                </figure>
+
+            ??? info "Cropped object Image"
+
+                Additional steps required to crop image to only include object region.
+
+                ![Example Crop Isolated Object Image No Background](https://github.com/ultralytics/ultralytics/assets/62214284/5910244f-d1e1-44af-af7f-6dea4c688da8){ align="right" }
+                ``` { .py .annotate }
+                # (1) Bounding box coordinates
+                x1, y1, x2, y2 = c.boxes.xyxy.cpu().numpy().squeeze().astype(np.int32)
+                # Crop image to object region
+                iso_crop = isolated[y1:y2, x1:x2]
+
+                ```
+
+                1.  For more information on bounding box results, see [Boxes Section from Predict Mode](../modes/predict.md/#boxes)
+
+                ??? question "What does this code do?"
+
+                    - When using `c.boxes.xyxy.cpu().numpy()`, the bounding boxes are returned as a NumPy array, using the `xyxy` box coordinates format, which correspond to the points `xmin, ymin, xmax, ymax` for the bounding box (rectangle), see [Boxes Section from Predict Mode](../modes/predict.md/#boxes) for more information.
+
+                    - Adding `squeeze()` ensures that any extraneous dimensions are removed from the NumPy array.
+
+                    - Converting the coordinate values using `.astype(np.int32)` changes the box coordinates data type from `float32` to `int32` which will be compatible when cropping the image using index slices.
+
+                    - Finally the image region for the bounding box is cropped using index slicing, where the bounds are set using the `[ymin:ymax, xmin:xmax]` coordinates of the detection bounding box.
+
+    ??? question "What if I want the cropped object **including** the background?"
+
+        This is a built in feature for the Ultralytics library. See the `save_crop` argument for  [Predict Mode Inference Arguments](../modes/predict.md/#inference-arguments) for details.
+
+    ***
+
+6. <u>What to do next is entirely left to you as the developer.</u> A basic example of one possible next step (saving the image to file for future use) is shown.
+
+    - **NOTE:** this step is optional and can be skipped if not required for your specific use case.
+
+    ??? example "Example Final Step"
+
+        ```py
+        # Save isolated object to file
+        _ = cv2.imwrite(f'{img_name}_{label}-{ci}.png', iso_crop)
+        ```
+
+        - In this example, the `img_name` is the base-name of the source image file, `label` is the detected class-name, and `ci` is the index of the object detection (in case of multiple instances with the same class name).
+
+## Full Example code
+
+Here, all steps from the previous section are combined into a single block of code. For repeated use, it would be optimal to define a function to do some or all commands contained in the `for`-loops, but that is an exercise left to the reader.
+
+```{ .py .annotate }
+from pathlib import Path
+
+import cv2
+import numpy as np
+from ultralytics import YOLO
+
+m = YOLO('yolov8n-seg.pt')#(4)!
+res = m.predict()#(3)!
+
+# iterate detection results (5)
+for r in res:
+    img = np.copy(r.orig_img)
+    img_name = Path(r.path).stem
+
+    # iterate each object contour (6)
+    for ci,c in enumerate(r):
+        label = c.names[c.boxes.cls.tolist().pop()]
+
+        b_mask = np.zeros(img.shape[:2], np.uint8)
+
+        # Create contour mask (1)
+        contour = c.masks.xy.pop().astype(np.int32).reshape(-1, 1, 2)
+        _ = cv2.drawContours(b_mask, [contour], -1, (255, 255, 255), cv2.FILLED)
+
+        # Choose one:
+
+        # OPTION-1: Isolate object with black background
+        mask3ch = cv2.cvtColor(b_mask, cv2.COLOR_GRAY2BGR)
+        isolated = cv2.bitwise_and(mask3ch, img)
+
+        # OPTION-2: Isolate object with transparent background (when saved as PNG)
+        isolated = np.dstack([img, b_mask])
+
+        # OPTIONAL: detection crop (from either OPT1 or OPT2)
+        x1, y1, x2, y2 = c.boxes.xyxy.cpu().numpy().squeeze().astype(np.int32)
+        iso_crop = isolated[y1:y2, x1:x2]
+
+        # TODO your actions go here (2)
+
+```
+
+1. The line populating `contour` is combined into a single line here, where it was split to multiple above.
+2. {==What goes here is up to you!==}
+3. See [Predict Mode](../modes/predict.md) for additional information.
+4. See [Segment Task](../tasks/segment.md#models) for more information.
+5. Learn more about [Working with Results](../modes/predict.md#working-with-results)
+6. Learn more about [Segmentation Mask Results](../modes/predict.md#masks)

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/kfold-cross-validation.md

@@ -0,0 +1,278 @@
+---
+comments: true
+description: An in-depth guide demonstrating the implementation of K-Fold Cross Validation with the Ultralytics ecosystem for object detection datasets, leveraging Python, YOLO, and sklearn.
+keywords: K-Fold cross validation, Ultralytics, YOLO detection format, Python, sklearn, object detection
+---
+
+# K-Fold Cross Validation with Ultralytics
+
+## Introduction
+
+This comprehensive guide illustrates the implementation of K-Fold Cross Validation for object detection datasets within the Ultralytics ecosystem. We'll leverage the YOLO detection format and key Python libraries such as sklearn, pandas, and PyYaml to guide you through the necessary setup, the process of generating feature vectors, and the execution of a K-Fold dataset split.
+
+<p align="center">
+  <img width="800" src="https://user-images.githubusercontent.com/26833433/258589390-8d815058-ece8-48b9-a94e-0e1ab53ea0f6.png" alt="K-Fold Cross Validation Overview">
+</p>
+
+Whether your project involves the Fruit Detection dataset or a custom data source, this tutorial aims to help you comprehend and apply K-Fold Cross Validation to bolster the reliability and robustness of your machine learning models. While we're applying `k=5` folds for this tutorial, keep in mind that the optimal number of folds can vary depending on your dataset and the specifics of your project.
+
+Without further ado, let's dive in!
+
+## Setup
+
+- Your annotations should be in the [YOLO detection format](../datasets/detect/index.md).
+
+- This guide assumes that annotation files are locally available.
+
+- For our demonstration, we use the [Fruit Detection](https://www.kaggle.com/datasets/lakshaytyagi01/fruit-detection/code) dataset.
+    - This dataset contains a total of 8479 images.
+    - It includes 6 class labels, each with its total instance counts listed below.
+
+| Class Label | Instance Count |
+|:------------|:--------------:|
+| Apple       |      7049      |
+| Grapes      |      7202      |
+| Pineapple   |      1613      |
+| Orange      |     15549      |
+| Banana      |      3536      |
+| Watermelon  |      1976      |
+
+- Necessary Python packages include:
+
+    - `ultralytics`
+    - `sklearn`
+    - `pandas`
+    - `pyyaml`
+
+- This tutorial operates with `k=5` folds. However, you should determine the best number of folds for your specific dataset.
+
+1. Initiate a new Python virtual environment (`venv`) for your project and activate it. Use `pip` (or your preferred package manager) to install:
+
+    - The Ultralytics library: `pip install -U ultralytics`. Alternatively, you can clone the official [repo](https://github.com/ultralytics/ultralytics).
+    - Scikit-learn, pandas, and PyYAML: `pip install -U scikit-learn pandas pyyaml`.
+
+2. Verify that your annotations are in the [YOLO detection format](../datasets/detect/index.md).
+
+    - For this tutorial, all annotation files are found in the `Fruit-Detection/labels` directory.
+
+## Generating Feature Vectors for Object Detection Dataset
+
+1. Start by creating a new Python file and import the required libraries.
+
+    ```python
+    import datetime
+    import shutil
+    from pathlib import Path
+    from collections import Counter
+
+    import yaml
+    import numpy as np
+    import pandas as pd
+    from ultralytics import YOLO
+    from sklearn.model_selection import KFold
+    ```
+
+2. Proceed to retrieve all label files for your dataset.
+
+    ```python
+    dataset_path = Path('./Fruit-detection') # replace with 'path/to/dataset' for your custom data
+    labels = sorted(dataset_path.rglob("*labels/*.txt")) # all data in 'labels'
+    ```
+
+3. Now, read the contents of the dataset YAML file and extract the indices of the class labels.
+
+    ```python
+    yaml_file = 'path/to/data.yaml'  # your data YAML with data directories and names dictionary
+    with open(yaml_file, 'r', encoding="utf8") as y:
+        classes = yaml.safe_load(y)['names']
+    cls_idx = sorted(classes.keys())
+    ```
+
+4. Initialize an empty `pandas` DataFrame.
+
+    ```python
+    indx = [l.stem for l in labels] # uses base filename as ID (no extension)
+    labels_df = pd.DataFrame([], columns=cls_idx, index=indx)
+    ```
+
+5. Count the instances of each class-label present in the annotation files.
+
+    ```python
+    for label in labels:
+        lbl_counter = Counter()
+
+        with open(label,'r') as lf:
+            lines = lf.readlines()
+
+        for l in lines:
+            # classes for YOLO label uses integer at first position of each line
+            lbl_counter[int(l.split(' ')[0])] += 1
+
+        labels_df.loc[label.stem] = lbl_counter
+
+    labels_df = labels_df.fillna(0.0) # replace `nan` values with `0.0`
+    ```
+
+6. The following is a sample view of the populated DataFrame:
+
+    ```pandas
+                                                           0    1    2    3    4    5
+    '0000a16e4b057580_jpg.rf.00ab48988370f64f5ca8ea4...'  0.0  0.0  0.0  0.0  0.0  7.0
+    '0000a16e4b057580_jpg.rf.7e6dce029fb67f01eb19aa7...'  0.0  0.0  0.0  0.0  0.0  7.0
+    '0000a16e4b057580_jpg.rf.bc4d31cdcbe229dd022957a...'  0.0  0.0  0.0  0.0  0.0  7.0
+    '00020ebf74c4881c_jpg.rf.508192a0a97aa6c4a3b6882...'  0.0  0.0  0.0  1.0  0.0  0.0
+    '00020ebf74c4881c_jpg.rf.5af192a2254c8ecc4188a25...'  0.0  0.0  0.0  1.0  0.0  0.0
+     ...                                                  ...  ...  ...  ...  ...  ...
+    'ff4cd45896de38be_jpg.rf.c4b5e967ca10c7ced3b9e97...'  0.0  0.0  0.0  0.0  0.0  2.0
+    'ff4cd45896de38be_jpg.rf.ea4c1d37d2884b3e3cbce08...'  0.0  0.0  0.0  0.0  0.0  2.0
+    'ff5fd9c3c624b7dc_jpg.rf.bb519feaa36fc4bf630a033...'  1.0  0.0  0.0  0.0  0.0  0.0
+    'ff5fd9c3c624b7dc_jpg.rf.f0751c9c3aa4519ea3c9d6a...'  1.0  0.0  0.0  0.0  0.0  0.0
+    'fffe28b31f2a70d4_jpg.rf.7ea16bd637ba0711c53b540...'  0.0  6.0  0.0  0.0  0.0  0.0
+    ```
+
+The rows index the label files, each corresponding to an image in your dataset, and the columns correspond to your class-label indices. Each row represents a pseudo feature-vector, with the count of each class-label present in your dataset. This data structure enables the application of K-Fold Cross Validation to an object detection dataset.
+
+## K-Fold Dataset Split
+
+1. Now we will use the `KFold` class from `sklearn.model_selection` to generate `k` splits of the dataset.
+
+    - Important:
+        - Setting `shuffle=True` ensures a randomized distribution of classes in your splits.
+        - By setting `random_state=M` where `M` is a chosen integer, you can obtain repeatable results.
+
+    ```python
+    ksplit = 5
+    kf = KFold(n_splits=ksplit, shuffle=True, random_state=20)   # setting random_state for repeatable results
+
+    kfolds = list(kf.split(labels_df))
+    ```
+
+2. The dataset has now been split into `k` folds, each having a list of `train` and `val` indices. We will construct a DataFrame to display these results more clearly.
+
+    ```python
+    folds = [f'split_{n}' for n in range(1, ksplit + 1)]
+    folds_df = pd.DataFrame(index=indx, columns=folds)
+
+    for idx, (train, val) in enumerate(kfolds, start=1):
+        folds_df[f'split_{idx}'].loc[labels_df.iloc[train].index] = 'train'
+        folds_df[f'split_{idx}'].loc[labels_df.iloc[val].index] = 'val'
+    ```
+
+3. Now we will calculate the distribution of class labels for each fold as a ratio of the classes present in `val` to those present in `train`.
+
+    ```python
+    fold_lbl_distrb = pd.DataFrame(index=folds, columns=cls_idx)
+
+    for n, (train_indices, val_indices) in enumerate(kfolds, start=1):
+        train_totals = labels_df.iloc[train_indices].sum()
+        val_totals = labels_df.iloc[val_indices].sum()
+
+        # To avoid division by zero, we add a small value (1E-7) to the denominator
+        ratio = val_totals / (train_totals + 1E-7)
+        fold_lbl_distrb.loc[f'split_{n}'] = ratio
+    ```
+
+   The ideal scenario is for all class ratios to be reasonably similar for each split and across classes. This, however, will be subject to the specifics of your dataset.
+
+4. Next, we create the directories and dataset YAML files for each split.
+
+    ```python
+    supported_extensions = ['.jpg', '.jpeg', '.png']
+
+    # Initialize an empty list to store image file paths
+    images = []
+
+    # Loop through supported extensions and gather image files
+    for ext in supported_extensions:
+        images.extend(sorted((dataset_path / 'images').rglob(f"*{ext}")))
+
+    # Create the necessary directories and dataset YAML files (unchanged)
+    save_path = Path(dataset_path / f'{datetime.date.today().isoformat()}_{ksplit}-Fold_Cross-val')
+    save_path.mkdir(parents=True, exist_ok=True)
+    ds_yamls = []
+
+    for split in folds_df.columns:
+        # Create directories
+        split_dir = save_path / split
+        split_dir.mkdir(parents=True, exist_ok=True)
+        (split_dir / 'train' / 'images').mkdir(parents=True, exist_ok=True)
+        (split_dir / 'train' / 'labels').mkdir(parents=True, exist_ok=True)
+        (split_dir / 'val' / 'images').mkdir(parents=True, exist_ok=True)
+        (split_dir / 'val' / 'labels').mkdir(parents=True, exist_ok=True)
+
+        # Create dataset YAML files
+        dataset_yaml = split_dir / f'{split}_dataset.yaml'
+        ds_yamls.append(dataset_yaml)
+
+        with open(dataset_yaml, 'w') as ds_y:
+            yaml.safe_dump({
+                'path': split_dir.as_posix(),
+                'train': 'train',
+                'val': 'val',
+                'names': classes
+            }, ds_y)
+    ```
+
+5. Lastly, copy images and labels into the respective directory ('train' or 'val') for each split.
+
+    - __NOTE:__ The time required for this portion of the code will vary based on the size of your dataset and your system hardware.
+
+    ```python
+    for image, label in zip(images, labels):
+        for split, k_split in folds_df.loc[image.stem].items():
+            # Destination directory
+            img_to_path = save_path / split / k_split / 'images'
+            lbl_to_path = save_path / split / k_split / 'labels'
+
+            # Copy image and label files to new directory (SamefileError if file already exists)
+            shutil.copy(image, img_to_path / image.name)
+            shutil.copy(label, lbl_to_path / label.name)
+    ```
+
+## Save Records (Optional)
+
+Optionally, you can save the records of the K-Fold split and label distribution DataFrames as CSV files for future reference.
+
+```python
+folds_df.to_csv(save_path / "kfold_datasplit.csv")
+fold_lbl_distrb.to_csv(save_path / "kfold_label_distribution.csv")
+```
+
+## Train YOLO using K-Fold Data Splits
+
+1. First, load the YOLO model.
+
+    ```python
+    weights_path = 'path/to/weights.pt'
+    model = YOLO(weights_path, task='detect')
+    ```
+
+2. Next, iterate over the dataset YAML files to run training. The results will be saved to a directory specified by the `project` and `name` arguments. By default, this directory is 'exp/runs#' where # is an integer index.
+
+    ```python
+    results = {}
+
+    # Define your additional arguments here
+    batch = 16
+    project = 'kfold_demo'
+    epochs = 100
+
+    for k in range(ksplit):
+        dataset_yaml = ds_yamls[k]
+        model.train(data=dataset_yaml,epochs=epochs, batch=batch, project=project)  # include any train arguments
+        results[k] = model.metrics  # save output metrics for further analysis
+    ```
+
+## Conclusion
+
+In this guide, we have explored the process of using K-Fold cross-validation for training the YOLO object detection model. We learned how to split our dataset into K partitions, ensuring a balanced class distribution across the different folds.
+
+We also explored the procedure for creating report DataFrames to visualize the data splits and label distributions across these splits, providing us a clear insight into the structure of our training and validation sets.
+
+Optionally, we saved our records for future reference, which could be particularly useful in large-scale projects or when troubleshooting model performance.
+
+Finally, we implemented the actual model training using each split in a loop, saving our training results for further analysis and comparison.
+
+This technique of K-Fold cross-validation is a robust way of making the most out of your available data, and it helps to ensure that your model performance is reliable and consistent across different data subsets. This results in a more generalizable and reliable model that is less likely to overfit to specific data patterns.
+
+Remember that although we used YOLO in this guide, these steps are mostly transferable to other machine learning models. Understanding these steps allows you to apply cross-validation effectively in your own machine learning projects. Happy coding!

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/model-deployment-options.md

@@ -0,0 +1,305 @@
+---
+comments: true
+description: A guide to help determine which deployment option to choose for your YOLOv8 model, including essential considerations.
+keywords: YOLOv8, Deployment, PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, CoreML, TensorFlow, Export
+---
+
+# Understanding YOLOv8’s Deployment Options
+
+## Introduction
+
+You've come a long way on your journey with YOLOv8. You've diligently collected data, meticulously annotated it, and put in the hours to train and rigorously evaluate your custom YOLOv8 model. Now, it’s time to put your model to work for your specific application, use case, or project. But there's a critical decision that stands before you: how to export and deploy your model effectively.
+
+This guide walks you through YOLOv8’s deployment options and the essential factors to consider to choose the right option for your project.
+
+## How to Select the Right Deployment Option for Your YOLOv8 Model
+
+When it's time to deploy your YOLOv8 model, selecting a suitable export format is very important. As outlined in the [Ultralytics YOLOv8 Modes documentation](../modes/export.md#usage-examples), the model.export() function allows for converting your trained model into a variety of formats tailored to diverse environments and performance requirements.
+
+The ideal format depends on your model's intended operational context, balancing speed, hardware constraints, and ease of integration. In the following section, we'll take a closer look at each export option, understanding when to choose each one.
+
+### YOLOv8’s Deployment Options
+
+Let’s walk through the different YOLOv8 deployment options. For a detailed walkthrough of the export process, visit the [Ultralytics documentation page on exporting](../modes/export.md).
+
+#### PyTorch
+
+PyTorch is an open-source machine learning library widely used for applications in deep learning and artificial intelligence. It provides a high level of flexibility and speed, which has made it a favorite among researchers and developers.
+
+- **Performance Benchmarks**: PyTorch is known for its ease of use and flexibility, which may result in a slight trade-off in raw performance when compared to other frameworks that are more specialized and optimized.
+
+- **Compatibility and Integration**: Offers excellent compatibility with various data science and machine learning libraries in Python.
+
+- **Community Support and Ecosystem**: One of the most vibrant communities, with extensive resources for learning and troubleshooting.
+
+- **Case Studies**: Commonly used in research prototypes, many academic papers reference models deployed in PyTorch.
+
+- **Maintenance and Updates**: Regular updates with active development and support for new features.
+
+- **Security Considerations**: Regular patches for security issues, but security is largely dependent on the overall environment it’s deployed in.
+
+- **Hardware Acceleration**: Supports CUDA for GPU acceleration, essential for speeding up model training and inference.
+
+#### TorchScript
+
+TorchScript extends PyTorch’s capabilities by allowing the exportation of models to be run in a C++ runtime environment. This makes it suitable for production environments where Python is unavailable.
+
+- **Performance Benchmarks**: Can offer improved performance over native PyTorch, especially in production environments.
+
+- **Compatibility and Integration**: Designed for seamless transition from PyTorch to C++ production environments, though some advanced features might not translate perfectly.
+
+- **Community Support and Ecosystem**: Benefits from PyTorch’s large community but has a narrower scope of specialized developers.
+
+- **Case Studies**: Widely used in industry settings where Python’s performance overhead is a bottleneck.
+
+- **Maintenance and Updates**: Maintained alongside PyTorch with consistent updates.
+
+- **Security Considerations**: Offers improved security by enabling the running of models in environments without full Python installations.
+
+- **Hardware Acceleration**: Inherits PyTorch’s CUDA support, ensuring efficient GPU utilization.
+
+#### ONNX
+
+The Open Neural Network Exchange (ONNX) is a format that allows for model interoperability across different frameworks, which can be critical when deploying to various platforms.
+
+- **Performance Benchmarks**: ONNX models may experience a variable performance depending on the specific runtime they are deployed on.
+
+- **Compatibility and Integration**: High interoperability across multiple platforms and hardware due to its framework-agnostic nature.
+
+- **Community Support and Ecosystem**: Supported by many organizations, leading to a broad ecosystem and a variety of tools for optimization.
+
+- **Case Studies**: Frequently used to move models between different machine learning frameworks, demonstrating its flexibility.
+
+- **Maintenance and Updates**: As an open standard, ONNX is regularly updated to support new operations and models.
+
+- **Security Considerations**: As with any cross-platform tool, it's essential to ensure secure practices in the conversion and deployment pipeline.
+
+- **Hardware Acceleration**: With ONNX Runtime, models can leverage various hardware optimizations.
+
+#### OpenVINO
+
+OpenVINO is an Intel toolkit designed to facilitate the deployment of deep learning models across Intel hardware, enhancing performance and speed.
+
+- **Performance Benchmarks**: Specifically optimized for Intel CPUs, GPUs, and VPUs, offering significant performance boosts on compatible hardware.
+
+- **Compatibility and Integration**: Works best within the Intel ecosystem but also supports a range of other platforms.
+
+- **Community Support and Ecosystem**: Backed by Intel, with a solid user base especially in the computer vision domain.
+
+- **Case Studies**: Often utilized in IoT and edge computing scenarios where Intel hardware is prevalent.
+
+- **Maintenance and Updates**: Intel regularly updates OpenVINO to support the latest deep learning models and Intel hardware.
+
+- **Security Considerations**: Provides robust security features suitable for deployment in sensitive applications.
+
+- **Hardware Acceleration**: Tailored for acceleration on Intel hardware, leveraging dedicated instruction sets and hardware features.
+
+For more details on deployment using OpenVINO, refer to the Ultralytics Integration documentation: [Intel OpenVINO Export](../integrations/openvino.md).
+
+#### TensorRT
+
+TensorRT is a high-performance deep learning inference optimizer and runtime from NVIDIA, ideal for applications needing speed and efficiency.
+
+- **Performance Benchmarks**: Delivers top-tier performance on NVIDIA GPUs with support for high-speed inference.
+
+- **Compatibility and Integration**: Best suited for NVIDIA hardware, with limited support outside this environment.
+
+- **Community Support and Ecosystem**: Strong support network through NVIDIA’s developer forums and documentation.
+
+- **Case Studies**: Widely adopted in industries requiring real-time inference on video and image data.
+
+- **Maintenance and Updates**: NVIDIA maintains TensorRT with frequent updates to enhance performance and support new GPU architectures.
+
+- **Security Considerations**: Like many NVIDIA products, it has a strong emphasis on security, but specifics depend on the deployment environment.
+
+- **Hardware Acceleration**: Exclusively designed for NVIDIA GPUs, providing deep optimization and acceleration.
+
+#### CoreML
+
+CoreML is Apple’s machine learning framework, optimized for on-device performance in the Apple ecosystem, including iOS, macOS, watchOS, and tvOS.
+
+- **Performance Benchmarks**: Optimized for on-device performance on Apple hardware with minimal battery usage.
+
+- **Compatibility and Integration**: Exclusively for Apple's ecosystem, providing a streamlined workflow for iOS and macOS applications.
+
+- **Community Support and Ecosystem**: Strong support from Apple and a dedicated developer community, with extensive documentation and tools.
+
+- **Case Studies**: Commonly used in applications that require on-device machine learning capabilities on Apple products.
+
+- **Maintenance and Updates**: Regularly updated by Apple to support the latest machine learning advancements and Apple hardware.
+
+- **Security Considerations**: Benefits from Apple's focus on user privacy and data security.
+
+- **Hardware Acceleration**: Takes full advantage of Apple's neural engine and GPU for accelerated machine learning tasks.
+
+#### TF SavedModel
+
+TF SavedModel is TensorFlow’s format for saving and serving machine learning models, particularly suited for scalable server environments.
+
+- **Performance Benchmarks**: Offers scalable performance in server environments, especially when used with TensorFlow Serving.
+
+- **Compatibility and Integration**: Wide compatibility across TensorFlow's ecosystem, including cloud and enterprise server deployments.
+
+- **Community Support and Ecosystem**: Large community support due to TensorFlow's popularity, with a vast array of tools for deployment and optimization.
+
+- **Case Studies**: Extensively used in production environments for serving deep learning models at scale.
+
+- **Maintenance and Updates**: Supported by Google and the TensorFlow community, ensuring regular updates and new features.
+
+- **Security Considerations**: Deployment using TensorFlow Serving includes robust security features for enterprise-grade applications.
+
+- **Hardware Acceleration**: Supports various hardware accelerations through TensorFlow's backends.
+
+#### TF GraphDef
+
+TF GraphDef is a TensorFlow format that represents the model as a graph, which is beneficial for environments where a static computation graph is required.
+
+- **Performance Benchmarks**: Provides stable performance for static computation graphs, with a focus on consistency and reliability.
+
+- **Compatibility and Integration**: Easily integrates within TensorFlow's infrastructure but less flexible compared to SavedModel.
+
+- **Community Support and Ecosystem**: Good support from TensorFlow's ecosystem, with many resources available for optimizing static graphs.
+
+- **Case Studies**: Useful in scenarios where a static graph is necessary, such as in certain embedded systems.
+
+- **Maintenance and Updates**: Regular updates alongside TensorFlow's core updates.
+
+- **Security Considerations**: Ensures safe deployment with TensorFlow's established security practices.
+
+- **Hardware Acceleration**: Can utilize TensorFlow's hardware acceleration options, though not as flexible as SavedModel.
+
+#### TF Lite
+
+TF Lite is TensorFlow’s solution for mobile and embedded device machine learning, providing a lightweight library for on-device inference.
+
+- **Performance Benchmarks**: Designed for speed and efficiency on mobile and embedded devices.
+
+- **Compatibility and Integration**: Can be used on a wide range of devices due to its lightweight nature.
+
+- **Community Support and Ecosystem**: Backed by Google, it has a robust community and a growing number of resources for developers.
+
+- **Case Studies**: Popular in mobile applications that require on-device inference with minimal footprint.
+
+- **Maintenance and Updates**: Regularly updated to include the latest features and optimizations for mobile devices.
+
+- **Security Considerations**: Provides a secure environment for running models on end-user devices.
+
+- **Hardware Acceleration**: Supports a variety of hardware acceleration options, including GPU and DSP.
+
+#### TF Edge TPU
+
+TF Edge TPU is designed for high-speed, efficient computing on Google's Edge TPU hardware, perfect for IoT devices requiring real-time processing.
+
+- **Performance Benchmarks**: Specifically optimized for high-speed, efficient computing on Google's Edge TPU hardware.
+
+- **Compatibility and Integration**: Works exclusively with TensorFlow Lite models on Edge TPU devices.
+
+- **Community Support and Ecosystem**: Growing support with resources provided by Google and third-party developers.
+
+- **Case Studies**: Used in IoT devices and applications that require real-time processing with low latency.
+
+- **Maintenance and Updates**: Continually improved upon to leverage the capabilities of new Edge TPU hardware releases.
+
+- **Security Considerations**: Integrates with Google's robust security for IoT and edge devices.
+
+- **Hardware Acceleration**: Custom-designed to take full advantage of Google Coral devices.
+
+#### TF.js
+
+TensorFlow.js (TF.js) is a library that brings machine learning capabilities directly to the browser, offering a new realm of possibilities for web developers and users alike. It allows for the integration of machine learning models in web applications without the need for back-end infrastructure.
+
+- **Performance Benchmarks**: Enables machine learning directly in the browser with reasonable performance, depending on the client device.
+
+- **Compatibility and Integration**: High compatibility with web technologies, allowing for easy integration into web applications.
+
+- **Community Support and Ecosystem**: Support from a community of web and Node.js developers, with a variety of tools for deploying ML models in browsers.
+
+- **Case Studies**: Ideal for interactive web applications that benefit from client-side machine learning without the need for server-side processing.
+
+- **Maintenance and Updates**: Maintained by the TensorFlow team with contributions from the open-source community.
+
+- **Security Considerations**: Runs within the browser's secure context, utilizing the security model of the web platform.
+
+- **Hardware Acceleration**: Performance can be enhanced with web-based APIs that access hardware acceleration like WebGL.
+
+#### PaddlePaddle
+
+PaddlePaddle is an open-source deep learning framework developed by Baidu. It is designed to be both efficient for researchers and easy to use for developers. It's particularly popular in China and offers specialized support for Chinese language processing.
+
+- **Performance Benchmarks**: Offers competitive performance with a focus on ease of use and scalability.
+
+- **Compatibility and Integration**: Well-integrated within Baidu's ecosystem and supports a wide range of applications.
+
+- **Community Support and Ecosystem**: While the community is smaller globally, it's rapidly growing, especially in China.
+
+- **Case Studies**: Commonly used in Chinese markets and by developers looking for alternatives to other major frameworks.
+
+- **Maintenance and Updates**: Regularly updated with a focus on serving Chinese language AI applications and services.
+
+- **Security Considerations**: Emphasizes data privacy and security, catering to Chinese data governance standards.
+
+- **Hardware Acceleration**: Supports various hardware accelerations, including Baidu's own Kunlun chips.
+
+#### NCNN
+
+NCNN is a high-performance neural network inference framework optimized for the mobile platform. It stands out for its lightweight nature and efficiency, making it particularly well-suited for mobile and embedded devices where resources are limited.
+
+- **Performance Benchmarks**: Highly optimized for mobile platforms, offering efficient inference on ARM-based devices.
+
+- **Compatibility and Integration**: Suitable for applications on mobile phones and embedded systems with ARM architecture.
+
+- **Community Support and Ecosystem**: Supported by a niche but active community focused on mobile and embedded ML applications.
+
+- **Case Studies**: Favoured for mobile applications where efficiency and speed are critical on Android and other ARM-based systems.
+
+- **Maintenance and Updates**: Continuously improved to maintain high performance on a range of ARM devices.
+
+- **Security Considerations**: Focuses on running locally on the device, leveraging the inherent security of on-device processing.
+
+- **Hardware Acceleration**: Tailored for ARM CPUs and GPUs, with specific optimizations for these architectures.
+
+## Comparative Analysis of YOLOv8 Deployment Options
+
+The following table provides a snapshot of the various deployment options available for YOLOv8 models, helping you to assess which may best fit your project needs based on several critical criteria. For an in-depth look at each deployment option's format, please see the [Ultralytics documentation page on export formats](../modes/export.md#export-formats).
+
+| Deployment Option | Performance Benchmarks                          | Compatibility and Integration                  | Community Support and Ecosystem               | Case Studies                               | Maintenance and Updates                     | Security Considerations                           | Hardware Acceleration              |
+|-------------------|-------------------------------------------------|------------------------------------------------|-----------------------------------------------|--------------------------------------------|---------------------------------------------|---------------------------------------------------|------------------------------------|
+| PyTorch           | Good flexibility; may trade off raw performance | Excellent with Python libraries                | Extensive resources and community             | Research and prototypes                    | Regular, active development                 | Dependent on deployment environment               | CUDA support for GPU acceleration  |
+| TorchScript       | Better for production than PyTorch              | Smooth transition from PyTorch to C++          | Specialized but narrower than PyTorch         | Industry where Python is a bottleneck      | Consistent updates with PyTorch             | Improved security without full Python             | Inherits CUDA support from PyTorch |
+| ONNX              | Variable depending on runtime                   | High across different frameworks               | Broad ecosystem, supported by many orgs       | Flexibility across ML frameworks           | Regular updates for new operations          | Ensure secure conversion and deployment practices | Various hardware optimizations     |
+| OpenVINO          | Optimized for Intel hardware                    | Best within Intel ecosystem                    | Solid in computer vision domain               | IoT and edge with Intel hardware           | Regular updates for Intel hardware          | Robust features for sensitive applications        | Tailored for Intel hardware        |
+| TensorRT          | Top-tier on NVIDIA GPUs                         | Best for NVIDIA hardware                       | Strong network through NVIDIA                 | Real-time video and image inference        | Frequent updates for new GPUs               | Emphasis on security                              | Designed for NVIDIA GPUs           |
+| CoreML            | Optimized for on-device Apple hardware          | Exclusive to Apple ecosystem                   | Strong Apple and developer support            | On-device ML on Apple products             | Regular Apple updates                       | Focus on privacy and security                     | Apple neural engine and GPU        |
+| TF SavedModel     | Scalable in server environments                 | Wide compatibility in TensorFlow ecosystem     | Large support due to TensorFlow popularity    | Serving models at scale                    | Regular updates by Google and community     | Robust features for enterprise                    | Various hardware accelerations     |
+| TF GraphDef       | Stable for static computation graphs            | Integrates well with TensorFlow infrastructure | Resources for optimizing static graphs        | Scenarios requiring static graphs          | Updates alongside TensorFlow core           | Established TensorFlow security practices         | TensorFlow acceleration options    |
+| TF Lite           | Speed and efficiency on mobile/embedded         | Wide range of device support                   | Robust community, Google backed               | Mobile applications with minimal footprint | Latest features for mobile                  | Secure environment on end-user devices            | GPU and DSP among others           |
+| TF Edge TPU       | Optimized for Google's Edge TPU hardware        | Exclusive to Edge TPU devices                  | Growing with Google and third-party resources | IoT devices requiring real-time processing | Improvements for new Edge TPU hardware      | Google's robust IoT security                      | Custom-designed for Google Coral   |
+| TF.js             | Reasonable in-browser performance               | High with web technologies                     | Web and Node.js developers support            | Interactive web applications               | TensorFlow team and community contributions | Web platform security model                       | Enhanced with WebGL and other APIs |
+| PaddlePaddle      | Competitive, easy to use and scalable           | Baidu ecosystem, wide application support      | Rapidly growing, especially in China          | Chinese market and language processing     | Focus on Chinese AI applications            | Emphasizes data privacy and security              | Including Baidu's Kunlun chips     |
+| NCNN              | Optimized for mobile ARM-based devices          | Mobile and embedded ARM systems                | Niche but active mobile/embedded ML community | Android and ARM systems efficiency         | High performance maintenance on ARM         | On-device security advantages                     | ARM CPUs and GPUs optimizations    |
+
+This comparative analysis gives you a high-level overview. For deployment, it's essential to consider the specific requirements and constraints of your project, and consult the detailed documentation and resources available for each option.
+
+## Community and Support
+
+When you're getting started with YOLOv8, having a helpful community and support can make a significant impact. Here's how to connect with others who share your interests and get the assistance you need.
+
+### Engage with the Broader Community
+
+- **GitHub Discussions:** The YOLOv8 repository on GitHub has a "Discussions" section where you can ask questions, report issues, and suggest improvements.
+
+- **Ultralytics Discord Server:** Ultralytics has a [Discord server](https://ultralytics.com/discord/) where you can interact with other users and developers.
+
+### Official Documentation and Resources
+
+- **Ultralytics YOLOv8 Docs:** The [official documentation](../index.md) provides a comprehensive overview of YOLOv8, along with guides on installation, usage, and troubleshooting.
+
+These resources will help you tackle challenges and stay updated on the latest trends and best practices in the YOLOv8 community.
+
+## Conclusion
+
+In this guide, we've explored the different deployment options for YOLOv8. We've also discussed the important factors to consider when making your choice. These options allow you to customize your model for various environments and performance requirements, making it suitable for real-world applications.
+
+Don't forget that the YOLOv8 and Ultralytics community is a valuable source of help. Connect with other developers and experts to learn unique tips and solutions you might not find in regular documentation. Keep seeking knowledge, exploring new ideas, and sharing your experiences.
+
+Happy deploying!

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/object-blurring.md

@@ -0,0 +1,91 @@
+---
+comments: true
+description: Learn to blur objects using Ultralytics YOLOv8 for privacy in images and videos.
+keywords: Ultralytics, YOLOv8, Object Detection, Object Blurring, Privacy Protection, Image Processing, Video Analysis, AI, Machine Learning
+---
+
+# Object Blurring using Ultralytics YOLOv8 🚀
+
+## What is Object Blurring?
+
+Object blurring with [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) involves applying a blurring effect to specific detected objects in an image or video. This can be achieved using the YOLOv8 model capabilities to identify and manipulate objects within a given scene.
+
+## Advantages of Object Blurring?
+
+- **Privacy Protection**: Object blurring is an effective tool for safeguarding privacy by concealing sensitive or personally identifiable information in images or videos.
+- **Selective Focus**: YOLOv8 allows for selective blurring, enabling users to target specific objects, ensuring a balance between privacy and retaining relevant visual information.
+- **Real-time Processing**: YOLOv8's efficiency enables object blurring in real-time, making it suitable for applications requiring on-the-fly privacy enhancements in dynamic environments.
+
+!!! Example "Object Blurring using YOLOv8 Example"
+
+    === "Object Blurring"
+
+        ```python
+        from ultralytics import YOLO
+        from ultralytics.utils.plotting import Annotator, colors
+        import cv2
+
+        model = YOLO("yolov8n.pt")
+        names = model.names
+
+        cap = cv2.VideoCapture("path/to/video/file.mp4")
+        assert cap.isOpened(), "Error reading video file"
+        w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
+
+        # Blur ratio
+        blur_ratio = 50
+
+        # Video writer
+        video_writer = cv2.VideoWriter("object_blurring_output.avi",
+                                       cv2.VideoWriter_fourcc(*'mp4v'),
+                                       fps, (w, h))
+
+        while cap.isOpened():
+            success, im0 = cap.read()
+            if not success:
+                print("Video frame is empty or video processing has been successfully completed.")
+                break
+
+            results = model.predict(im0, show=False)
+            boxes = results[0].boxes.xyxy.cpu().tolist()
+            clss = results[0].boxes.cls.cpu().tolist()
+            annotator = Annotator(im0, line_width=2, example=names)
+
+            if boxes is not None:
+                for box, cls in zip(boxes, clss):
+                    annotator.box_label(box, color=colors(int(cls), True), label=names[int(cls)])
+
+                    obj = im0[int(box[1]):int(box[3]), int(box[0]):int(box[2])]
+                    blur_obj = cv2.blur(obj, (blur_ratio, blur_ratio))
+
+                    im0[int(box[1]):int(box[3]), int(box[0]):int(box[2])] = blur_obj
+
+            cv2.imshow("ultralytics", im0)
+            video_writer.write(im0)
+            if cv2.waitKey(1) & 0xFF == ord('q'):
+                break
+
+        cap.release()
+        video_writer.release()
+        cv2.destroyAllWindows()
+        ```
+
+### Arguments `model.predict`
+
+| Name            | Type           | Default                | Description                                                                |
+|-----------------|----------------|------------------------|----------------------------------------------------------------------------|
+| `source`        | `str`          | `'ultralytics/assets'` | source directory for images or videos                                      |
+| `conf`          | `float`        | `0.25`                 | object confidence threshold for detection                                  |
+| `iou`           | `float`        | `0.7`                  | intersection over union (IoU) threshold for NMS                            |
+| `imgsz`         | `int or tuple` | `640`                  | image size as scalar or (h, w) list, i.e. (640, 480)                       |
+| `half`          | `bool`         | `False`                | use half precision (FP16)                                                  |
+| `device`        | `None or str`  | `None`                 | device to run on, i.e. cuda device=0/1/2/3 or device=cpu                   |
+| `max_det`       | `int`          | `300`                  | maximum number of detections per image                                     |
+| `vid_stride`    | `bool`         | `False`                | video frame-rate stride                                                    |
+| `stream_buffer` | `bool`         | `False`                | buffer all streaming frames (True) or return the most recent frame (False) |
+| `visualize`     | `bool`         | `False`                | visualize model features                                                   |
+| `augment`       | `bool`         | `False`                | apply image augmentation to prediction sources                             |
+| `agnostic_nms`  | `bool`         | `False`                | class-agnostic NMS                                                         |
+| `classes`       | `list[int]`    | `None`                 | filter results by class, i.e. classes=0, or classes=[0,2,3]                |
+| `retina_masks`  | `bool`         | `False`                | use high-resolution segmentation masks                                     |
+| `embed`         | `list[int]`    | `None`                 | return feature vectors/embeddings from given layers                        |

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/object-counting.md

@@ -0,0 +1,246 @@
+---
+comments: true
+description: Object Counting Using Ultralytics YOLOv8
+keywords: Ultralytics, YOLOv8, Object Detection, Object Counting, Object Tracking, Notebook, IPython Kernel, CLI, Python SDK
+---
+
+# Object Counting using Ultralytics YOLOv8 🚀
+
+## What is Object Counting?
+
+Object counting with [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) involves accurate identification and counting of specific objects in videos and camera streams. YOLOv8 excels in real-time applications, providing efficient and precise object counting for various scenarios like crowd analysis and surveillance, thanks to its state-of-the-art algorithms and deep learning capabilities.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/Ag2e-5_NpS0"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Object Counting using Ultralytics YOLOv8
+</p>
+
+## Advantages of Object Counting?
+
+- **Resource Optimization:** Object counting facilitates efficient resource management by providing accurate counts, and optimizing resource allocation in applications like inventory management.
+- **Enhanced Security:** Object counting enhances security and surveillance by accurately tracking and counting entities, aiding in proactive threat detection.
+- **Informed Decision-Making:** Object counting offers valuable insights for decision-making, optimizing processes in retail, traffic management, and various other domains.
+
+## Real World Applications
+
+|                                                                           Logistics                                                                           |                                                                     Aquaculture                                                                     |
+|:-------------------------------------------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------------------------------:|
+| ![Conveyor Belt Packets Counting Using Ultralytics YOLOv8](https://github.com/RizwanMunawar/ultralytics/assets/62513924/70e2d106-510c-4c6c-a57a-d34a765aa757) | ![Fish Counting in Sea using Ultralytics YOLOv8](https://github.com/RizwanMunawar/ultralytics/assets/62513924/c60d047b-3837-435f-8d29-bb9fc95d2191) |
+|                                                    Conveyor Belt Packets Counting Using Ultralytics YOLOv8                                                    |                                                    Fish Counting in Sea using Ultralytics YOLOv8                                                    |
+
+!!! Example "Object Counting using YOLOv8 Example"
+
+    === "Count in Region"
+
+        ```python
+        from ultralytics import YOLO
+        from ultralytics.solutions import object_counter
+        import cv2
+
+        model = YOLO("yolov8n.pt")
+        cap = cv2.VideoCapture("path/to/video/file.mp4")
+        assert cap.isOpened(), "Error reading video file"
+        w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
+
+        # Define region points
+        region_points = [(20, 400), (1080, 404), (1080, 360), (20, 360)]
+
+        # Video writer
+        video_writer = cv2.VideoWriter("object_counting_output.avi",
+                               cv2.VideoWriter_fourcc(*'mp4v'),
+                               fps,
+                               (w, h))
+
+        # Init Object Counter
+        counter = object_counter.ObjectCounter()
+        counter.set_args(view_img=True,
+                         reg_pts=region_points,
+                         classes_names=model.names,
+                         draw_tracks=True)
+
+        while cap.isOpened():
+            success, im0 = cap.read()
+            if not success:
+                print("Video frame is empty or video processing has been successfully completed.")
+                break
+            tracks = model.track(im0, persist=True, show=False)
+
+            im0 = counter.start_counting(im0, tracks)
+            video_writer.write(im0)
+
+        cap.release()
+        video_writer.release()
+        cv2.destroyAllWindows()
+        ```
+    
+    === "Count in Polygon"
+
+        ```python
+        from ultralytics import YOLO
+        from ultralytics.solutions import object_counter
+        import cv2
+        
+        model = YOLO("yolov8n.pt")
+        cap = cv2.VideoCapture("path/to/video/file.mp4")
+        assert cap.isOpened(), "Error reading video file"
+        w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
+        
+        # Define region points as a polygon with 5 points
+        region_points = [(20, 400), (1080, 404), (1080, 360), (20, 360), (20, 400)]
+        
+        # Video writer
+        video_writer = cv2.VideoWriter("object_counting_output.avi",
+                               cv2.VideoWriter_fourcc(*'mp4v'),
+                               fps,
+                               (w, h))
+        
+        # Init Object Counter
+        counter = object_counter.ObjectCounter()
+        counter.set_args(view_img=True,
+                         reg_pts=region_points,
+                         classes_names=model.names,
+                         draw_tracks=True)
+        
+        while cap.isOpened():
+            success, im0 = cap.read()
+            if not success:
+                print("Video frame is empty or video processing has been successfully completed.")
+                break
+            tracks = model.track(im0, persist=True, show=False)
+        
+            im0 = counter.start_counting(im0, tracks)
+            video_writer.write(im0)
+        
+        cap.release()
+        video_writer.release()
+        cv2.destroyAllWindows()
+        ```
+    
+    === "Count in Line"
+
+        ```python
+        from ultralytics import YOLO
+        from ultralytics.solutions import object_counter
+        import cv2
+
+        model = YOLO("yolov8n.pt")
+        cap = cv2.VideoCapture("path/to/video/file.mp4")
+        assert cap.isOpened(), "Error reading video file"
+        w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
+
+        # Define line points
+        line_points = [(20, 400), (1080, 400)]
+
+        # Video writer
+        video_writer = cv2.VideoWriter("object_counting_output.avi",
+                               cv2.VideoWriter_fourcc(*'mp4v'),
+                               fps,
+                               (w, h))
+
+        # Init Object Counter
+        counter = object_counter.ObjectCounter()
+        counter.set_args(view_img=True,
+                         reg_pts=line_points,
+                         classes_names=model.names,
+                         draw_tracks=True)
+
+        while cap.isOpened():
+            success, im0 = cap.read()
+            if not success:
+                print("Video frame is empty or video processing has been successfully completed.")
+                break
+            tracks = model.track(im0, persist=True, show=False)
+
+            im0 = counter.start_counting(im0, tracks)
+            video_writer.write(im0)
+
+        cap.release()
+        video_writer.release()
+        cv2.destroyAllWindows()
+        ```
+
+    === "Specific Classes"
+
+        ```python
+        from ultralytics import YOLO
+        from ultralytics.solutions import object_counter
+        import cv2
+
+        model = YOLO("yolov8n.pt")
+        cap = cv2.VideoCapture("path/to/video/file.mp4")
+        assert cap.isOpened(), "Error reading video file"
+        w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
+
+        line_points = [(20, 400), (1080, 400)]  # line or region points
+        classes_to_count = [0, 2]  # person and car classes for count
+
+        # Video writer
+        video_writer = cv2.VideoWriter("object_counting_output.avi",
+                               cv2.VideoWriter_fourcc(*'mp4v'),
+                               fps,
+                               (w, h))
+
+        # Init Object Counter
+        counter = object_counter.ObjectCounter()
+        counter.set_args(view_img=True,
+                         reg_pts=line_points,
+                         classes_names=model.names,
+                         draw_tracks=True)
+
+        while cap.isOpened():
+            success, im0 = cap.read()
+            if not success:
+                print("Video frame is empty or video processing has been successfully completed.")
+                break
+            tracks = model.track(im0, persist=True, show=False,
+                                 classes=classes_to_count)
+
+            im0 = counter.start_counting(im0, tracks)
+            video_writer.write(im0)
+
+        cap.release()
+        video_writer.release()
+        cv2.destroyAllWindows()
+        ```
+
+???+ tip "Region is Movable"
+
+    You can move the region anywhere in the frame by clicking on its edges
+
+### Optional Arguments `set_args`
+
+| Name                  | Type        | Default                    | Description                                   |
+|-----------------------|-------------|----------------------------|-----------------------------------------------|
+| `view_img`            | `bool`      | `False`                    | Display frames with counts                    |
+| `view_in_counts`      | `bool`      | `True`                     | Display in-counts only on video frame         |
+| `view_out_counts`     | `bool`      | `True`                     | Display out-counts only on video frame        |
+| `line_thickness`      | `int`       | `2`                        | Increase bounding boxes thickness             |
+| `reg_pts`             | `list`      | `[(20, 400), (1260, 400)]` | Points defining the Region Area               |
+| `classes_names`       | `dict`      | `model.model.names`        | Dictionary of Class Names                     |
+| `region_color`        | `RGB Color` | `(255, 0, 255)`            | Color of the Object counting Region or Line   |
+| `track_thickness`     | `int`       | `2`                        | Thickness of Tracking Lines                   |
+| `draw_tracks`         | `bool`      | `False`                    | Enable drawing Track lines                    |
+| `track_color`         | `RGB Color` | `(0, 255, 0)`              | Color for each track line                     |
+| `line_dist_thresh`    | `int`       | `15`                       | Euclidean Distance threshold for line counter |
+| `count_txt_thickness` | `int`       | `2`                        | Thickness of Object counts text               |
+| `count_txt_color`     | `RGB Color` | `(0, 0, 0)`                | Foreground color for Object counts text       |
+| `count_color`         | `RGB Color` | `(255, 255, 255)`          | Background color for Object counts text       |
+| `region_thickness`    | `int`       | `5`                        | Thickness for object counter region or line   |
+
+### Arguments `model.track`
+
+| Name      | Type    | Default        | Description                                                 |
+|-----------|---------|----------------|-------------------------------------------------------------|
+| `source`  | `im0`   | `None`         | source directory for images or videos                       |
+| `persist` | `bool`  | `False`        | persisting tracks between frames                            |
+| `tracker` | `str`   | `botsort.yaml` | Tracking method 'bytetrack' or 'botsort'                    |
+| `conf`    | `float` | `0.3`          | Confidence Threshold                                        |
+| `iou`     | `float` | `0.5`          | IOU Threshold                                               |
+| `classes` | `list`  | `None`         | filter results by class, i.e. classes=0, or classes=[0,2,3] |
+| `verbose` | `bool`  | `True`         | Display the object tracking results                         |

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/object-cropping.md

@@ -0,0 +1,102 @@
+---
+comments: true
+description: Learn how to isolate and extract specific objects from images and videos using YOLOv8 object cropping.
+keywords: Ultralytics, YOLOv8, Object Detection, Object Cropping, Image Analysis, Video Processing, Data Extraction, Python
+---
+
+# Object Cropping using Ultralytics YOLOv8 🚀
+
+## What is Object Cropping?
+
+Object cropping with [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) involves isolating and extracting specific detected objects from an image or video. The YOLOv8 model capabilities are utilized to accurately identify and delineate objects, enabling precise cropping for further analysis or manipulation.
+
+## Advantages of Object Cropping?
+
+- **Focused Analysis**: YOLOv8 facilitates targeted object cropping, allowing for in-depth examination or processing of individual items within a scene.
+- **Reduced Data Volume**: By extracting only relevant objects, object cropping helps in minimizing data size, making it efficient for storage, transmission, or subsequent computational tasks.
+- **Enhanced Precision**: YOLOv8's object detection accuracy ensures that the cropped objects maintain their spatial relationships, preserving the integrity of the visual information for detailed analysis.
+
+## Visuals
+
+|                                                                               Airport Luggage                                                                                |                                                                                                                         
+|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|
+| ![Conveyor Belt at Airport Suitcases Cropping using Ultralytics YOLOv8](https://github.com/RizwanMunawar/RizwanMunawar/assets/62513924/648f46be-f233-4307-a8e5-046eea38d2e4) |
+|                                                     Suitcases Cropping at airport conveyor belt using Ultralytics YOLOv8                                                     |                                                                                                       
+
+!!! Example "Object Cropping using YOLOv8 Example"
+
+    === "Object Cropping"
+
+        ```python
+        from ultralytics import YOLO
+        from ultralytics.utils.plotting import Annotator, colors
+        import cv2
+        import os
+
+        model = YOLO("yolov8n.pt")
+        names = model.names
+
+        cap = cv2.VideoCapture("path/to/video/file.mp4")
+        assert cap.isOpened(), "Error reading video file"
+        w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
+
+        crop_dir_name = "ultralytics_crop"
+        if not os.path.exists(crop_dir_name):
+            os.mkdir(crop_dir_name)
+
+        # Video writer
+        video_writer = cv2.VideoWriter("object_cropping_output.avi",
+                                       cv2.VideoWriter_fourcc(*'mp4v'),
+                                       fps, (w, h))
+
+        idx = 0
+        while cap.isOpened():
+            success, im0 = cap.read()
+            if not success:
+                print("Video frame is empty or video processing has been successfully completed.")
+                break
+
+            results = model.predict(im0, show=False)
+            boxes = results[0].boxes.xyxy.cpu().tolist()
+            clss = results[0].boxes.cls.cpu().tolist()
+            annotator = Annotator(im0, line_width=2, example=names)
+
+            if boxes is not None:
+                for box, cls in zip(boxes, clss):
+                    idx += 1
+                    annotator.box_label(box, color=colors(int(cls), True), label=names[int(cls)])
+
+                    crop_obj = im0[int(box[1]):int(box[3]), int(box[0]):int(box[2])]
+
+                    cv2.imwrite(os.path.join(crop_dir_name, str(idx)+".png"), crop_obj)
+
+            cv2.imshow("ultralytics", im0)
+            video_writer.write(im0)
+
+            if cv2.waitKey(1) & 0xFF == ord('q'):
+                break
+
+        cap.release()
+        video_writer.release()
+        cv2.destroyAllWindows()
+        ```
+
+### Arguments `model.predict`
+
+| Name            | Type           | Default                | Description                                                                |
+|-----------------|----------------|------------------------|----------------------------------------------------------------------------|
+| `source`        | `str`          | `'ultralytics/assets'` | source directory for images or videos                                      |
+| `conf`          | `float`        | `0.25`                 | object confidence threshold for detection                                  |
+| `iou`           | `float`        | `0.7`                  | intersection over union (IoU) threshold for NMS                            |
+| `imgsz`         | `int or tuple` | `640`                  | image size as scalar or (h, w) list, i.e. (640, 480)                       |
+| `half`          | `bool`         | `False`                | use half precision (FP16)                                                  |
+| `device`        | `None or str`  | `None`                 | device to run on, i.e. cuda device=0/1/2/3 or device=cpu                   |
+| `max_det`       | `int`          | `300`                  | maximum number of detections per image                                     |
+| `vid_stride`    | `bool`         | `False`                | video frame-rate stride                                                    |
+| `stream_buffer` | `bool`         | `False`                | buffer all streaming frames (True) or return the most recent frame (False) |
+| `visualize`     | `bool`         | `False`                | visualize model features                                                   |
+| `augment`       | `bool`         | `False`                | apply image augmentation to prediction sources                             |
+| `agnostic_nms`  | `bool`         | `False`                | class-agnostic NMS                                                         |
+| `classes`       | `list[int]`    | `None`                 | filter results by class, i.e. classes=0, or classes=[0,2,3]                |
+| `retina_masks`  | `bool`         | `False`                | use high-resolution segmentation masks                                     |
+| `embed`         | `list[int]`    | `None`                 | return feature vectors/embeddings from given layers                        |

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/optimizing-openvino-latency-vs-throughput-modes.md

@@ -0,0 +1,69 @@
+---
+comments: true
+description: Learn how to optimize Ultralytics YOLOv8 models with Intel OpenVINO for maximum performance. Discover expert techniques to minimize latency and maximize throughput for real-time object detection applications.
+keywords: Ultralytics, YOLOv8, OpenVINO, optimization, latency, throughput, inference, object detection, deep learning, machine learning, guide, Intel
+---
+
+# Optimizing OpenVINO Inference for Ultralytics YOLO Models: A Comprehensive Guide
+
+<img width="1024" src="https://github.com/RizwanMunawar/RizwanMunawar/assets/62513924/2b181f68-aa91-4514-ba09-497cc3c83b00" alt="OpenVINO Ecosystem">
+
+## Introduction
+
+When deploying deep learning models, particularly those for object detection such as Ultralytics YOLO models, achieving optimal performance is crucial. This guide delves into leveraging Intel's OpenVINO toolkit to optimize inference, focusing on latency and throughput. Whether you're working on consumer-grade applications or large-scale deployments, understanding and applying these optimization strategies will ensure your models run efficiently on various devices.
+
+## Optimizing for Latency
+
+Latency optimization is vital for applications requiring immediate response from a single model given a single input, typical in consumer scenarios. The goal is to minimize the delay between input and inference result. However, achieving low latency involves careful consideration, especially when running concurrent inferences or managing multiple models.
+
+### Key Strategies for Latency Optimization:
+
+- **Single Inference per Device:** The simplest way to achieve low latency is by limiting to one inference at a time per device. Additional concurrency often leads to increased latency.
+- **Leveraging Sub-Devices:** Devices like multi-socket CPUs or multi-tile GPUs can execute multiple requests with minimal latency increase by utilizing their internal sub-devices.
+- **OpenVINO Performance Hints:** Utilizing OpenVINO's `ov::hint::PerformanceMode::LATENCY` for the `ov::hint::performance_mode` property during model compilation simplifies performance tuning, offering a device-agnostic and future-proof approach.
+
+### Managing First-Inference Latency:
+
+- **Model Caching:** To mitigate model load and compile times impacting latency, use model caching where possible. For scenarios where caching isn't viable, CPUs generally offer the fastest model load times.
+- **Model Mapping vs. Reading:** To reduce load times, OpenVINO replaced model reading with mapping. However, if the model is on a removable or network drive, consider using `ov::enable_mmap(false)` to switch back to reading.
+- **AUTO Device Selection:** This mode begins inference on the CPU, shifting to an accelerator once ready, seamlessly reducing first-inference latency.
+
+## Optimizing for Throughput
+
+Throughput optimization is crucial for scenarios serving numerous inference requests simultaneously, maximizing resource utilization without significantly sacrificing individual request performance.
+
+### Approaches to Throughput Optimization:
+
+1. **OpenVINO Performance Hints:** A high-level, future-proof method to enhance throughput across devices using performance hints.
+
+   ```python
+   import openvino.properties as props
+   import openvino.properties.hint as hints
+
+   config = {hints.performance_mode: hints.PerformanceMode.THROUGHPUT}
+   compiled_model = core.compile_model(model, "GPU", config)
+   ```
+
+2. **Explicit Batching and Streams:** A more granular approach involving explicit batching and the use of streams for advanced performance tuning.
+
+### Designing Throughput-Oriented Applications:
+
+To maximize throughput, applications should:
+
+- Process inputs in parallel, making full use of the device's capabilities.
+- Decompose data flow into concurrent inference requests, scheduled for parallel execution.
+- Utilize the Async API with callbacks to maintain efficiency and avoid device starvation.
+
+### Multi-Device Execution:
+
+OpenVINO's multi-device mode simplifies scaling throughput by automatically balancing inference requests across devices without requiring application-level device management.
+
+## Conclusion
+
+Optimizing Ultralytics YOLO models for latency and throughput with OpenVINO can significantly enhance your application's performance. By carefully applying the strategies outlined in this guide, developers can ensure their models run efficiently, meeting the demands of various deployment scenarios. Remember, the choice between optimizing for latency or throughput depends on your specific application needs and the characteristics of the deployment environment.
+
+For more detailed technical information and the latest updates, refer to the [OpenVINO documentation](https://docs.openvino.ai/latest/index.html) and [Ultralytics YOLO repository](https://github.com/ultralytics/ultralytics). These resources provide in-depth guides, tutorials, and community support to help you get the most out of your deep learning models.
+
+---
+
+Ensuring your models achieve optimal performance is not just about tweaking configurations; it's about understanding your application's needs and making informed decisions. Whether you're optimizing for real-time responses or maximizing throughput for large-scale processing, the combination of Ultralytics YOLO models and OpenVINO offers a powerful toolkit for developers to deploy high-performance AI solutions.

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/raspberry-pi.md

@@ -0,0 +1,196 @@
+---
+comments: true
+description: Quick start guide to setting up YOLO on a Raspberry Pi with a Pi Camera using the libcamera stack. Detailed comparison between Raspberry Pi 3, 4 and 5 models.
+keywords: Ultralytics, YOLO, Raspberry Pi, Pi Camera, libcamera, quick start guide, Raspberry Pi 4 vs Raspberry Pi 5, YOLO on Raspberry Pi, hardware setup, machine learning, AI
+---
+
+# Quick Start Guide: Raspberry Pi and Pi Camera with YOLOv5 and YOLOv8
+
+This comprehensive guide aims to expedite your journey with YOLO object detection models on a [Raspberry Pi](https://www.raspberrypi.com/) using a [Pi Camera](https://www.raspberrypi.com/products/camera-module-v2/). Whether you're a student, hobbyist, or a professional, this guide is designed to get you up and running in less than 30 minutes. The instructions here are rigorously tested to minimize setup issues, allowing you to focus on utilizing YOLO for your specific projects.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/yul4gq_LrOI"
+    title="Introducing Raspberry Pi 5" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Raspberry Pi 5 updates and improvements.
+</p>
+
+## Prerequisites
+
+- Raspberry Pi 3, 4 or 5
+- Pi Camera
+- 64-bit Raspberry Pi Operating System
+
+Connect the Pi Camera to your Raspberry Pi via a CSI cable and install the 64-bit Raspberry Pi Operating System. Verify your camera with the following command:
+
+```bash
+libcamera-hello
+```
+
+You should see a video feed from your camera.
+
+## Choose Your YOLO Version: YOLOv5 or YOLOv8
+
+This guide offers you the flexibility to start with either [YOLOv5](https://github.com/ultralytics/yolov5) or [YOLOv8](https://github.com/ultralytics/ultralytics). Both versions have their unique advantages and use-cases. The choice is yours, but remember, the guide's aim is not just quick setup but also a robust foundation for your future work in object detection.
+
+## Hardware Specifics: At a Glance
+
+To assist you in making an informed hardware decision, we've summarized the key hardware specifics of Raspberry Pi 3, 4, and 5 in the table below:
+
+| Feature                    | Raspberry Pi 3                                                                           | Raspberry Pi 4                                                                           | Raspberry Pi 5                                                       |
+|----------------------------|------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------|----------------------------------------------------------------------|
+| **CPU**                    | 1.2GHz Quad-Core ARM Cortex-A53                                                          | 1.5GHz Quad-core 64-bit ARM Cortex-A72                                                   | 2.4GHz Quad-core 64-bit Arm Cortex-A76                               |
+| **RAM**                    | 1GB LPDDR2                                                                               | 2GB, 4GB or 8GB LPDDR4                                                                   | *Details not yet available*                                          |
+| **USB Ports**              | 4 x USB 2.0                                                                              | 2 x USB 2.0, 2 x USB 3.0                                                                 | 2 x USB 3.0, 2 x USB 2.0                                             |
+| **Network**                | Ethernet & Wi-Fi 802.11n                                                                 | Gigabit Ethernet & Wi-Fi 802.11ac                                                        | Gigabit Ethernet with PoE+ support, Dual-band 802.11ac Wi-Fi®        |
+| **Performance**            | Slower, may require lighter YOLO models                                                  | Faster, can run complex YOLO models                                                      | *Details not yet available*                                          |
+| **Power Requirement**      | 2.5A power supply                                                                        | 3.0A USB-C power supply                                                                  | *Details not yet available*                                          |
+| **Official Documentation** | [Link](https://www.raspberrypi.org/documentation/hardware/raspberrypi/bcm2837/README.md) | [Link](https://www.raspberrypi.org/documentation/hardware/raspberrypi/bcm2711/README.md) | [Link](https://www.raspberrypi.com/news/introducing-raspberry-pi-5/) |
+
+Please make sure to follow the instructions specific to your Raspberry Pi model to ensure a smooth setup process.
+
+## Quick Start with YOLOv5
+
+This section outlines how to set up YOLOv5 on a Raspberry Pi with a Pi Camera. These steps are designed to be compatible with the libcamera camera stack introduced in Raspberry Pi OS Bullseye.
+
+### Install Necessary Packages
+
+1. Update the Raspberry Pi:
+
+    ```bash
+    sudo apt-get update
+    sudo apt-get upgrade -y
+    sudo apt-get autoremove -y
+    ```
+
+2. Clone the YOLOv5 repository:
+
+    ```bash
+    cd ~
+    git clone https://github.com/Ultralytics/yolov5.git
+    ```
+
+3. Install the required dependencies:
+
+    ```bash
+    cd ~/yolov5
+    pip3 install -r requirements.txt
+    ```
+
+4. For Raspberry Pi 3, install compatible versions of PyTorch and Torchvision (skip for Raspberry Pi 4):
+
+    ```bash
+    pip3 uninstall torch torchvision
+    pip3 install torch==1.11.0 torchvision==0.12.0
+    ```
+
+### Modify `detect.py`
+
+To enable TCP streams via SSH or the CLI, minor modifications are needed in `detect.py`.
+
+1. Open `detect.py`:
+
+    ```bash
+    sudo nano ~/yolov5/detect.py
+    ```
+
+2. Find and modify the `is_url` line to accept TCP streams:
+
+    ```python
+    is_url = source.lower().startswith(('rtsp://', 'rtmp://', 'http://', 'https://', 'tcp://'))
+    ```
+
+3. Comment out the `view_img` line:
+
+    ```python
+    # view_img = check_imshow(warn=True)
+    ```
+
+4. Save and exit:
+
+    ```bash
+    CTRL + O -> ENTER -> CTRL + X
+    ```
+
+### Initiate TCP Stream with Libcamera
+
+1. Start the TCP stream:
+
+    ```bash
+    libcamera-vid -n -t 0 --width 1280 --height 960 --framerate 1 --inline --listen -o tcp://127.0.0.1:8888
+    ```
+
+Keep this terminal session running for the next steps.
+
+### Perform YOLOv5 Inference
+
+1. Run the YOLOv5 detection:
+
+    ```bash
+    cd ~/yolov5
+    python3 detect.py --source=tcp://127.0.0.1:8888
+    ```
+
+## Quick Start with YOLOv8
+
+Follow this section if you are interested in setting up YOLOv8 instead. The steps are quite similar but are tailored for YOLOv8's specific needs.
+
+### Install Necessary Packages
+
+1. Update the Raspberry Pi:
+
+    ```bash
+    sudo apt-get update
+    sudo apt-get upgrade -y
+    sudo apt-get autoremove -y
+    ```
+
+2. Install the `ultralytics` Python package:
+
+    ```bash
+    pip3 install ultralytics
+    ```
+
+3. Reboot:
+
+    ```bash
+    sudo reboot
+    ```
+
+### Initiate TCP Stream with Libcamera
+
+1. Start the TCP stream:
+
+    ```bash
+    libcamera-vid -n -t 0 --width 1280 --height 960 --framerate 1 --inline --listen -o tcp://127.0.0.1:8888
+    ```
+
+### Perform YOLOv8 Inference
+
+To perform inference with YOLOv8, you can use the following Python code snippet:
+
+```python
+from ultralytics import YOLO
+
+model = YOLO('yolov8n.pt')
+results = model('tcp://127.0.0.1:8888', stream=True)
+
+while True:
+    for result in results:
+        boxes = result.boxes
+        probs = result.probs
+```
+
+## Next Steps
+
+Congratulations on successfully setting up YOLO on your Raspberry Pi! For further learning and support, visit [Ultralytics](https://ultralytics.com/) and [Kashmir World Foundation](https://www.kashmirworldfoundation.org/).
+
+## Acknowledgements and Citations
+
+This guide was initially created by Daan Eeltink for Kashmir World Foundation, an organization dedicated to the use of YOLO for the conservation of endangered species. We acknowledge their pioneering work and educational focus in the realm of object detection technologies.
+
+For more information about Kashmir World Foundation's activities, you can visit their [website](https://www.kashmirworldfoundation.org/).

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/region-counting.md

@@ -0,0 +1,86 @@
+---
+comments: true
+description: Object Counting in Different Region using Ultralytics YOLOv8
+keywords: Ultralytics, YOLOv8, Object Detection, Object Counting, Object Tracking, Notebook, IPython Kernel, CLI, Python SDK
+---
+
+# Object Counting in Different Regions using Ultralytics YOLOv8 🚀
+
+## What is Object Counting in Regions?
+
+[Object counting](https://docs.ultralytics.com/guides/object-counting/) in regions with [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) involves precisely determining the number of objects within specified areas using advanced computer vision. This approach is valuable for optimizing processes, enhancing security, and improving efficiency in various applications.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/okItf1iHlV8"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Ultralytics YOLOv8 Object Counting in Multiple & Movable Regions
+</p>
+
+## Advantages of Object Counting in Regions?
+
+- **Precision and Accuracy:** Object counting in regions with advanced computer vision ensures precise and accurate counts, minimizing errors often associated with manual counting.
+- **Efficiency Improvement:** Automated object counting enhances operational efficiency, providing real-time results and streamlining processes across different applications.
+- **Versatility and Application:** The versatility of object counting in regions makes it applicable across various domains, from manufacturing and surveillance to traffic monitoring, contributing to its widespread utility and effectiveness.
+
+## Real World Applications
+
+|                                                                               Retail                                                                               |                                                                          Market Streets                                                                           |
+|:------------------------------------------------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------:|
+| ![People Counting in Different Region using Ultralytics YOLOv8](https://github.com/RizwanMunawar/ultralytics/assets/62513924/5ab3bbd7-fd12-4849-928e-5f294d6c3fcf) | ![Crowd Counting in Different Region using Ultralytics YOLOv8](https://github.com/RizwanMunawar/ultralytics/assets/62513924/e7c1aea7-474d-4d78-8d48-b50854ffe1ca) |
+|                                                    People Counting in Different Region using Ultralytics YOLOv8                                                    |                                                    Crowd Counting in Different Region using Ultralytics YOLOv8                                                    |
+
+## Steps to Run
+
+### Step 1: Install Required Libraries
+
+Begin by cloning the Ultralytics repository, installing dependencies, and navigating to the local directory using the provided commands in Step 2.
+
+```bash
+# Clone Ultralytics repo
+git clone https://github.com/ultralytics/ultralytics
+
+# Navigate to the local directory
+cd ultralytics/examples/YOLOv8-Region-Counter
+```
+
+### Step 2: Run Region Counting Using Ultralytics YOLOv8
+
+Execute the following basic commands for inference.
+
+???+ tip "Region is Movable"
+
+    During video playback, you can interactively move the region within the video by clicking and dragging using the left mouse button.
+
+```bash
+# Save results
+python yolov8_region_counter.py --source "path/to/video.mp4" --save-img
+
+# Run model on CPU
+python yolov8_region_counter.py --source "path/to/video.mp4" --device cpu
+
+# Change model file
+python yolov8_region_counter.py --source "path/to/video.mp4" --weights "path/to/model.pt"
+
+# Detect specific classes (e.g., first and third classes)
+python yolov8_region_counter.py --source "path/to/video.mp4" --classes 0 2
+
+# View results without saving
+python yolov8_region_counter.py --source "path/to/video.mp4" --view-img
+```
+
+### Optional Arguments
+
+| Name                 | Type   | Default      | Description                                |
+|----------------------|--------|--------------|--------------------------------------------|
+| `--source`           | `str`  | `None`       | Path to video file, for webcam 0           |
+| `--line_thickness`   | `int`  | `2`          | Bounding Box thickness                     |
+| `--save-img`         | `bool` | `False`      | Save the predicted video/image             |
+| `--weights`          | `str`  | `yolov8n.pt` | Weights file path                          |
+| `--classes`          | `list` | `None`       | Detect specific classes i.e. --classes 0 2 |
+| `--region-thickness` | `int`  | `2`          | Region Box thickness                       |
+| `--track-thickness`  | `int`  | `2`          | Tracking line thickness                    |

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/sahi-tiled-inference.md

@@ -0,0 +1,185 @@
+---
+comments: true
+description: A comprehensive guide on how to use YOLOv8 with SAHI for standard and sliced inference in object detection tasks.
+keywords: YOLOv8, SAHI, Sliced Inference, Object Detection, Ultralytics, Large Scale Image Analysis, High-Resolution Imagery
+---
+
+# Ultralytics Docs: Using YOLOv8 with SAHI for Sliced Inference
+
+Welcome to the Ultralytics documentation on how to use YOLOv8 with [SAHI](https://github.com/obss/sahi) (Slicing Aided Hyper Inference). This comprehensive guide aims to furnish you with all the essential knowledge you'll need to implement SAHI alongside YOLOv8. We'll deep-dive into what SAHI is, why sliced inference is critical for large-scale applications, and how to integrate these functionalities with YOLOv8 for enhanced object detection performance.
+
+<p align="center">
+  <img width="1024" src="https://raw.githubusercontent.com/obss/sahi/main/resources/sliced_inference.gif" alt="SAHI Sliced Inference Overview">
+</p>
+
+## Introduction to SAHI
+
+SAHI (Slicing Aided Hyper Inference) is an innovative library designed to optimize object detection algorithms for large-scale and high-resolution imagery. Its core functionality lies in partitioning images into manageable slices, running object detection on each slice, and then stitching the results back together. SAHI is compatible with a range of object detection models, including the YOLO series, thereby offering flexibility while ensuring optimized use of computational resources.
+
+### Key Features of SAHI
+
+- **Seamless Integration**: SAHI integrates effortlessly with YOLO models, meaning you can start slicing and detecting without a lot of code modification.
+- **Resource Efficiency**: By breaking down large images into smaller parts, SAHI optimizes the memory usage, allowing you to run high-quality detection on hardware with limited resources.
+- **High Accuracy**: SAHI maintains the detection accuracy by employing smart algorithms to merge overlapping detection boxes during the stitching process.
+
+## What is Sliced Inference?
+
+Sliced Inference refers to the practice of subdividing a large or high-resolution image into smaller segments (slices), conducting object detection on these slices, and then recompiling the slices to reconstruct the object locations on the original image. This technique is invaluable in scenarios where computational resources are limited or when working with extremely high-resolution images that could otherwise lead to memory issues.
+
+### Benefits of Sliced Inference
+
+- **Reduced Computational Burden**: Smaller image slices are faster to process, and they consume less memory, enabling smoother operation on lower-end hardware.
+
+- **Preserved Detection Quality**: Since each slice is treated independently, there is no reduction in the quality of object detection, provided the slices are large enough to capture the objects of interest.
+
+- **Enhanced Scalability**: The technique allows for object detection to be more easily scaled across different sizes and resolutions of images, making it ideal for a wide range of applications from satellite imagery to medical diagnostics.
+
+<table border="0">
+  <tr>
+    <th>YOLOv8 without SAHI</th>
+    <th>YOLOv8 with SAHI</th>
+  </tr>
+  <tr>
+    <td><img src="https://user-images.githubusercontent.com/26833433/266123241-260a9740-5998-4e9a-ad04-b39b7767e731.png" alt="YOLOv8 without SAHI" width="640"></td>
+    <td><img src="https://user-images.githubusercontent.com/26833433/266123245-55f696ad-ec74-4e71-9155-c211d693bb69.png" alt="YOLOv8 with SAHI" width="640"></td>
+  </tr>
+</table>
+
+## Installation and Preparation
+
+### Installation
+
+To get started, install the latest versions of SAHI and Ultralytics:
+
+```bash
+pip install -U ultralytics sahi
+```
+
+### Import Modules and Download Resources
+
+Here's how to import the necessary modules and download a YOLOv8 model and some test images:
+
+```python
+from sahi.utils.yolov8 import download_yolov8s_model
+from sahi import AutoDetectionModel
+from sahi.utils.cv import read_image
+from sahi.utils.file import download_from_url
+from sahi.predict import get_prediction, get_sliced_prediction, predict
+from pathlib import Path
+from IPython.display import Image
+
+# Download YOLOv8 model
+yolov8_model_path = "models/yolov8s.pt"
+download_yolov8s_model(yolov8_model_path)
+
+# Download test images
+download_from_url('https://raw.githubusercontent.com/obss/sahi/main/demo/demo_data/small-vehicles1.jpeg', 'demo_data/small-vehicles1.jpeg')
+download_from_url('https://raw.githubusercontent.com/obss/sahi/main/demo/demo_data/terrain2.png', 'demo_data/terrain2.png')
+```
+
+## Standard Inference with YOLOv8
+
+### Instantiate the Model
+
+You can instantiate a YOLOv8 model for object detection like this:
+
+```python
+detection_model = AutoDetectionModel.from_pretrained(
+    model_type='yolov8',
+    model_path=yolov8_model_path,
+    confidence_threshold=0.3,
+    device="cpu",  # or 'cuda:0'
+)
+```
+
+### Perform Standard Prediction
+
+Perform standard inference using an image path or a numpy image.
+
+```python
+# With an image path
+result = get_prediction("demo_data/small-vehicles1.jpeg", detection_model)
+
+# With a numpy image
+result = get_prediction(read_image("demo_data/small-vehicles1.jpeg"), detection_model)
+```
+
+### Visualize Results
+
+Export and visualize the predicted bounding boxes and masks:
+
+```python
+result.export_visuals(export_dir="demo_data/")
+Image("demo_data/prediction_visual.png")
+```
+
+## Sliced Inference with YOLOv8
+
+Perform sliced inference by specifying the slice dimensions and overlap ratios:
+
+```python
+result = get_sliced_prediction(
+    "demo_data/small-vehicles1.jpeg",
+    detection_model,
+    slice_height=256,
+    slice_width=256,
+    overlap_height_ratio=0.2,
+    overlap_width_ratio=0.2
+)
+```
+
+## Handling Prediction Results
+
+SAHI provides a `PredictionResult` object, which can be converted into various annotation formats:
+
+```python
+# Access the object prediction list
+object_prediction_list = result.object_prediction_list
+
+# Convert to COCO annotation, COCO prediction, imantics, and fiftyone formats
+result.to_coco_annotations()[:3]
+result.to_coco_predictions(image_id=1)[:3]
+result.to_imantics_annotations()[:3]
+result.to_fiftyone_detections()[:3]
+```
+
+## Batch Prediction
+
+For batch prediction on a directory of images:
+
+```python
+predict(
+    model_type="yolov8",
+    model_path="path/to/yolov8n.pt",
+    model_device="cpu",  # or 'cuda:0'
+    model_confidence_threshold=0.4,
+    source="path/to/dir",
+    slice_height=256,
+    slice_width=256,
+    overlap_height_ratio=0.2,
+    overlap_width_ratio=0.2,
+)
+```
+
+That's it! Now you're equipped to use YOLOv8 with SAHI for both standard and sliced inference.
+
+## Citations and Acknowledgments
+
+If you use SAHI in your research or development work, please cite the original SAHI paper and acknowledge the authors:
+
+!!! Quote ""
+
+    === "BibTeX"
+
+        ```bibtex
+        @article{akyon2022sahi,
+          title={Slicing Aided Hyper Inference and Fine-tuning for Small Object Detection},
+          author={Akyon, Fatih Cagatay and Altinuc, Sinan Onur and Temizel, Alptekin},
+          journal={2022 IEEE International Conference on Image Processing (ICIP)},
+          doi={10.1109/ICIP46576.2022.9897990},
+          pages={966-970},
+          year={2022}
+        }
+        ```
+
+We extend our thanks to the SAHI research group for creating and maintaining this invaluable resource for the computer vision community. For more information about SAHI and its creators, visit the [SAHI GitHub repository](https://github.com/obss/sahi).

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/security-alarm-system.md

@@ -0,0 +1,166 @@
+---
+comments: true
+description: Security Alarm System Project Using Ultralytics YOLOv8. Learn How to implement a Security Alarm System Using ultralytics YOLOv8
+keywords: Object Detection, Security Alarm, Object Tracking, YOLOv8, Computer Vision Projects
+---
+
+# Security Alarm System Project Using Ultralytics YOLOv8
+
+<img src="https://github.com/RizwanMunawar/ultralytics/assets/62513924/f4e4a613-fb25-4bd0-9ec5-78352ddb62bd" alt="Security Alarm System">
+
+The Security Alarm System Project utilizing Ultralytics YOLOv8 integrates advanced computer vision capabilities to enhance security measures. YOLOv8, developed by Ultralytics, provides real-time object detection, allowing the system to identify and respond to potential security threats promptly. This project offers several advantages:
+
+- **Real-time Detection:** YOLOv8's efficiency enables the Security Alarm System to detect and respond to security incidents in real-time, minimizing response time.
+- **Accuracy:** YOLOv8 is known for its accuracy in object detection, reducing false positives and enhancing the reliability of the security alarm system.
+- **Integration Capabilities:** The project can be seamlessly integrated with existing security infrastructure, providing an upgraded layer of intelligent surveillance.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/_1CmwUzoxY4"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Security Alarm System Project with Ultralytics YOLOv8 Object Detection
+</p>
+
+### Code
+
+#### Import Libraries
+
+```python
+import torch
+import numpy as np
+import cv2
+from time import time
+from ultralytics import YOLO
+from ultralytics.utils.plotting import Annotator, colors
+import smtplib
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+```
+
+#### Set up the parameters of the message
+
+???+ tip "Note"
+
+    App Password Generation is necessary
+
+- Navigate to [App Password Generator](https://myaccount.google.com/apppasswords), designate an app name such as "security project," and obtain a 16-digit password. Copy this password and paste it into the designated password field as instructed.
+
+```python
+password = ""
+from_email = ""  # must match the email used to generate the password
+to_email = ""  # receiver email
+```
+
+#### Server creation and authentication
+
+```python
+server = smtplib.SMTP('smtp.gmail.com: 587')
+server.starttls()
+server.login(from_email, password)
+```
+
+#### Email Send Function
+
+```python
+def send_email(to_email, from_email, object_detected=1):
+    message = MIMEMultipart()
+    message['From'] = from_email
+    message['To'] = to_email
+    message['Subject'] = "Security Alert"
+    # Add in the message body
+    message_body = f'ALERT - {object_detected} objects has been detected!!'
+
+    message.attach(MIMEText(message_body, 'plain'))
+    server.sendmail(from_email, to_email, message.as_string())
+```
+
+#### Object Detection and Alert Sender
+
+```python
+class ObjectDetection:
+    def __init__(self, capture_index):
+        # default parameters
+        self.capture_index = capture_index
+        self.email_sent = False
+
+        # model information
+        self.model = YOLO("yolov8n.pt")
+
+        # visual information
+        self.annotator = None
+        self.start_time = 0
+        self.end_time = 0
+
+        # device information
+        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+    def predict(self, im0):
+        results = self.model(im0)
+        return results
+
+    def display_fps(self, im0):
+        self.end_time = time()
+        fps = 1 / np.round(self.end_time - self.start_time, 2)
+        text = f'FPS: {int(fps)}'
+        text_size = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 1.0, 2)[0]
+        gap = 10
+        cv2.rectangle(im0, (20 - gap, 70 - text_size[1] - gap), (20 + text_size[0] + gap, 70 + gap), (255, 255, 255), -1)
+        cv2.putText(im0, text, (20, 70), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 0), 2)
+
+    def plot_bboxes(self, results, im0):
+        class_ids = []
+        self.annotator = Annotator(im0, 3, results[0].names)
+        boxes = results[0].boxes.xyxy.cpu()
+        clss = results[0].boxes.cls.cpu().tolist()
+        names = results[0].names
+        for box, cls in zip(boxes, clss):
+            class_ids.append(cls)
+            self.annotator.box_label(box, label=names[int(cls)], color=colors(int(cls), True))
+        return im0, class_ids
+
+    def __call__(self):
+        cap = cv2.VideoCapture(self.capture_index)
+        assert cap.isOpened()
+        cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
+        cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
+        frame_count = 0
+        while True:
+            self.start_time = time()
+            ret, im0 = cap.read()
+            assert ret
+            results = self.predict(im0)
+            im0, class_ids = self.plot_bboxes(results, im0)
+
+            if len(class_ids) > 0:  # Only send email If not sent before
+                if not self.email_sent:
+                    send_email(to_email, from_email, len(class_ids))
+                    self.email_sent = True
+            else:
+                self.email_sent = False
+
+            self.display_fps(im0)
+            cv2.imshow('YOLOv8 Detection', im0)
+            frame_count += 1
+            if cv2.waitKey(5) & 0xFF == 27:
+                break
+        cap.release()
+        cv2.destroyAllWindows()
+        server.quit()
+```
+
+#### Call the Object Detection class and Run the Inference
+
+```python
+detector = ObjectDetection(capture_index=0)
+detector()
+```
+
+That's it! When you execute the code, you'll receive a single notification on your email if any object is detected. The notification is sent immediately, not repeatedly. However, feel free to customize the code to suit your project requirements.
+
+#### Email Received Sample
+
+<img width="256" src="https://github.com/RizwanMunawar/ultralytics/assets/62513924/db79ccc6-aabd-4566-a825-b34e679c90f9" alt="Email Received Sample">

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/speed-estimation.md

@@ -0,0 +1,110 @@
+---
+comments: true
+description: Speed Estimation Using Ultralytics YOLOv8
+keywords: Ultralytics, YOLOv8, Object Detection, Speed Estimation, Object Tracking, Notebook, IPython Kernel, CLI, Python SDK
+---
+
+# Speed Estimation using Ultralytics YOLOv8 🚀
+
+## What is Speed Estimation?
+
+Speed estimation is the process of calculating the rate of movement of an object within a given context, often employed in computer vision applications. Using [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) you can now calculate the speed of object using [object tracking](https://docs.ultralytics.com/modes/track/) alongside distance and time data, crucial for tasks like traffic and surveillance. The accuracy of speed estimation directly influences the efficiency and reliability of various applications, making it a key component in the advancement of intelligent systems and real-time decision-making processes.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/rCggzXRRSRo"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Speed Estimation using Ultralytics YOLOv8
+</p>
+
+## Advantages of Speed Estimation?
+
+- **Efficient Traffic Control:** Accurate speed estimation aids in managing traffic flow, enhancing safety, and reducing congestion on roadways.
+- **Precise Autonomous Navigation:** In autonomous systems like self-driving cars, reliable speed estimation ensures safe and accurate vehicle navigation.
+- **Enhanced Surveillance Security:** Speed estimation in surveillance analytics helps identify unusual behaviors or potential threats, improving the effectiveness of security measures.
+
+## Real World Applications
+
+|                                                                     Transportation                                                                      |                                                                      Transportation                                                                       |
+|:-------------------------------------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------------------------------------:|
+| ![Speed Estimation on Road using Ultralytics YOLOv8](https://github.com/RizwanMunawar/ultralytics/assets/62513924/c8a0fd4a-d394-436d-8de3-d5b754755fc7) | ![Speed Estimation on Bridge using Ultralytics YOLOv8](https://github.com/RizwanMunawar/ultralytics/assets/62513924/cee10e02-b268-4304-b73a-5b9cb42da669) |
+|                                                    Speed Estimation on Road using Ultralytics YOLOv8                                                    |                                                    Speed Estimation on Bridge using Ultralytics YOLOv8                                                    |
+
+!!! Example "Speed Estimation using YOLOv8 Example"
+
+    === "Speed Estimation"
+
+        ```python
+        from ultralytics import YOLO
+        from ultralytics.solutions import speed_estimation
+        import cv2
+
+        model = YOLO("yolov8n.pt")
+        names = model.model.names
+
+        cap = cv2.VideoCapture("path/to/video/file.mp4")
+        assert cap.isOpened(), "Error reading video file"
+        w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
+
+        # Video writer
+        video_writer = cv2.VideoWriter("speed_estimation.avi",
+                                       cv2.VideoWriter_fourcc(*'mp4v'),
+                                       fps,
+                                       (w, h))
+
+        line_pts = [(0, 360), (1280, 360)]
+
+        # Init speed-estimation obj
+        speed_obj = speed_estimation.SpeedEstimator()
+        speed_obj.set_args(reg_pts=line_pts,
+                           names=names,
+                           view_img=True)
+
+        while cap.isOpened():
+
+            success, im0 = cap.read()
+            if not success:
+                print("Video frame is empty or video processing has been successfully completed.")
+                break
+
+            tracks = model.track(im0, persist=True, show=False)
+
+            im0 = speed_obj.estimate_speed(im0, tracks)
+            video_writer.write(im0)
+
+        cap.release()
+        video_writer.release()
+        cv2.destroyAllWindows()
+
+        ```
+
+???+ warning "Speed is Estimate"
+
+    Speed will be an estimate and may not be completely accurate. Additionally, the estimation can vary depending on GPU speed.
+
+### Optional Arguments `set_args`
+
+| Name               | Type   | Default                    | Description                                       |
+|--------------------|--------|----------------------------|---------------------------------------------------|
+| `reg_pts`          | `list` | `[(20, 400), (1260, 400)]` | Points defining the Region Area                   |
+| `names`            | `dict` | `None`                     | Classes names                                     |
+| `view_img`         | `bool` | `False`                    | Display frames with counts                        |
+| `line_thickness`   | `int`  | `2`                        | Increase bounding boxes thickness                 |
+| `region_thickness` | `int`  | `5`                        | Thickness for object counter region or line       |
+| `spdl_dist_thresh` | `int`  | `10`                       | Euclidean Distance threshold for speed check line |
+
+### Arguments `model.track`
+
+| Name      | Type    | Default        | Description                                                 |
+|-----------|---------|----------------|-------------------------------------------------------------|
+| `source`  | `im0`   | `None`         | source directory for images or videos                       |
+| `persist` | `bool`  | `False`        | persisting tracks between frames                            |
+| `tracker` | `str`   | `botsort.yaml` | Tracking method 'bytetrack' or 'botsort'                    |
+| `conf`    | `float` | `0.3`          | Confidence Threshold                                        |
+| `iou`     | `float` | `0.5`          | IOU Threshold                                               |
+| `classes` | `list`  | `None`         | filter results by class, i.e. classes=0, or classes=[0,2,3] |
+| `verbose` | `bool`  | `True`         | Display the object tracking results                         |

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/triton-inference-server.md

@@ -0,0 +1,137 @@
+---
+comments: true
+description: A step-by-step guide on integrating Ultralytics YOLOv8 with Triton Inference Server for scalable and high-performance deep learning inference deployments.
+keywords: YOLOv8, Triton Inference Server, ONNX, Deep Learning Deployment, Scalable Inference, Ultralytics, NVIDIA, Object Detection, Cloud Inference
+---
+
+# Triton Inference Server with Ultralytics YOLOv8
+
+The [Triton Inference Server](https://developer.nvidia.com/nvidia-triton-inference-server) (formerly known as TensorRT Inference Server) is an open-source software solution developed by NVIDIA. It provides a cloud inference solution optimized for NVIDIA GPUs. Triton simplifies the deployment of AI models at scale in production. Integrating Ultralytics YOLOv8 with Triton Inference Server allows you to deploy scalable, high-performance deep learning inference workloads. This guide provides steps to set up and test the integration.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/NQDtfSi5QF4"
+    title="Getting Started with NVIDIA Triton Inference Server" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Getting Started with NVIDIA Triton Inference Server.
+</p>
+
+## What is Triton Inference Server?
+
+Triton Inference Server is designed to deploy a variety of AI models in production. It supports a wide range of deep learning and machine learning frameworks, including TensorFlow, PyTorch, ONNX Runtime, and many others. Its primary use cases are:
+
+- Serving multiple models from a single server instance.
+- Dynamic model loading and unloading without server restart.
+- Ensemble inference, allowing multiple models to be used together to achieve results.
+- Model versioning for A/B testing and rolling updates.
+
+## Prerequisites
+
+Ensure you have the following prerequisites before proceeding:
+
+- Docker installed on your machine.
+- Install `tritonclient`:
+    ```bash
+    pip install tritonclient[all]
+    ```
+
+## Exporting YOLOv8 to ONNX Format
+
+Before deploying the model on Triton, it must be exported to the ONNX format. ONNX (Open Neural Network Exchange) is a format that allows models to be transferred between different deep learning frameworks. Use the `export` function from the `YOLO` class:
+
+```python
+from ultralytics import YOLO
+
+# Load a model
+model = YOLO('yolov8n.pt')  # load an official model
+
+# Export the model
+onnx_file = model.export(format='onnx', dynamic=True)
+```
+
+## Setting Up Triton Model Repository
+
+The Triton Model Repository is a storage location where Triton can access and load models.
+
+1. Create the necessary directory structure:
+
+    ```python
+    from pathlib import Path
+
+    # Define paths
+    triton_repo_path = Path('tmp') / 'triton_repo'
+    triton_model_path = triton_repo_path / 'yolo'
+
+    # Create directories
+    (triton_model_path / '1').mkdir(parents=True, exist_ok=True)
+    ```
+
+2. Move the exported ONNX model to the Triton repository:
+
+    ```python
+    from pathlib import Path
+
+    # Move ONNX model to Triton Model path
+    Path(onnx_file).rename(triton_model_path / '1' / 'model.onnx')
+
+    # Create config file
+    (triton_model_path / 'config.pbtxt').touch()
+    ```
+
+## Running Triton Inference Server
+
+Run the Triton Inference Server using Docker:
+
+```python
+import subprocess
+import time
+
+from tritonclient.http import InferenceServerClient
+
+# Define image https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver
+tag = 'nvcr.io/nvidia/tritonserver:23.09-py3'  # 6.4 GB
+
+# Pull the image
+subprocess.call(f'docker pull {tag}', shell=True)
+
+# Run the Triton server and capture the container ID
+container_id = subprocess.check_output(
+    f'docker run -d --rm -v {triton_repo_path}:/models -p 8000:8000 {tag} tritonserver --model-repository=/models',
+    shell=True).decode('utf-8').strip()
+
+# Wait for the Triton server to start
+triton_client = InferenceServerClient(url='localhost:8000', verbose=False, ssl=False)
+
+# Wait until model is ready
+for _ in range(10):
+    with contextlib.suppress(Exception):
+        assert triton_client.is_model_ready(model_name)
+        break
+    time.sleep(1)
+```
+
+Then run inference using the Triton Server model:
+
+```python
+from ultralytics import YOLO
+
+# Load the Triton Server model
+model = YOLO(f'http://localhost:8000/yolo', task='detect')
+
+# Run inference on the server
+results = model('path/to/image.jpg')
+```
+
+Cleanup the container:
+
+```python
+# Kill and remove the container at the end of the test
+subprocess.call(f'docker kill {container_id}', shell=True)
+```
+
+---
+
+By following the above steps, you can deploy and run Ultralytics YOLOv8 models efficiently on Triton Inference Server, providing a scalable and high-performance solution for deep learning inference tasks. If you face any issues or have further queries, refer to the [official Triton documentation](https://docs.nvidia.com/deeplearning/triton-inference-server/user-guide/docs/index.html) or reach out to the Ultralytics community for support.

packages/inula-code-generator/YOLOv10_cs/docs/en/guides/view-results-in-terminal.md

@@ -0,0 +1,146 @@
+---
+comments: true
+description: Learn how to view image results inside a compatible VSCode terminal.
+keywords: YOLOv8, VSCode, Terminal, Remote Development, Ultralytics, SSH, Object Detection, Inference, Results, Remote Tunnel, Images, Helpful, Productivity Hack
+---
+
+# Viewing Inference Results in a Terminal
+
+<p align="center">
+  <img width="800" src="https://raw.githubusercontent.com/saitoha/libsixel/data/data/sixel.gif" alt="Sixel example of image in Terminal">
+</p>
+
+Image from the [libsixel](https://saitoha.github.io/libsixel/) website.
+
+## Motivation
+
+When connecting to a remote machine, normally visualizing image results is not possible or requires moving data to a local device with a GUI. The VSCode integrated terminal allows for directly rendering images. This is a short demonstration on how to use this in conjunction with `ultralytics` with [prediction results](../modes/predict.md).
+
+!!! warning
+
+    Only compatible with Linux and MacOS. Check the VSCode [repository](https://github.com/microsoft/vscode), check [Issue status](https://github.com/microsoft/vscode/issues/198622), or [documentation](https://code.visualstudio.com/docs) for updates about Windows support to view images in terminal with `sixel`.
+
+The VSCode compatible protocols for viewing images using the integrated terminal are [`sixel`](https://en.wikipedia.org/wiki/Sixel) and [`iTerm`](https://iterm2.com/documentation-images.html). This guide will demonstrate use of the `sixel` protocol.
+
+## Process
+
+1. First, you must enable settings `terminal.integrated.enableImages` and `terminal.integrated.gpuAcceleration` in VSCode.
+
+    ```yaml
+    "terminal.integrated.gpuAcceleration": "auto" # "auto" is default, can also use "on"
+    "terminal.integrated.enableImages": false
+    ```
+
+<p align="center">
+  <img width="800" src="https://github.com/ultralytics/ultralytics/assets/62214284/d158ab1c-893c-4397-a5de-2f9f74f81175" alt="VSCode enable terminal images setting">
+</p>
+
+1. Install the `python-sixel` library in your virtual environment. This is a [fork](https://github.com/lubosz/python-sixel?tab=readme-ov-file) of the `PySixel` library, which is no longer maintained.
+
+    ```bash
+    pip install sixel
+    ```
+
+1. Import the relevant libraries
+
+    ```py
+    import io
+
+    import cv2 as cv
+
+    from ultralytics import YOLO
+    from sixel import SixelWriter
+    ```
+
+1. Load a model and execute inference, then plot the results and store in a variable. See more about inference arguments and working with results on the [predict mode](../modes/predict.md) page.
+
+    ```{ .py .annotate }
+    from ultralytics import YOLO
+
+    # Load a model
+    model = YOLO("yolov8n.pt")
+
+    # Run inference on an image
+    results = model.predict(source="ultralytics/assets/bus.jpg")
+    
+    # Plot inference results
+    plot = results[0].plot() #(1)!
+    ```
+
+    1. See [plot method parameters](../modes/predict.md#plot-method-parameters) to see possible arguments to use.
+
+1. Now, use OpenCV to convert the `numpy.ndarray` to `bytes` data. Then use `io.BytesIO` to make a "file-like" object.
+
+    ```{ .py .annotate }
+    # Results image as bytes
+    im_bytes = cv.imencode(
+        ".png", #(1)!
+        plot,
+        )[1].tobytes() #(2)!
+
+    # Image bytes as a file-like object
+    mem_file = io.BytesIO(im_bytes)
+    ```
+
+    1. It's possible to use other image extensions as well.
+    2. Only the object at index `1` that is returned is needed.
+
+1. Create a `SixelWriter` instance, and then use the `.draw()` method to draw the image in the terminal.
+
+    ```py
+    # Create sixel writer object
+    w = SixelWriter()
+
+    # Draw the sixel image in the terminal
+    w.draw(mem_file)
+    ```
+
+## Example Inference Results
+
+<p align="center">
+  <img width="800" src="https://github.com/ultralytics/ultralytics/assets/62214284/6743ab64-300d-4429-bdce-e246455f7b68" alt="View Image in Terminal">
+</p>
+
+!!! danger
+
+    Using this example with videos or animated GIF frames has **not** been tested. Attempt at your own risk.
+
+## Full Code Example
+
+```{ .py .annotate }
+import io
+
+import cv2 as cv
+
+from ultralytics import YOLO
+from sixel import SixelWriter
+
+# Load a model
+model = YOLO("yolov8n.pt")
+
+# Run inference on an image
+results = model.predict(source="ultralytics/assets/bus.jpg")
+
+# Plot inference results
+plot = results[0].plot() #(3)!
+
+# Results image as bytes
+im_bytes = cv.imencode(
+    ".png", #(1)!
+    plot,
+    )[1].tobytes() #(2)!
+
+mem_file = io.BytesIO(im_bytes)
+w = SixelWriter()
+w.draw(mem_file)
+```
+
+1. It's possible to use other image extensions as well.
+2. Only the object at index `1` that is returned is needed.
+3. See [plot method parameters](../modes/predict.md#plot-method-parameters) to see possible arguments to use.
+
+---
+
+!!! tip
+
+    You may need to use `clear` to "erase" the view of the image in the terminal.