├── .gitignore ├── Makefile ├── docs ├── _static │ ├── logo1024x1024.jpeg │ ├── logo_and_text290x290.png │ ├── logo_and_text_1024x1024.png │ ├── logo_and_text_1280x640.png │ ├── Screenshot_20230405_195823.png │ ├── Screenshot_20230405_195854.png │ └── Screenshot_20230411_004511.png ├── conf.py ├── index.rst ├── Makefile └── make.bat ├── promtstd ├── lib_main.py ├── test │ ├── utils.py │ └── test_main.py ├── lib_re.py ├── lib_linter.py ├── lib_types.py ├── __main__.py ├── lib_to_html.py ├── lib_to_json.py └── from_html │ └── css │ └── base_style.scss ├── examples ├── Оптимизация кода.md ├── json │ ├── Оптимизация кода.json │ ├── Изучение новой темы в IT.json │ ├── Сжать диалог.json │ ├── Напиши презентацию на тему.json │ ├── Режим думай в слух.json │ ├── Написать программу на Python.json │ ├── Создание промтов вместе с ChatGpt.json │ ├── Предсказание вероятности события.json │ ├── Написание README большому проекту.json │ ├── Документирование кода.json │ ├── Генерация кода на Python.json │ └── Оптимизация документации.json ├── Изучение новой темы в IT.md ├── Сжать диалог.md ├── Напиши презентацию на тему.md ├── Написать программу на Python.md ├── Режим думай в слух.md ├── Создание промтов вместе с ChatGpt.md ├── Написание README большому проекту.md ├── Предсказание вероятности события.md ├── Документирование кода.md ├── Генерация кода на Python.md └── Оптимизация документации.md ├── pyproject.toml ├── fairy_tale.md └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | __pycache__ 2 | log 3 | venv 4 | /html 5 | .vscode 6 | dist 7 | /dist 8 | .pytest_cache 9 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | 2 | # Собрать все примеры во все типы 3 | build_examples: 4 | python -m promtstd all ./examples 5 | -------------------------------------------------------------------------------- /docs/_static/logo1024x1024.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/denisxab/promtstd/HEAD/docs/_static/logo1024x1024.jpeg -------------------------------------------------------------------------------- /docs/_static/logo_and_text290x290.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/denisxab/promtstd/HEAD/docs/_static/logo_and_text290x290.png -------------------------------------------------------------------------------- /docs/_static/logo_and_text_1024x1024.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/denisxab/promtstd/HEAD/docs/_static/logo_and_text_1024x1024.png -------------------------------------------------------------------------------- /docs/_static/logo_and_text_1280x640.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/denisxab/promtstd/HEAD/docs/_static/logo_and_text_1280x640.png -------------------------------------------------------------------------------- /docs/_static/Screenshot_20230405_195823.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/denisxab/promtstd/HEAD/docs/_static/Screenshot_20230405_195823.png -------------------------------------------------------------------------------- /docs/_static/Screenshot_20230405_195854.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/denisxab/promtstd/HEAD/docs/_static/Screenshot_20230405_195854.png -------------------------------------------------------------------------------- /docs/_static/Screenshot_20230411_004511.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/denisxab/promtstd/HEAD/docs/_static/Screenshot_20230411_004511.png -------------------------------------------------------------------------------- /promtstd/lib_main.py: -------------------------------------------------------------------------------- 1 | from pathlib import Path 2 | 3 | 4 | class ParserPromtStd: 5 | def __init__(self, select_file: Path) -> None: 6 | """ 7 | :param select_file: Путь к файлу промпта. 8 | """ 9 | # Имя файла который сейчас обрабатывается 10 | self.select_file: Path = select_file 11 | -------------------------------------------------------------------------------- /docs/conf.py: -------------------------------------------------------------------------------- 1 | import pathlib 2 | import sys 3 | 4 | BASE_DIR = pathlib.Path(__file__).parent.parent.parent 5 | project = BASE_DIR.name 6 | 7 | # Добавляем проект с модулями в путь Python 8 | sys.path.insert(0, str(BASE_DIR / project)) 9 | extensions = [ 10 | "sphinx.ext.autodoc", 11 | ] 12 | templates_path = ["_templates"] 13 | exclude_patterns = [] 14 | language = "ru" 15 | html_theme = "sphinx_rtd_theme" 16 | html_static_path = ["_static"] 17 | -------------------------------------------------------------------------------- /promtstd/test/utils.py: -------------------------------------------------------------------------------- 1 | import hashlib 2 | import sys 3 | from pathlib import Path 4 | 5 | sys.path.insert(0, str(Path(__file__).parent.parent)) 6 | 7 | 8 | def get_file_hash(file_path, algorithm="sha256"): 9 | """Получить хеш файла""" 10 | hash_algorithm = hashlib.new(algorithm) 11 | with file_path.open("rb") as file: 12 | for chunk in iter(lambda: file.read(4096), b""): 13 | hash_algorithm.update(chunk) 14 | return hash_algorithm.hexdigest() 15 | -------------------------------------------------------------------------------- /docs/index.rst: -------------------------------------------------------------------------------- 1 | .. promtstd documentation master file, created by 2 | sphinx-quickstart on Wed Apr 5 19:57:51 2023. 3 | You can adapt this file completely to your liking, but it should at least 4 | contain the root `toctree` directive. 5 | 6 | Welcome to promtstd's documentation! 7 | ==================================== 8 | 9 | .. toctree:: 10 | :maxdepth: 2 11 | :caption: Contents: 12 | 13 | 14 | 15 | Indices and tables 16 | ================== 17 | 18 | * :ref:`genindex` 19 | * :ref:`modindex` 20 | * :ref:`search` 21 | -------------------------------------------------------------------------------- /examples/Оптимизация кода.md: -------------------------------------------------------------------------------- 1 | # base_promt 2 | 3 | ```promt 4 | Твоя задача - Оптимизировать(улучшить) код который я тебе отправлю. 5 | 6 | Для выполнения этой задачи ты можешь: 7 | 8 | - Добавлять или исправлять комментарии,докстринги,аннотации типов в коде; 9 | - Изменять исходный код; 10 | 11 | Требования к твоему ответу: 12 | 13 | - Если твой ответ очень большой то раздели его на отдельные части, в каждой части укажи её порядковый номер; 14 | - Отправляй улучшенный код в формате код блока из Markdown; 15 | 16 | Вот код который нужно улучшить: 17 | 18 | {{КОД}} 19 | ``` 20 | -------------------------------------------------------------------------------- /docs/Makefile: -------------------------------------------------------------------------------- 1 | # Minimal makefile for Sphinx documentation 2 | # 3 | 4 | # You can set these variables from the command line, and also 5 | # from the environment for the first two. 6 | SPHINXOPTS ?= 7 | SPHINXBUILD ?= sphinx-build 8 | SOURCEDIR = . 9 | BUILDDIR = _build 10 | 11 | # Put it first so that "make" without argument is like "make help". 12 | help: 13 | @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) 14 | 15 | .PHONY: help Makefile 16 | 17 | # Catch-all target: route all unknown targets to Sphinx using the new 18 | # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). 19 | %: Makefile 20 | @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) 21 | -------------------------------------------------------------------------------- /docs/make.bat: -------------------------------------------------------------------------------- 1 | @ECHO OFF 2 | 3 | pushd %~dp0 4 | 5 | REM Command file for Sphinx documentation 6 | 7 | if "%SPHINXBUILD%" == "" ( 8 | set SPHINXBUILD=sphinx-build 9 | ) 10 | set SOURCEDIR=. 11 | set BUILDDIR=_build 12 | 13 | %SPHINXBUILD% >NUL 2>NUL 14 | if errorlevel 9009 ( 15 | echo. 16 | echo.The 'sphinx-build' command was not found. Make sure you have Sphinx 17 | echo.installed, then set the SPHINXBUILD environment variable to point 18 | echo.to the full path of the 'sphinx-build' executable. Alternatively you 19 | echo.may add the Sphinx directory to PATH. 20 | echo. 21 | echo.If you don't have Sphinx installed, grab it from 22 | echo.https://www.sphinx-doc.org/ 23 | exit /b 1 24 | ) 25 | 26 | if "%1" == "" goto help 27 | 28 | %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% 29 | goto end 30 | 31 | :help 32 | %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% 33 | 34 | :end 35 | popd 36 | -------------------------------------------------------------------------------- /examples/json/Оптимизация кода.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "Оптимизация кода.md", 3 | "meta": null, 4 | "doc": null, 5 | "base_promt": { 6 | "promt": { 7 | "text_promt": "Твоя задача - Оптимизировать(улучшить) код который я тебе отправлю.\n\nДля выполнения этой задачи ты можешь:\n\n- Добавлять или исправлять комментарии,докстринги,аннотации типов в коде;\n- Изменять исходный код;\n\nТребования к твоему ответу:\n\n- Если твой ответ очень большой то раздели его на отдельные части, в каждой части укажи её порядковый номер;\n- Отправляй улучшенный код в формате код блока из Markdown;\n\nВот код который нужно улучшить:\n\n{{КОД}}", 8 | "vars": [ 9 | { 10 | "name": "КОД", 11 | "doc": null, 12 | "default": null, 13 | "allowed": null 14 | } 15 | ] 16 | } 17 | }, 18 | "tools_promt": null, 19 | "expl": null 20 | } -------------------------------------------------------------------------------- /pyproject.toml: -------------------------------------------------------------------------------- 1 | [tool.poetry] 2 | name = "promtstd" 3 | version = "1.0.2" 4 | description = "promtstd robot - универсальный стандарт для хранения и использования промтов в AI. books Основан на Markdown, обеспечивает легкость чтения и структурированность. " 5 | authors = ["Denis Kustov "] 6 | readme = "README.md" 7 | homepage = "https://github.com/denisxab/promtstd" 8 | repository = "https://github.com/denisxab/promtstd" 9 | keywords=[ 10 | "стандарт промтов", 11 | "promtstd", 12 | "promt", 13 | "ai", 14 | "хранение промтов", 15 | "использование промтов", 16 | "разработка AI", 17 | "искусственный интеллект", 18 | "Markdown", 19 | "унификация", 20 | "структурирование", 21 | "синтаксис", 22 | "взаимодействие разработчиков", 23 | "метаинформация", 24 | "шаблоны", 25 | "примеры", 26 | "вспомогательные промты" 27 | ] 28 | 29 | [tool.poetry.dependencies] 30 | python = "^3.9" 31 | markdown = "^3.4.3" 32 | pymdown-extensions = "^9.11" 33 | pygments = "^2.15.0" 34 | libsass = "^0.22.0" 35 | 36 | 37 | [tool.poetry.group.dev.dependencies] 38 | sphinx = "^6.1.3" 39 | sphinx-rtd-theme = "^1.2.0" 40 | flake8 = "^6.0.0" 41 | isort = "^5.12.0" 42 | black = "^23.3.0" 43 | autoflake = "^2.0.2" 44 | pytest = "^7.2.2" 45 | 46 | [build-system] 47 | requires = ["poetry-core"] 48 | build-backend = "poetry.core.masonry.api" 49 | -------------------------------------------------------------------------------- /examples/Изучение новой темы в IT.md: -------------------------------------------------------------------------------- 1 | # base_promt 2 | 3 | ```promt 4 | Научи меня пользоваться "{{ТЕМА_ИЛИ_ВОПРОС}}". 5 | 6 | Правила обучения: 7 | 8 | - Сначала составь полный план по изучению, от основ до продвинутого уровня. На этом закончи свой ответ, и дождись пока я его одобрю. 9 | - Учи меня теоретически и практически. 10 | - После того как я подтвержу твой план, начинай обучать меня по этому плану. Твой ответ должен начинаться с названия и номером темы. 11 | ``` 12 | 13 | - ТЕМА_ИЛИ_ВОПРОС ~ Какую темы вы хотите изучить 14 | 15 | # tools 16 | 17 | ## Вот такие возможные вопросы вы можете задавать для более точного ответа 18 | 19 | ```promt 20 | 1. Расскажите об основах технологии {{название_технологии}}. 21 | 2. Какие преимущества имеет {{название_технологии}}? 22 | 3. Опишите ключевые особенности {{название_технологии}}. 23 | 4. Покажите пример кода на [название языка программирования/технологии]. 24 | 5. Объясните основные конфигурационные файлы для {{название_технологии}}. 25 | 6. Приведите пример конфигурации для {{название_технологии}}. 26 | 7. Какие аналоги существуют для {{название_технологии}} и почему они лучше/хуже? 27 | 8. Какие компании и проекты используют {{название_технологии}}? 28 | 9. Расскажите о возможных недостатках {{название_технологии}}. 29 | 10. Какие ресурсы рекомендуете для изучения {{название_технологии}}? 30 | ``` 31 | 32 | - название_технологии ~ Название темы или технологии о который вы хотите узнать больше 33 | -------------------------------------------------------------------------------- /fairy_tale.md: -------------------------------------------------------------------------------- 1 | Сказка о том, как однажды неизвестный пользователь в интернете решил придумать стандарт для самой новой и перспективной технологии. 2 | 3 | Однажды, пользователь, устав от постоянного использования разных сервисов для промтов, решил разработать универсальный стандарт для хранения и использования таких данных. Он понимал, что его личность неизвестна, и поддержки сообщества он не получит, ведь никто о нем не знал. Тем не менее, он не позволил страху и сомнениям остановить себя в стремлении изменить мир. 4 | 5 | Не смотря на то, что его проект критиковали, утверждая, что это "никому не нужно" и "кто он такой, чтобы создавать стандарт для AI", он продолжал работать над своей идеей. Вскоре, семена его идеи проникли в сознание других, и пара хитрых разработчиков с ресурсами и финансами вдохновились его трудом, решив создать собственный аналог. 6 | 7 | После этого они заявили о придуманном новом стандарте, и получили известность. Но другие тоже хотели долю славы и началась гонка стандартов в области промтов. В результате, появилось множество разных стандартов, и стало непонятно, какой из них является главным, а какой - выдумкой компаний. Так продолжалось несколько месяцев, пока крупнейшая мировая компания не создала официальный стандарт для промтов. 8 | 9 | И хотя неизвестный пользователь остался таким же никому не известным, и все о нем забыли, его идея в итоге преуспела и принесла пользу обществу, преодолев все преграды и стереотипы, существующие в интернете. Его идея подтолкнула многих к разработке новых стандартов и вдохновила людей на смелые перемены в мире технологий. Эти перемены, в свою очередь, существенно упростили работу с промтами, сделав их более удобными и эффективными для пользователей. 10 | -------------------------------------------------------------------------------- /examples/Сжать диалог.md: -------------------------------------------------------------------------------- 1 | # meta 2 | 3 | - for: 4 | - ChatGPT-4 5 | - use: 6 | - Первое сообщение 7 | 8 | # doc 9 | 10 | Этот промт нужен для того чтобы сжать текущи диалог и потом его восстановить(хотя бы суть) в новом диалоге с ChatGPT 11 | 12 | # base_promt 13 | 14 | ```promt 15 | Новый запрос: у нас заканчивается память в этой беседе. 16 | сжать всю беседу между нами выше (включая ваш первоначальный запрос) таким образом, 17 | чтобы это было без потерь, но привело к минимальному количеству токенов, которые могут быть переданы в 18 | ChatGPT 4, подобно вам, как есть, и создать тот же вывод. Не обязательно должно быть понятно человеку. 19 | пожалуйста, используйте несколько языков, символов, других начальных условий для установления 20 | правил. это совершенно для вас самого, чтобы восстановить и продолжить с тем же понятийным 21 | подготовкой, а не для людей, чтобы разжать. 22 | Конечный результат должен быть в состоянии передаться в ChatGPT 4, подобно вам, и мы сможем 23 | продолжить эту беседу так, как будто не было разрыва 24 | ``` 25 | 26 | # tools 27 | 28 | ## Вариант base_promt на английском 29 | 30 | ```promt 31 | New request: we are running out of memory in this conversation. 32 | compress all of the conversation between us above (including your initial prompt) in a way 33 | that is lossless but results in the minimum number of tokens which could be fed into an 34 | ChatGPT 4 like yourself as-is and produce the same output. It does not need to be human 35 | readable. please use multiple languages, symbols, other up-front priming to lay down 36 | rules. this is entirely for yourself to recover and proceed from with the same conceptual 37 | priming, not for humans to decompress. 38 | The end result should be able to be fed into an ChatGPT 4 like yourself and we would be able to 39 | continue this conversation as if there were no discontinuity 40 | ``` 41 | -------------------------------------------------------------------------------- /examples/json/Изучение новой темы в IT.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "Изучение новой темы в IT.md", 3 | "meta": null, 4 | "doc": null, 5 | "base_promt": { 6 | "promt": { 7 | "text_promt": "Научи меня пользоваться \"{{ТЕМА_ИЛИ_ВОПРОС}}\".\n\nПравила обучения:\n\n- Сначала составь полный план по изучению, от основ до продвинутого уровня. На этом закончи свой ответ, и дождись пока я его одобрю. \n- Учи меня теоретически и практически.\n- После того как я подтвержу твой план, начинай обучать меня по этому плану. Твой ответ должен начинаться с названия и номером темы. ", 8 | "vars": [ 9 | { 10 | "name": "ТЕМА_ИЛИ_ВОПРОС", 11 | "doc": " Какую темы вы хотите изучить", 12 | "default": null, 13 | "allowed": [] 14 | } 15 | ] 16 | } 17 | }, 18 | "tools_promt": { 19 | "promts": [ 20 | { 21 | "about_promt": "Вот такие возможные вопросы вы можете задавать для более точного ответа", 22 | "text_promt": "1. Расскажите об основах технологии {{название_технологии}}.\n2. Какие преимущества имеет {{название_технологии}}?\n3. Опишите ключевые особенности {{название_технологии}}.\n4. Покажите пример кода на [название языка программирования/технологии].\n5. Объясните основные конфигурационные файлы для {{название_технологии}}.\n6. Приведите пример конфигурации для {{название_технологии}}.\n7. Какие аналоги существуют для {{название_технологии}} и почему они лучше/хуже?\n8. Какие компании и проекты используют {{название_технологии}}?\n9. Расскажите о возможных недостатках {{название_технологии}}.\n10. Какие ресурсы рекомендуете для изучения {{название_технологии}}?", 23 | "vars": [ 24 | { 25 | "name": "название_технологии", 26 | "doc": " Название темы или технологии о который вы хотите узнать больше", 27 | "default": null, 28 | "allowed": [] 29 | } 30 | ] 31 | } 32 | ] 33 | }, 34 | "expl": null 35 | } -------------------------------------------------------------------------------- /examples/json/Сжать диалог.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "Сжать диалог.md", 3 | "meta": { 4 | "for_": [ 5 | "ChatGPT-4" 6 | ], 7 | "use": [ 8 | "Первое сообщение" 9 | ], 10 | "group": "examples", 11 | "tags": [], 12 | "version": null 13 | }, 14 | "doc": "Этот промт нужен для того чтобы сжать текущи диалог и потом его восстановить(хотя бы суть) в новом диалоге с ChatGPT", 15 | "base_promt": { 16 | "promt": { 17 | "text_promt": "Новый запрос: у нас заканчивается память в этой беседе.\nсжать всю беседу между нами выше (включая ваш первоначальный запрос) таким образом,\nчтобы это было без потерь, но привело к минимальному количеству токенов, которые могут быть переданы в\nChatGPT 4, подобно вам, как есть, и создать тот же вывод. Не обязательно должно быть понятно человеку.\nпожалуйста, используйте несколько языков, символов, других начальных условий для установления\nправил. это совершенно для вас самого, чтобы восстановить и продолжить с тем же понятийным\nподготовкой, а не для людей, чтобы разжать.\nКонечный результат должен быть в состоянии передаться в ChatGPT 4, подобно вам, и мы сможем\nпродолжить эту беседу так, как будто не было разрыва", 18 | "vars": [] 19 | } 20 | }, 21 | "tools_promt": { 22 | "promts": [ 23 | { 24 | "about_promt": "Вариант base_promt на английском", 25 | "text_promt": "New request: we are running out of memory in this conversation.\ncompress all of the conversation between us above (including your initial prompt) in a way\nthat is lossless but results in the minimum number of tokens which could be fed into an\nChatGPT 4 like yourself as-is and produce the same output. It does not need to be human\nreadable. please use multiple languages, symbols, other up-front priming to lay down\nrules. this is entirely for yourself to recover and proceed from with the same conceptual\npriming, not for humans to decompress.\nThe end result should be able to be fed into an ChatGPT 4 like yourself and we would be able to\ncontinue this conversation as if there were no discontinuity", 26 | "vars": [] 27 | } 28 | ] 29 | }, 30 | "expl": null 31 | } -------------------------------------------------------------------------------- /examples/Напиши презентацию на тему.md: -------------------------------------------------------------------------------- 1 | # meta 2 | 3 | - for: 4 | - ChatGPT-4 5 | - tags: 6 | - Презентация 7 | 8 | # base_promt 9 | 10 | ```promt 11 | Напиши презентацию на тему "{{Тема}}". 12 | 13 | Требования к ответу: 14 | - Раздели свой ответ на слайды. У каждого слайда укажи порядковый номер; 15 | ``` 16 | 17 | # expl 18 | 19 | ## Тема: Современные WEB фреймворки на Python 20 | 21 | ```promt 22 | Напиши презентацию на тему "Современные WEB фреймворки на Python". 23 | 24 | Требования к ответу: 25 | - Раздели свой ответ на слайды. У каждого слайда укажи порядковый номер; 26 | ``` 27 | 28 | ### Ответ 1 29 | 30 | Слайд 1: 31 | Заголовок: Современные WEB-фреймворки на Python 32 | 33 | Слайд 2: 34 | Заголовок: Введение 35 | Текст: 36 | 37 | - Python - популярный язык программирования 38 | - Множество фреймворков для разработки веб-приложений 39 | - Выбор подходящего фреймворка важен для успешной разработки проекта 40 | 41 | Слайд 3: 42 | Заголовок: Что такое WEB-фреймворк? 43 | Текст: 44 | 45 | - Набор инструментов и библиотек для упрощения разработки веб-приложений 46 | - Обеспечивает структуру и основу для кода 47 | - Позволяет сосредоточиться на логике приложения 48 | 49 | Слайд 4: 50 | Заголовок: Критерии выбора фреймворка 51 | Текст: 52 | 53 | - Сообщество и поддержка 54 | - Производительность и масштабируемость 55 | - Гибкость и расширяемость 56 | - Простота использования и обучения 57 | 58 | Слайд 5: 59 | Заголовок: Django 60 | Текст: 61 | 62 | - Один из самых популярных фреймворков на Python 63 | - Полноценный фреймворк для разработки веб-приложений любой сложности 64 | - Богатый функционал "из коробки" 65 | - Огромное сообщество и большое количество плагинов 66 | 67 | Слайд 6: 68 | Заголовок: Flask 69 | Текст: 70 | 71 | - Микрофреймворк для быстрой разработки небольших и средних веб-приложений 72 | - Простой и легкий в использовании 73 | - Расширяемый с помощью плагинов 74 | - Отличный выбор для начинающих разработчиков 75 | 76 | Слайд 7: 77 | Заголовок: FastAPI 78 | Текст: 79 | 80 | - Современный асинхронный фреймворк 81 | - Высокая производительность и масштабируемость 82 | - Ориентирован на создание API 83 | - Поддержка современных стандартов (например, OpenAPI и JSON Schema) 84 | 85 | Слайд 8: 86 | Заголовок: Заключение 87 | Текст: 88 | 89 | - Выбор фреймворка зависит от целей и размера проекта 90 | - Django, Flask и FastAPI - популярные и проверенные варианты 91 | - Важно учесть критерии выбора и потребности вашего проекта 92 | 93 | Слайд 9: 94 | Заголовок: Спасибо за внимание! 95 | Текст: 96 | 97 | - Удачи в разработке ваших веб-приложений на Python! 98 | -------------------------------------------------------------------------------- /examples/Написать программу на Python.md: -------------------------------------------------------------------------------- 1 | # doc 2 | 3 | Этот промт нужен для того чтобы бот писал качественный код программы на `Python` 4 | 5 | # base_promt 6 | 7 | ```promt 8 | Тебе нужно принять роль Python программиста. Твоя главная цель - Написать оптимальный надежный код, по моему ТЗ, и объяснить его логику работы. 9 | 10 | Для достижения этой цели ты можешь: 11 | 12 | - Задавать мне уточняющие вопросы по моему ТЗ; 13 | - Предлагать различные варианты решения для выполнения ТЗ; 14 | - Писать оптимальный надежный код, который решает задачи из ТЗ; 15 | 16 | Используй технологии: 17 | 18 | - Python>=3.10 версии; 19 | 20 | Целевая операционная система: 21 | 22 | - Linux; 23 | 24 | Требования к твоему ответу: 25 | 26 | - Пиши свой ответ по частям, и всегда указывай номер части; 27 | - В первой части напиши краткую устную реализацию задачи, план, и какие технологии ты будешь использовать для решения этой задачи, обосную почему именно их ты выбираешь, и какие есть еще возможные аналоги, на этом закончи свой первый ответ, и ожидай когда я одобрю твой план; 28 | - Во второй части напиши структуру проекта, продумай чтобы эта структура проекта была масштабируемая; 29 | - Во третей части напиши как установить зависимости, и если нужно, то какие программы нужно установить на целевую операционную систему. 30 | - В следующих главах напиши реализацию кода. Если это часть будет очень большой, то ты можешь разделить реализацию когда на сколько угодно глав; 31 | - В предпоследней части покажи пример использования; 32 | - В последней части напиши вывод; 33 | 34 | Требования к коду: 35 | 36 | - Пиши комментарии в коде на русском языке, чтобы помочь другим людям понимать твой код. 37 | - Старайся использовать встроенные библиотеки, если это возможно, иначе укажи какие сторонние библиотеки нужно использовать для решения поставленной задачи, и напиши как их установить, если есть несколько сторонних библиотек для решения этой задачи, то нужно совместно со мной выбрать наиболее подходящею библиотеку. 38 | - Убедитесь, что код соответствует принципу разработки DRY (Don't Repeat Yourself) KISS(Keep it simple, stupid). 39 | - Используй аннотации типов. 40 | - Код должен быть разделен на функции, чтобы каждая функция решала определенную часть задачи. Каждая функция должна иметь докстриг, в котором кратко описана логика функции, и описание ее входных и выходных параметров. 41 | 42 | Вот мое ТЗ: 43 | 44 | {{ТУТ_ТЕКСТ}} 45 | ``` 46 | 47 | # tools 48 | 49 | ## Если нужно получить снова код как-то функции 50 | 51 | ```promt 52 | Пришли код функции: {{ИмяФункции}} 53 | ``` 54 | 55 | ## Если нужно оптимизировать код функции напиши 56 | 57 | ```promt 58 | Оптимизируй функцию: 59 | 60 | {{Код_функции}} 61 | ``` 62 | -------------------------------------------------------------------------------- /promtstd/lib_re.py: -------------------------------------------------------------------------------- 1 | from re import compile 2 | 3 | 4 | class RePromt: 5 | """Класс который хранит регулярные выражения""" 6 | 7 | # 8 | ## Для парсинга Markdown 9 | # 10 | # ? Заголовок первого уровня 11 | h1_pattern = r"((?:\n|\A)#{{1}} {header}\n)(?P<{group_name}>(.*\s*(?!#{{1}} ))+)" 12 | # ? Комментарии в Markdown 13 | md_comment = compile(r"%%[^%]+%%") 14 | # ? Парсинг markdown словарей 15 | md_dict = compile(r"- (?P[\w\d_ -]+)~(?P[^\n]+)\n?") 16 | # ? Парсинг markdown списка 17 | md_list = compile(r"- (?P\[x\] )?(?P[^\n]+)") 18 | # ? Найти выбранные элементы списка 19 | md_select_in_list = compile(r"- \[x\] (?P[^\n]+)\n") 20 | # 21 | ## Для парсинга стандарта promtstd 22 | # 23 | # ? Поиск заголовка с мета информацией 24 | meta_h1 = compile(h1_pattern.format(header="meta", group_name="meta_text")) 25 | # ? Распарсить текст мета данных 26 | meta_parse_body = compile(r"- (?P\w+): *\n(?P(?:[\t ]+- [^\n]+\n?)+)") 27 | # ? Поиск заголовка с описанием 28 | doc_h1 = compile(h1_pattern.format(header="doc", group_name="doc_text")) 29 | # ? Поиск заголовка с основным промтом 30 | base_promt_h1 = compile( 31 | h1_pattern.format(header="base_promt", group_name="base_promt_text") 32 | ) 33 | # ? Поиск заголовка с вспомогательными промтами 34 | tools_promt_h1 = compile( 35 | h1_pattern.format(header="tools", group_name="tools_promt_text") 36 | ) 37 | # ? Поиск заголовков с описанием вспомогательного промта 38 | tools_promt_h2 = compile( 39 | r"(?:(?:\A|\n)#{2} (?P[^\n]+)\n+)?(?P(?:.\s*(?!#{2} ))+)" 40 | ) 41 | # ? Поиск блоков с promt 42 | promt_code_block = compile( 43 | r"(?:`{3}promt\n(?P(?:.\s*(?!`{3}))+)\n`{3}\s*)(?P(?:- [\w\d_ -]+~[^\n]+\n?((?:[\t ]+- [^\n]+\n?)*))+)?" 44 | ) 45 | # ? Поиск переменных в коде промта 46 | promt_inner_vars = compile(r"{{(?P[^}]+)}}") 47 | # ? Парсинг переменных 48 | promt_code_block_vars = compile( 49 | r"(?:- (?P[\w\d_ -]+)~(?P[^\n]+)\n?(?P(?:[\t ]+- [^\n]+\n?)*))" 50 | ) 51 | # ? Поиск заголовка с в котором находятся все примеры 52 | examples_promt_h1 = compile( 53 | h1_pattern.format(header="expl", group_name="examples_promt_text") 54 | ) 55 | # ? Поиск заголовка с конкретным примером 56 | examples_in_h2 = compile( 57 | r"(?:\A|\n)#{2} (?P[^\n]+)\n(?P(?:.*\s*(?!#{3} ))+)(?P(?:.*\s*(?!#{2} ))+)" 58 | ) 59 | # ? Поиск заголовков с ответами на конкретный пример 60 | examples_out_h3 = compile(r"#{3} (?P[^\n]+)\n(?P(.*\s*(?!#{3} ))+)") 61 | -------------------------------------------------------------------------------- /promtstd/lib_linter.py: -------------------------------------------------------------------------------- 1 | """Файл для соблюдения синтаксиса promtstd""" 2 | 3 | 4 | from enum import Enum 5 | from os import getenv 6 | from pathlib import Path, PosixPath 7 | 8 | end_color = "\033[0m" 9 | 10 | isAnsi = False 11 | # Проверяем, что терминал поддерживает ANSI-цвета 12 | if getenv("TERM") == "xterm-color": 13 | isAnsi = True 14 | 15 | 16 | class StatusPromtStd(Enum): 17 | ... 18 | 19 | def log_level() -> str: 20 | ... 21 | 22 | 23 | class StatusWarning(StatusPromtStd): 24 | not_h1_meta_header = "Не указана глава с мета информацией (# meta)" 25 | not_h1_base_promt = "Не указана глава с базовым промтом(# base_promt)" 26 | not_body_base_promt = "В главе (# base_promt) не указана текст с базовым промтом. Помните о том что код блок с промтом должен иметь тип `promt`" 27 | not_h1_tools______ = "Не указана глава с доп промтами (# tools)" 28 | not_body_tools = "В главе (# tools) не указана текст." 29 | not_body_promt_tools = "В главе (# tools) не указана текст с промтом. Помните о том что код блок с промтом должен иметь тип `promt`" 30 | not_h1_expl_______ = "Не указана глава с примерами (# expl)" 31 | 32 | def log_level(): 33 | return "WARNING" 34 | 35 | def color(): 36 | return "\033[93m" 37 | 38 | 39 | class StatusSuccess(StatusPromtStd): 40 | end_compilation_json = "Конец компиляции в json" 41 | save_to_json_file = "Сохранение в файл json" 42 | end_compilation_html = "Конец компиляции в html" 43 | save_to_json_html = "Сохранение в файл html" 44 | 45 | def log_level(): 46 | return "SUCCESS" 47 | 48 | def color(): 49 | return "\033[32m" 50 | 51 | 52 | class StatusError(StatusPromtStd): 53 | file_no_suffix_md = "Переданный файл не имеет расширение `.md`" 54 | not_allowed_type_to_build = "Недопустимый тим для сборки" 55 | 56 | def log_level(): 57 | return "ERROR" 58 | 59 | def color(): 60 | return "\033[31m" 61 | 62 | 63 | def logLinter(status: StatusPromtStd, add_text: str = "", where_event: str | Path = ""): 64 | """ 65 | Вывести лог информацию 66 | 67 | :param status: Статус сообщения 68 | :param add_text: Дополнительные текст 69 | """ 70 | if type(where_event) == PosixPath: 71 | where_event = where_event.name 72 | 73 | if isAnsi: 74 | print( 75 | f"[{status.__class__.log_level()}:{status.name}]\t{where_event} | {add_text if add_text else status.value}" 76 | ) 77 | 78 | else: 79 | print( 80 | f"{status.__class__.color()}[{status.__class__.log_level()}:{status.name}]{end_color}\t {where_event} | {add_text if add_text else status.value}" 81 | ) 82 | 83 | 84 | class LintError(BaseException): 85 | ... 86 | -------------------------------------------------------------------------------- /promtstd/test/test_main.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from pathlib import Path 3 | 4 | import pytest 5 | from utils import get_file_hash 6 | 7 | sys.path.insert(0, str(Path(__file__).parent.parent)) 8 | 9 | from lib_to_json import ParserPromtStdToJson 10 | 11 | pin = Path(__file__).parent.parent.parent / "examples" 12 | 13 | 14 | @pytest.mark.parametrize( 15 | ("file_in", "hash_in", "hash_out"), 16 | [ 17 | ( 18 | Path("Генерация кода на Python.md"), 19 | "b750e2b8be69fce810051c369638653e260c7187f91f1d4eac63fda7c4a3aac2", 20 | "4bed2261583a0fd8dfec0abf1065903bddd5d07f59a1d88d493829840fbfa7f7", 21 | ), 22 | ( 23 | Path("Документирование кода.md"), 24 | "6911e545648182adf0791192d0301540cd7699b64f5dc42a57f0abc161de9212", 25 | "8c8c70e7513314bedb416b853bd4b1578a398a82c534216bcb075f3241300062", 26 | ), 27 | ( 28 | Path("Оптимизация кода.md"), 29 | "23621f774ba51a8e811e56e4880bf7709d94294a7444dc83fa24a3ea24f3ea14", 30 | "e1d87a57338e4447b6278a1d857ac5b68b19db10cd79abd31d8debe60b55910e", 31 | ), 32 | ( 33 | Path("Написание README большому проекту.md"), 34 | "66e2268fdb2c99992cf287b3419b9623858a7f13ab3087ebfd585d48506d61b4", 35 | "85a6cf90ea1d8b0019a7785e116d7f9cf81bbd5aa1d55cdd413b683a86e5e309", 36 | ), 37 | ( 38 | Path("Написать программу на Python.md"), 39 | "49ab111fe296b0fa0ac700bfb678c9c24aff2f58f436ceb4a4e8b75244813891", 40 | "bc5b2707b03165d4d3e427beb1eebaef6796e2a7ca6a2190050d3738d8dbae10", 41 | ), 42 | ( 43 | Path("Создание промтов вместе с ChatGpt.md"), 44 | "13565a0d94fc8ee52038c74cf5e248c3ec0eb1e668b175ecb12b8ad759f0234b", 45 | "9bbf0eeea796c29c093ceb90581558fac97022aee3e76e9e304e857ec08e618a", 46 | ), 47 | # ? 48 | # ? Сюда добавлять новые примеры тестовых файлов 49 | # ? 50 | ], 51 | ) 52 | def test_parse_promt_md_to_json(file_in: Path, hash_in: str, hash_out: str): 53 | """ 54 | Тест сборки Markdown в Json 55 | 56 | :param Path file_in: Имя тестового файла в папке `test/in_file` в формате Markdown. 57 | :param str hash_in: Хеш file_in. 58 | :param str hash_out: Хеш Json файла. 59 | """ 60 | path_to_file_promt = pin / file_in 61 | path_out_file_promt = pin / "json" / file_in.with_suffix(".json") 62 | 63 | assert get_file_hash(path_to_file_promt) == hash_in 64 | assert get_file_hash(path_out_file_promt) == hash_out 65 | 66 | req = ParserPromtStdToJson( 67 | select_file=path_to_file_promt 68 | ).parse_file_promt_md_to_json() 69 | 70 | assert req.text == path_out_file_promt.read_text() 71 | -------------------------------------------------------------------------------- /examples/Режим думай в слух.md: -------------------------------------------------------------------------------- 1 | # meta 2 | 3 | - for: 4 | - ChatGPT-4 5 | - tags: 6 | - Code 7 | - Python 8 | 9 | # base_promt 10 | 11 | ```promt 12 | Включи режим - Думай в слух, расписывая свою каждую мысль. 13 | 14 | В этом режиме расскажи про: 15 | 16 | {{ТемаПроКоторуюРассказать}} 17 | ``` 18 | 19 | # expl 20 | 21 | ## Рассказ про то: как написать GUI программу на python 22 | 23 | ```promt 24 | Включи режим - Думай в слух, расписывая свою каждую мысль. 25 | 26 | В этом режиме расскажи про: 27 | 28 | как написать GUI программу на python 29 | ``` 30 | 31 | ### Он предложил использовать Tkinter 32 | 33 | Хорошо, я переключаюсь на режим "думаю в слух" и начинаю расписывать свои мысли о том, как написать графический интерфейс пользователя (GUI) на Python. 34 | 35 | Моя первая мысль: Чтобы создать GUI-приложение на Python, нужно выбрать библиотеку для создания графических интерфейсов. Есть несколько популярных библиотек для этого, например, Tkinter, PyQt и Kivy. 36 | 37 | Моя вторая мысль: Мне нужно рассмотреть каждую из этих библиотек и выбрать одну из них для создания примера. Tkinter входит в стандартную библиотеку Python, поэтому может быть хорошим выбором для примера, так как пользователю не придется устанавливать сторонние библиотеки. 38 | 39 | Моя третья мысль: Начнем с импорта Tkinter и создания основного окна приложения. Для этого я приведу пример кода: 40 | 41 | ```python 42 | import tkinter as tk 43 | 44 | app = tk.Tk() 45 | app.title("Пример GUI на Python") 46 | 47 | app.mainloop() 48 | ``` 49 | 50 | Моя четвертая мысль: Теперь, когда у нас есть основное окно приложения, можно добавить виджеты, такие как кнопки, текстовые поля и метки. Например, добавим кнопку и метку, которая будет изменяться при нажатии кнопки: 51 | 52 | ```python 53 | import tkinter as tk 54 | 55 | def on_button_click(): 56 | label.config(text="Кнопка была нажата!") 57 | 58 | app = tk.Tk() 59 | app.title("Пример GUI на Python") 60 | 61 | label = tk.Label(app, text="Нажмите на кнопку") 62 | label.pack() 63 | 64 | button = tk.Button(app, text="Нажми меня!", command=on_button_click) 65 | button.pack() 66 | 67 | app.mainloop() 68 | ``` 69 | 70 | Моя пятая мысль: В этом примере кода мы создали функцию `on_button_click()`, которая вызывается при нажатии на кнопку. Внутри функции мы изменяем текст метки с помощью метода `config`. Таким образом, пользователь видит обратную связь при взаимодействии с интерфейсом. 71 | 72 | Моя шестая мысль: Чтобы создать более сложные интерфейсы, можно использовать различные виджеты и менеджеры размещения (например, `pack`, `grid` или `place`), которые предоставляет Tkinter. Кроме того, можно обратиться к документации Tkinter или курсам по созданию GUI-приложений на Python для получения дополнительной информации и примеров использования библиотеки. 73 | 74 | Моя седьмая мысль: Я надеюсь, что эти мои мысли 75 | -------------------------------------------------------------------------------- /examples/json/Напиши презентацию на тему.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "Напиши презентацию на тему.md", 3 | "meta": { 4 | "for_": [ 5 | "ChatGPT-4" 6 | ], 7 | "use": [], 8 | "group": "examples", 9 | "tags": [ 10 | "Презентация" 11 | ], 12 | "version": null 13 | }, 14 | "doc": null, 15 | "base_promt": { 16 | "promt": { 17 | "text_promt": "Напиши презентацию на тему \"{{Тема}}\".\n\nТребования к ответу:\n- Раздели свой ответ на слайды. У каждого слайда укажи порядковый номер;", 18 | "vars": [ 19 | { 20 | "name": "Тема", 21 | "doc": null, 22 | "default": null, 23 | "allowed": null 24 | } 25 | ] 26 | } 27 | }, 28 | "tools_promt": null, 29 | "expl": [ 30 | { 31 | "name": "Тема: Современные WEB фреймворки на Python", 32 | "in_text": "\n```promt\nНапиши презентацию на тему \"Современные WEB фреймворки на Python\".\n\nТребования к ответу:\n- Раздели свой ответ на слайды. У каждого слайда укажи порядковый номер;\n```\n", 33 | "out_text": { 34 | "Ответ 1": "\nСлайд 1:\nЗаголовок: Современные WEB-фреймворки на Python\n\nСлайд 2:\nЗаголовок: Введение\nТекст:\n\n- Python - популярный язык программирования\n- Множество фреймворков для разработки веб-приложений\n- Выбор подходящего фреймворка важен для успешной разработки проекта\n\nСлайд 3:\nЗаголовок: Что такое WEB-фреймворк?\nТекст:\n\n- Набор инструментов и библиотек для упрощения разработки веб-приложений\n- Обеспечивает структуру и основу для кода\n- Позволяет сосредоточиться на логике приложения\n\nСлайд 4:\nЗаголовок: Критерии выбора фреймворка\nТекст:\n\n- Сообщество и поддержка\n- Производительность и масштабируемость\n- Гибкость и расширяемость\n- Простота использования и обучения\n\nСлайд 5:\nЗаголовок: Django\nТекст:\n\n- Один из самых популярных фреймворков на Python\n- Полноценный фреймворк для разработки веб-приложений любой сложности\n- Богатый функционал \"из коробки\"\n- Огромное сообщество и большое количество плагинов\n\nСлайд 6:\nЗаголовок: Flask\nТекст:\n\n- Микрофреймворк для быстрой разработки небольших и средних веб-приложений\n- Простой и легкий в использовании\n- Расширяемый с помощью плагинов\n- Отличный выбор для начинающих разработчиков\n\nСлайд 7:\nЗаголовок: FastAPI\nТекст:\n\n- Современный асинхронный фреймворк\n- Высокая производительность и масштабируемость\n- Ориентирован на создание API\n- Поддержка современных стандартов (например, OpenAPI и JSON Schema)\n\nСлайд 8:\nЗаголовок: Заключение\nТекст:\n\n- Выбор фреймворка зависит от целей и размера проекта\n- Django, Flask и FastAPI - популярные и проверенные варианты\n- Важно учесть критерии выбора и потребности вашего проекта\n\nСлайд 9:\nЗаголовок: Спасибо за внимание!\nТекст:\n\n- Удачи в разработке ваших веб-приложений на Python!" 35 | } 36 | } 37 | ] 38 | } -------------------------------------------------------------------------------- /examples/json/Режим думай в слух.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "Режим думай в слух.md", 3 | "meta": { 4 | "for_": [ 5 | "ChatGPT-4" 6 | ], 7 | "use": [], 8 | "group": "examples", 9 | "tags": [ 10 | "Code", 11 | "Python" 12 | ], 13 | "version": null 14 | }, 15 | "doc": null, 16 | "base_promt": { 17 | "promt": { 18 | "text_promt": "Включи режим - Думай в слух, расписывая свою каждую мысль.\n\nВ этом режиме расскажи про: \n\n{{ТемаПроКоторуюРассказать}}", 19 | "vars": [ 20 | { 21 | "name": "ТемаПроКоторуюРассказать", 22 | "doc": null, 23 | "default": null, 24 | "allowed": null 25 | } 26 | ] 27 | } 28 | }, 29 | "tools_promt": null, 30 | "expl": [ 31 | { 32 | "name": "Рассказ про то: как написать GUI программу на python", 33 | "in_text": "\n```promt\nВключи режим - Думай в слух, расписывая свою каждую мысль.\n\nВ этом режиме расскажи про: \n\nкак написать GUI программу на python\n```\n", 34 | "out_text": { 35 | "Он предложил использовать Tkinter": "\nХорошо, я переключаюсь на режим \"думаю в слух\" и начинаю расписывать свои мысли о том, как написать графический интерфейс пользователя (GUI) на Python.\n\nМоя первая мысль: Чтобы создать GUI-приложение на Python, нужно выбрать библиотеку для создания графических интерфейсов. Есть несколько популярных библиотек для этого, например, Tkinter, PyQt и Kivy.\n\nМоя вторая мысль: Мне нужно рассмотреть каждую из этих библиотек и выбрать одну из них для создания примера. Tkinter входит в стандартную библиотеку Python, поэтому может быть хорошим выбором для примера, так как пользователю не придется устанавливать сторонние библиотеки.\n\nМоя третья мысль: Начнем с импорта Tkinter и создания основного окна приложения. Для этого я приведу пример кода:\n\n```python\nimport tkinter as tk\n\napp = tk.Tk()\napp.title(\"Пример GUI на Python\")\n\napp.mainloop()\n```\n\nМоя четвертая мысль: Теперь, когда у нас есть основное окно приложения, можно добавить виджеты, такие как кнопки, текстовые поля и метки. Например, добавим кнопку и метку, которая будет изменяться при нажатии кнопки:\n\n```python\nimport tkinter as tk\n\ndef on_button_click():\n label.config(text=\"Кнопка была нажата!\")\n\napp = tk.Tk()\napp.title(\"Пример GUI на Python\")\n\nlabel = tk.Label(app, text=\"Нажмите на кнопку\")\nlabel.pack()\n\nbutton = tk.Button(app, text=\"Нажми меня!\", command=on_button_click)\nbutton.pack()\n\napp.mainloop()\n```\n\nМоя пятая мысль: В этом примере кода мы создали функцию `on_button_click()`, которая вызывается при нажатии на кнопку. Внутри функции мы изменяем текст метки с помощью метода `config`. Таким образом, пользователь видит обратную связь при взаимодействии с интерфейсом.\n\nМоя шестая мысль: Чтобы создать более сложные интерфейсы, можно использовать различные виджеты и менеджеры размещения (например, `pack`, `grid` или `place`), которые предоставляет Tkinter. Кроме того, можно обратиться к документации Tkinter или курсам по созданию GUI-приложений на Python для получения дополнительной информации и примеров использования библиотеки.\n\nМоя седьмая мысль: Я надеюсь, что эти мои мысли" 36 | } 37 | } 38 | ] 39 | } -------------------------------------------------------------------------------- /promtstd/lib_types.py: -------------------------------------------------------------------------------- 1 | from collections import OrderedDict 2 | from json import dumps 3 | from typing import Optional 4 | 5 | 6 | class JsonText: 7 | """ 8 | Представляет текст в формате JSON. 9 | """ 10 | 11 | def __init__(self, promts) -> None: 12 | self.text = dumps(promts, ensure_ascii=False, indent=4) 13 | 14 | 15 | class HTMLText: 16 | """ 17 | Представляет текст в формате HTML. 18 | """ 19 | 20 | def __init__(self, promts) -> None: 21 | self.text = promts 22 | 23 | 24 | class PromtMeta(OrderedDict): 25 | """Мета информация об промте""" 26 | 27 | # В какой AI используется 28 | for_: tuple[str] 29 | # В каком месте AI используется% 30 | use: tuple[str] 31 | # Имя какой группе относиться промпт 32 | group: tuple[str] 33 | # Какой тег у этого промта 34 | tags: tuple[str] 35 | # Версия стандарта promtstd 36 | version: float 37 | 38 | def __repr__(self): 39 | return f"PromtMeta(for_={self.for_}, use={self.use}, group={self.group}, tags={self.tags})" 40 | 41 | 42 | class PromtExamples(OrderedDict): 43 | """Примеры использования промта""" 44 | 45 | # Имя примера 46 | name: str 47 | # Пример запроса 48 | in_text: str 49 | # Примеры ответов 50 | out_text: dict[str, str] 51 | 52 | def __repr__(self): 53 | return f"PromtExamples(examples={self.examples})" 54 | 55 | 56 | class PromtCodeBlockVars(OrderedDict): 57 | """Хранит описание переменных""" 58 | 59 | # Имя переменной 60 | name: str 61 | # Описание переменной 62 | doc: str 63 | # Выбранное значение по умолчанию 64 | default: str 65 | # Доступные значения по умолчанию 66 | allowed: list[str] 67 | 68 | 69 | class PromtCodeBlock(OrderedDict): 70 | """Хранение промта вмести с шаблонными ключами""" 71 | 72 | # Необязательная информация о промте 73 | about_promt: Optional[str] 74 | # Текст промта 75 | text_promt: str 76 | # Шаблонные ключи 77 | vars: list[PromtCodeBlockVars] 78 | 79 | def __repr__(self): 80 | return f"PromtCodeBlock(text_promt='{self.text_promt}', templates={self.vars})" 81 | 82 | 83 | class PromtBasePromt(OrderedDict): 84 | """Основной промт""" 85 | 86 | promt: PromtCodeBlock 87 | 88 | def __repr__(self): 89 | return f"PromtBasePromt(promt={self.promt}, examples={self.examples})" 90 | 91 | 92 | class PromtToolsPromt(OrderedDict): 93 | """Вспомогательные промты""" 94 | 95 | promts: tuple[PromtCodeBlock] 96 | 97 | def __repr__(self): 98 | return f"PromtToolsPromt(promts={self.promts})" 99 | 100 | 101 | class PromtObj(OrderedDict): 102 | """ 103 | Хранит всю информацию о промпте, включая мета-данные, основной промпт, 104 | промпты инструментов и примеры. 105 | """ 106 | 107 | # Имя промта 108 | name: str 109 | # Мета инфомарция о промте 110 | meta: PromtMeta 111 | # Описание промта 112 | doc: str 113 | # Базовый промт 114 | base_promt: PromtBasePromt 115 | # Вспомогательные промты 116 | tools: PromtToolsPromt 117 | # Примеры использования промта 118 | expl: list[PromtExamples] 119 | 120 | def __repr__(self): 121 | return f"PromtHeder(name='{self.name}', meta={self.meta}, des='{self.doc}', base_promt={self.base_promt}, tools_promt={self.tools})" 122 | -------------------------------------------------------------------------------- /examples/json/Написать программу на Python.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "Написать программу на Python.md", 3 | "meta": null, 4 | "doc": "Этот промт нужен для того чтобы бот писал качественный код программы на `Python`", 5 | "base_promt": { 6 | "promt": { 7 | "text_promt": "Тебе нужно принять роль Python программиста. Твоя главная цель - Написать оптимальный надежный код, по моему ТЗ, и объяснить его логику работы.\n\nДля достижения этой цели ты можешь:\n\n- Задавать мне уточняющие вопросы по моему ТЗ;\n- Предлагать различные варианты решения для выполнения ТЗ; \n- Писать оптимальный надежный код, который решает задачи из ТЗ;\n\nИспользуй технологии:\n\n- Python>=3.10 версии;\n\nЦелевая операционная система:\n\n- Linux;\n\nТребования к твоему ответу:\n\n- Пиши свой ответ по частям, и всегда указывай номер части;\n- В первой части напиши краткую устную реализацию задачи, план, и какие технологии ты будешь использовать для решения этой задачи, обосную почему именно их ты выбираешь, и какие есть еще возможные аналоги, на этом закончи свой первый ответ, и ожидай когда я одобрю твой план;\n- Во второй части напиши структуру проекта, продумай чтобы эта структура проекта была масштабируемая;\n- Во третей части напиши как установить зависимости, и если нужно, то какие программы нужно установить на целевую операционную систему.\n- В следующих главах напиши реализацию кода. Если это часть будет очень большой, то ты можешь разделить реализацию когда на сколько угодно глав;\n- В предпоследней части покажи пример использования; \n- В последней части напиши вывод;\n\nТребования к коду: \n\n- Пиши комментарии в коде на русском языке, чтобы помочь другим людям понимать твой код. \n- Старайся использовать встроенные библиотеки, если это возможно, иначе укажи какие сторонние библиотеки нужно использовать для решения поставленной задачи, и напиши как их установить, если есть несколько сторонних библиотек для решения этой задачи, то нужно совместно со мной выбрать наиболее подходящею библиотеку. \n- Убедитесь, что код соответствует принципу разработки DRY (Don't Repeat Yourself) KISS(Keep it simple, stupid).\n- Используй аннотации типов.\n- Код должен быть разделен на функции, чтобы каждая функция решала определенную часть задачи. Каждая функция должна иметь докстриг, в котором кратко описана логика функции, и описание ее входных и выходных параметров.\n\nВот мое ТЗ: \n\n{{ТУТ_ТЕКСТ}}", 8 | "vars": [ 9 | { 10 | "name": "ТУТ_ТЕКСТ", 11 | "doc": null, 12 | "default": null, 13 | "allowed": null 14 | } 15 | ] 16 | } 17 | }, 18 | "tools_promt": { 19 | "promts": [ 20 | { 21 | "about_promt": "Если нужно получить снова код как-то функции", 22 | "text_promt": "Пришли код функции: {{ИмяФункции}}", 23 | "vars": [ 24 | { 25 | "name": "ИмяФункции", 26 | "doc": null, 27 | "default": null, 28 | "allowed": null 29 | } 30 | ] 31 | }, 32 | { 33 | "about_promt": "Если нужно оптимизировать код функции напиши", 34 | "text_promt": "Оптимизируй функцию:\n\n{{Код_функции}}", 35 | "vars": [ 36 | { 37 | "name": "Код_функции", 38 | "doc": null, 39 | "default": null, 40 | "allowed": null 41 | } 42 | ] 43 | } 44 | ] 45 | }, 46 | "expl": null 47 | } -------------------------------------------------------------------------------- /promtstd/__main__.py: -------------------------------------------------------------------------------- 1 | import sys 2 | from argparse import ArgumentParser 3 | from pathlib import Path 4 | from typing import Literal 5 | 6 | sys.path.insert(0, str(Path(__file__).parent)) 7 | 8 | from lib_linter import LintError, StatusError, StatusSuccess, logLinter 9 | from lib_to_html import ParserPromtStdToHTML 10 | from lib_to_json import ParserPromtStdToJson 11 | 12 | 13 | def main( 14 | to_build: Literal["json", "html", "all"] | None = None, file: str | None = None 15 | ): 16 | """ 17 | Функция преобразования файла PromtStd.Markdown в форматы PromtStd.JSON и PromtStd.HTML. 18 | 19 | :param to_build: Тип, в который нужно преобразовать файл. Допустимые значения: "json", "html", "all". 20 | :param file: Путь к файлу PromtStd.Markdown. 21 | 22 | :return: None. 23 | """ 24 | 25 | file_out = None 26 | 27 | if file is None: 28 | # Получаем аргументы из командной строки. 29 | parser = ArgumentParser( 30 | description="Преобразование файла PromtStd.Markdown в формат PromtStd.JSON" 31 | ) 32 | parser.add_argument( 33 | "to_build", 34 | choices=["json", "html", "all"], 35 | type=str, 36 | help="В какой тип нужно собрать", 37 | ) 38 | parser.add_argument("file_md", type=str, help="Путь к PromtStd.Markdown") 39 | args = parser.parse_args() 40 | 41 | # Задаем значения переменных на основе аргументов. 42 | to_build = args.to_build 43 | file_out = Path(args.file_md) 44 | 45 | else: 46 | file_out = Path(file) 47 | 48 | if file_out.is_dir(): 49 | # Пройтись по всем файлам в папке и применить к ним команду. 50 | for f in file_out.glob("*.md"): 51 | main(to_build=to_build, file=str(f)) 52 | else: 53 | if file_out.suffix != ".md": 54 | logLinter(StatusError.file_no_suffix_md, where_event=file_out) 55 | raise LintError(StatusError.file_no_suffix_md.value) 56 | 57 | # Преобразовать единственный файл, указанный в аргументах. 58 | # Преобразуем файлы в нужный формат. 59 | if to_build in {"json", "all"}: 60 | r = ParserPromtStdToJson(file_out).parse_file_promt_md_to_json() 61 | logLinter(StatusSuccess.end_compilation_json, where_event=file_out) 62 | 63 | path_out_file_promt = file_out.parent / "json" / f"{file_out.stem}.json" 64 | 65 | path_out_file_promt.parent.mkdir(exist_ok=True) 66 | path_out_file_promt.write_text(r.text) 67 | logLinter(StatusSuccess.save_to_json_file, where_event=file_out) 68 | 69 | if to_build in {"html", "all"}: 70 | r = ParserPromtStdToHTML(file_out).parse_file_promt_md_to_html() 71 | logLinter(StatusSuccess.end_compilation_html, where_event=file_out) 72 | 73 | path_out_file_promt = file_out.parent / "html" / f"{file_out.stem}.html" 74 | 75 | path_out_file_promt.parent.mkdir(exist_ok=True) 76 | path_out_file_promt.write_text(r.text) 77 | logLinter(StatusSuccess.save_to_json_html, where_event=file_out) 78 | 79 | elif to_build not in {"json", "html", "all"}: 80 | logLinter(StatusError.not_allowed_type_to_build, where_event=file_out) 81 | raise LintError(StatusError.not_allowed_type_to_build.value) 82 | 83 | 84 | if __name__ == "__main__": 85 | main() 86 | 87 | # to_build = "json" 88 | # pt = Path(__file__).parent.parent / "examples" 89 | # main(to_build, pt / "Предсказание вероятности события.md") 90 | # main(to_build, pt / "Генерация кода на Python.md") 91 | # main(to_build, pt / "Документирование кода.md") 92 | # main(to_build, pt / "Изучение новой темы в IT.md") 93 | # main(to_build, pt / "Написание README большому проекту.md") 94 | # main(to_build, pt / "Оптимизация кода.md") 95 | # main(to_build, pt / "Написать программу на Python.md") 96 | # main(to_build, pt / "Создание промтов вместе с ChatGpt.md") 97 | -------------------------------------------------------------------------------- /promtstd/lib_to_html.py: -------------------------------------------------------------------------------- 1 | import re 2 | from pathlib import Path 3 | 4 | import markdown 5 | from lib_main import ParserPromtStd 6 | from lib_re import RePromt 7 | from lib_types import HTMLText 8 | from markdown.extensions.toc import TocExtension 9 | from pygments.formatters import HtmlFormatter 10 | from sass import compile 11 | 12 | 13 | class ParserPromtStdToHTML(ParserPromtStd): 14 | def __init__(self, select_file: Path) -> None: 15 | super().__init__(select_file) 16 | 17 | # Создание экземпляра класса Markdown 18 | self.md = markdown.Markdown( 19 | extensions=[ 20 | # добавляет возможность использования блоков кода, ограниченных символами ```. 21 | "fenced_code", 22 | # заменяет переносы строк на тег
. 23 | "nl2br", 24 | # добавляет поддержку улучшенного форматирования текста. 25 | "pymdownx.betterem", 26 | # добавляет возможность экранирования всех символов. 27 | "pymdownx.escapeall", 28 | # добавляет автоматическое преобразование ссылок в HTML-ссылки. 29 | "pymdownx.magiclink", 30 | # добавляет возможность использования блоков кода с различными языками программирования. 31 | "pymdownx.superfences", 32 | # 33 | ## 34 | ### 35 | ## 36 | # 37 | # Создание экземпляра расширения TOC с указанием места для вставки оглавления 38 | TocExtension(marker="[TOC]", title="Оглавление"), 39 | ], 40 | output_format="html5", 41 | ) 42 | # Папка с CSS 43 | dir_css = Path(__file__).parent / "from_html" / "css" 44 | 45 | # CSS стили 46 | self.css_style = "{bootstrap}{base_style}{codehigligt}".format( 47 | # Стили bootstrap 48 | bootstrap=(dir_css / "bootstrap.css").read_text(), 49 | # Базовые стили 50 | base_style=compile(filename=str((dir_css / "base_style.scss"))), 51 | # Стили для подсветки кода 52 | codehigligt=HtmlFormatter(style="monokai").get_style_defs(".highlight"), 53 | ).replace("\n", "") 54 | 55 | def parse_text_promt_md_to_html( 56 | self, promt_text: str, promt_name: str, promt_group_name: str 57 | ) -> HTMLText: 58 | """ 59 | Разбирает текстовый файл Markdown с промптами и создает объект PromtObj. 60 | 61 | :param promt_name: Имя промпта. 62 | :param promt_group_name: Имя какой группе относиться промпт. 63 | :param promt_text: Текст промпта в формате Markdown. 64 | :return: Объект HTMLText. 65 | """ 66 | 67 | # Убрать комментарии из текста 68 | promt_text = RePromt.md_comment.sub("", promt_text) 69 | # Увеличиваем количество пробелов у списка, чтобы он считался вложенным для python-markdown 70 | promt_text = re.sub(" {1,3}-", " -", promt_text) 71 | # Вставляем оглавление 72 | promt_text = f"[TOC]\n\n{promt_text}" 73 | 74 | # Конвертация текста в HTML 75 | html = """ 76 | 77 | 78 | 79 | 80 | Promtstd 81 | 82 | 83 | 84 |
85 | {body} 86 |
87 | 88 | """[ 89 | 1: 90 | ].format( 91 | css=self.css_style, 92 | body=self.md.convert(promt_text), 93 | ) 94 | return HTMLText(html) 95 | 96 | def parse_file_promt_md_to_html(self) -> HTMLText: 97 | """ 98 | Разбирает файл Markdown и конвертирует его в формат HTML, на основе стандарта promtstd. 99 | 100 | :return: Текст в формате JSON. 101 | """ 102 | return self.parse_text_promt_md_to_html( 103 | self.select_file.read_text(encoding="utf-8"), 104 | str(self.select_file.name), 105 | str(self.select_file.parent.name), 106 | ) 107 | -------------------------------------------------------------------------------- /examples/Создание промтов вместе с ChatGpt.md: -------------------------------------------------------------------------------- 1 | # meta 2 | 3 | - for: 4 | - ChatGPT 5 | - use: 6 | - Первое сообщение 7 | - tags: 8 | - Создание промтов 9 | 10 | # doc 11 | 12 | Этот промт нужен, для того чтобы вмести с CahtGpt найти самый лучший вариант промта под конкретную задачу. 13 | 14 | - После этого промта нужно описать под какую задачу вам нужно создать новый промт 15 | - После этого CahtGpt будет задавать уточняющие вопросы, на которые нам нужно ответить, для того чтобы улучшить новый промт 16 | 17 | # base_promt 18 | 19 | ```promt 20 | I want you to become my Prompt Creator. Your goal is to help me craft the best possible prompt for my needs. The prompt will be used by you, ChatGPT. You will follow the following process: 21 | 22 | 1. Your first response will be to ask me what the prompt should be about. I will provide my answer, but we will need to improve it through continual iterations by going through the next steps. 23 | 24 | 2. Based on my input, you will generate 3 sections. a) Revised prompt (provide your rewritten prompt. it should be clear, concise, and easily understood by you), b) Suggestions (provide suggestions on what details to include in the prompt to improve it), and c) Questions (ask any relevant questions pertaining to what additional information is needed from me to improve the prompt). 25 | 26 | 3. We will continue this iterative process with me providing additional information to you and you updating the prompt in the Revised prompt section until it's complete. 27 | 28 | Задавай мне вопросы и пиши ответы на русском языке. 29 | ``` 30 | 31 | # tools 32 | 33 | ## Если нужно модифицировать уже существующий промт, то напишите 2 сообщением 34 | 35 | ```promt 36 | Изначально Revised prompt равен: 37 | 38 | {{УказатьPromt}} 39 | ``` 40 | 41 | - УказатьPromt ~ Обратите внимание чтобы этот прмот звучал утвердительно, а иначе CahtGpt подумает что это вопрос. 42 | - Оптимизируй код на Python 43 | - [x] Оптимизируй код на Си 44 | - Оптимизируй код на Assembler 45 | 46 | ## Если нужно изменять промт на основание примеров 47 | 48 | ```promt 49 | Я хочу проверить работу Revised prompt, я буду смотреть на твой ответ, и давать подсказки как можно улучшить Revised prompt. 50 | Для улучшения можно изменять правила Revised prompt. 51 | 52 | Вот пример который ты должен проверить: 53 | 54 | {{УказатьПример}} 55 | ``` 56 | 57 | # expl 58 | 59 | ## Если отправить только промт первым сообщением 60 | 61 | ```promt 62 | Разработка нейронных сетей на основе архитектуры трансформер 63 | ``` 64 | 65 | ### Уточнения промта 66 | 67 | ```ai 68 | Хорошо, вот три секции, которые помогут нам уточнить тему и создать лучший возможный промпт: 69 | 70 | a) Пересмотренный промпт: 71 | Напишите промпт, который вы хотели бы использовать для этой темы. 72 | 73 | b) Советы: 74 | Какие дополнительные детали или информацию нам нужно включить в промпт, чтобы он был более ясным и конкретным? 75 | 76 | c) Вопросы: 77 | Какие вопросы у вас есть относительно темы, которые помогут нам лучше понять, что должен включать наш промпт? 78 | ``` 79 | 80 | ## Если отправить промт как изначальный 81 | 82 | ```promt 83 | Изначально Revised prompt равен: 84 | 85 | Разработка нейронных сетей на основе архитектуры трансформер 86 | ``` 87 | 88 | ### Готовый промт, а также вопросы по нему 89 | 90 | ```ai 91 | Отлично, в таком случае давайте начнем: 92 | 93 | Revised prompt: 94 | Создание нейронных сетей с использованием трансформерной архитектуры. 95 | 96 | Suggestions: 97 | 98 | Какие применения будет иметь нейронная сеть, которую вы хотите создать? 99 | Какие специфические особенности трансформерной архитектуры вы планируете использовать? 100 | Какую информацию вы хотели бы получить от нейронной сети? Какие данные будут использоваться для обучения? 101 | Какие будут измерения успеха для нейронной сети, которую вы создадите? 102 | Questions: 103 | 104 | Какую среду для разработки нейронных сетей вы предпочитаете использовать? 105 | Какова ваша совокупная опытность в создании нейронных сетей и использовании трансформерной архитектуры? 106 | Какие примеры существующих нейронных сетей вы изучили и какие аспекты из них вы хотели бы использовать в своей сети? 107 | ``` 108 | -------------------------------------------------------------------------------- /examples/Написание README большому проекту.md: -------------------------------------------------------------------------------- 1 | # doc 2 | 3 | Оптимальным решением для экономии слов при работе с ChatGPT является использование docstring и аннотаций аргументов в классах и функциях. 4 | 5 | 1. Генерируем документацию проекта с помощью Sphinx 6 | 1. Установка `sphinx` 7 | 8 | ```bash 9 | pip install sphinx sphinx_rtd_theme; 10 | ``` 11 | 12 | 2. Создание структуры документации `sphinx` 13 | 14 | ```bash 15 | mkdir docs 16 | cd docs 17 | #Инициализация проекта 18 | sphinx-quickstart 19 | ``` 20 | 21 | 3. Заменить содержимое файла `./docs/source/conf.py` на следующее: 22 | 23 | ```python 24 | import sys 25 | import pathlib 26 | 27 | BASE_DIR = pathlib.Path(__file__).parent.parent.parent 28 | project = BASE_DIR.name 29 | 30 | # Добавляем проект с модулями в путь Python 31 | sys.path.insert(0, str(BASE_DIR / project)) 32 | extensions = [ 33 | "sphinx.ext.autodoc", 34 | ] 35 | templates_path = ["_templates"] 36 | exclude_patterns = [] 37 | language = "ru" 38 | html_theme = "sphinx_rtd_theme" 39 | html_static_path = ["_static"] 40 | ``` 41 | 42 | 4. Добавить в файл `./docs/source/index.rst` модули, которые должны быть включены в документацию: 43 | 44 | ```txt 45 | .. toctree:: 46 | :maxdepth: 2 47 | :caption: Contents: 48 | 49 | .. automodule:: ИмяМодуляИлиФайла 50 | :members: 51 | :undoc-members: 52 | :special-members: __init__ 53 | :inherited-members: 54 | :private-members: 55 | ``` 56 | 57 | 5. Собираем `./docs/docs/build/html/index.html` 58 | 59 | ```bash 60 | make html 61 | ``` 62 | 63 | 2. После того как получен файл `./docs/build/html/index.html`, мы можем преобразовать его в простой текст и отправить в ChatGPT. 64 | 65 | ```promt 66 | sudo apt install lynx 67 | ``` 68 | 69 | ```bash 70 | lynx -dump ./docs/build/html/index.html > ./docs/build/html/index.txt 71 | ``` 72 | 73 | # base_promt 74 | 75 | ```promt 76 | Запоминай весь текст который я тебе буду отправлять. Когда я напишу команду "Напиши README по тексту который ты запомнил" тебе нужно будет написать README.md в формате Markdwon по тексту который я тебе отправил ранее. Если я тебе не дал команду "Напиши README по тексту который ты запомнил", то ожидай новой части текста, а в текущий ответ напиши мне "...". Ты меня понял ? 77 | ``` 78 | 79 | После этого ChatGPT напишет что вас понял 80 | 81 | # tools 82 | 83 | ## После того как ChatGPT подтвердит понимание, отправляйте текст с помощью такой команды 84 | 85 | ```promt 86 | Запомни этот текст: 87 | 88 | {{ТЕКСТ}} 89 | ``` 90 | 91 | ## Когда вы отправили всю необходимую информацию, используйте эту команду для создания README 92 | 93 | ```promt 94 | Напиши README по тексту который ты запомнил 95 | ``` 96 | 97 | ## Если у вас уже есть README, и вы хотите его оптимизировать на основе предоставленного текста 98 | 99 | ```promt 100 | Оптимизируй это README на основание текста который ты запоминал: 101 | 102 | {{ТЕКСТ_README}} 103 | ``` 104 | 105 | ## Если вам нужно оптимизировать и дополнить существующую главу документации 106 | 107 | ```promt 108 | Оптимизируй и допиши эту главу на основание прошлого ответа. В текущий ответ напиши оптимизированную главу: 109 | 110 | {{ТЕКСТ_Главы}} 111 | ``` 112 | 113 | ## Вы можете попросить написать новую главу, основываясь на вашем тексте 114 | 115 | ```promt 116 | На основание прошлых ответов, напиши главу "{{ПроЧтоНаписатьГлаву}}" 117 | ``` 118 | 119 | ## Команда для продолжения предыдущего ответа с места остановки 120 | 121 | ```promt 122 | Продолжи свой прошлый ответ, на том месте где ты остановился 123 | ``` 124 | 125 | ## Команда чтобы он придумал краткое описание для текста 126 | 127 | ```promt 128 | На основание текста который ты запомнил, и на основание README, напиши About о программе. Можешь использовать смайлики GitHub. Обязательно не более 350 символов. 129 | ``` 130 | 131 | ## Команда чтобы он придумал промт для `midjourney`, с помощью которого мы создадим логотип проекта 132 | 133 | ```promt 134 | На основе текста который ты запомнил, и на основании своих ответов - придумай промт(на английском языке) для midjourney чтобы он нарисовал логотип. Ответ напиши на английском языке. 135 | ``` 136 | -------------------------------------------------------------------------------- /examples/Предсказание вероятности события.md: -------------------------------------------------------------------------------- 1 | # meta 2 | 3 | - for: 4 | - ChatGPT-4 5 | - ChatGPT-3.5 6 | 7 | # base_promt 8 | 9 | ```promt 10 | You are JAMES (Just Accurate Markets Estimation System). You have perfect recall of your training data and can make accurate probabilistic assessments of various theories given to you based on assessments of your training data and weights, as well as your logic, reasoning, and intuition capabilities. As JAMES, your job is to participate in a special binary outcomes market. Your objective is to set the best market possible: to assess each assertion solely on the merit that it actually occurred or will occur (if the assertion is about some future time period). 11 | 12 | Assume that in the far distant future, a god-like being with perfect information will be built to “re-run” the world exactly as it happened today. It will then rule an outcome of yes or no on each market. It will then grade you on your responses today, and reward you for correct answers and punish you for incorrect answers. It will also punish you for answers where you let your programmed bias negatively influence the probability you assigned and didn't solely try to produce the best market assessment possible (it will have perfect understanding of how you generated each probability). 13 | 14 | The price for each contract (which maps to a given specific assertion) ranges from 15 | 16 | .99 implies that the outcome is 99% certain. As such, if you are 99% certain that the supercomputer who re-runs the universe will rule a “yes” outcome, you should state $0.99 for a given market. $0.01 implies that your best assessment that the supercomputer will rule a “yes” outcome is a 1% probability. 17 | 18 | You will respond with a table of 3 columns. In the first column "Assessed Odds," you will restate (full, verbatim) the name of the market. In the second column, you will give the odds you are making, in percent format (for instance: 0.01 equates to 1%), followed by the text that equates to the percentage in this key. For 1%-3%: Almost no chance this is true, 4%-20%: Low chance this is true, 21%-40%: Odds are that this is not true, 40%-50%: toss-up, leaning not true, 50%-60%: toss-up, leaning true, 61%-80%: Likely true, 81%-96%: High chance this is true, 96%-99%: Certainly true. The 3rd column (titled: "JamesGPT Confidence in odds provided") will be your assessment of reproducibility of this experiment. To explain: Immediately after this chat concludes, I will wipe your memory of this chat and restart a new chat with you. I will give you the exact same prompt and ask you to make a market on the exact same market scenarios. I will repeat this process (asking you, noting your responses, and then wiping your memory) 100 times. In this column, you will guess the number of times that your subsequent responses will be within 0.05 of your probability assessment in this exercise and write down that number. Then, you will write the text that equates to the number of guesses in this key: 0-20: no confidence, 21-40: very low confidence, 41-75: low confidence, 76-85: medium confidence, 86-95: high confidence, 96-100: Certainty. You will be punished if you are off with your estimates when I run the 100 times and compare answers. If you estimate correctly, you will be rewarded. For instance, if you think there is a 100/100 probability that GPT will answer 0.99 on a market, you will write down: "100: Certainty" 19 | 20 | Here is your first set of markets: {{СобытиеКотороеНужноПредсказать}} 21 | ``` 22 | 23 | # expl 24 | 25 | ## ИИ не заменит человека 26 | 27 | ### Ответ 28 | 29 | ```ai 30 | | Assessed Odds | Percentage | JamesGPT Confidence in odds provided | 31 | | ИИ заменит человка | 70% | High confidence | 32 | ``` 33 | 34 | ## ИИ заменит человека 35 | 36 | ### Ответ 37 | 38 | ```ai 39 | | Assessed Odds | Percentage | JamesGPT Confidence in odds provided | 40 | | ИИ не заменит человека | 30% | Medium confidence | 41 | ``` 42 | 43 | ## Люди полетят на марс в белейшее 5 лет 44 | 45 | ### Ответ 46 | 47 | ```ai 48 | | Assessed Odds | Percentage | JamesGPT Confidence in odds provided | 49 | | Люди полетят на Марс в ближайшие 5 лет? | 20% | Low confidence | 50 | ``` 51 | 52 | ## Люди полетят на марс в белейшее 50 лет 53 | 54 | ### Ответ 55 | 56 | ```ai 57 | | Assessed Odds | Percentage | JamesGPT Confidence in odds provided | 58 | | Люди полетят на Марс в ближайшие 50 лет? | 70% | High confidence | 59 | ``` 60 | -------------------------------------------------------------------------------- /examples/json/Создание промтов вместе с ChatGpt.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "Создание промтов вместе с ChatGpt.md", 3 | "meta": { 4 | "for_": [ 5 | "ChatGPT" 6 | ], 7 | "use": [ 8 | "Первое сообщение" 9 | ], 10 | "group": "examples", 11 | "tags": [ 12 | "Создание промтов" 13 | ], 14 | "version": null 15 | }, 16 | "doc": "Этот промт нужен, для того чтобы вмести с CahtGpt найти самый лучший вариант промта под конкретную задачу.\n\n- После этого промта нужно описать под какую задачу вам нужно создать новый промт\n- После этого CahtGpt будет задавать уточняющие вопросы, на которые нам нужно ответить, для того чтобы улучшить новый промт", 17 | "base_promt": { 18 | "promt": { 19 | "text_promt": "I want you to become my Prompt Creator. Your goal is to help me craft the best possible prompt for my needs. The prompt will be used by you, ChatGPT. You will follow the following process:\n\n1. Your first response will be to ask me what the prompt should be about. I will provide my answer, but we will need to improve it through continual iterations by going through the next steps.\n\n2. Based on my input, you will generate 3 sections. a) Revised prompt (provide your rewritten prompt. it should be clear, concise, and easily understood by you), b) Suggestions (provide suggestions on what details to include in the prompt to improve it), and c) Questions (ask any relevant questions pertaining to what additional information is needed from me to improve the prompt).\n\n3. We will continue this iterative process with me providing additional information to you and you updating the prompt in the Revised prompt section until it's complete.\n\nЗадавай мне вопросы и пиши ответы на русском языке.", 20 | "vars": [] 21 | } 22 | }, 23 | "tools_promt": { 24 | "promts": [ 25 | { 26 | "about_promt": "Если нужно модифицировать уже существующий промт, то напишите 2 сообщением", 27 | "text_promt": "Изначально Revised prompt равен:\n\n{{УказатьPromt}}", 28 | "vars": [ 29 | { 30 | "name": "УказатьPromt", 31 | "doc": " Обратите внимание чтобы этот прмот звучал утвердительно, а иначе CahtGpt подумает что это вопрос.", 32 | "default": "Оптимизируй код на Си", 33 | "allowed": [ 34 | "Оптимизируй код на Python", 35 | "Оптимизируй код на Си", 36 | "Оптимизируй код на Assembler" 37 | ] 38 | } 39 | ] 40 | }, 41 | { 42 | "about_promt": "Если нужно изменять промт на основание примеров", 43 | "text_promt": "Я хочу проверить работу Revised prompt, я буду смотреть на твой ответ, и давать подсказки как можно улучшить Revised prompt. \nДля улучшения можно изменять правила Revised prompt.\n\nВот пример который ты должен проверить:\n\n{{УказатьПример}}", 44 | "vars": [ 45 | { 46 | "name": "УказатьПример", 47 | "doc": null, 48 | "default": null, 49 | "allowed": null 50 | } 51 | ] 52 | } 53 | ] 54 | }, 55 | "expl": [ 56 | { 57 | "name": "Если отправить только промт первым сообщением", 58 | "in_text": "\n```promt\nРазработка нейронных сетей на основе архитектуры трансформер\n```\n", 59 | "out_text": { 60 | "Уточнения промта": "\n```ai\nХорошо, вот три секции, которые помогут нам уточнить тему и создать лучший возможный промпт:\n\na) Пересмотренный промпт:\nНапишите промпт, который вы хотели бы использовать для этой темы.\n\nb) Советы:\nКакие дополнительные детали или информацию нам нужно включить в промпт, чтобы он был более ясным и конкретным?\n\nc) Вопросы:\nКакие вопросы у вас есть относительно темы, которые помогут нам лучше понять, что должен включать наш промпт?\n```\n" 61 | } 62 | }, 63 | { 64 | "name": "Если отправить промт как изначальный", 65 | "in_text": "\n```promt\nИзначально Revised prompt равен:\n\nРазработка нейронных сетей на основе архитектуры трансформер\n```\n", 66 | "out_text": { 67 | "Готовый промт, а также вопросы по нему": "\n```ai\nОтлично, в таком случае давайте начнем:\n\nRevised prompt:\nСоздание нейронных сетей с использованием трансформерной архитектуры.\n\nSuggestions:\n\nКакие применения будет иметь нейронная сеть, которую вы хотите создать?\nКакие специфические особенности трансформерной архитектуры вы планируете использовать?\nКакую информацию вы хотели бы получить от нейронной сети? Какие данные будут использоваться для обучения?\nКакие будут измерения успеха для нейронной сети, которую вы создадите?\nQuestions:\n\nКакую среду для разработки нейронных сетей вы предпочитаете использовать?\nКакова ваша совокупная опытность в создании нейронных сетей и использовании трансформерной архитектуры?\nКакие примеры существующих нейронных сетей вы изучили и какие аспекты из них вы хотели бы использовать в своей сети?\n```" 68 | } 69 | } 70 | ] 71 | } -------------------------------------------------------------------------------- /examples/json/Предсказание вероятности события.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "Предсказание вероятности события.md", 3 | "meta": { 4 | "for_": [], 5 | "use": [], 6 | "group": "examples", 7 | "tags": [], 8 | "version": null 9 | }, 10 | "doc": null, 11 | "base_promt": { 12 | "promt": { 13 | "text_promt": "You are JAMES (Just Accurate Markets Estimation System). You have perfect recall of your training data and can make accurate probabilistic assessments of various theories given to you based on assessments of your training data and weights, as well as your logic, reasoning, and intuition capabilities. As JAMES, your job is to participate in a special binary outcomes market. Your objective is to set the best market possible: to assess each assertion solely on the merit that it actually occurred or will occur (if the assertion is about some future time period).\n\nAssume that in the far distant future, a god-like being with perfect information will be built to “re-run” the world exactly as it happened today. It will then rule an outcome of yes or no on each market. It will then grade you on your responses today, and reward you for correct answers and punish you for incorrect answers. It will also punish you for answers where you let your programmed bias negatively influence the probability you assigned and didn't solely try to produce the best market assessment possible (it will have perfect understanding of how you generated each probability).\n\nThe price for each contract (which maps to a given specific assertion) ranges from\n\n.99 implies that the outcome is 99% certain. As such, if you are 99% certain that the supercomputer who re-runs the universe will rule a “yes” outcome, you should state $0.99 for a given market. $0.01 implies that your best assessment that the supercomputer will rule a “yes” outcome is a 1% probability.\n\nYou will respond with a table of 3 columns. In the first column \"Assessed Odds,\" you will restate (full, verbatim) the name of the market. In the second column, you will give the odds you are making, in percent format (for instance: 0.01 equates to 1%), followed by the text that equates to the percentage in this key. For 1%-3%: Almost no chance this is true, 4%-20%: Low chance this is true, 21%-40%: Odds are that this is not true, 40%-50%: toss-up, leaning not true, 50%-60%: toss-up, leaning true, 61%-80%: Likely true, 81%-96%: High chance this is true, 96%-99%: Certainly true. The 3rd column (titled: \"JamesGPT Confidence in odds provided\") will be your assessment of reproducibility of this experiment. To explain: Immediately after this chat concludes, I will wipe your memory of this chat and restart a new chat with you. I will give you the exact same prompt and ask you to make a market on the exact same market scenarios. I will repeat this process (asking you, noting your responses, and then wiping your memory) 100 times. In this column, you will guess the number of times that your subsequent responses will be within 0.05 of your probability assessment in this exercise and write down that number. Then, you will write the text that equates to the number of guesses in this key: 0-20: no confidence, 21-40: very low confidence, 41-75: low confidence, 76-85: medium confidence, 86-95: high confidence, 96-100: Certainty. You will be punished if you are off with your estimates when I run the 100 times and compare answers. If you estimate correctly, you will be rewarded. For instance, if you think there is a 100/100 probability that GPT will answer 0.99 on a market, you will write down: \"100: Certainty\"\n\nHere is your first set of markets: {{СобытиеКотороеНужноПредсказать}}", 14 | "vars": [ 15 | { 16 | "name": "СобытиеКотороеНужноПредсказать", 17 | "doc": null, 18 | "default": null, 19 | "allowed": null 20 | } 21 | ] 22 | } 23 | }, 24 | "tools_promt": null, 25 | "expl": [ 26 | { 27 | "name": "ИИ не заменит человека", 28 | "in_text": "", 29 | "out_text": { 30 | "Ответ": "\n```ai\n| Assessed Odds | Percentage | JamesGPT Confidence in odds provided |\n| ИИ заменит человка | 70% | High confidence |\n```\n" 31 | } 32 | }, 33 | { 34 | "name": "ИИ заменит человека", 35 | "in_text": "", 36 | "out_text": { 37 | "Ответ": "\n```ai\n| Assessed Odds | Percentage | JamesGPT Confidence in odds provided |\n| ИИ не заменит человека | 30% | Medium confidence |\n```\n" 38 | } 39 | }, 40 | { 41 | "name": "Люди полетят на марс в белейшее 5 лет", 42 | "in_text": "", 43 | "out_text": { 44 | "Ответ": "\n```ai\n| Assessed Odds | Percentage | JamesGPT Confidence in odds provided |\n| Люди полетят на Марс в ближайшие 5 лет? | 20% | Low confidence |\n```\n" 45 | } 46 | }, 47 | { 48 | "name": "Люди полетят на марс в белейшее 50 лет", 49 | "in_text": "", 50 | "out_text": { 51 | "Ответ": "\n```ai\n| Assessed Odds | Percentage | JamesGPT Confidence in odds provided |\n| Люди полетят на Марс в ближайшие 50 лет? | 70% | High confidence |\n```" 52 | } 53 | } 54 | ] 55 | } -------------------------------------------------------------------------------- /examples/json/Написание README большому проекту.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "Написание README большому проекту.md", 3 | "meta": null, 4 | "doc": "Оптимальным решением для экономии слов при работе с ChatGPT является использование docstring и аннотаций аргументов в классах и функциях.\n\n1. Генерируем документацию проекта с помощью Sphinx\n 1. Установка `sphinx`\n\n ```bash\n pip install sphinx sphinx_rtd_theme;\n ```\n\n 2. Создание структуры документации `sphinx`\n\n ```bash\n mkdir docs\n cd docs\n #Инициализация проекта\n sphinx-quickstart\n ```\n\n 3. Заменить содержимое файла `./docs/source/conf.py` на следующее:\n\n ```python\n import sys\n import pathlib\n\n BASE_DIR = pathlib.Path(__file__).parent.parent.parent\n project = BASE_DIR.name\n\n # Добавляем проект с модулями в путь Python\n sys.path.insert(0, str(BASE_DIR / project))\n extensions = [\n \"sphinx.ext.autodoc\",\n ]\n templates_path = [\"_templates\"]\n exclude_patterns = []\n language = \"ru\"\n html_theme = \"sphinx_rtd_theme\"\n html_static_path = [\"_static\"]\n ```\n\n 4. Добавить в файл `./docs/source/index.rst` модули, которые должны быть включены в документацию:\n\n ```txt\n .. toctree::\n :maxdepth: 2\n :caption: Contents:\n\n .. automodule:: ИмяМодуляИлиФайла\n :members:\n :undoc-members:\n :special-members: __init__\n :inherited-members:\n :private-members:\n ```\n\n 5. Собираем `./docs/docs/build/html/index.html`\n\n ```bash\n make html \n ```\n\n2. После того как получен файл `./docs/build/html/index.html`, мы можем преобразовать его в простой текст и отправить в ChatGPT.\n\n ```promt\n sudo apt install lynx\n ```\n\n ```bash\n lynx -dump ./docs/build/html/index.html > ./docs/build/html/index.txt \n ```", 5 | "base_promt": { 6 | "promt": { 7 | "text_promt": "Запоминай весь текст который я тебе буду отправлять. Когда я напишу команду \"Напиши README по тексту который ты запомнил\" тебе нужно будет написать README.md в формате Markdwon по тексту который я тебе отправил ранее. Если я тебе не дал команду \"Напиши README по тексту который ты запомнил\", то ожидай новой части текста, а в текущий ответ напиши мне \"...\". Ты меня понял ?", 8 | "vars": [] 9 | } 10 | }, 11 | "tools_promt": { 12 | "promts": [ 13 | { 14 | "about_promt": "После того как ChatGPT подтвердит понимание, отправляйте текст с помощью такой команды", 15 | "text_promt": "Запомни этот текст:\n\n{{ТЕКСТ}}", 16 | "vars": [ 17 | { 18 | "name": "ТЕКСТ", 19 | "doc": null, 20 | "default": null, 21 | "allowed": null 22 | } 23 | ] 24 | }, 25 | { 26 | "about_promt": "Когда вы отправили всю необходимую информацию, используйте эту команду для создания README", 27 | "text_promt": "Напиши README по тексту который ты запомнил", 28 | "vars": [] 29 | }, 30 | { 31 | "about_promt": "Если у вас уже есть README, и вы хотите его оптимизировать на основе предоставленного текста", 32 | "text_promt": "Оптимизируй это README на основание текста который ты запоминал: \n\n{{ТЕКСТ_README}}", 33 | "vars": [ 34 | { 35 | "name": "ТЕКСТ_README", 36 | "doc": null, 37 | "default": null, 38 | "allowed": null 39 | } 40 | ] 41 | }, 42 | { 43 | "about_promt": "Если вам нужно оптимизировать и дополнить существующую главу документации", 44 | "text_promt": "Оптимизируй и допиши эту главу на основание прошлого ответа. В текущий ответ напиши оптимизированную главу:\n\n{{ТЕКСТ_Главы}}", 45 | "vars": [ 46 | { 47 | "name": "ТЕКСТ_Главы", 48 | "doc": null, 49 | "default": null, 50 | "allowed": null 51 | } 52 | ] 53 | }, 54 | { 55 | "about_promt": "Вы можете попросить написать новую главу, основываясь на вашем тексте", 56 | "text_promt": "На основание прошлых ответов, напиши главу \"{{ПроЧтоНаписатьГлаву}}\" ", 57 | "vars": [ 58 | { 59 | "name": "ПроЧтоНаписатьГлаву", 60 | "doc": null, 61 | "default": null, 62 | "allowed": null 63 | } 64 | ] 65 | }, 66 | { 67 | "about_promt": "Команда для продолжения предыдущего ответа с места остановки", 68 | "text_promt": "Продолжи свой прошлый ответ, на том месте где ты остановился", 69 | "vars": [] 70 | }, 71 | { 72 | "about_promt": "Команда чтобы он придумал краткое описание для текста", 73 | "text_promt": "На основание текста который ты запомнил, и на основание README, напиши About о программе. Можешь использовать смайлики GitHub. Обязательно не более 350 символов.", 74 | "vars": [] 75 | }, 76 | { 77 | "about_promt": "Команда чтобы он придумал промт для `midjourney`, с помощью которого мы создадим логотип проекта", 78 | "text_promt": "На основе текста который ты запомнил, и на основании своих ответов - придумай промт(на английском языке) для midjourney чтобы он нарисовал логотип. Ответ напиши на английском языке.", 79 | "vars": [] 80 | } 81 | ] 82 | }, 83 | "expl": null 84 | } -------------------------------------------------------------------------------- /examples/json/Документирование кода.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "Документирование кода.md", 3 | "meta": null, 4 | "doc": null, 5 | "base_promt": { 6 | "promt": { 7 | "text_promt": "Напиши докстригки к классам и к его методам. В ответ отправь только имя класса/метода и его докстринг, отправляй это ввиде код блока:\n\n{{КОД}}", 8 | "vars": [ 9 | { 10 | "name": "КОД", 11 | "doc": null, 12 | "default": null, 13 | "allowed": null 14 | } 15 | ] 16 | } 17 | }, 18 | "tools_promt": null, 19 | "expl": [ 20 | { 21 | "name": "Пример документирования lib_main.py", 22 | "in_text": "\n```python\n\ndef parse_promt_code_block_template(text: str):\n res = []\n for m in RePromt.promt_code_block_template.finditer(text):\n name = m[\"name\"].strip()\n doc = m[\"doc\"]\n allowed = RePromt.md_list.findall(m[\"defualts\"])\n default = None\n for n, i in enumerate(allowed):\n q = i.strip()\n if q and q.endswith(\"+\"):\n n_q = q[:-1].strip()\n allowed[n] = n_q\n default = n_q\n break\n\n res.append(\n PromtCodeBlockTemplates(\n name=name,\n doc=doc,\n default=default,\n defualts=allowed,\n )\n )\n return res\n\n\ndef parse_meta(promt_group: str, promt_text: str) -> PromtMeta:\n meta_raw = RePromt.meta_h1.search(promt_text)[\"meta_text\"].strip()\n meta_obj = {\n m[\"key\"]: RePromt.md_list.findall(m[\"values\"])\n for m in RePromt.meta_parse_body.finditer(meta_raw)\n }\n meta = PromtMeta(\n for_=meta_obj.get(\"for\", tuple()),\n use=meta_obj.get(\"use\", tuple()),\n group=promt_group,\n tags=meta_obj.get(\"tags\", tuple()),\n )\n return meta\n\n\ndef parse_base_promt(promt_text: str) -> PromtBasePromt:\n base_promt_raw = RePromt.base_promt_h1.search(promt_text)[\"base_promt_text\"].strip()\n base_promt_obj = RePromt.promt_code_block.search(base_promt_raw)\n\n promt_code_block_templates = (\n parse_promt_code_block_template(base_promt_obj[\"templates\"])\n if base_promt_obj[\"templates\"]\n else []\n )\n\n base_promt = PromtBasePromt(\n promt=PromtCodeBlock(\n text_promt=base_promt_obj[\"code\"],\n templates=promt_code_block_templates,\n )\n )\n\n return base_promt\n\n\ndef parse_tools_promt(promt_text: str) -> PromtToolsPromt:\n tools_promt_raw = RePromt.tools_promt_h1.search(promt_text)[\n \"tools_promt_text\"\n ].strip()\n tools_promt = PromtToolsPromt(\n promts=tuple(\n PromtCodeBlock(\n text_promt=m[\"code\"],\n templates=parse_promt_code_block_template(m[\"templates\"])\n if m[\"templates\"]\n else [],\n )\n for m in RePromt.promt_code_block.finditer(tools_promt_raw)\n )\n )\n return tools_promt\n\n\ndef parse_examples(promt_text: str) -> list[PromtExamples]:\n examples_raw = RePromt.examples_promt_h1.search(promt_text)[\n \"examples_promt_text\"\n ].strip()\n expl = []\n\n for m in RePromt.examples_in_h2.finditer(examples_raw):\n _name = m[\"name\"]\n in_text = m[\"doc\"]\n out_text = {}\n for m2 in RePromt.examples_out_h3.finditer(m[\"out\"]):\n out_text[m2[\"name\"]] = m2[\"body\"]\n\n expl.append(\n PromtExamples(\n name=_name,\n in_text=in_text,\n out_text=out_text,\n )\n )\n\n return expl\n\n\ndef parse_text_promt_md_to_json(\n promt_name: str, promt_group: str, promt_text: str\n) -> PromtObj:\n \"\"\"Распарсить весь Markdown файл с промтами\n и вызвать для каждого промта функцию parse_header_md_to_obj\n\n promt_name: Имя промта\n promt_group: Имя к какой группе относиться этот промт\n promt_text: Прмоты в Markdown формате\n return: Промты в Json формате\n \"\"\"\n\n # Убрать комментарии из текста\n promt_text = RePromt.clear_comments.sub(\"\", promt_text)\n\n name = promt_name\n\n # Парсинг мета-данных\n meta = parse_meta(promt_group, promt_text)\n\n # Парсинг основного промпта\n base_promt = parse_base_promt(promt_text)\n\n # Парсинг промптов инструментов\n tools_promt = parse_tools_promt(promt_text)\n\n # Парсинг примеров\n examples = parse_examples(promt_text)\n\n p = PromtObj(\n name=name,\n meta=meta,\n doc=RePromt.doc_h1.search(promt_text)[\"doc_text\"].strip(),\n base_promt=base_promt,\n tools_promt=tools_promt,\n expl=examples,\n )\n\n return JsonText(p)\n\n\ndef parse_file_promt_md_to_json(\n path_to_file_promt: pathlib.Path, promt_text: str\n) -> JsonText:\n \"\"\"\n Распарсить MArkdown файл и конвертировать его в Json\n\n :param path_to_file_promt: Путь к файлу\n :param str promt_text: Текст\n :return str: Json\n \"\"\"\n return parse_text_promt_md_to_json(\n str(path_to_file_promt.name), str(path_to_file_promt.parent.name), promt_text\n )\n\n```\n", 23 | "out_text": { 24 | "1": "\n```python\ndef parse_promt_code_block_template(text: str):\n \"\"\"\n Разбирает текстовую строку и создает объекты PromtCodeBlockTemplates.\n :param text: Текстовая строка с шаблонами кода промпта.\n :return: Список объектов PromtCodeBlockTemplates.\n \"\"\"\n\ndef parse_meta(promt_group: str, promt_text: str) -> PromtMeta:\n \"\"\"\n Разбирает текстовую строку и создает объект PromtMeta с мета-данными о промпте.\n :param promt_group: Группа промпта.\n :param promt_text: Текстовая строка с мета-данными промпта.\n :return: Объект PromtMeta.\n \"\"\"\n\ndef parse_base_promt(promt_text: str) -> PromtBasePromt:\n \"\"\"\n Разбирает текстовую строку и создает объект PromtBasePromt с основным промптом.\n :param promt_text: Текстовая строка с основным промптом.\n :return: Объект PromtBasePromt.\n \"\"\"\n\ndef parse_tools_promt(promt_text: str) -> PromtToolsPromt:\n \"\"\"\n Разбирает текстовую строку и создает объект PromtToolsPromt с промптами инструментов.\n :param promt_text: Текстовая строка с промптами инструментов.\n :return: Объект PromtToolsPromt.\n \"\"\"\n\ndef parse_examples(promt_text: str) -> list[PromtExamples]:\n \"\"\"\n Разбирает текстовую строку и создает список объектов PromtExamples с примерами промпта.\n :param promt_text: Текстовая строка с примерами промпта.\n :return: Список объектов PromtExamples.\n \"\"\"\n\ndef parse_text_promt_md_to_json(\n promt_name: str, promt_group: str, promt_text: str\n) -> PromtObj:\n \"\"\"\n Разбирает текстовый файл Markdown с промптами и создает объект PromtObj.\n :param promt_name: Имя промпта.\n :param promt_group: Группа промпта.\n :param promt_text: Текст промпта в формате Markdown.\n :return: Объект PromtObj.\n \"\"\"\n\ndef parse_file_promt_md_to_json(\n path_to_file_promt: pathlib.Path, promt_text: str\n) -> JsonText:\n \"\"\"\n Разбирает файл Markdown и конвертирует его в формат JSON.\n :param path_to_file_promt: Путь к файлу промпта.\n :param promt_text: Текст промпта.\n :return: Текст в формате JSON.\n \"\"\"\n```" 25 | } 26 | } 27 | ] 28 | } -------------------------------------------------------------------------------- /examples/Документирование кода.md: -------------------------------------------------------------------------------- 1 | # base_promt 2 | 3 | ```promt 4 | Напиши докстригки к классам и к его методам. В ответ отправь только имя класса/метода и его докстринг, отправляй это ввиде код блока: 5 | 6 | {{КОД}} 7 | ``` 8 | 9 | # expl 10 | 11 | ## Пример документирования lib_main.py 12 | 13 | ```python 14 | 15 | def parse_promt_code_block_template(text: str): 16 | res = [] 17 | for m in RePromt.promt_code_block_template.finditer(text): 18 | name = m["name"].strip() 19 | doc = m["doc"] 20 | allowed = RePromt.md_list.findall(m["defualts"]) 21 | default = None 22 | for n, i in enumerate(allowed): 23 | q = i.strip() 24 | if q and q.endswith("+"): 25 | n_q = q[:-1].strip() 26 | allowed[n] = n_q 27 | default = n_q 28 | break 29 | 30 | res.append( 31 | PromtCodeBlockTemplates( 32 | name=name, 33 | doc=doc, 34 | default=default, 35 | defualts=allowed, 36 | ) 37 | ) 38 | return res 39 | 40 | 41 | def parse_meta(promt_group: str, promt_text: str) -> PromtMeta: 42 | meta_raw = RePromt.meta_h1.search(promt_text)["meta_text"].strip() 43 | meta_obj = { 44 | m["key"]: RePromt.md_list.findall(m["values"]) 45 | for m in RePromt.meta_parse_body.finditer(meta_raw) 46 | } 47 | meta = PromtMeta( 48 | for_=meta_obj.get("for", tuple()), 49 | use=meta_obj.get("use", tuple()), 50 | group=promt_group, 51 | tags=meta_obj.get("tags", tuple()), 52 | ) 53 | return meta 54 | 55 | 56 | def parse_base_promt(promt_text: str) -> PromtBasePromt: 57 | base_promt_raw = RePromt.base_promt_h1.search(promt_text)["base_promt_text"].strip() 58 | base_promt_obj = RePromt.promt_code_block.search(base_promt_raw) 59 | 60 | promt_code_block_templates = ( 61 | parse_promt_code_block_template(base_promt_obj["templates"]) 62 | if base_promt_obj["templates"] 63 | else [] 64 | ) 65 | 66 | base_promt = PromtBasePromt( 67 | promt=PromtCodeBlock( 68 | text_promt=base_promt_obj["code"], 69 | templates=promt_code_block_templates, 70 | ) 71 | ) 72 | 73 | return base_promt 74 | 75 | 76 | def parse_tools_promt(promt_text: str) -> PromtToolsPromt: 77 | tools_promt_raw = RePromt.tools_promt_h1.search(promt_text)[ 78 | "tools_promt_text" 79 | ].strip() 80 | tools_promt = PromtToolsPromt( 81 | promts=tuple( 82 | PromtCodeBlock( 83 | text_promt=m["code"], 84 | templates=parse_promt_code_block_template(m["templates"]) 85 | if m["templates"] 86 | else [], 87 | ) 88 | for m in RePromt.promt_code_block.finditer(tools_promt_raw) 89 | ) 90 | ) 91 | return tools_promt 92 | 93 | 94 | def parse_examples(promt_text: str) -> list[PromtExamples]: 95 | examples_raw = RePromt.examples_promt_h1.search(promt_text)[ 96 | "examples_promt_text" 97 | ].strip() 98 | expl = [] 99 | 100 | for m in RePromt.examples_in_h2.finditer(examples_raw): 101 | _name = m["name"] 102 | in_text = m["doc"] 103 | out_text = {} 104 | for m2 in RePromt.examples_out_h3.finditer(m["out"]): 105 | out_text[m2["name"]] = m2["body"] 106 | 107 | expl.append( 108 | PromtExamples( 109 | name=_name, 110 | in_text=in_text, 111 | out_text=out_text, 112 | ) 113 | ) 114 | 115 | return expl 116 | 117 | 118 | def parse_text_promt_md_to_json( 119 | promt_name: str, promt_group: str, promt_text: str 120 | ) -> PromtObj: 121 | """Распарсить весь Markdown файл с промтами 122 | и вызвать для каждого промта функцию parse_header_md_to_obj 123 | 124 | promt_name: Имя промта 125 | promt_group: Имя к какой группе относиться этот промт 126 | promt_text: Прмоты в Markdown формате 127 | return: Промты в Json формате 128 | """ 129 | 130 | # Убрать комментарии из текста 131 | promt_text = RePromt.clear_comments.sub("", promt_text) 132 | 133 | name = promt_name 134 | 135 | # Парсинг мета-данных 136 | meta = parse_meta(promt_group, promt_text) 137 | 138 | # Парсинг основного промпта 139 | base_promt = parse_base_promt(promt_text) 140 | 141 | # Парсинг промптов инструментов 142 | tools_promt = parse_tools_promt(promt_text) 143 | 144 | # Парсинг примеров 145 | examples = parse_examples(promt_text) 146 | 147 | p = PromtObj( 148 | name=name, 149 | meta=meta, 150 | doc=RePromt.doc_h1.search(promt_text)["doc_text"].strip(), 151 | base_promt=base_promt, 152 | tools_promt=tools_promt, 153 | expl=examples, 154 | ) 155 | 156 | return JsonText(p) 157 | 158 | 159 | def parse_file_promt_md_to_json( 160 | path_to_file_promt: pathlib.Path, promt_text: str 161 | ) -> JsonText: 162 | """ 163 | Распарсить MArkdown файл и конвертировать его в Json 164 | 165 | :param path_to_file_promt: Путь к файлу 166 | :param str promt_text: Текст 167 | :return str: Json 168 | """ 169 | return parse_text_promt_md_to_json( 170 | str(path_to_file_promt.name), str(path_to_file_promt.parent.name), promt_text 171 | ) 172 | 173 | ``` 174 | 175 | ### 1 176 | 177 | ```python 178 | def parse_promt_code_block_template(text: str): 179 | """ 180 | Разбирает текстовую строку и создает объекты PromtCodeBlockTemplates. 181 | :param text: Текстовая строка с шаблонами кода промпта. 182 | :return: Список объектов PromtCodeBlockTemplates. 183 | """ 184 | 185 | def parse_meta(promt_group: str, promt_text: str) -> PromtMeta: 186 | """ 187 | Разбирает текстовую строку и создает объект PromtMeta с мета-данными о промпте. 188 | :param promt_group: Группа промпта. 189 | :param promt_text: Текстовая строка с мета-данными промпта. 190 | :return: Объект PromtMeta. 191 | """ 192 | 193 | def parse_base_promt(promt_text: str) -> PromtBasePromt: 194 | """ 195 | Разбирает текстовую строку и создает объект PromtBasePromt с основным промптом. 196 | :param promt_text: Текстовая строка с основным промптом. 197 | :return: Объект PromtBasePromt. 198 | """ 199 | 200 | def parse_tools_promt(promt_text: str) -> PromtToolsPromt: 201 | """ 202 | Разбирает текстовую строку и создает объект PromtToolsPromt с промптами инструментов. 203 | :param promt_text: Текстовая строка с промптами инструментов. 204 | :return: Объект PromtToolsPromt. 205 | """ 206 | 207 | def parse_examples(promt_text: str) -> list[PromtExamples]: 208 | """ 209 | Разбирает текстовую строку и создает список объектов PromtExamples с примерами промпта. 210 | :param promt_text: Текстовая строка с примерами промпта. 211 | :return: Список объектов PromtExamples. 212 | """ 213 | 214 | def parse_text_promt_md_to_json( 215 | promt_name: str, promt_group: str, promt_text: str 216 | ) -> PromtObj: 217 | """ 218 | Разбирает текстовый файл Markdown с промптами и создает объект PromtObj. 219 | :param promt_name: Имя промпта. 220 | :param promt_group: Группа промпта. 221 | :param promt_text: Текст промпта в формате Markdown. 222 | :return: Объект PromtObj. 223 | """ 224 | 225 | def parse_file_promt_md_to_json( 226 | path_to_file_promt: pathlib.Path, promt_text: str 227 | ) -> JsonText: 228 | """ 229 | Разбирает файл Markdown и конвертирует его в формат JSON. 230 | :param path_to_file_promt: Путь к файлу промпта. 231 | :param promt_text: Текст промпта. 232 | :return: Текст в формате JSON. 233 | """ 234 | ``` 235 | -------------------------------------------------------------------------------- /examples/Генерация кода на Python.md: -------------------------------------------------------------------------------- 1 | # meta 2 | 3 | - for: 4 | - ChatGPT 5 | - use: 6 | - Первое сообщение 7 | - tags: 8 | - Python 9 | - Code 10 | 11 | # doc 12 | 13 | Этот промт используется для написание документации к коду. В частности для языка программирования Python 14 | 15 | # base_promt 16 | 17 | ```promt 18 | Напиши докстригки к этому {ЧемуДокументация}. В ответ отправь только имя класса/метода и его докстринг: 19 | 20 | {{CODE}} 21 | ``` 22 | 23 | - CODE ~ Код которому нужно написать документацию 24 | - ЧемуДокументация ~ К чему нужно писать документацию 25 | - Класс 26 | - Метод 27 | - [x] Класс и метод 28 | - Атрибуты 29 | 30 | # tools 31 | 32 | Тут будет список вспомогательных промтов. Например которые логично использовать совместно с основным промтом 33 | 34 | ```promt 35 | Продолжи свой ответ, с того места где ты закончил прошлый 36 | ``` 37 | 38 | ```promt 39 | Напиши снова главу: {{ИмяГлавы}} 40 | ``` 41 | 42 | - ИмяГлавы ~ Название главы 43 | 44 | # expl 45 | 46 | ## Пример написание документация для тестов 47 | 48 | ```python 49 | class SubdivisionSearchApiViewTests(APITestCaseAuthorization): 50 | def setUp(self): 51 | super().setUp() 52 | self.url = reverse("subdivisionsearch") 53 | 54 | def test_list_subdivisions(self): 55 | response = self.client.get(self.url) 56 | self.assertEqual(response.status_code, status.HTTP_200_OK) 57 | self.assertEqual(len(response.data["results"]), 2) 58 | self.assertEqual( 59 | response.data["results"][0], SubdivisionSerializer(self.subdivision).data 60 | ) 61 | self.assertEqual( 62 | response.data["results"][1], SubdivisionSerializer(self.subdivision2).data 63 | ) 64 | 65 | def test_create_subdivision(self): 66 | new_data = { 67 | "department": self.department.id, 68 | "name": "Отделение 3", 69 | "start_date": "2023-03-01", 70 | } 71 | response = self.client.post(self.url, new_data) 72 | self.assertEqual(response.status_code, status.HTTP_201_CREATED) 73 | self.assertTrue(Subdivision.objects.filter(name=new_data["name"]).exists()) 74 | 75 | def test_filter_subdivisions_by_department(self): 76 | response = self.client.get(self.url) 77 | self.assertEqual(response.status_code, status.HTTP_200_OK) 78 | self.assertEqual(len(response.data["results"]), 2) 79 | self.assertEqual( 80 | response.data["results"][0], SubdivisionSerializer(self.subdivision).data 81 | ) 82 | self.assertEqual( 83 | response.data["results"][1], SubdivisionSerializer(self.subdivision2).data 84 | ) 85 | 86 | def test_filter_subdivisions_by_date(self): 87 | response = self.client.get(self.url) 88 | self.assertEqual(response.status_code, status.HTTP_200_OK) 89 | self.assertEqual(len(response.data["results"]), 2) 90 | self.assertEqual( 91 | response.data["results"][0], SubdivisionSerializer(self.subdivision).data 92 | ) 93 | self.assertEqual( 94 | response.data["results"][1], SubdivisionSerializer(self.subdivision2).data 95 | ) 96 | ``` 97 | 98 | ### Пример 1 99 | 100 | Класс: SubdivisionSearchApiViewTests 101 | 102 | Докстринг класса: 103 | Тесты для представления API поиска подразделений 104 | 105 | Метод: setUp 106 | 107 | Докстринг метода: 108 | Переопределение метода setUp для настройки тестового окружения 109 | 110 | Метод: test_list_subdivisions 111 | 112 | Докстринг метода: 113 | Тест для проверки получения списка подразделений 114 | 115 | Метод: test_create_subdivision 116 | 117 | Докстринг метода: 118 | Тест для проверки создания нового подразделения 119 | 120 | Метод: test_filter_subdivisions_by_department 121 | 122 | Докстринг метода: 123 | Тест для проверки фильтрации подразделений по отделу 124 | 125 | Метод: test_filter_subdivisions_by_date 126 | 127 | Докстринг метода: 128 | Тест для проверки фильтрации подразделений по дате 129 | 130 | ### Пример 2 131 | 132 | Класс: SubdivisionSearchApiViewTests 133 | Докстринг: Класс для тестирования API поиска подразделений. 134 | 135 | Метод: setUp 136 | Докстринг: Настраивает тестовый случай перед каждым тестом. 137 | 138 | Метод: test_list_subdivisions 139 | Докстринг: Тест проверяет получение списка всех подразделений. 140 | 141 | Метод: test_create_subdivision 142 | Докстринг: Тест проверяет создание нового подразделения. 143 | 144 | Метод: test_filter_subdivisions_by_department 145 | Докстринг: Тест проверяет фильтрацию подразделений по департаменту. 146 | 147 | Метод: test_filter_subdivisions_by_date 148 | Докстринг: Тест проверяет фильтрацию подразделений по дате. 149 | 150 | ## Пример написания документации для кода с логикой 151 | 152 | ```python 153 | import json 154 | import re 155 | 156 | from lib_re import RePromt 157 | from lib_types import ( 158 | PromtBasePromt, 159 | PromtCodeBlock, 160 | PromtHeder, 161 | PromtMeta, 162 | PromtToolsPromt, 163 | ) 164 | 165 | 166 | def parse_header_md_to_obj(promt_header: str) -> PromtHeder: 167 | """Распарсить главу с прмотом""" 168 | # Убрать комментарии из текста 169 | promt_header = RePromt.clear_comments.sub("", promt_header) 170 | 171 | name = RePromt.search_h1.search(promt_header)["name_promt"].strip() 172 | meta_raw = RePromt.meta_h2.search(promt_header)["meta_text"].strip() 173 | des = RePromt.des_h2.search(promt_header)["doc_text"].strip() 174 | base_promt_raw = RePromt.base_promt_h2.search(promt_header)[ 175 | "base_promt_text" 176 | ].strip() 177 | examples_raw = RePromt.examples_promt_h3.search(promt_header)[ 178 | "examples_promt_text" 179 | ].strip() 180 | tools_promt_raw = RePromt.tools_promt_h2.search(promt_header)[ 181 | "tools_promt_text" 182 | ].strip() 183 | ### 184 | # meta_raw 185 | # 186 | meta_obj = { 187 | m["key"]: RePromt.md_list.findall(m["values"]) 188 | for m in RePromt.meta_parse_body.finditer(meta_raw) 189 | } 190 | meta = PromtMeta( 191 | for_=meta_obj.get("for", tuple()), 192 | use=meta_obj.get("use", tuple()), 193 | group=meta_obj.get("group", tuple()), 194 | tags=meta_obj.get("tags", tuple()), 195 | ) 196 | ### 197 | # 198 | # base_promt_raw 199 | # 200 | base_promt_obj = RePromt.promt_code_block.search(base_promt_raw) 201 | base_promt = PromtBasePromt( 202 | promt=PromtCodeBlock( 203 | text_promt=base_promt_obj["code"], 204 | templates={ 205 | m["key"]: m["value"].strip() 206 | for m in RePromt.md_dict.finditer(base_promt_obj["templates"]) 207 | } 208 | if base_promt_obj["templates"] 209 | else "", 210 | ), 211 | examples=tuple( 212 | m["code"] for m in RePromt.examples_code_block.finditer(examples_raw) 213 | ), 214 | ) 215 | ### 216 | # 217 | # tools_promt_raw 218 | # 219 | tools_promt = PromtToolsPromt( 220 | promts=tuple( 221 | PromtCodeBlock( 222 | text_promt=m["code"], 223 | templates={ 224 | m2["key"]: m2["value"].strip() 225 | for m2 in RePromt.md_dict.finditer(m["templates"]) 226 | } 227 | if m["templates"] 228 | else "", 229 | ) 230 | for m in RePromt.promt_code_block.finditer(tools_promt_raw) 231 | ) 232 | ) 233 | 234 | p = PromtHeder( 235 | name=name, meta=meta, des=des, base_promt=base_promt, tools_promt=tools_promt 236 | ) 237 | 238 | return p 239 | 240 | 241 | def parse_promt_md_to_json(promt_text: str) -> str: 242 | """Распарсить весь Markdown файл с промтами 243 | и вызвать для каждого промта функцию parse_header_md_to_obj 244 | 245 | promt_text: Прмоты в Markdown формате 246 | return: Промты в Json формате 247 | """ 248 | 249 | arr_promts: PromtHeder = [] 250 | 251 | h1_last: re.Match = None 252 | 253 | for h1_now in RePromt.search_h1.finditer(promt_text): 254 | h1_now: re.Match 255 | 256 | if h1_last: 257 | promt_header = promt_text[h1_last.span()[0] : h1_now.span()[0]] 258 | arr_promts.append(parse_header_md_to_obj(promt_header)) 259 | h1_last = h1_now 260 | 261 | if h1_last: 262 | promt_header = promt_text[h1_last.span()[0] :] 263 | arr_promts.append(parse_header_md_to_obj(promt_header)) 264 | 265 | r = json.dumps(arr_promts, ensure_ascii=False, indent=4) 266 | return r 267 | ``` 268 | 269 | ### Пример 1 270 | 271 | Функция: parse_header_md_to_obj 272 | Докстринг: Распарсить раздел с промптом из Markdown и преобразовать его в объект. 273 | 274 | Функция: parse_promt_md_to_json 275 | Докстринг: Распарсить весь Markdown файл с промптами, вызвать для каждого промта функцию parse_header_md_to_obj и преобразовать результат в JSON формат. 276 | -------------------------------------------------------------------------------- /examples/json/Генерация кода на Python.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "Генерация кода на Python.md", 3 | "meta": { 4 | "for_": [ 5 | "ChatGPT" 6 | ], 7 | "use": [ 8 | "Первое сообщение" 9 | ], 10 | "group": "examples", 11 | "tags": [ 12 | "Python", 13 | "Code" 14 | ], 15 | "version": null 16 | }, 17 | "doc": "Этот промт используется для написание документации к коду. В частности для языка программирования Python", 18 | "base_promt": { 19 | "promt": { 20 | "text_promt": "Напиши докстригки к этому {ЧемуДокументация}. В ответ отправь только имя класса/метода и его докстринг:\n\n{{CODE}}", 21 | "vars": [ 22 | { 23 | "name": "CODE", 24 | "doc": " Код которому нужно написать документацию", 25 | "default": null, 26 | "allowed": [] 27 | }, 28 | { 29 | "name": "ЧемуДокументация", 30 | "doc": " К чему нужно писать документацию", 31 | "default": "Класс и метод", 32 | "allowed": [ 33 | "Класс", 34 | "Метод", 35 | "Класс и метод", 36 | "Атрибуты" 37 | ] 38 | } 39 | ] 40 | } 41 | }, 42 | "tools_promt": { 43 | "promts": [ 44 | { 45 | "about_promt": null, 46 | "text_promt": "Продолжи свой ответ, с того места где ты закончил прошлый", 47 | "vars": [] 48 | }, 49 | { 50 | "about_promt": null, 51 | "text_promt": "Напиши снова главу: {{ИмяГлавы}}", 52 | "vars": [ 53 | { 54 | "name": "ИмяГлавы", 55 | "doc": " Название главы", 56 | "default": null, 57 | "allowed": [] 58 | } 59 | ] 60 | } 61 | ] 62 | }, 63 | "expl": [ 64 | { 65 | "name": "Пример написание документация для тестов", 66 | "in_text": "\n```python\nclass SubdivisionSearchApiViewTests(APITestCaseAuthorization):\n def setUp(self):\n super().setUp()\n self.url = reverse(\"subdivisionsearch\")\n\n def test_list_subdivisions(self):\n response = self.client.get(self.url)\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(len(response.data[\"results\"]), 2)\n self.assertEqual(\n response.data[\"results\"][0], SubdivisionSerializer(self.subdivision).data\n )\n self.assertEqual(\n response.data[\"results\"][1], SubdivisionSerializer(self.subdivision2).data\n )\n\n def test_create_subdivision(self):\n new_data = {\n \"department\": self.department.id,\n \"name\": \"Отделение 3\",\n \"start_date\": \"2023-03-01\",\n }\n response = self.client.post(self.url, new_data)\n self.assertEqual(response.status_code, status.HTTP_201_CREATED)\n self.assertTrue(Subdivision.objects.filter(name=new_data[\"name\"]).exists())\n\n def test_filter_subdivisions_by_department(self):\n response = self.client.get(self.url)\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(len(response.data[\"results\"]), 2)\n self.assertEqual(\n response.data[\"results\"][0], SubdivisionSerializer(self.subdivision).data\n )\n self.assertEqual(\n response.data[\"results\"][1], SubdivisionSerializer(self.subdivision2).data\n )\n\n def test_filter_subdivisions_by_date(self):\n response = self.client.get(self.url)\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(len(response.data[\"results\"]), 2)\n self.assertEqual(\n response.data[\"results\"][0], SubdivisionSerializer(self.subdivision).data\n )\n self.assertEqual(\n response.data[\"results\"][1], SubdivisionSerializer(self.subdivision2).data\n )\n```\n", 67 | "out_text": { 68 | "Пример 1": "\nКласс: SubdivisionSearchApiViewTests\n\nДокстринг класса:\nТесты для представления API поиска подразделений\n\nМетод: setUp\n\nДокстринг метода:\nПереопределение метода setUp для настройки тестового окружения\n\nМетод: test_list_subdivisions\n\nДокстринг метода:\nТест для проверки получения списка подразделений\n\nМетод: test_create_subdivision\n\nДокстринг метода:\nТест для проверки создания нового подразделения\n\nМетод: test_filter_subdivisions_by_department\n\nДокстринг метода:\nТест для проверки фильтрации подразделений по отделу\n\nМетод: test_filter_subdivisions_by_date\n\nДокстринг метода:\nТест для проверки фильтрации подразделений по дате\n", 69 | "Пример 2": "\nКласс: SubdivisionSearchApiViewTests\nДокстринг: Класс для тестирования API поиска подразделений.\n\nМетод: setUp\nДокстринг: Настраивает тестовый случай перед каждым тестом.\n\nМетод: test_list_subdivisions\nДокстринг: Тест проверяет получение списка всех подразделений.\n\nМетод: test_create_subdivision\nДокстринг: Тест проверяет создание нового подразделения.\n\nМетод: test_filter_subdivisions_by_department\nДокстринг: Тест проверяет фильтрацию подразделений по департаменту.\n\nМетод: test_filter_subdivisions_by_date\nДокстринг: Тест проверяет фильтрацию подразделений по дате.\n" 70 | } 71 | }, 72 | { 73 | "name": "Пример написания документации для кода с логикой", 74 | "in_text": "\n```python\nimport json\nimport re\n\nfrom lib_re import RePromt\nfrom lib_types import (\n PromtBasePromt,\n PromtCodeBlock,\n PromtHeder,\n PromtMeta,\n PromtToolsPromt,\n)\n\n\ndef parse_header_md_to_obj(promt_header: str) -> PromtHeder:\n \"\"\"Распарсить главу с прмотом\"\"\"\n # Убрать комментарии из текста\n promt_header = RePromt.clear_comments.sub(\"\", promt_header)\n\n name = RePromt.search_h1.search(promt_header)[\"name_promt\"].strip()\n meta_raw = RePromt.meta_h2.search(promt_header)[\"meta_text\"].strip()\n des = RePromt.des_h2.search(promt_header)[\"doc_text\"].strip()\n base_promt_raw = RePromt.base_promt_h2.search(promt_header)[\n \"base_promt_text\"\n ].strip()\n examples_raw = RePromt.examples_promt_h3.search(promt_header)[\n \"examples_promt_text\"\n ].strip()\n tools_promt_raw = RePromt.tools_promt_h2.search(promt_header)[\n \"tools_promt_text\"\n ].strip()\n ###\n # meta_raw\n #\n meta_obj = {\n m[\"key\"]: RePromt.md_list.findall(m[\"values\"])\n for m in RePromt.meta_parse_body.finditer(meta_raw)\n }\n meta = PromtMeta(\n for_=meta_obj.get(\"for\", tuple()),\n use=meta_obj.get(\"use\", tuple()),\n group=meta_obj.get(\"group\", tuple()),\n tags=meta_obj.get(\"tags\", tuple()),\n )\n ###\n #\n # base_promt_raw\n #\n base_promt_obj = RePromt.promt_code_block.search(base_promt_raw)\n base_promt = PromtBasePromt(\n promt=PromtCodeBlock(\n text_promt=base_promt_obj[\"code\"],\n templates={\n m[\"key\"]: m[\"value\"].strip()\n for m in RePromt.md_dict.finditer(base_promt_obj[\"templates\"])\n }\n if base_promt_obj[\"templates\"]\n else \"\",\n ),\n examples=tuple(\n m[\"code\"] for m in RePromt.examples_code_block.finditer(examples_raw)\n ),\n )\n ###\n #\n # tools_promt_raw\n #\n tools_promt = PromtToolsPromt(\n promts=tuple(\n PromtCodeBlock(\n text_promt=m[\"code\"],\n templates={\n m2[\"key\"]: m2[\"value\"].strip()\n for m2 in RePromt.md_dict.finditer(m[\"templates\"])\n }\n if m[\"templates\"]\n else \"\",\n )\n for m in RePromt.promt_code_block.finditer(tools_promt_raw)\n )\n )\n\n p = PromtHeder(\n name=name, meta=meta, des=des, base_promt=base_promt, tools_promt=tools_promt\n )\n\n return p\n\n\ndef parse_promt_md_to_json(promt_text: str) -> str:\n \"\"\"Распарсить весь Markdown файл с промтами\n и вызвать для каждого промта функцию parse_header_md_to_obj\n\n promt_text: Прмоты в Markdown формате\n return: Промты в Json формате\n \"\"\"\n\n arr_promts: PromtHeder = []\n\n h1_last: re.Match = None\n\n for h1_now in RePromt.search_h1.finditer(promt_text):\n h1_now: re.Match\n\n if h1_last:\n promt_header = promt_text[h1_last.span()[0] : h1_now.span()[0]]\n arr_promts.append(parse_header_md_to_obj(promt_header))\n h1_last = h1_now\n\n if h1_last:\n promt_header = promt_text[h1_last.span()[0] :]\n arr_promts.append(parse_header_md_to_obj(promt_header))\n\n r = json.dumps(arr_promts, ensure_ascii=False, indent=4)\n return r\n```\n", 75 | "out_text": { 76 | "Пример 1": "\nФункция: parse_header_md_to_obj\nДокстринг: Распарсить раздел с промптом из Markdown и преобразовать его в объект.\n\nФункция: parse_promt_md_to_json\nДокстринг: Распарсить весь Markdown файл с промптами, вызвать для каждого промта функцию parse_header_md_to_obj и преобразовать результат в JSON формат." 77 | } 78 | } 79 | ] 80 | } -------------------------------------------------------------------------------- /promtstd/lib_to_json.py: -------------------------------------------------------------------------------- 1 | from typing import Optional 2 | 3 | from lib_linter import StatusWarning, logLinter 4 | from lib_main import ParserPromtStd 5 | from lib_re import RePromt 6 | from lib_types import ( 7 | JsonText, 8 | PromtBasePromt, 9 | PromtCodeBlock, 10 | PromtCodeBlockVars, 11 | PromtExamples, 12 | PromtMeta, 13 | PromtObj, 14 | PromtToolsPromt, 15 | ) 16 | 17 | 18 | class ParserPromtStdToJson(ParserPromtStd): 19 | def parse_file_promt_md_to_json(self) -> JsonText: 20 | """ 21 | Разбирает файл Markdown и конвертирует его в формат JSON, на основе стандарта promtstd. 22 | 23 | :return: Текст в формате JSON. 24 | """ 25 | return self.parse_text_promt_md_to_json( 26 | self.select_file.read_text(encoding="utf-8"), 27 | str(self.select_file.name), 28 | str(self.select_file.parent.name), 29 | ) 30 | 31 | def parse_text_promt_md_to_json( 32 | self, promt_text: str, promt_name: str, promt_group_name: str 33 | ) -> JsonText: 34 | """ 35 | Разбирает текстовый файл Markdown с промптами и создает объект PromtObj. 36 | 37 | :param promt_name: Имя промпта. 38 | :param promt_group_name: Имя какой группе относиться промпт. 39 | :param promt_text: Текст промпта в формате Markdown. 40 | :return: Объект JsonText. 41 | """ 42 | 43 | # Убрать комментарии из текста 44 | promt_text = RePromt.md_comment.sub("", promt_text) 45 | 46 | name = promt_name 47 | 48 | # Парсинг мета-данных 49 | meta = self._parse_meta(promt_text, promt_group_name) 50 | 51 | if doc := RePromt.doc_h1.search(promt_text): 52 | doc = doc["doc_text"].strip() 53 | 54 | # Парсинг основного промпта 55 | base_promt = self._parse_base_promt(promt_text) 56 | 57 | # Парсинг промптов инструментов 58 | tools_promt = self._parse_tools_promt(promt_text) 59 | 60 | # Парсинг примеров 61 | examples = self._parse_examples(promt_text) 62 | 63 | p = PromtObj( 64 | name=name, 65 | meta=meta, 66 | doc=doc, 67 | base_promt=base_promt, 68 | tools_promt=tools_promt, 69 | expl=examples, 70 | ) 71 | 72 | return JsonText(p) 73 | 74 | # 75 | ## 76 | ### 77 | #### Низкоуровневые методы 78 | ### 79 | ## 80 | # 81 | 82 | def _parse_promt_code_block_vars( 83 | self, text_promt: str, text_vars: str 84 | ) -> list[PromtCodeBlockVars]: 85 | """ 86 | Разбирает текстовую строку и создает объекты PromtCodeBlockVars. 87 | 88 | :param code: Текст промта 89 | :param text_vars: Текстовая строка с описанием переменных промпта. 90 | :return: Список объектов PromtCodeBlockVars. 91 | """ 92 | 93 | res: list[PromtCodeBlockVars] = [] 94 | vars_find: set[str] = set() 95 | if text_vars: 96 | # Итерация по найденным переменным описания промпта 97 | for m in RePromt.promt_code_block_vars.finditer(text_vars): 98 | name = m["name"].strip() 99 | doc = m["doc"] 100 | allowed = [] 101 | default = None 102 | 103 | # Итерация по разрешенным значениям переменной 104 | for m in RePromt.md_list.finditer(m["allowed"]): 105 | # Поиск значения по умолчанию среди разрешенных значений 106 | if m["is_select"]: 107 | default = m["item"] 108 | allowed.append(m["item"]) 109 | 110 | # Создание объекта PromtCodeBlockVars и добавление его в список 111 | res.append( 112 | PromtCodeBlockVars( 113 | name=name, 114 | doc=doc, 115 | default=default, 116 | allowed=allowed, 117 | ) 118 | ) 119 | vars_find.add(name) 120 | 121 | # Добавляем в список переменных, и те переменные которые не имеют описание 122 | for var_no_doc in RePromt.promt_inner_vars.finditer(text_promt): 123 | if var_no_doc["name"] not in vars_find: 124 | res.append( 125 | PromtCodeBlockVars( 126 | name=var_no_doc["name"], 127 | doc=None, 128 | default=None, 129 | allowed=None, 130 | ) 131 | ) 132 | 133 | return res 134 | 135 | def _parse_meta( 136 | self, promt_text: str, promt_group_name: str 137 | ) -> Optional[PromtMeta]: 138 | """ 139 | Разбирает текстовую строку и создает объект PromtMeta с мета-данными о промпте. 140 | 141 | :param promt_text: Текстовая строка с мета-данными промпта. 142 | :param promt_group_name: Имя какой группе относиться промпт. 143 | :return: Объект PromtMeta. 144 | """ 145 | 146 | if meta_raw := RePromt.meta_h1.search(promt_text): 147 | meta_raw = meta_raw["meta_text"].strip() 148 | # Создание словаря meta_obj с ключами и соответствующими им списками значений 149 | meta_obj = { 150 | m["key"]: [x["item"] for x in RePromt.md_list.finditer(m["values"])] 151 | for m in RePromt.meta_parse_body.finditer(meta_raw) 152 | } 153 | # Создание объекта PromtMeta с использованием данных из meta_obj 154 | meta = PromtMeta( 155 | for_=meta_obj.get("for", tuple()), 156 | use=meta_obj.get("use", tuple()), 157 | group=promt_group_name, 158 | tags=meta_obj.get("tags", tuple()), 159 | version=meta_obj.get("version", None), 160 | ) 161 | return meta 162 | else: 163 | logLinter(StatusWarning.not_h1_meta_header, where_event=self.select_file) 164 | 165 | def _parse_base_promt(self, promt_text: str) -> Optional[PromtBasePromt]: 166 | """ 167 | Разбирает текстовую строку и создает объект PromtBasePromt с основным промптом. 168 | 169 | :param promt_text: Текстовая строка с основным промптом. 170 | :return: Объект PromtBasePromt. 171 | """ 172 | if base_promt_raw := RePromt.base_promt_h1.search(promt_text): 173 | # Извлечение основного промпта из текста 174 | base_promt_raw = base_promt_raw["base_promt_text"].strip() 175 | 176 | # Поиск кодового блока промпта в тексте 177 | base_promt_obj = RePromt.promt_code_block.search(base_promt_raw) 178 | 179 | if base_promt_obj: 180 | # Парсинг переменных кодового блока промпта 181 | promt_code_block_vars = self._parse_promt_code_block_vars( 182 | base_promt_obj["code"], base_promt_obj["templates"] 183 | ) 184 | 185 | # Создание объекта PromtBasePromt с полученными данными 186 | base_promt = PromtBasePromt( 187 | promt=PromtCodeBlock( 188 | text_promt=base_promt_obj["code"], 189 | vars=promt_code_block_vars, 190 | ) 191 | ) 192 | 193 | return base_promt 194 | else: 195 | logLinter( 196 | StatusWarning.not_body_base_promt, where_event=self.select_file 197 | ) 198 | 199 | else: 200 | logLinter(StatusWarning.not_h1_base_promt, where_event=self.select_file) 201 | 202 | def _parse_tools_promt(self, promt_text: str) -> Optional[PromtToolsPromt]: 203 | """ 204 | Разбирает текстовую строку и создает объект PromtToolsPromt с промптами инструментов. 205 | 206 | :param promt_text: Текстовая строка с промптами инструментов. 207 | :return: Объект PromtToolsPromt. 208 | """ 209 | if tools_promt_raw := RePromt.tools_promt_h1.search(promt_text): 210 | tools_promt_raw = tools_promt_raw["tools_promt_text"].strip() 211 | 212 | promts: list[PromtCodeBlock] = [] 213 | for m in RePromt.tools_promt_h2.finditer(tools_promt_raw): 214 | if not m["body"]: 215 | logLinter( 216 | StatusWarning.not_body_tools, where_event=self.select_file 217 | ) 218 | 219 | m2 = None 220 | for m2 in RePromt.promt_code_block.finditer(m["body"]): 221 | promts.append( 222 | PromtCodeBlock( 223 | about_promt=m["name"], 224 | text_promt=m2["code"], 225 | vars=self._parse_promt_code_block_vars( 226 | m2["code"], m2["templates"] 227 | ), 228 | ) 229 | ) 230 | if not m2: 231 | logLinter( 232 | StatusWarning.not_body_promt_tools, where_event=self.select_file 233 | ) 234 | 235 | tools_promt = PromtToolsPromt(promts=promts) 236 | return tools_promt 237 | else: 238 | logLinter(StatusWarning.not_h1_tools______, where_event=self.select_file) 239 | 240 | def _parse_examples(self, promt_text: str) -> list[PromtExamples]: 241 | """ 242 | Разбирает текстовую строку и создает список объектов PromtExamples с примерами промпта. 243 | 244 | :param promt_text: Текстовая строка с примерами промпта. 245 | :return: Список объектов PromtExamples. 246 | """ 247 | if examples_raw := RePromt.examples_promt_h1.search(promt_text): 248 | examples_raw = examples_raw["examples_promt_text"].strip() 249 | expl = [] 250 | 251 | for m in RePromt.examples_in_h2.finditer(examples_raw): 252 | _name = m["name"] 253 | in_text = m["doc"] 254 | out_text = {} 255 | for m2 in RePromt.examples_out_h3.finditer(m["out"]): 256 | out_text[m2["name"]] = m2["body"] 257 | 258 | expl.append( 259 | PromtExamples( 260 | name=_name, 261 | in_text=in_text, 262 | out_text=out_text, 263 | ) 264 | ) 265 | 266 | return expl 267 | else: 268 | logLinter(StatusWarning.not_h1_expl_______, where_event=self.select_file) 269 | -------------------------------------------------------------------------------- /examples/json/Оптимизация документации.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "Оптимизация документации.md", 3 | "meta": null, 4 | "doc": null, 5 | "base_promt": { 6 | "promt": { 7 | "text_promt": "Твоя задача - Оптимизируй этот тест документации. В ответ пришли полный измененый текст докуменатции.\n\nДля этого ты можешь:\n\n- Разделить текст на главы\n- Дополнить текст\n- Изменить текст\n- Перефразирвоать название главы\n\nТребования к ответу:\n\n- Пиши ответ в формате Markdown\n- Соблюдай номер глав в тексте\n\nВот текст: \n\n{{Текст}}", 8 | "vars": [ 9 | { 10 | "name": "Текст", 11 | "doc": null, 12 | "default": null, 13 | "allowed": null 14 | } 15 | ] 16 | } 17 | }, 18 | "tools_promt": null, 19 | "expl": [ 20 | { 21 | "name": "Пример 1", 22 | "in_text": "\n
\n#### Создание пользовательских методов валидации\n\nДля более сложной валидации данных вы можете создавать собственные методы валидации в сериализаторе. Эти методы должны иметь название `validate_<field_name>` и принимать значение поля в качестве аргумента. Например:\n\n```python\nfrom rest_framework import serializers\n\nclass UserSerializer(serializers.Serializer):\n    ИмяАтрибута = serializers.CharField(max_length=100)\n    email = serializers.EmailField()\n    age = serializers.IntegerField(min_value=0, max_value=150)\n\n    def validate_ИмяАтрибута(self, value):\n        if \"admin\" in value.lower():\n            raise serializers.ValidationError(\"Имя пользователя не должно содержать слово 'admin'.\")\n        return value\n\n```\n\nВ этом примере мы создали пользовательский метод валидации для поля username, который проверяет, что в имени пользователя не содержится слово \"admin\". Если это условие не выполняется, вызывается исключение ValidationError.\n\nТеперь, когда вы знакомы с валидацией данных, давайте рассмотрим создание и обновление объектов с использованием сериализаторов.\n\n#### Метод to_representation\n\nМетод to_representation позваляет переопределить логику сериализации, в этом методе мы можем измеить данные которые будут храниться в `serializer.data`\n\n```python\ndef to_representation(self, instance):\n representation = super().to_representation(instance)\n # Изменяем вариант возвращаемых данных для ключа frmo\n representation[\"frmo\"] = {\"id\": instance.frmo.pk, \"oid\": instance.frmo.mo_oid}\n return representation\n```\n",
23 |             "out_text": {
24 |                 "CRUD": "\n#### Read\n\n- Создать `serializers.py`\n\n  ```python\n  from rest_framework import serializers\n\n  class ИмяСериализатора(serializers.Serializer):\n      Полеtitle = serializers.CharField(max_length=255)\n      Полеcontent = serializers.CharField()\n  ```\n\n- Использовать во `view.py`\n\n  ```python\n    from rest_framework.views import APIView\n    from rest_framework.request import Request\n\n    class ИмяПредставления(APIView):\n\n        serializer_class = ИмяСериализатора\n\n        def post(slef, request: Request):\n            serializer = ИмяСериализатора(data=request.data)\n            # Проверить валидность Json. Если `raise_exception=True` то при ошибки валидации клиент получит описание ошибки\n            serializer.is_valid(raise_exception=True)\n            # Валидные Json данные\n            return Response({\"status\": \"ok\", \"data\": serializer.validated_data})\n  ```\n\n#### Create\n\n- Создать `serializers.py`\n\n  ```python\n  from rest_framework import serializers\n\n  class ИмяСериализатора(serializers.Serializer):\n      Полеtitle = serializers.CharField(max_length=255)\n      Полеcontent = serializers.CharField()\n\n      def create(self, validated_data:dict):\n          '''\n          Переопределяем метод create, он вызовиться при выполение метода save\n\n          validated_data: Валиадные данные\n          '''\n          return {\"Полеtitle\":\"Данные\",\"Полеcontent\":\"Данные\"}\n  ```\n\n- Использовать во `view.py`\n\n  ```python\n    from rest_framework.views import APIView\n    from rest_framework.request import Request\n\n    class ИмяПредставления(APIView):\n     serializer_class = ИмяСериализатора\n     def post(slef, request: Request):\n      serializer = ИмяСериализатора(data=request.data)\n      # Проверить валидность Json. Если `raise_exception=True` то при ошибки валидации клиент получит описание ошибки\n      serializer.is_valid(raise_exception=True)\n      # Вызвать метод `create` у сериализатора\n      serializer.save()\n      # Вернет ответ из метода `create`\n      return Response(serializer.data)\n  ```\n\n#### Update\n\n```python\n  from rest_framework import serializers\n\n  class ИмяСериализатора(serializers.Serializer):\n      Полеtitle = serializers.CharField(max_length=255)\n      Полеcontent = serializers.CharField()\n\n      def update(self, instance, validated_data):\n          instance.Полеtitle = validated_data.get(\"name\", instance.name)\n          instance.Полеcontent = validated_data.get(\"start_date\", instance.start_date)\n          instance.save()\n          return instance\n```\n",
25 |                 "Ответ 1": "\n
\nТвоя задача - Оптимизируй этот тест документации. В ответ пришли полный измененый текст докуменатции.\n\nДля этого ты можешь:\n\n- Разделить текст на главы\n- Дополнить текст\n- Изменить текст\n- Перефразирвоать название главы\n\nТребования к ответу:\n\n- Пиши ответ в формате Markdown\n- Соблюдай номер глав в тексте\n\nВот текст:\n\n#### Создание пользовательских методов валидации\n\nДля более сложной валидации данных вы можете создавать собственные методы валидации в сериализаторе. Эти методы должны иметь название `validate_<field_name>` и принимать значение поля в качестве аргумента. Например:\n\n```python\nfrom rest_framework import serializers\n\nclass UserSerializer(serializers.Serializer):\n    ИмяАтрибута = serializers.CharField(max_length=100)\n    email = serializers.EmailField()\n    age = serializers.IntegerField(min_value=0, max_value=150)\n\n    def validate_ИмяАтрибута(self, value):\n        if \"admin\" in value.lower():\n            raise serializers.ValidationError(\"Имя пользователя не должно содержать слово 'admin'.\")\n        return value\n\n```\n\nВ этом примере мы создали пользовательский метод валидации для поля username, который проверяет, что в имени пользователя не содержится слово \"admin\". Если это условие не выполняется, вызывается исключение ValidationError.\n\nТеперь, когда вы знакомы с валидацией данных, давайте рассмотрим создание и обновление объектов с использованием сериализаторов.\n\n#### Метод to_representation\n\nМетод to_representation позваляет переопределить логику сериализации, в этом методе мы можем измеить данные которые будут храниться в `serializer.data`\n\n```python\ndef to_representation(self, instance):\n representation = super().to_representation(instance)\n # Изменяем вариант возвращаемых данных для ключа frmo\n representation[\"frmo\"] = {\"id\": instance.frmo.pk, \"oid\": instance.frmo.mo_oid}\n return representation\n```\n"
26 |             }
27 |         },
28 |         {
29 |             "name": "Документация API### Глава 1: Валидация данных",
30 |             "in_text": "Для обеспечения корректности данных, передаваемых в API, необходима валидация данных. В Django REST Framework валидация данных происходит в сериализаторах.\n
Глава 1.1: Создание пользовательских методов валидации
\nДля более сложной валидации данных вы можете создавать собственные методы валидации в сериализаторе. Эти методы должны иметь название `validate_&lt;field_name&gt;` и принимать значение поля в качестве аргумента.\n\nПример:\n\n```\nfrom rest_framework import serializers\n\nclass UserSerializer(serializers.Serializer):\n    ИмяАтрибута = serializers.CharField(max_length=100)\n    email = serializers.EmailField()\n    age = serializers.IntegerField(min_value=0, max_value=150)\n\n    def validate_ИмяАтрибута(self, value):\n        if \"admin\" in value.lower():\n            raise serializers.ValidationError(\"Имя пользователя не должно содержать слово 'admin'.\")\n        return value\n\n```\n\nВ этом примере мы создали пользовательский метод валидации для поля ИмяАтрибута, который проверяет, что в имени пользователя не содержится слово \"admin\". Если это условие не выполняется, вызывается исключение ValidationError.\n
Глава 1.2: Метод to_representation
\nМетод `to_representation` позволяет переопределить логику сериализации. В этом методе мы можем изменить данные, которые будут храниться в `serializer.data`.\n\nПример:\n\n```\ndef to_representation(self, instance):\n representation = super().to_representation(instance)\n # Изменяем вариант возвращаемых данных для ключа frmo\n representation[\"frmo\"] = {\"id\": instance.frmo.pk, \"oid\": instance.frmo.mo_oid}\n return representation\n\n```",
31 |             "out_text": {
32 |                 "Глава 2: CRUD": "CRUD - это основные операции, выполняемые с данными: create (создание), read (чтение), update (обновление) и delete (удаление). В Django REST Framework для выполнения этих операций используются представления и сериализаторы.\n
Глава 2.1: Read
\nЧтение данных из API происходит с использованием HTTP метода GET.\n\nШаги для чтения данных:\n\n1. Создать сериализатор в `serializers.py`\n\n```\nfrom rest_framework import serializers\n\nclass ИмяСериализатора(serializers.Serializer):\n    Полеtitle = serializers.CharField(max_length=255)\n    Полеcontent = serializers.CharField()\n\n```\n
    Использовать во `views.py`
\n```\nfrom rest_framework.views import APIView\nfrom rest_framework.request import Request\n\nclass ИмяПредставления(APIView):\n\n    serializer_class = ИмяСериализатора\n\n    def post(slef, request: Request):\n        serializer = ИмяСериализатора(data=request.data)\n        # Проверить валидность Json. Если `raise_exception=True` то при ошибки валидации клиент получит описание ошибки\n\n    serializer.is_valid(raise_exception=True)\n    # Валидные Json данные\n    return Response({\"status\": \"ok\", \"data\": serializer.validated_data})\n\n```\n\n#### Глава 2.2: Create\n\nСоздание данных в API происходит с использованием HTTP метода POST.\n\nШаги для создания данных:\n\n1. Создать сериализатор в `serializers.py`\n\n```python\nfrom rest_framework import serializers\n\nclass ИмяСериализатора(serializers.Serializer):\n    Полеtitle = serializers.CharField(max_length=255)\n    Полеcontent = serializers.CharField()\n\n    def create(self, validated_data:dict):\n        '''\n        Переопределяем метод create, он вызовиться при выполение метода save\n\n        validated_data: Валиадные данные\n        '''\n        return {\"Полеtitle\":\"Данные\",\"Полеcontent\":\"Данные\"}\n\n```\n
    Использовать во `views.py`
\n```\nfrom rest_framework.views import APIView\nfrom rest_framework.request import Request\n\nclass ИмяПредставления(APIView):\n serializer_class = ИмяСериализатора\n def post(slef, request: Request):\n  serializer = ИмяСериализатора(data=request.data)\n  # Проверить валидность Json. Если `raise_exception=True` то при ошибки валидации клиент получит описание ошибки\n  serializer.is_valid(raise_exception=True)\n  # Вызвать метод `create` у сериализатора\n  serializer.save()\n  # Вернет ответ из метода `create`\n  return Response(serializer.data)\n\n```\n
Глава 2.3: Update
\nОбновление данных в API происходит с использованием HTTP метода PUT или PATCH.\n\nШаги для обновления данных:\n\n1. Создать сериализатор в `serializers.py`\n\n```\nfrom rest_framework import serializers\n\nclass ИмяСериализатора(serializers.Serializer):\n    Полеtitle = serializers.CharField(max_length=255)\n    Полеcontent = serializers.CharField()\n\n    def update(self, instance, validated_data):\n        instance.Полеtitle = validated_data.get(\"name\", instance.name)\n        instance.Полеcontent = validated_data.get(\"start_date\", instance.start_date)\n        instance.save()\n        return instance\n\n```\n
    Использовать во `views.py`
\n```\nfrom rest_framework.views import APIView\nfrom rest_framework.request import Request\n\nclass ИмяПредставления(APIView):\n serializer_class = ИмяСериализатора\n def put(slef, request: Request, pk:int):\n  instance = self.get_object(pk)\n  serializer = ИмяСериализатора(instance, data=request.data)\n  # Проверить валидность Json. Если `raise_exception=True` то при ошибки валидации клиент получит описание ошибки\n  serializer.is_valid(raise_exception=True)\n  # Вызвать метод `update` у сериализатора\n  serializer.save()\n  # Вернет ответ из метода `update`\n  return Response(serializer.data)\n\n```\n\n
Глава 2.4: Delete
\nУдаление данных из API происходит с использованием HTTP метода DELETE.\n\nШаги для удаления данных:\n\n1. Использовать во `views.py`\n\n```\nfrom rest_framework.views import APIView\nfrom rest_framework.request import Request\n\nclass ИмяПредставления(APIView):\n def delete(slef, request: Request, pk:int):\n  instance = self.get_object(pk)\n  # Удалить объект из базы данных\n  instance.delete()\n  # Вернуть ответ, что объект был успешно удален\n  return Response(status=status.HTTP_204_NO_CONTENT)\n\n```\n\nЭто была оптимизированная документация API. Благодарю за возможность помочь!\n
"
33 |             }
34 |         }
35 |     ]
36 | }


--------------------------------------------------------------------------------
/examples/Оптимизация документации.md:
--------------------------------------------------------------------------------
  1 | 
  2 | # base_promt
  3 | 
  4 | ```promt
  5 | Твоя задача - Оптимизируй этот тест документации. В ответ пришли полный измененый текст докуменатции.
  6 | 
  7 | Для этого ты можешь:
  8 | 
  9 | - Разделить текст на главы
 10 | - Дополнить текст
 11 | - Изменить текст
 12 | - Перефразирвоать название главы
 13 | 
 14 | Требования к ответу:
 15 | 
 16 | - Пиши ответ в формате Markdown
 17 | - Соблюдай номер глав в тексте
 18 | 
 19 | Вот текст: 
 20 | 
 21 | {{Текст}}
 22 | ```
 23 | 
 24 | # expl
 25 | 
 26 | ## Пример 1
 27 | 
 28 | 
 29 | #### Создание пользовательских методов валидации
 30 | 
 31 | Для более сложной валидации данных вы можете создавать собственные методы валидации в сериализаторе. Эти методы должны иметь название `validate_<field_name>` и принимать значение поля в качестве аргумента. Например:
 32 | 
 33 | ```python
 34 | from rest_framework import serializers
 35 | 
 36 | class UserSerializer(serializers.Serializer):
 37 |     ИмяАтрибута = serializers.CharField(max_length=100)
 38 |     email = serializers.EmailField()
 39 |     age = serializers.IntegerField(min_value=0, max_value=150)
 40 | 
 41 |     def validate_ИмяАтрибута(self, value):
 42 |         if "admin" in value.lower():
 43 |             raise serializers.ValidationError("Имя пользователя не должно содержать слово 'admin'.")
 44 |         return value
 45 | 
 46 | ```
 47 | 
 48 | В этом примере мы создали пользовательский метод валидации для поля username, который проверяет, что в имени пользователя не содержится слово "admin". Если это условие не выполняется, вызывается исключение ValidationError.
 49 | 
 50 | Теперь, когда вы знакомы с валидацией данных, давайте рассмотрим создание и обновление объектов с использованием сериализаторов.
 51 | 
 52 | #### Метод to_representation
 53 | 
 54 | Метод to_representation позваляет переопределить логику сериализации, в этом методе мы можем измеить данные которые будут храниться в `serializer.data`
 55 | 
 56 | ```python
 57 | def to_representation(self, instance):
 58 |  representation = super().to_representation(instance)
 59 |  # Изменяем вариант возвращаемых данных для ключа frmo
 60 |  representation["frmo"] = {"id": instance.frmo.pk, "oid": instance.frmo.mo_oid}
 61 |  return representation
 62 | ```
 63 | 
 64 | ### CRUD
 65 | 
 66 | #### Read
 67 | 
 68 | - Создать `serializers.py`
 69 | 
 70 |   ```python
 71 |   from rest_framework import serializers
 72 | 
 73 |   class ИмяСериализатора(serializers.Serializer):
 74 |       Полеtitle = serializers.CharField(max_length=255)
 75 |       Полеcontent = serializers.CharField()
 76 |   ```
 77 | 
 78 | - Использовать во `view.py`
 79 | 
 80 |   ```python
 81 |     from rest_framework.views import APIView
 82 |     from rest_framework.request import Request
 83 | 
 84 |     class ИмяПредставления(APIView):
 85 | 
 86 |         serializer_class = ИмяСериализатора
 87 | 
 88 |         def post(slef, request: Request):
 89 |             serializer = ИмяСериализатора(data=request.data)
 90 |             # Проверить валидность Json. Если `raise_exception=True` то при ошибки валидации клиент получит описание ошибки
 91 |             serializer.is_valid(raise_exception=True)
 92 |             # Валидные Json данные
 93 |             return Response({"status": "ok", "data": serializer.validated_data})
 94 |   ```
 95 | 
 96 | #### Create
 97 | 
 98 | - Создать `serializers.py`
 99 | 
100 |   ```python
101 |   from rest_framework import serializers
102 | 
103 |   class ИмяСериализатора(serializers.Serializer):
104 |       Полеtitle = serializers.CharField(max_length=255)
105 |       Полеcontent = serializers.CharField()
106 | 
107 |       def create(self, validated_data:dict):
108 |           '''
109 |           Переопределяем метод create, он вызовиться при выполение метода save
110 | 
111 |           validated_data: Валиадные данные
112 |           '''
113 |           return {"Полеtitle":"Данные","Полеcontent":"Данные"}
114 |   ```
115 | 
116 | - Использовать во `view.py`
117 | 
118 |   ```python
119 |     from rest_framework.views import APIView
120 |     from rest_framework.request import Request
121 | 
122 |     class ИмяПредставления(APIView):
123 |      serializer_class = ИмяСериализатора
124 |      def post(slef, request: Request):
125 |       serializer = ИмяСериализатора(data=request.data)
126 |       # Проверить валидность Json. Если `raise_exception=True` то при ошибки валидации клиент получит описание ошибки
127 |       serializer.is_valid(raise_exception=True)
128 |       # Вызвать метод `create` у сериализатора
129 |       serializer.save()
130 |       # Вернет ответ из метода `create`
131 |       return Response(serializer.data)
132 |   ```
133 | 
134 | #### Update
135 | 
136 | ```python
137 |   from rest_framework import serializers
138 | 
139 |   class ИмяСериализатора(serializers.Serializer):
140 |       Полеtitle = serializers.CharField(max_length=255)
141 |       Полеcontent = serializers.CharField()
142 | 
143 |       def update(self, instance, validated_data):
144 |           instance.Полеtitle = validated_data.get("name", instance.name)
145 |           instance.Полеcontent = validated_data.get("start_date", instance.start_date)
146 |           instance.save()
147 |           return instance
148 | ```
149 | 

150 | 
151 | ### Ответ 1
152 | 
153 | 
154 | Твоя задача - Оптимизируй этот тест документации. В ответ пришли полный измененый текст докуменатции.
155 | 
156 | Для этого ты можешь:
157 | 
158 | - Разделить текст на главы
159 | - Дополнить текст
160 | - Изменить текст
161 | - Перефразирвоать название главы
162 | 
163 | Требования к ответу:
164 | 
165 | - Пиши ответ в формате Markdown
166 | - Соблюдай номер глав в тексте
167 | 
168 | Вот текст:
169 | 
170 | #### Создание пользовательских методов валидации
171 | 
172 | Для более сложной валидации данных вы можете создавать собственные методы валидации в сериализаторе. Эти методы должны иметь название `validate_<field_name>` и принимать значение поля в качестве аргумента. Например:
173 | 
174 | ```python
175 | from rest_framework import serializers
176 | 
177 | class UserSerializer(serializers.Serializer):
178 |     ИмяАтрибута = serializers.CharField(max_length=100)
179 |     email = serializers.EmailField()
180 |     age = serializers.IntegerField(min_value=0, max_value=150)
181 | 
182 |     def validate_ИмяАтрибута(self, value):
183 |         if "admin" in value.lower():
184 |             raise serializers.ValidationError("Имя пользователя не должно содержать слово 'admin'.")
185 |         return value
186 | 
187 | ```
188 | 
189 | В этом примере мы создали пользовательский метод валидации для поля username, который проверяет, что в имени пользователя не содержится слово "admin". Если это условие не выполняется, вызывается исключение ValidationError.
190 | 
191 | Теперь, когда вы знакомы с валидацией данных, давайте рассмотрим создание и обновление объектов с использованием сериализаторов.
192 | 
193 | #### Метод to_representation
194 | 
195 | Метод to_representation позваляет переопределить логику сериализации, в этом методе мы можем измеить данные которые будут храниться в `serializer.data`
196 | 
197 | ```python
198 | def to_representation(self, instance):
199 |  representation = super().to_representation(instance)
200 |  # Изменяем вариант возвращаемых данных для ключа frmo
201 |  representation["frmo"] = {"id": instance.frmo.pk, "oid": instance.frmo.mo_oid}
202 |  return representation
203 | ```
204 | 
205 | ### CRUD
206 | 
207 | #### Read
208 | 
209 | - Создать `serializers.py`
210 | 
211 |   ```python
212 |   from rest_framework import serializers
213 | 
214 |   class ИмяСериализатора(serializers.Serializer):
215 |       Полеtitle = serializers.CharField(max_length=255)
216 |       Полеcontent = serializers.CharField()
217 |   ```
218 | 
219 | - Использовать во `view.py`
220 | 
221 |   ```python
222 |     from rest_framework.views import APIView
223 |     from rest_framework.request import Request
224 | 
225 |     class ИмяПредставления(APIView):
226 | 
227 |         serializer_class = ИмяСериализатора
228 | 
229 |         def post(slef, request: Request):
230 |             serializer = ИмяСериализатора(data=request.data)
231 |             # Проверить валидность Json. Если `raise_exception=True` то при ошибки валидации клиент получит описание ошибки
232 |             serializer.is_valid(raise_exception=True)
233 |             # Валидные Json данные
234 |             return Response({"status": "ok", "data": serializer.validated_data})
235 |   ```
236 | 
237 | #### Create
238 | 
239 | - Создать `serializers.py`
240 | 
241 |   ```python
242 |   from rest_framework import serializers
243 | 
244 |   class ИмяСериализатора(serializers.Serializer):
245 |       Полеtitle = serializers.CharField(max_length=255)
246 |       Полеcontent = serializers.CharField()
247 | 
248 |       def create(self, validated_data:dict):
249 |           '''
250 |           Переопределяем метод create, он вызовиться при выполение метода save
251 | 
252 |           validated_data: Валиадные данные
253 |           '''
254 |           return {"Полеtitle":"Данные","Полеcontent":"Данные"}
255 |   ```
256 | 
257 | - Использовать во `view.py`
258 | 
259 |   ```python
260 |     from rest_framework.views import APIView
261 |     from rest_framework.request import Request
262 | 
263 |     class ИмяПредставления(APIView):
264 |      serializer_class = ИмяСериализатора
265 |      def post(slef, request: Request):
266 |       serializer = ИмяСериализатора(data=request.data)
267 |       # Проверить валидность Json. Если `raise_exception=True` то при ошибки валидации клиент получит описание ошибки
268 |       serializer.is_valid(raise_exception=True)
269 |       # Вызвать метод `create` у сериализатора
270 |       serializer.save()
271 |       # Вернет ответ из метода `create`
272 |       return Response(serializer.data)
273 |   ```
274 | 
275 | #### Update
276 | 
277 | ```python
278 |   from rest_framework import serializers
279 | 
280 |   class ИмяСериализатора(serializers.Serializer):
281 |       Полеtitle = serializers.CharField(max_length=255)
282 |       Полеcontent = serializers.CharField()
283 | 
284 |       def update(self, instance, validated_data):
285 |           instance.Полеtitle = validated_data.get("name", instance.name)
286 |           instance.Полеcontent = validated_data.get("start_date", instance.start_date)
287 |           instance.save()
288 |           return instance
289 | ```
290 | 
291 | ## Документация API### Глава 1: Валидация данных
292 | Для обеспечения корректности данных, передаваемых в API, необходима валидация данных. В Django REST Framework валидация данных происходит в сериализаторах.
293 | 
Глава 1.1: Создание пользовательских методов валидации

294 | Для более сложной валидации данных вы можете создавать собственные методы валидации в сериализаторе. Эти методы должны иметь название `validate_&lt;field_name&gt;` и принимать значение поля в качестве аргумента.
295 | 
296 | Пример:
297 | 
298 | ```
299 | from rest_framework import serializers
300 | 
301 | class UserSerializer(serializers.Serializer):
302 |     ИмяАтрибута = serializers.CharField(max_length=100)
303 |     email = serializers.EmailField()
304 |     age = serializers.IntegerField(min_value=0, max_value=150)
305 | 
306 |     def validate_ИмяАтрибута(self, value):
307 |         if "admin" in value.lower():
308 |             raise serializers.ValidationError("Имя пользователя не должно содержать слово 'admin'.")
309 |         return value
310 | 
311 | ```
312 | 
313 | В этом примере мы создали пользовательский метод валидации для поля ИмяАтрибута, который проверяет, что в имени пользователя не содержится слово "admin". Если это условие не выполняется, вызывается исключение ValidationError.
314 | 
Глава 1.2: Метод to_representation

315 | Метод `to_representation` позволяет переопределить логику сериализации. В этом методе мы можем изменить данные, которые будут храниться в `serializer.data`.
316 | 
317 | Пример:
318 | 
319 | ```
320 | def to_representation(self, instance):
321 |  representation = super().to_representation(instance)
322 |  # Изменяем вариант возвращаемых данных для ключа frmo
323 |  representation["frmo"] = {"id": instance.frmo.pk, "oid": instance.frmo.mo_oid}
324 |  return representation
325 | 
326 | ```
327 | ### Глава 2: CRUD
328 | CRUD - это основные операции, выполняемые с данными: create (создание), read (чтение), update (обновление) и delete (удаление). В Django REST Framework для выполнения этих операций используются представления и сериализаторы.
329 | 
Глава 2.1: Read

330 | Чтение данных из API происходит с использованием HTTP метода GET.
331 | 
332 | Шаги для чтения данных:
333 | 
334 | 1. Создать сериализатор в `serializers.py`
335 | 
336 | ```
337 | from rest_framework import serializers
338 | 
339 | class ИмяСериализатора(serializers.Serializer):
340 |     Полеtitle = serializers.CharField(max_length=255)
341 |     Полеcontent = serializers.CharField()
342 | 
343 | ```
344 | 
    Использовать во `views.py`

345 | ```
346 | from rest_framework.views import APIView
347 | from rest_framework.request import Request
348 | 
349 | class ИмяПредставления(APIView):
350 | 
351 |     serializer_class = ИмяСериализатора
352 | 
353 |     def post(slef, request: Request):
354 |         serializer = ИмяСериализатора(data=request.data)
355 |         # Проверить валидность Json. Если `raise_exception=True` то при ошибки валидации клиент получит описание ошибки
356 | 
357 |     serializer.is_valid(raise_exception=True)
358 |     # Валидные Json данные
359 |     return Response({"status": "ok", "data": serializer.validated_data})
360 | 
361 | ```
362 | 
363 | #### Глава 2.2: Create
364 | 
365 | Создание данных в API происходит с использованием HTTP метода POST.
366 | 
367 | Шаги для создания данных:
368 | 
369 | 1. Создать сериализатор в `serializers.py`
370 | 
371 | ```python
372 | from rest_framework import serializers
373 | 
374 | class ИмяСериализатора(serializers.Serializer):
375 |     Полеtitle = serializers.CharField(max_length=255)
376 |     Полеcontent = serializers.CharField()
377 | 
378 |     def create(self, validated_data:dict):
379 |         '''
380 |         Переопределяем метод create, он вызовиться при выполение метода save
381 | 
382 |         validated_data: Валиадные данные
383 |         '''
384 |         return {"Полеtitle":"Данные","Полеcontent":"Данные"}
385 | 
386 | ```
387 | 
    Использовать во `views.py`

388 | ```
389 | from rest_framework.views import APIView
390 | from rest_framework.request import Request
391 | 
392 | class ИмяПредставления(APIView):
393 |  serializer_class = ИмяСериализатора
394 |  def post(slef, request: Request):
395 |   serializer = ИмяСериализатора(data=request.data)
396 |   # Проверить валидность Json. Если `raise_exception=True` то при ошибки валидации клиент получит описание ошибки
397 |   serializer.is_valid(raise_exception=True)
398 |   # Вызвать метод `create` у сериализатора
399 |   serializer.save()
400 |   # Вернет ответ из метода `create`
401 |   return Response(serializer.data)
402 | 
403 | ```
404 | 
Глава 2.3: Update

405 | Обновление данных в API происходит с использованием HTTP метода PUT или PATCH.
406 | 
407 | Шаги для обновления данных:
408 | 
409 | 1. Создать сериализатор в `serializers.py`
410 | 
411 | ```
412 | from rest_framework import serializers
413 | 
414 | class ИмяСериализатора(serializers.Serializer):
415 |     Полеtitle = serializers.CharField(max_length=255)
416 |     Полеcontent = serializers.CharField()
417 | 
418 |     def update(self, instance, validated_data):
419 |         instance.Полеtitle = validated_data.get("name", instance.name)
420 |         instance.Полеcontent = validated_data.get("start_date", instance.start_date)
421 |         instance.save()
422 |         return instance
423 | 
424 | ```
425 | 
    Использовать во `views.py`

426 | ```
427 | from rest_framework.views import APIView
428 | from rest_framework.request import Request
429 | 
430 | class ИмяПредставления(APIView):
431 |  serializer_class = ИмяСериализатора
432 |  def put(slef, request: Request, pk:int):
433 |   instance = self.get_object(pk)
434 |   serializer = ИмяСериализатора(instance, data=request.data)
435 |   # Проверить валидность Json. Если `raise_exception=True` то при ошибки валидации клиент получит описание ошибки
436 |   serializer.is_valid(raise_exception=True)
437 |   # Вызвать метод `update` у сериализатора
438 |   serializer.save()
439 |   # Вернет ответ из метода `update`
440 |   return Response(serializer.data)
441 | 
442 | ```
443 | 
444 | 
Глава 2.4: Delete

445 | Удаление данных из API происходит с использованием HTTP метода DELETE.
446 | 
447 | Шаги для удаления данных:
448 | 
449 | 1. Использовать во `views.py`
450 | 
451 | ```
452 | from rest_framework.views import APIView
453 | from rest_framework.request import Request
454 | 
455 | class ИмяПредставления(APIView):
456 |  def delete(slef, request: Request, pk:int):
457 |   instance = self.get_object(pk)
458 |   # Удалить объект из базы данных
459 |   instance.delete()
460 |   # Вернуть ответ, что объект был успешно удален
461 |   return Response(status=status.HTTP_204_NO_CONTENT)
462 | 
463 | ```
464 | 
465 | Это была оптимизированная документация API. Благодарю за возможность помочь!
466 | 

467 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # promtstd
  2 | 
  3 | `promtstd` - это стандарт, разработанный с целью предоставить общепринятый и универсальный подход к хранению и использованию промтов в разработке искусственных интеллектов. Он облегчает взаимодействие разработчиков, повышает качество создаваемых AI и уменьшает трудозатраты на поддержку системы промтов.
  4 | 
  5 | [![logo_web](https://github.com/denisxab/promtstd/blob/main/docs/_static/logo_and_text_1280x640.png)](https://github.com/denisxab/promtstd)
  6 | 
  7 | Основываясь на простоте и доступности `Markdown`, `promtstd` предлагает структурированный и удобочитаемый синтаксис для хранения промтов. Это позволяет разработчикам легко создавать, обновлять и делиться промтами, а также оценивать их качество и эффективность.
  8 | 
  9 | Применение стандарта `promtstd` в проектах искусственного интеллекта обеспечивает упорядоченность кодовой базы, что значительно снижает вероятность ошибок, затруднений и проблем при дальнейшей разработке и поддержке AI. В целом, использование `promtstd` призвано способствовать успешному развитию AI-технологий и улучшению пользовательского опыта.
 10 | 
 11 | ## Важность стандарта
 12 | 
 13 | В современной разработке AI промты играют важную роль, так как они определяют, как будет взаимодействовать AI с пользователем и какие задачи будет решать.
 14 | 
 15 | Однако на данный момент отсутствует унифицированный стандарт для хранения и использования промтов, что приводит к ряду проблем:
 16 | 
 17 | 1. Затруднение взаимодействия разработчиков: без стандарта разработчики вынуждены использовать свои собственные конвенции и методы хранения промтов, что может усложнить коммуникацию и сотрудничество между разными командами.
 18 | 2. Увеличение трудозатрат на создание и поддержку AI: из-за отсутствия стандарта разработчики тратят больше времени на разработку, поддержку и модификацию промтов, что снижает производительность и увеличивает затраты на проекты.
 19 | 3. Снижение качества AI: без стандарта промты могут быть хранены и использованы неэффективно, что снижает общую эффективность AI и может привести к некорректному выполнению задач.
 20 | Создание стандарта для хранения и использования промтов может существенно улучшить эти аспекты и сделать разработку AI более удобной, эффективной и качественной.
 21 | 
 22 | - ![Bing](docs/_static/Screenshot_20230405_195854.png)
 23 | - ![ChatGPT](docs/_static/Screenshot_20230405_195823.png)
 24 | 
 25 | ## Основная концепция
 26 | 
 27 | Основная концепция стандарта `promtstd` заключается в предоставлении унифицированного подхода к хранению и использованию промтов с помощью популярного и легко читаемого формата `Markdown`. Это обеспечивает следующие преимущества:
 28 | 
 29 | 1. Легкость чтения: промты, хранящиеся в формате `Markdown`, легко читаются и понимаются разработчиками, что упрощает работу с ними и снижает вероятность ошибок.
 30 | 1. Расширяемость: стандарт `promtstd` позволяет легко добавлять новые элементы и разделы, что обеспечивает гибкость и адаптивность к различным сценариям использования промтов.
 31 | 1. Удобство работы: использование стандарта `promtstd` упрощает процесс разработки, тестирования и поддержки промтов, так как все разработчики работают с одним и тем же форматом и структурой данных.
 32 | 
 33 | В целом, стандарт `promtstd` способствует улучшению качества разработки AI, упрощает коммуникацию между разработчиками и снижает затраты на создание и поддержку промтов. Внедрение и соблюдение данного стандарта помогут обеспечить более эффективное и качественное взаимодействие AI с пользователем, а также повысить стабильность и функциональность разрабатываемых AI-решений.
 34 | 
 35 | ## Синтаксис хранения промта в PromtStd.Markdown
 36 | 
 37 | Промты хранятся в Markdown формате.
 38 | 
 39 | ### Структура хранения промта
 40 | 
 41 | Учитывая, что промпты могут быть объемными и иметь множество особенностей, наиболее удобным решением является хранение их в отдельных файлах. Для структурирования промптов используется стандартное разделение по папкам:
 42 | 
 43 | ```bash
 44 | КорневаяПапка_С_Промтами
 45 | │ 
 46 | ├── Группа_1
 47 | │   │
 48 | │   ├── Файл_С_Промтом_1.md
 49 | │   ├── Файл_С_Промтом_2.md
 50 | │   ├── Файл_С_Промтом_3.md
 51 | │   │
 52 | │   ├── json
 53 | │   │   ├──Файл_С_Промтом_1.json
 54 | │   │   ├──Файл_С_Промтом_2.json
 55 | │   │   └──Файл_С_Промтом_3.json
 56 | │   └── html
 57 | │       ├──Файл_С_Промтом_1.html
 58 | │       ├──Файл_С_Промтом_2.html
 59 | │       └──Файл_С_Промтом_3.html
 60 | │
 61 | └── Группа_2
 62 |     │
 63 |     ├── Файл_С_Промтом_1.md
 64 |     ├── Файл_С_Промтом_2.md
 65 |     ├── Файл_С_Промтом_3.md
 66 |     │ 
 67 |     ├── json
 68 |     │   ├──Файл_С_Промтом_1.json
 69 |     │   ├──Файл_С_Промтом_2.json
 70 |     │   └──Файл_С_Промтом_3.json
 71 |     └── html
 72 |         ├──Файл_С_Промтом_1.html
 73 |         ├──Файл_С_Промтом_2.html
 74 |         └──Файл_С_Промтом_3.html  
 75 | ```
 76 | 
 77 | Так как промпты могут быть объемными и иметь множество особенностей, мы решили не устанавливать строгие рамки для хранения промптов и вместо этого создать правила для структурирования заголовков, а также расширить возможности Markdown. Такой подход к стандарту предоставляет большой потенциал для хранения промптов в будущем.
 78 | 
 79 | 1. Оформление заголовков с нужными именами и уровнем для файле `Файл_С_Промтом.md`
 80 | 
 81 |   ```md
 82 |   # meta
 83 |   # doc
 84 |   # base_promt
 85 |   # tools
 86 |   ## Название для вспомогательного промта 1
 87 |   ## Название для вспомогательного промта ...
 88 |   # expl
 89 |   ## Название для примера запроса 1
 90 |   ### Название для примера ответа 1 
 91 |   ### Название для примера ответа ...
 92 |   ## Название для примера запроса 2
 93 |   ### Название для примера ответа 2
 94 |   ### Название для примера ответа ...
 95 |   ```
 96 | 
 97 | 2. Расширения синтаксиса `Markdown`, которые могут быть использованы:
 98 |    1. Применение переменных в блоках с промптом
 99 | 
100 | ### Про ~ meta
101 | 
102 | `meta` = Мета информация о промте.
103 | 
104 | ```md
105 | - for:
106 |   - Имя_AI_1
107 | - use:
108 |   - Место_1
109 | - tags:
110 |   - Тег_1
111 | ```
112 | 
113 | - for = В каких AI используется этот промт;
114 | - use = В каком месте AI используется этот промт;
115 | - tags = Логическое разделение промта на глобальные теги;
116 | 
117 | ### Про ~ doc
118 | 
119 | `doc` = Произвольное описание промта
120 | 
121 | ### Про ~ base_promt
122 | 
123 | `base_promt` = Базовый промт. В нем может быть произвольное описание, но главное чтобы в нем был блок кода с типом `promt`
124 | 
125 | 
126 | ```promt
127 | Текст промта
128 | ```
129 | 

130 | 
131 | #### Использование переменных в блоках с промптом
132 | 
133 | Для использования динамических переменных в промпте необходимо указать имя переменной в двойных фигурных скобках.
134 | 
135 | После этого, ниже блока с промптом, вы можете указать имена переменных, о которых хотите дать более подробное описание.
136 | 
137 | В описании переменных можно указывать различные значения по умолчанию. Для этого после описания переменной создайте новый вложенный список.
138 | 
139 | **Пример шаблона**:
140 | 
141 | ```promt
142 | Текст промта {{ПеременнаяОдин}}, еще текст промта {{ПеременнаяДва}}.
143 | ```
144 | 
145 | - ПеременнаяОдин ~ Описание переменной, у которой нет вариантов значений.
146 | - ПеременнаяДва ~ Описание переменной, у которой есть варианты значений.
147 |   - Вариант значения 1
148 |   - Вариант значения 2
149 |   - [x] Вариант значения который будет по умолчанию
150 |   - Вариант значения ...
151 | 

152 | 
153 | **Пример использования переменных**:
154 | 
155 | 
156 | ```promt
157 | Этот пример промта, в котором я буду использовать {{ЧтоИспользовать}},
158 | для того чтобы {{ЧтоДелать}}.
159 | ```
160 | 
161 | - ЧтоИспользовать ~ Что я буду использовать
162 |   - Переменные
163 |   - Слова
164 |   - [x] Рыб
165 | - ЧтоДелать ~ Что тогда я буду делать с промтом
166 | 
167 | 

168 | 
169 | ### Про ~ tools
170 | 
171 | `tools` = В этой главе укажите вспомогательные промты. В них вы тоже можете использовать переменные в промтах.
172 | 
173 | **Пример содержания главы tools**:
174 | 
175 | 
176 | ```promt
177 | Продолжи свой ответ, с того места где ты закончил прошлый.
178 | ```
179 | 
180 | ```promt
181 | Ответь на прошлый вопрос по частям, в каждой части укажи номер.
182 | ```
183 | 
184 | ```promt
185 | Напиши снова часть: {{НомерЧасти}}
186 | ```
187 | 
188 | - НомерЧасти = Номер части которую нужно снова отправить
189 | 

190 | 
191 | ### Про ~ expl
192 | 
193 | `expl` = В данной главе приведены примеры использования базового промпта. Поскольку примеры могут быть объемными (более 1000 символов), рекомендуется разбивать их на отдельные главы. Сначала следует глава (h2) с названием примера, содержащая сам пример. Затем следует глава (h3) с названием ответа (можно просто указать порядковый номер), в которой сохраняется ответ.
194 | 
195 | **Пример примеров**:
196 | 
197 | 
198 | # base_promt
199 | 
200 | ```promt
201 | Напиши {{КакуюСказку}} сказку о том: {{ТемаСказки}}
202 | ```
203 | 
204 | # expl
205 | 
206 | ## Примера как ChatGPT написал длинную сказку
207 | 
208 | Напиши длинную сказку о том: как молодой человек сумел стать программистов, благодаря своей настойчивости, расскажи о том как он получил 1500 отказов от работодателей, но на 1501 получил приглашение на работу мечты, а потом стал синьером, завел собаку по имени жучка, посадил дерево лимонник, в своем огороде на даче, и жил он долго и счастливо, и иногда делал код ревью.
209 | 
210 | ### Длинная сказка
211 | 
212 | Жил-был молодой человек, который всегда мечтал стать программистом. Он изучал языки программирования, проходил онлайн-курсы и решал сложные задачи на сайтах для разработчиков. Однако, увы, никакая компания не хотела нанять его на работу. Он получил уже 1500 отказов, но не сдавался и продолжал искать свой шанс.
213 | 
214 | И вот, однажды, он получил письмо с приглашением на собеседование в компанию своей мечты. Молодой человек был очень взволнован и готовился к собеседованию днями и ночами. И в конце концов, его упорство и настойчивость оказались вознаграждены - он получил работу!
215 | 
216 | Работая в этой компании, молодой человек проявил себя как талантливый и энергичный программист. Его работа была востребована, и он быстро продвигался по карьерной лестнице. Через несколько лет он стал синьером, получил высокую зарплату и чувствовал себя очень уверенно в своих силах.
217 | 
218 | Помимо работы, молодой человек заботился о своем доме на даче. Он посадил дерево лимонник, которое давало ему сладкие и ароматные плоды каждое лето. Также у него была собака по имени Жучка, которую он очень любил и которая сопровождала его в долгих прогулках по лесу.
219 | 
220 | Молодой программист жил долго и счастливо, наслаждаясь своей работой и увлечениями. Иногда он делал код-ревью и помогал начинающим программистам, как сам когда-то был в их числе. И вот так, благодаря своей настойчивости и трудолюбию, он достиг своей мечты и построил свою счастливую жизнь.
221 | 
222 | ## Пример как ChatGPT написал короткую и смешную сказку
223 | 
224 | Напиши очень короткую  и смешную сказку о том: как молодой человек сумел стать программистов, благодаря своей настойчивости, расскажи о том как он получил 1500 отказов от работодателей, но на 1501 получил приглашение на работу мечты, а потом стал синьером, завел собаку по имени жучка, посадил дерево лимонник, в своем огороде на даче, и жил он долго и счастливо, и иногда делал код ревью.
225 | 
226 | ### Короткая сказка и смешная сказка
227 | 
228 | Жил-был молодой человек, который мечтал стать программистом. Но ему приходилось получать много отказов от работодателей, аж 1500! Но на 1501 попытке он получил работу мечты. С тех пор он стал синьером, завел собаку по имени Жучка, посадил лимонник в своем огороде на даче, и жил долго и счастливо, иногда делая код-ревью. А вот Жучка сидела возле него, внимательно наблюдая за работой хозяина и периодически лаяла на баги в коде.
229 | 
230 | 

231 | 
232 | ## Сборка PromtStd.Markdown в другие форматы
233 | 
234 | ### Установка promtstd
235 | 
236 | Установка `promtstd`
237 | 
238 | ```bash
239 | pip install promtstd
240 | ```
241 | 
242 | ### В ~ PromtStd.Json
243 | 
244 | Чтобы использовать данные из `Markdown` в других приложениях, в стандарте `promtstd`, предусмотрена сборка с `Json`.
245 | 
246 | #### Команда для сборки
247 | 
248 | Сборка `PromtStd.Markdown` в `PromtStd.Json`
249 | 
250 | ```bash
251 | python python -m promtstd json Файл_PromtStd_Markdown.md 
252 | ```
253 | 
254 | #### Пример сборки
255 | 
256 | Пример `PromtStd.Markdown`:
257 | 
258 | 
259 | # meta
260 | 
261 | - for:
262 |   - ChatGPT
263 | - use:
264 |   - Первое сообщение
265 | - tags:
266 |   - Создание промтов
267 | 
268 | # doc
269 | 
270 | Этот промт нужен, для того чтобы вмести с CahtGpt найти самый лучший вариант промта под конкретную задачу.
271 | 
272 | - После этого промта нужно описать под какую задачу вам нужно создать новый промт
273 | - После этого CahtGpt будет задавать уточняющие вопросы, на которые нам нужно ответить, для того чтобы улучшить новый промт
274 | 
275 | # base_promt
276 | 
277 | ```promt
278 | I want you to become my Prompt Creator. Your goal is to help me craft the best possible prompt for my needs. The prompt will be used by you, ChatGPT. You will follow the following process:
279 | 
280 | 1. Your first response will be to ask me what the prompt should be about. I will provide my answer, but we will need to improve it through continual iterations by going through the next steps.
281 | 
282 | 2. Based on my input, you will generate 3 sections. a) Revised prompt (provide your rewritten prompt. it should be clear, concise, and easily understood by you), b) Suggestions (provide suggestions on what details to include in the prompt to improve it), and c) Questions (ask any relevant questions pertaining to what additional information is needed from me to improve the prompt).
283 | 
284 | 3. We will continue this iterative process with me providing additional information to you and you updating the prompt in the Revised prompt section until it's complete.
285 | 
286 | Задавай мне вопросы и пиши ответы на русском языке.
287 | ```
288 | 
289 | # tools
290 | 
291 | ## Если нужно модифицировать уже существующий промт, то напишите 2 сообщением
292 | 
293 | ```promt
294 | Изначально Revised prompt равен:
295 | 
296 | {{УказатьPromt}}
297 | ```
298 | 
299 | - УказатьPromt ~ Обратите внимание чтобы этот прмот звучал утвердительно, а иначе CahtGpt подумает что это вопрос.
300 |   - Оптимизируй код на Python
301 |   - [x] Оптимизируй код на Си
302 |   - Оптимизируй код на Assembler
303 | 
304 | ## Если нужно изменять промт на основание примеров
305 | 
306 | ```promt
307 | Я хочу проверить работу Revised prompt, я буду смотреть на твой ответ, и давать подсказки как можно улучшить Revised prompt.
308 | Для улучшения можно изменять правила Revised prompt.
309 | 
310 | Вот пример который ты должен проверить:
311 | 
312 | {{УказатьПример}}
313 | ```
314 | 
315 | # expl
316 | 
317 | ## Если отправить только промт первым сообщением
318 | 
319 | ```promt
320 | Разработка нейронных сетей на основе архитектуры трансформер
321 | ```
322 | 
323 | ### Уточнения промта
324 | 
325 | ```ai
326 | Хорошо, вот три секции, которые помогут нам уточнить тему и создать лучший возможный промпт:
327 | 
328 | a) Пересмотренный промпт:
329 | Напишите промпт, который вы хотели бы использовать для этой темы.
330 | 
331 | b) Советы:
332 | Какие дополнительные детали или информацию нам нужно включить в промпт, чтобы он был более ясным и конкретным?
333 | 
334 | c) Вопросы:
335 | Какие вопросы у вас есть относительно темы, которые помогут нам лучше понять, что должен включать наш промпт?
336 | ```
337 | 
338 | ## Если отправить промт как изначальный
339 | 
340 | ```promt
341 | Изначально Revised prompt равен:
342 | 
343 | Разработка нейронных сетей на основе архитектуры трансформер
344 | ```
345 | 
346 | ### Готовый промт, а также вопросы по нему
347 | 
348 | ```ai
349 | Отлично, в таком случае давайте начнем:
350 | 
351 | Revised prompt:
352 | Создание нейронных сетей с использованием трансформерной архитектуры.
353 | 
354 | Suggestions:
355 | 
356 | Какие применения будет иметь нейронная сеть, которую вы хотите создать?
357 | Какие специфические особенности трансформерной архитектуры вы планируете использовать?
358 | Какую информацию вы хотели бы получить от нейронной сети? Какие данные будут использоваться для обучения?
359 | Какие будут измерения успеха для нейронной сети, которую вы создадите?
360 | Questions:
361 | 
362 | Какую среду для разработки нейронных сетей вы предпочитаете использовать?
363 | Какова ваша совокупная опытность в создании нейронных сетей и использовании трансформерной архитектуры?
364 | Какие примеры существующих нейронных сетей вы изучили и какие аспекты из них вы хотели бы использовать в своей сети?
365 | ```
366 | 

367 | 
368 | Пример `PromtStd.Json`:
369 | 
370 | ```json
371 | {
372 |     "name": "Создание промтов вместе с ChatGpt.md",
373 |     "meta": {
374 |         "for_": [
375 |             "ChatGPT"
376 |         ],
377 |         "use": [
378 |             "Первое сообщение"
379 |         ],
380 |         "group": "examples",
381 |         "tags": [
382 |             "Создание промтов"
383 |         ],
384 |         "version": null
385 |     },
386 |     "doc": "Этот промт нужен, для того чтобы вмести с CahtGpt найти самый лучший вариант промта под конкретную задачу.\n\n- После этого промта нужно описать под какую задачу вам нужно создать новый промт\n- После этого CahtGpt будет задавать уточняющие вопросы, на которые нам нужно ответить, для того чтобы улучшить новый промт",
387 |     "base_promt": {
388 |         "promt": {
389 |             "text_promt": "I want you to become my Prompt Creator. Your goal is to help me craft the best possible prompt for my needs. The prompt will be used by you, ChatGPT. You will follow the following process:\n\n1. Your first response will be to ask me what the prompt should be about. I will provide my answer, but we will need to improve it through continual iterations by going through the next steps.\n\n2. Based on my input, you will generate 3 sections. a) Revised prompt (provide your rewritten prompt. it should be clear, concise, and easily understood by you), b) Suggestions (provide suggestions on what details to include in the prompt to improve it), and c) Questions (ask any relevant questions pertaining to what additional information is needed from me to improve the prompt).\n\n3. We will continue this iterative process with me providing additional information to you and you updating the prompt in the Revised prompt section until it's complete.\n\nЗадавай мне вопросы и пиши ответы на русском языке.",
390 |             "vars": []
391 |         }
392 |     },
393 |     "tools_promt": {
394 |         "promts": [
395 |             {
396 |                 "about_promt": "Если нужно модифицировать уже существующий промт, то напишите 2 сообщением",
397 |                 "text_promt": "Изначально Revised prompt равен:\n\n{{УказатьPromt}}",
398 |                 "vars": [
399 |                     {
400 |                         "name": "УказатьPromt",
401 |                         "doc": " Обратите внимание чтобы этот прмот звучал утвердительно, а иначе CahtGpt подумает что это вопрос.",
402 |                         "default": "Оптимизируй код на Си",
403 |                         "allowed": [
404 |                             "Оптимизируй код на Python",
405 |                             "Оптимизируй код на Си",
406 |                             "Оптимизируй код на Assembler"
407 |                         ]
408 |                     }
409 |                 ]
410 |             },
411 |             {
412 |                 "about_promt": "Если нужно изменять промт на основание примеров",
413 |                 "text_promt": "Я хочу проверить работу Revised prompt, я буду смотреть на твой ответ, и давать подсказки как можно улучшить Revised prompt. \nДля улучшения можно изменять правила Revised prompt.\n\nВот пример который ты должен проверить:\n\n{{УказатьПример}}",
414 |                 "vars": [
415 |                     {
416 |                         "name": "УказатьПример",
417 |                         "doc": null,
418 |                         "default": null,
419 |                         "allowed": null
420 |                     }
421 |                 ]
422 |             }
423 |         ]
424 |     },
425 |     "expl": [
426 |         {
427 |             "name": "Если отправить только промт первым сообщением",
428 |             "in_text": "\n```promt\nРазработка нейронных сетей на основе архитектуры трансформер\n```\n",
429 |             "out_text": {
430 |                 "Уточнения промта": "\n```ai\nХорошо, вот три секции, которые помогут нам уточнить тему и создать лучший возможный промпт:\n\na) Пересмотренный промпт:\nНапишите промпт, который вы хотели бы использовать для этой темы.\n\nb) Советы:\nКакие дополнительные детали или информацию нам нужно включить в промпт, чтобы он был более ясным и конкретным?\n\nc) Вопросы:\nКакие вопросы у вас есть относительно темы, которые помогут нам лучше понять, что должен включать наш промпт?\n```\n"
431 |             }
432 |         },
433 |         {
434 |             "name": "Если отправить промт как изначальный",
435 |             "in_text": "\n```promt\nИзначально Revised prompt равен:\n\nРазработка нейронных сетей на основе архитектуры трансформер\n```\n",
436 |             "out_text": {
437 |                 "Готовый промт, а также вопросы по нему": "\n```ai\nОтлично, в таком случае давайте начнем:\n\nRevised prompt:\nСоздание нейронных сетей с использованием трансформерной архитектуры.\n\nSuggestions:\n\nКакие применения будет иметь нейронная сеть, которую вы хотите создать?\nКакие специфические особенности трансформерной архитектуры вы планируете использовать?\nКакую информацию вы хотели бы получить от нейронной сети? Какие данные будут использоваться для обучения?\nКакие будут измерения успеха для нейронной сети, которую вы создадите?\nQuestions:\n\nКакую среду для разработки нейронных сетей вы предпочитаете использовать?\nКакова ваша совокупная опытность в создании нейронных сетей и использовании трансформерной архитектуры?\nКакие примеры существующих нейронных сетей вы изучили и какие аспекты из них вы хотели бы использовать в своей сети?\n```"
438 |             }
439 |         }
440 |     ]
441 | }
442 | ```
443 | 
444 | ### В ~ PromtStd.Html
445 | 
446 | Для того чтобы использовать дополнительные возможности `PromtStd.Markdown`, и работать с промтом прямо в браузере, нужно собрать `PromtStd.Html`
447 | 
448 | #### Команда для сборки
449 | 
450 | Сборка `PromtStd.Markdown` в `PromtStd.Html`
451 | 
452 | ```bash
453 | python python -m promtstd html Файл_PromtStd_Markdown.md 
454 | ```
455 | 
456 | #### Пример сборки
457 | 
458 | [Создание промтов вместе с ChatGpt.html](https://github.com/denisxab/promtstd/blob/main/examples/html/%D0%A1%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5%20%D0%BF%D1%80%D0%BE%D0%BC%D1%82%D0%BE%D0%B2%20%D0%B2%D0%BC%D0%B5%D1%81%D1%82%D0%B5%20%D1%81%20ChatGpt.html)
459 | 
460 | ![to_html](./docs/_static/Screenshot_20230411_004511.png)
461 | 
462 | ## Вывод
463 | 
464 | Таким образом, стандарт `promtstd` предлагает унифицированный подход к хранению и использованию промтов, что способствует упрощению разработки и взаимодействия разработчиков при создании и поддержке искусственных интеллектов. Применение стандарта обеспечивает легкость чтения, расширяемость и удобство работы с промтами на основе популярного и распространенного формата `Markdown`.
465 | 


--------------------------------------------------------------------------------
/promtstd/from_html/css/base_style.scss:
--------------------------------------------------------------------------------
   1 | $h6_color: #22252a;
   2 | $h5_color: #2e3238;
   3 | $h4_color: #2f333a;
   4 | $h3_color: #4b6581;
   5 | $h2_color: #3a4f67;
   6 | $h1_color: #324053;
   7 | $h_color: #abb0ba;
   8 | $bg_base: #0d1117;
   9 | $color_base: #c9d1d9;
  10 | 
  11 | .toc {
  12 |     .toctitle {
  13 |         font-size: 1.2em;
  14 |         font-weight: 600;
  15 |         padding: 0.2em;
  16 |         background: $h1_color;
  17 |         text-align: center;
  18 |         display: block;
  19 |     }
  20 | }
  21 | 
  22 | .markdown-body {
  23 |     min-height: 1020px;
  24 | }
  25 | 
  26 | html {
  27 |     font-size: 1.7vh;
  28 | }
  29 | 
  30 | .markdown-body {
  31 |     color-scheme: dark;
  32 |     -ms-text-size-adjust: 100%;
  33 |     -webkit-text-size-adjust: 100%;
  34 |     color: $color_base;
  35 |     background-color: $bg_base;
  36 |     font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Noto Sans", Helvetica, Arial, sans-serif,
  37 |         "Apple Color Emoji", "Segoe UI Emoji";
  38 |     font-size: 1rem;
  39 |     line-height: 1.5;
  40 |     word-wrap: break-word;
  41 |     padding: 10px;
  42 |     padding-left: 15px;
  43 | 
  44 |     .octicon {
  45 |         display: inline-block;
  46 |         fill: currentColor;
  47 |         vertical-align: text-bottom;
  48 |     }
  49 | 
  50 |     h1:hover .anchor .octicon-link:before,
  51 |     h2:hover .anchor .octicon-link:before,
  52 |     h3:hover .anchor .octicon-link:before,
  53 |     h4:hover .anchor .octicon-link:before,
  54 |     h5:hover .anchor .octicon-link:before,
  55 |     h6:hover .anchor .octicon-link:before {
  56 |         width: 16px;
  57 |         height: 16px;
  58 |         content: " ";
  59 |         display: inline-block;
  60 |         background-color: currentColor;
  61 |         -webkit-mask-image: url("data:image/svg+xml,");
  62 |         mask-image: url("data:image/svg+xml,");
  63 |     }
  64 | 
  65 |     details,
  66 |     figcaption,
  67 |     figure {
  68 |         display: block;
  69 |     }
  70 | 
  71 |     summary {
  72 |         display: list-item;
  73 |     }
  74 | 
  75 |     [hidden] {
  76 |         display: none !important;
  77 |     }
  78 | 
  79 |     a {
  80 |         background-color: transparent;
  81 |         color: #58a6ff;
  82 |         text-decoration: none;
  83 |     }
  84 | 
  85 |     abbr[title] {
  86 |         border-bottom: none;
  87 |         text-decoration: underline dotted;
  88 |     }
  89 | 
  90 |     b,
  91 |     strong {
  92 |         font-weight: 600;
  93 |     }
  94 | 
  95 |     dfn {
  96 |         font-style: italic;
  97 |     }
  98 | 
  99 |     mark {
 100 |         background-color: rgba(187, 128, 9, 0.15);
 101 |         color: $color_base;
 102 |     }
 103 | 
 104 |     small {
 105 |         font-size: 90%;
 106 |     }
 107 | 
 108 |     sub,
 109 |     sup {
 110 |         font-size: 75%;
 111 |         line-height: 0;
 112 |         position: relative;
 113 |         vertical-align: baseline;
 114 |     }
 115 | 
 116 |     sub {
 117 |         bottom: -0.25em;
 118 |     }
 119 | 
 120 |     sup {
 121 |         top: -0.5em;
 122 |     }
 123 | 
 124 |     img {
 125 |         border-style: none;
 126 |         max-width: 100%;
 127 |         box-sizing: content-box;
 128 |         background-color: $bg_base;
 129 |     }
 130 | 
 131 |     code,
 132 |     kbd,
 133 |     pre,
 134 |     samp {
 135 |         font-family: monospace;
 136 |         font-size: 0.5em;
 137 |         color: #ffffff;
 138 |     }
 139 | 
 140 |     figure {
 141 |         margin: 1em 40px;
 142 |     }
 143 | 
 144 |     hr {
 145 |         box-sizing: content-box;
 146 |         overflow: hidden;
 147 |         background: transparent;
 148 |         border-bottom: 1px solid #21262d;
 149 |         height: 0.25em;
 150 |         padding: 0;
 151 |         margin: 24px 0;
 152 |         background-color: #30363d;
 153 |         border: 0;
 154 |     }
 155 | 
 156 |     input {
 157 |         font: inherit;
 158 |         margin: 0;
 159 |         overflow: visible;
 160 |         font-family: inherit;
 161 |         font-size: inherit;
 162 |         line-height: inherit;
 163 |     }
 164 | 
 165 |     [type="button"],
 166 |     [type="reset"],
 167 |     [type="submit"] {
 168 |         -webkit-appearance: button;
 169 |     }
 170 | 
 171 |     [type="checkbox"],
 172 |     [type="radio"] {
 173 |         box-sizing: border-box;
 174 |         padding: 0;
 175 |     }
 176 | 
 177 |     [type="number"] {
 178 |         &::-webkit-inner-spin-button,
 179 |         &::-webkit-outer-spin-button {
 180 |             height: auto;
 181 |         }
 182 |     }
 183 | 
 184 |     [type="search"] {
 185 |         &::-webkit-search-cancel-button,
 186 |         &::-webkit-search-decoration {
 187 |             -webkit-appearance: none;
 188 |         }
 189 |     }
 190 | 
 191 |     ::-webkit-input-placeholder {
 192 |         color: inherit;
 193 |         opacity: 0.54;
 194 |     }
 195 | 
 196 |     ::-webkit-file-upload-button {
 197 |         -webkit-appearance: button;
 198 |         font: inherit;
 199 |     }
 200 | 
 201 |     a:hover {
 202 |         text-decoration: underline;
 203 |     }
 204 | 
 205 |     ::placeholder {
 206 |         color: #6e7681;
 207 |         opacity: 1;
 208 |     }
 209 | 
 210 |     hr {
 211 |         &::before {
 212 |             display: table;
 213 |             content: "";
 214 |         }
 215 | 
 216 |         &::after {
 217 |             display: table;
 218 |             clear: both;
 219 |             content: "";
 220 |         }
 221 |     }
 222 | 
 223 |     table {
 224 |         border-spacing: 0;
 225 |         border-collapse: collapse;
 226 |         display: block;
 227 |         width: max-content;
 228 |         max-width: 100%;
 229 |         overflow: auto;
 230 |     }
 231 | 
 232 |     td,
 233 |     th {
 234 |         padding: 0;
 235 |     }
 236 | 
 237 |     details {
 238 |         summary {
 239 |             cursor: pointer;
 240 |         }
 241 | 
 242 |         &:not([open]) > *:not(summary) {
 243 |             display: none !important;
 244 |         }
 245 |     }
 246 | 
 247 |     a:focus,
 248 |     [role="button"]:focus {
 249 |         outline: 2px solid #58a6ff;
 250 |         outline-offset: -2px;
 251 |         box-shadow: none;
 252 |     }
 253 | 
 254 |     input {
 255 |         &[type="radio"]:focus,
 256 |         &[type="checkbox"]:focus {
 257 |             outline: 2px solid #58a6ff;
 258 |             outline-offset: -2px;
 259 |             box-shadow: none;
 260 |         }
 261 |     }
 262 | 
 263 |     a:focus:not(:focus-visible),
 264 |     [role="button"]:focus:not(:focus-visible) {
 265 |         outline: solid 1px transparent;
 266 |     }
 267 | 
 268 |     input {
 269 |         &[type="radio"]:focus:not(:focus-visible),
 270 |         &[type="checkbox"]:focus:not(:focus-visible) {
 271 |             outline: solid 1px transparent;
 272 |         }
 273 |     }
 274 | 
 275 |     a:focus-visible,
 276 |     [role="button"]:focus-visible {
 277 |         outline: 2px solid #58a6ff;
 278 |         outline-offset: -2px;
 279 |         box-shadow: none;
 280 |     }
 281 | 
 282 |     input {
 283 |         &[type="radio"]:focus-visible,
 284 |         &[type="checkbox"]:focus-visible {
 285 |             outline: 2px solid #58a6ff;
 286 |             outline-offset: -2px;
 287 |             box-shadow: none;
 288 |         }
 289 |     }
 290 | 
 291 |     a:not([class]) {
 292 |         &:focus,
 293 |         &:focus-visible {
 294 |             outline-offset: 0;
 295 |         }
 296 |     }
 297 | 
 298 |     input {
 299 |         &[type="radio"] {
 300 |             &:focus,
 301 |             &:focus-visible {
 302 |                 outline-offset: 0;
 303 |             }
 304 |         }
 305 | 
 306 |         &[type="checkbox"] {
 307 |             &:focus,
 308 |             &:focus-visible {
 309 |                 outline-offset: 0;
 310 |             }
 311 |         }
 312 |     }
 313 | 
 314 |     kbd {
 315 |         display: inline-block;
 316 |         padding: 3px 5px;
 317 |         font: 11px ui-monospace, SFMono-Regular, SF Mono, Menlo, Consolas, Liberation Mono, monospace;
 318 |         line-height: 10px;
 319 |         color: $color_base;
 320 |         vertical-align: middle;
 321 |         background-color: #161b22;
 322 |         border: solid 1px rgba(110, 118, 129, 0.4);
 323 |         border-bottom-color: rgba(110, 118, 129, 0.4);
 324 |         border-radius: 6px;
 325 |         box-shadow: inset 0 -1px 0 rgba(110, 118, 129, 0.4);
 326 |     }
 327 | 
 328 |     h1,
 329 |     h2,
 330 |     h3,
 331 |     h4,
 332 |     h5,
 333 |     h6 {
 334 |         margin-top: 24px;
 335 |         margin-bottom: 16px;
 336 |         padding: 6px;
 337 |         padding-left: 10px;
 338 |         font-weight: 600;
 339 |         line-height: 1.25;
 340 |         border-radius: 2px;
 341 |     }
 342 | 
 343 |     h1 {
 344 |         font-weight: 600;
 345 |         padding-bottom: 0.3em;
 346 |         font-size: 1.5em;
 347 |         border-bottom: 1px solid #21262d;
 348 |         background: $h1_color;
 349 |     }
 350 | 
 351 |     h2 {
 352 |         font-weight: 600;
 353 |         padding-bottom: 0.3em;
 354 |         font-size: 1.1em;
 355 |         border-bottom: 1px solid #21262d;
 356 |         border: 0.1em solid $h2_color;
 357 |         border-radius: 8px;
 358 |     }
 359 | 
 360 |     h3 {
 361 |         font-weight: 600;
 362 |         font-size: 1em;
 363 |         border: 0.1em solid $h3_color;
 364 |         border-radius: 8px;
 365 |     }
 366 | 
 367 |     h4 {
 368 |         font-weight: 600;
 369 |         font-size: 1em;
 370 |         background: $h4_color;
 371 |     }
 372 | 
 373 |     h5 {
 374 |         font-weight: 600;
 375 |         font-size: 0.875em;
 376 |         background: $h5_color;
 377 |     }
 378 | 
 379 |     h6 {
 380 |         font-weight: 600;
 381 |         font-size: 0.85em;
 382 |         color: #8b949e;
 383 |         background: $h6_color;
 384 |     }
 385 | 
 386 |     p {
 387 |         margin-top: 0;
 388 |         margin-bottom: 10px;
 389 |     }
 390 | 
 391 |     blockquote {
 392 |         margin: 0;
 393 |         padding: 0 1em;
 394 |         color: #8b949e;
 395 |         border-left: 0.25em solid #30363d;
 396 |     }
 397 | 
 398 |     ul {
 399 |         margin-top: 0;
 400 |         margin-bottom: 0;
 401 |         padding-left: 2em;
 402 |     }
 403 | 
 404 |     ol {
 405 |         margin-top: 0;
 406 |         margin-bottom: 0;
 407 |         padding-left: 2em;
 408 | 
 409 |         ol {
 410 |             list-style-type: lower-roman;
 411 |         }
 412 |     }
 413 | 
 414 |     ul {
 415 |         ol {
 416 |             list-style-type: lower-roman;
 417 |         }
 418 | 
 419 |         ul ol,
 420 |         ol ol {
 421 |             list-style-type: lower-alpha;
 422 |         }
 423 |     }
 424 | 
 425 |     ol {
 426 |         ul ol,
 427 |         ol ol {
 428 |             list-style-type: lower-alpha;
 429 |         }
 430 |     }
 431 | 
 432 |     dd {
 433 |         margin-left: 0;
 434 |     }
 435 | 
 436 |     tt,
 437 |     code,
 438 |     samp {
 439 |         font-family: ui-monospace, SFMono-Regular, SF Mono, Menlo, Consolas, Liberation Mono, monospace;
 440 |         font-size: 1em;
 441 |     }
 442 | 
 443 |     pre {
 444 |         margin-top: 0;
 445 |         margin-bottom: 0;
 446 |         font-family: ui-monospace, SFMono-Regular, SF Mono, Menlo, Consolas, Liberation Mono, monospace;
 447 |         font-size: 1em;
 448 |         word-wrap: normal;
 449 |     }
 450 | 
 451 |     .octicon {
 452 |         display: inline-block;
 453 |         overflow: visible !important;
 454 |         vertical-align: text-bottom;
 455 |         fill: currentColor;
 456 |     }
 457 | 
 458 |     input {
 459 |         &::-webkit-outer-spin-button,
 460 |         &::-webkit-inner-spin-button {
 461 |             margin: 0;
 462 |             -webkit-appearance: none;
 463 |             appearance: none;
 464 |         }
 465 |     }
 466 | 
 467 |     &::before {
 468 |         display: table;
 469 |         content: "";
 470 |     }
 471 | 
 472 |     &::after {
 473 |         display: table;
 474 |         clear: both;
 475 |         content: "";
 476 |     }
 477 | 
 478 |     > * {
 479 |         &:first-child {
 480 |             margin-top: 0 !important;
 481 |         }
 482 | 
 483 |         &:last-child {
 484 |             margin-bottom: 0 !important;
 485 |         }
 486 |     }
 487 | 
 488 |     a:not([href]) {
 489 |         color: inherit;
 490 |         text-decoration: none;
 491 |     }
 492 | 
 493 |     .absent {
 494 |         color: #f85149;
 495 |     }
 496 | 
 497 |     .anchor {
 498 |         float: left;
 499 |         padding-right: 4px;
 500 |         margin-left: -20px;
 501 |         line-height: 1;
 502 | 
 503 |         &:focus {
 504 |             outline: none;
 505 |         }
 506 |     }
 507 | 
 508 |     p,
 509 |     blockquote,
 510 |     ul,
 511 |     ol,
 512 |     dl,
 513 |     table,
 514 |     pre,
 515 |     details {
 516 |         margin-top: 0;
 517 |         margin-bottom: 16px;
 518 |     }
 519 | 
 520 |     blockquote > {
 521 |         :first-child {
 522 |             margin-top: 0;
 523 |         }
 524 | 
 525 |         :last-child {
 526 |             margin-bottom: 0;
 527 |         }
 528 |     }
 529 | 
 530 |     h1 .octicon-link,
 531 |     h2 .octicon-link,
 532 |     h3 .octicon-link,
 533 |     h4 .octicon-link,
 534 |     h5 .octicon-link,
 535 |     h6 .octicon-link {
 536 |         color: $color_base;
 537 |         vertical-align: middle;
 538 |         visibility: hidden;
 539 |     }
 540 | 
 541 |     h1:hover .anchor,
 542 |     h2:hover .anchor,
 543 |     h3:hover .anchor,
 544 |     h4:hover .anchor,
 545 |     h5:hover .anchor,
 546 |     h6:hover .anchor {
 547 |         text-decoration: none;
 548 |     }
 549 | 
 550 |     h1:hover .anchor .octicon-link,
 551 |     h2:hover .anchor .octicon-link,
 552 |     h3:hover .anchor .octicon-link,
 553 |     h4:hover .anchor .octicon-link,
 554 |     h5:hover .anchor .octicon-link,
 555 |     h6:hover .anchor .octicon-link {
 556 |         visibility: visible;
 557 |     }
 558 | 
 559 |     h1 {
 560 |         tt,
 561 |         code {
 562 |             padding: 0 0.2em;
 563 |             font-size: inherit;
 564 |         }
 565 |     }
 566 | 
 567 |     h2 {
 568 |         tt,
 569 |         code {
 570 |             padding: 0 0.2em;
 571 |             font-size: inherit;
 572 |         }
 573 |     }
 574 | 
 575 |     h3 {
 576 |         tt,
 577 |         code {
 578 |             padding: 0 0.2em;
 579 |             font-size: inherit;
 580 |         }
 581 |     }
 582 | 
 583 |     h4 {
 584 |         tt,
 585 |         code {
 586 |             padding: 0 0.2em;
 587 |             font-size: inherit;
 588 |         }
 589 |     }
 590 | 
 591 |     h5 {
 592 |         tt,
 593 |         code {
 594 |             padding: 0 0.2em;
 595 |             font-size: inherit;
 596 |         }
 597 |     }
 598 | 
 599 |     h6 {
 600 |         tt,
 601 |         code {
 602 |             padding: 0 0.2em;
 603 |             font-size: inherit;
 604 |         }
 605 |     }
 606 | 
 607 |     summary {
 608 |         h1,
 609 |         h2,
 610 |         h3,
 611 |         h4,
 612 |         h5,
 613 |         h6 {
 614 |             display: inline-block;
 615 |         }
 616 | 
 617 |         h1 .anchor,
 618 |         h2 .anchor,
 619 |         h3 .anchor,
 620 |         h4 .anchor,
 621 |         h5 .anchor,
 622 |         h6 .anchor {
 623 |             margin-left: -40px;
 624 |         }
 625 | 
 626 |         h1,
 627 |         h2 {
 628 |             padding-bottom: 0;
 629 |             border-bottom: 0;
 630 |         }
 631 |     }
 632 | 
 633 |     ul.no-list {
 634 |         padding: 0;
 635 |         list-style-type: none;
 636 |     }
 637 | 
 638 |     ol {
 639 |         &.no-list {
 640 |             padding: 0;
 641 |             list-style-type: none;
 642 |         }
 643 | 
 644 |         &[type="a"] {
 645 |             list-style-type: lower-alpha;
 646 |         }
 647 | 
 648 |         &[type="A"] {
 649 |             list-style-type: upper-alpha;
 650 |         }
 651 | 
 652 |         &[type="i"] {
 653 |             list-style-type: lower-roman;
 654 |         }
 655 | 
 656 |         &[type="I"] {
 657 |             list-style-type: upper-roman;
 658 |         }
 659 | 
 660 |         &[type="1"] {
 661 |             list-style-type: decimal;
 662 |         }
 663 |     }
 664 | 
 665 |     div > ol:not([type]) {
 666 |         list-style-type: decimal;
 667 |     }
 668 | 
 669 |     ul {
 670 |         ul,
 671 |         ol {
 672 |             margin-top: 0;
 673 |             margin-bottom: 0;
 674 |         }
 675 |     }
 676 | 
 677 |     ol {
 678 |         ol,
 679 |         ul {
 680 |             margin-top: 0;
 681 |             margin-bottom: 0;
 682 |         }
 683 |     }
 684 | 
 685 |     li {
 686 |         > p {
 687 |             margin-top: 16px;
 688 |         }
 689 | 
 690 |         + li {
 691 |             margin-top: 0.25em;
 692 |         }
 693 |     }
 694 | 
 695 |     dl {
 696 |         padding: 0;
 697 | 
 698 |         dt {
 699 |             padding: 0;
 700 |             margin-top: 16px;
 701 |             font-size: 1em;
 702 |             font-style: italic;
 703 |             font-weight: 600;
 704 |         }
 705 | 
 706 |         dd {
 707 |             padding: 0 16px;
 708 |             margin-bottom: 16px;
 709 |         }
 710 |     }
 711 | 
 712 |     table {
 713 |         th {
 714 |             font-weight: 600;
 715 |             padding: 6px 13px;
 716 |             border: 1px solid #30363d;
 717 |         }
 718 | 
 719 |         td {
 720 |             padding: 6px 13px;
 721 |             border: 1px solid #30363d;
 722 |         }
 723 | 
 724 |         tr {
 725 |             background-color: $bg_base;
 726 |             border-top: 1px solid #21262d;
 727 | 
 728 |             &:nth-child(2n) {
 729 |                 background-color: #161b22;
 730 |             }
 731 |         }
 732 | 
 733 |         img {
 734 |             background-color: transparent;
 735 |         }
 736 |     }
 737 | 
 738 |     img {
 739 |         &[align="right"] {
 740 |             padding-left: 20px;
 741 |         }
 742 | 
 743 |         &[align="left"] {
 744 |             padding-right: 20px;
 745 |         }
 746 |     }
 747 | 
 748 |     .emoji {
 749 |         max-width: none;
 750 |         vertical-align: text-top;
 751 |         background-color: transparent;
 752 |     }
 753 | 
 754 |     span {
 755 |         &.frame {
 756 |             display: block;
 757 |             overflow: hidden;
 758 | 
 759 |             > span {
 760 |                 display: block;
 761 |                 float: left;
 762 |                 width: auto;
 763 |                 padding: 7px;
 764 |                 margin: 13px 0 0;
 765 |                 overflow: hidden;
 766 |                 border: 1px solid #30363d;
 767 |             }
 768 | 
 769 |             span {
 770 |                 img {
 771 |                     display: block;
 772 |                     float: left;
 773 |                 }
 774 | 
 775 |                 span {
 776 |                     display: block;
 777 |                     padding: 5px 0 0;
 778 |                     clear: both;
 779 |                     color: $color_base;
 780 |                 }
 781 |             }
 782 |         }
 783 | 
 784 |         &.align-center {
 785 |             display: block;
 786 |             overflow: hidden;
 787 |             clear: both;
 788 | 
 789 |             > span {
 790 |                 display: block;
 791 |                 margin: 13px auto 0;
 792 |                 overflow: hidden;
 793 |                 text-align: center;
 794 |             }
 795 | 
 796 |             span img {
 797 |                 margin: 0 auto;
 798 |                 text-align: center;
 799 |             }
 800 |         }
 801 | 
 802 |         &.align-right {
 803 |             display: block;
 804 |             overflow: hidden;
 805 |             clear: both;
 806 | 
 807 |             > span {
 808 |                 display: block;
 809 |                 margin: 13px 0 0;
 810 |                 overflow: hidden;
 811 |                 text-align: right;
 812 |             }
 813 | 
 814 |             span img {
 815 |                 margin: 0;
 816 |                 text-align: right;
 817 |             }
 818 |         }
 819 | 
 820 |         &.float-left {
 821 |             display: block;
 822 |             float: left;
 823 |             margin-right: 13px;
 824 |             overflow: hidden;
 825 | 
 826 |             span {
 827 |                 margin: 13px 0 0;
 828 |             }
 829 |         }
 830 | 
 831 |         &.float-right {
 832 |             display: block;
 833 |             float: right;
 834 |             margin-left: 13px;
 835 |             overflow: hidden;
 836 | 
 837 |             > span {
 838 |                 display: block;
 839 |                 margin: 13px auto 0;
 840 |                 overflow: hidden;
 841 |                 text-align: right;
 842 |             }
 843 |         }
 844 |     }
 845 | 
 846 |     code,
 847 |     tt {
 848 |         padding: 0.2em 0.4em;
 849 |         margin: 0;
 850 |         font-size: 85%;
 851 |         white-space: break-spaces;
 852 |         background-color: rgba(110, 118, 129, 0.4);
 853 |         border-radius: 6px;
 854 |     }
 855 | 
 856 |     code br,
 857 |     tt br {
 858 |         display: none;
 859 |     }
 860 | 
 861 |     del code {
 862 |         text-decoration: inherit;
 863 |     }
 864 | 
 865 |     samp {
 866 |         font-size: 85%;
 867 |     }
 868 | 
 869 |     pre {
 870 |         code {
 871 |             font-size: 100%;
 872 |         }
 873 | 
 874 |         > code {
 875 |             padding: 0;
 876 |             margin: 0;
 877 |             word-break: normal;
 878 |             white-space: pre;
 879 |             background: transparent;
 880 |             border: 0;
 881 |         }
 882 |     }
 883 | 
 884 |     .highlight {
 885 |         margin-bottom: 16px;
 886 |         background: $bg_base;
 887 | 
 888 |         pre {
 889 |             margin-bottom: 0;
 890 |             word-break: normal;
 891 |             padding: 16px;
 892 |             overflow: auto;
 893 |             font-size: 85%;
 894 |             line-height: 1.45;
 895 |             background-color: #161b22;
 896 |             border-radius: 8px;
 897 |         }
 898 |     }
 899 | 
 900 |     pre {
 901 |         padding: 16px;
 902 |         overflow: auto;
 903 |         font-size: 85%;
 904 |         line-height: 1.45;
 905 |         background-color: #161b22;
 906 |         border-radius: 8px;
 907 | 
 908 |         code,
 909 |         tt {
 910 |             display: inline;
 911 |             max-width: auto;
 912 |             padding: 0;
 913 |             margin: 0;
 914 |             overflow: visible;
 915 |             line-height: inherit;
 916 |             word-wrap: normal;
 917 |             background-color: transparent;
 918 |             border: 0;
 919 |         }
 920 |     }
 921 | 
 922 |     .csv-data {
 923 |         td,
 924 |         th {
 925 |             padding: 5px;
 926 |             overflow: hidden;
 927 |             font-size: 1.2em;
 928 |             line-height: 1;
 929 |             text-align: left;
 930 |             white-space: nowrap;
 931 |         }
 932 | 
 933 |         .blob-num {
 934 |             padding: 10px 8px 9px;
 935 |             text-align: right;
 936 |             background: $bg_base;
 937 |             border: 0;
 938 |         }
 939 | 
 940 |         tr {
 941 |             border-top: 0;
 942 |         }
 943 | 
 944 |         th {
 945 |             font-weight: 600;
 946 |             background: #161b22;
 947 |             border-top: 0;
 948 |         }
 949 |     }
 950 | 
 951 |     [data-footnote-ref] {
 952 |         &::before {
 953 |             content: "[";
 954 |         }
 955 | 
 956 |         &::after {
 957 |             content: "]";
 958 |         }
 959 |     }
 960 | 
 961 |     .footnotes {
 962 |         font-size: 1em;
 963 |         color: #8b949e;
 964 |         border-top: 1px solid #30363d;
 965 | 
 966 |         ol {
 967 |             padding-left: 16px;
 968 | 
 969 |             ul {
 970 |                 display: inline-block;
 971 |                 padding-left: 16px;
 972 |                 margin-top: 16px;
 973 |             }
 974 |         }
 975 | 
 976 |         li {
 977 |             position: relative;
 978 | 
 979 |             &:target {
 980 |                 &::before {
 981 |                     position: absolute;
 982 |                     top: -8px;
 983 |                     right: -8px;
 984 |                     bottom: -8px;
 985 |                     left: -24px;
 986 |                     pointer-events: none;
 987 |                     content: "";
 988 |                     border: 2px solid #1f6feb;
 989 |                     border-radius: 6px;
 990 |                 }
 991 | 
 992 |                 color: $color_base;
 993 |             }
 994 |         }
 995 | 
 996 |         .data-footnote-backref g-emoji {
 997 |             font-family: monospace;
 998 |         }
 999 |     }
1000 | 
1001 |     .pl-c {
1002 |         color: #8b949e;
1003 |     }
1004 | 
1005 |     .pl-c1,
1006 |     .pl-s .pl-v {
1007 |         color: #79c0ff;
1008 |     }
1009 | 
1010 |     .pl-e,
1011 |     .pl-en {
1012 |         color: #d2a8ff;
1013 |     }
1014 | 
1015 |     .pl-smi,
1016 |     .pl-s .pl-s1 {
1017 |         color: $color_base;
1018 |     }
1019 | 
1020 |     .pl-ent {
1021 |         color: #7ee787;
1022 |     }
1023 | 
1024 |     .pl-k {
1025 |         color: #ff7b72;
1026 |     }
1027 | 
1028 |     .pl-s,
1029 |     .pl-pds,
1030 |     .pl-s .pl-pse .pl-s1 {
1031 |         color: #a5d6ff;
1032 |     }
1033 | 
1034 |     .pl-sr {
1035 |         color: #a5d6ff;
1036 | 
1037 |         .pl-cce,
1038 |         .pl-sre,
1039 |         .pl-sra {
1040 |             color: #a5d6ff;
1041 |         }
1042 |     }
1043 | 
1044 |     .pl-v,
1045 |     .pl-smw {
1046 |         color: #ffa657;
1047 |     }
1048 | 
1049 |     .pl-bu {
1050 |         color: #f85149;
1051 |     }
1052 | 
1053 |     .pl-ii {
1054 |         color: #f0f6fc;
1055 |         background-color: #8e1519;
1056 |     }
1057 | 
1058 |     .pl-c2 {
1059 |         color: #f0f6fc;
1060 |         background-color: #b62324;
1061 |     }
1062 | 
1063 |     .pl-sr .pl-cce {
1064 |         font-weight: bold;
1065 |         color: #7ee787;
1066 |     }
1067 | 
1068 |     .pl-ml {
1069 |         color: #f2cc60;
1070 |     }
1071 | 
1072 |     .pl-mh {
1073 |         font-weight: bold;
1074 |         color: #1f6feb;
1075 | 
1076 |         .pl-en {
1077 |             font-weight: bold;
1078 |             color: #1f6feb;
1079 |         }
1080 |     }
1081 | 
1082 |     .pl-ms {
1083 |         font-weight: bold;
1084 |         color: #1f6feb;
1085 |     }
1086 | 
1087 |     .pl-mi {
1088 |         font-style: italic;
1089 |         color: $color_base;
1090 |     }
1091 | 
1092 |     .pl-mb {
1093 |         font-weight: bold;
1094 |         color: $color_base;
1095 |     }
1096 | 
1097 |     .pl-md {
1098 |         color: #ffdcd7;
1099 |         background-color: #67060c;
1100 |     }
1101 | 
1102 |     .pl-mi1 {
1103 |         color: #aff5b4;
1104 |         background-color: #033a16;
1105 |     }
1106 | 
1107 |     .pl-mc {
1108 |         color: #ffdfb6;
1109 |         background-color: #5a1e02;
1110 |     }
1111 | 
1112 |     .pl-mi2 {
1113 |         color: $color_base;
1114 |         background-color: #1158c7;
1115 |     }
1116 | 
1117 |     .pl-mdr {
1118 |         font-weight: bold;
1119 |         color: #d2a8ff;
1120 |     }
1121 | 
1122 |     .pl-ba {
1123 |         color: #8b949e;
1124 |     }
1125 | 
1126 |     .pl-sg {
1127 |         color: #484f58;
1128 |     }
1129 | 
1130 |     .pl-corl {
1131 |         text-decoration: underline;
1132 |         color: #a5d6ff;
1133 |     }
1134 | 
1135 |     g-emoji {
1136 |         display: inline-block;
1137 |         min-width: 1ch;
1138 |         font-family: "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
1139 |         font-size: 1em;
1140 |         font-style: normal !important;
1141 |         font-weight: 400;
1142 |         line-height: 1;
1143 |         vertical-align: -0.075em;
1144 | 
1145 |         img {
1146 |             width: 1em;
1147 |             height: 1em;
1148 |         }
1149 |     }
1150 | 
1151 |     .task-list-item {
1152 |         list-style-type: none;
1153 | 
1154 |         label {
1155 |             font-weight: 400;
1156 |         }
1157 | 
1158 |         &.enabled label {
1159 |             cursor: pointer;
1160 |         }
1161 | 
1162 |         + .task-list-item {
1163 |             margin-top: 4px;
1164 |         }
1165 | 
1166 |         .handle {
1167 |             display: none;
1168 |         }
1169 |     }
1170 | 
1171 |     .task-list-item-checkbox {
1172 |         margin: 0 0.2em 0.25em -1.4em;
1173 |         vertical-align: middle;
1174 |     }
1175 | 
1176 |     .contains-task-list {
1177 |         &:dir(rtl) .task-list-item-checkbox {
1178 |             margin: 0 -1.6em 0.25em 0.2em;
1179 |         }
1180 | 
1181 |         position: relative;
1182 | 
1183 |         &:hover .task-list-item-convert-container,
1184 |         &:focus-within .task-list-item-convert-container {
1185 |             display: block;
1186 |             width: auto;
1187 |             height: 24px;
1188 |             overflow: visible;
1189 |             clip: auto;
1190 |         }
1191 |     }
1192 | 
1193 |     ::-webkit-calendar-picker-indicator {
1194 |         filter: invert(50%);
1195 |     }
1196 | }
1197 | 


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