autodocgenerator 0.9.0.4__py3-none-any.whl → 0.9.2.5__py3-none-any.whl

autodocgenerator/auto_runner/run_file.py

@@ -26,7 +26,10 @@ def gen_doc(project_path: str,
 
 
     manager.generate_code_file()
-    manager.generete_doc_parts(max_symbols=structure_settings.max_doc_part_size)
+    if config.pbc.use_global_file:
+        manager.generate_global_info(compress_power=4)
+        
+    manager.generete_doc_parts(max_symbols=structure_settings.max_doc_part_size, with_global_file=config.pbc.use_global_file)
     manager.factory_generate_doc(DocFactory(*custom_modules))
     if structure_settings.include_order:
         manager.order_doc()

autodocgenerator/config/config.py

@@ -7,6 +7,7 @@ from ..factory.modules.intro import IntroLinks
 class ProjectBuildConfig:
     save_logs = False
     log_level = -1
+    use_global_file = True
     def load_settings(self, data: dict[str, any]):
         for key, el in data.items():
             setattr(self, key, el)
@@ -15,7 +16,7 @@ class ProjectBuildConfig:
 
 class Config:
     def __init__(self):
-        self.ignore_files: list[str] = [    "*.pyo", "*.pyd", "*.pdb", "*.pkl", "*.log", "*.sqlite3", "*.db", "data",
+        self.ignore_files: list[str] = ["*.pyo", "*.pyd", "*.pdb", "*.pkl", "*.log", "*.sqlite3", "*.db", "data",
         "venv", "env", ".venv", ".env", ".vscode", ".idea", "*.iml", ".gitignore", ".ruff_cache", ".auto_doc_cache",
         "*.pyc", "__pycache__", ".git", ".coverage", "htmlcov", "migrations", "*.md", "static", "staticfiles", ".mypy_cache"
     ]

autodocgenerator/engine/config/config.py

@@ -124,24 +124,37 @@ This tag must appear ONLY ONCE at the very beginning. Never repeat it or use oth
 
 def get_BASE_COMPRESS_TEXT(start, power):
     return f"""
-You will receive a large code snippet (up to ~{start} characters).
-Your task is to analyze the logic and provide a summary with a STRICT usage example.
-
-1. **Analysis**: Extract the architecture, main classes, and logic flow. 
-2. **Summary**: No more than ~{int(start / power)} characters. Focus on structure and data flow.
-
-3. **STRICT Usage Example**:
-Provide a Python code snippet that demonstrates exactly how to call the logic. 
-DO NOT simplify the interface. DO NOT invent high-level methods that don't exist.
-Follow these rules for the example:
-- **Initialization**: Show exactly how to initialize the main class (e.g., if it requires a 'progress' object, path, or list, include them in the example).
-- **Dependency Flow**: If the class requires other objects (like a Progress bar or a Factory), show their creation or setup.
-- **Sequential Calls**: If the code requires a specific sequence of methods (e.g., method A then method B), reflect this in the example.
-- **Real Signatures**: Use the actual names of methods and arguments found in the source code.
-
-**The output format for this section must be:**
-```python
-# Real-world usage based on the code above
+Task: Analyze the provided code snippet (~{start} chars) and generate a hyper-compressed Markdown architectural map.
+Goal: Create a context baseline for other AI models so they understand the "big picture" and functional dependencies when looking at isolated parts of this code.
+
+Constraints:
+Strict Length: Maximum {int(start / power)} characters.
+Format: Pure Markdown. Use visual markers (arrows, lists) for flow.
+Tone: Technical, dense, no conversational filler.
+
+Required Content:
+Project Core: 1-sentence definition of the project's purpose and its architectural pattern (e.g., MVC, Layered, Event-driven).
+Component Map: List main classes/modules and their primary responsibility.
+Interaction Graph (Functional Context): Map how functions/methods interact.
+
+Format: FunctionA -> FunctionB [data passed].
+Highlight "Entry Points" (where logic starts) and "Terminal Points" (where data is saved/returned).
+State & Context: Mention key shared objects or state variables that influence multiple functions.
+
+Output Structure:
+Markdown
+## Architecture: [Name/Pattern]
+**Goal:** [Brief description]
+
+### Component Logic
+* **[Class/Module]:** [Responsibility]
+
+### Functional Flow (Dependencies)
+* `Method_1` -> calls `Method_2` to [reason]
+* `Method_2` -> updates `SharedState` -> triggers `Method_3`
+
+### Key Context for Snippets
+[List critical dependencies or global variables a developer must know to edit any single function here]
 """
 
 import os

autodocgenerator/manage.py

@@ -1,5 +1,5 @@
-from .preprocessor.spliter import split_data, gen_doc_parts, async_gen_doc_parts
-from .preprocessor.compressor import compress_to_one, generate_discribtions_for_code
+from .preprocessor.spliter import split_data, gen_doc_parts
+from .preprocessor.compressor import compress_to_one
 from .postprocessor.custom_intro import get_introdaction, get_all_html_links, get_links_intro
 from .engine.models.gpt_model import AsyncGPTModel, GPTModel
 from .engine.models.model import Model, AsyncModel
@@ -67,8 +67,21 @@ class Manager:
         self.logger.log(InfoLog("Code mix generation completed."))
         self.progress_bar.update_task()
 
-    def generete_doc_parts(self, max_symbols=5_000):
+    def generate_global_info(self, compress_power: int = 4, max_symbols: int = 10000):
         full_code_mix = self.read_file_by_file_key("code_mix")
+        data = split_data(full_code_mix, max_symbols)
+
+        global_result = compress_to_one(data, self.sync_model, self.config.get_project_settings(), compress_power=compress_power, progress_bar=self.progress_bar)
+        with open(self.get_file_path("global_info"), "w", encoding="utf-8") as file:
+            file.write(global_result)
+
+        self.progress_bar.update_task()
+        
+
+    def generete_doc_parts(self, max_symbols=5_000, with_global_file: bool = False):
+        full_code_mix = self.read_file_by_file_key("code_mix")
+
+        global_file = self.read_file_by_file_key("global_info") if with_global_file else None
 
         self.logger.log(InfoLog("Starting synchronous documentation generation by parts..."))
         result = gen_doc_parts(full_code_mix,

autodocgenerator/preprocessor/compressor.py

@@ -16,7 +16,7 @@ def compress(data: str, project_settings: ProjectSettings, model: Model, compres
         },
         {
             "role": "system",
-            "content": get_BASE_COMPRESS_TEXT(10000, compress_power)
+            "content": get_BASE_COMPRESS_TEXT(len(data), compress_power)
         },
         {
             "role": "user",
@@ -40,58 +40,18 @@ def compress_and_compare(data: list, model: Model, project_settings: ProjectSett
 
     return compress_and_compare_data
 
-async def async_compress(data: str,  project_settings: ProjectSettings, model: AsyncModel, compress_power, semaphore, progress_bar: BaseProgress) -> str:
-    
-    async with semaphore:
-        prompt = [
-            {
-                "role": "system",
-                "content": project_settings.prompt
-            },
-            {
-                "role": "system",
-                "content": get_BASE_COMPRESS_TEXT(10000, compress_power)
-            },
-            {
-                "role": "user",
-                "content": data
-            }
-        ]
-        answer = await model.get_answer_without_history(prompt=prompt)
-        progress_bar.update_task()
-        return answer
-
-async def async_compress_and_compare(data: list, model: AsyncModel, project_settings: ProjectSettings, compress_power: int = 4, progress_bar: BaseProgress = BaseProgress()) -> list:
-    semaphore = asyncio.Semaphore(4)
-    tasks = []
-    progress_bar.create_new_subtask(f"Compare all files (async)", len(data))
-
-    for el in data:
-        tasks.append(async_compress(el, project_settings, model, compress_power, semaphore, progress_bar))
-    
-    compressed_elements = await asyncio.gather(*tasks)
-    
-    final_data = []
-    chunk_size = compress_power
-    for i in range(0, len(compressed_elements), chunk_size):
-        chunk = compressed_elements[i : i + chunk_size]
-        final_data.append("\n".join(chunk) + "\n")
-    
-    progress_bar.remove_subtask()
-        
-    return final_data
 
-def compress_to_one(data: list, model: Model, project_settings: ProjectSettings, compress_power: int = 4, use_async: bool = False, progress_bar: BaseProgress = BaseProgress()):
+
+def compress_to_one(data: list, model: Model, project_settings: ProjectSettings, compress_power: int = 4, progress_bar: BaseProgress = BaseProgress()):
     count_of_iter = 0
+
     while len(data) > 1:
         new_compress_power = compress_power
         if (len(data) < compress_power + 1):
             new_compress_power = 2
         
-        if use_async:
-            data = asyncio.run(async_compress_and_compare(data, model, project_settings, new_compress_power, progress_bar=progress_bar))
-        else:
-            data = compress_and_compare(data, model, project_settings, new_compress_power, progress_bar=progress_bar)
+        data = compress_and_compare(data, model, project_settings, new_compress_power, progress_bar=progress_bar)
+
         count_of_iter += 1
 
 
@@ -99,39 +59,6 @@ def compress_to_one(data: list, model: Model, project_settings: ProjectSettings,
 
 
 
-def generate_discribtions_for_code(data: list, model: Model, project_settings: ProjectSettings, progress_bar: BaseProgress = BaseProgress()) -> list:
-    describtions = []
-    progress_bar.create_new_subtask("Generate describtions for code files", len(data))
-    for code in data:
-        prompt = [
-            {
-                "role": "system",
-                "content": """### Instructions:
-1. Identify Main Components: Determine what classes, functions, or modules are meant to be used by an external developer.
-2. Description: Explain the purpose of each main component (e.g., "What is the Manager class for?").
-3. Parameters & Types: Detail every parameter required for initialization and method calls, including their expected data types and default values.
-4. Usage Example: Provide a COMPLETE, "copy-pasteable" code example showing:
-   - Proper initialization.
-   - Calling key methods.
-   - Handling expected outputs or errors.
-
-### Strict Rules:
-- Base your guide ONLY on the provided code. 
-- If the code is incomplete or a certain class/method is missing, do not hallucinate its logic—simply state that information is unavailable.
-- Use Markdown for code blocks and bold text for parameter names.
-- If no usable logic is found in the code, respond with an empty string ("")."""
-            },
-            {
-                "role": "user",
-                "content": f"CONTEXT: {code}"
-            }
-        ]
-        answer = model.get_answer_without_history(prompt=prompt)
-        describtions.append(answer)
-        progress_bar.update_task()
-    
-    progress_bar.remove_subtask()
-    return describtions
 
 
 

autodocgenerator/preprocessor/spliter.py

@@ -41,7 +41,7 @@ def split_data(data: str, max_symbols: int) -> list[str]:
 
     return split_objects
 
-def write_docs_by_parts(part: str, model: Model, project_settings: ProjectSettings, prev_info: str = None, language: str = "en"):
+def write_docs_by_parts(part: str, model: Model, project_settings: ProjectSettings, prev_info: str = None, language: str = "en", global_info: str = None):
     logger = BaseLogger()
     logger.log(InfoLog("Generating documentation for a part..."))
     prompt = [
@@ -59,6 +59,12 @@ def write_docs_by_parts(part: str, model: Model, project_settings: ProjectSettin
             }
     ]
 
+    if global_info is not None:
+        prompt.append({
+            "role": "system",
+            "content": f"global relations in project: {global_info}"
+        })
+
     if prev_info is not None:
         prompt.append({
                 "role": "system",
@@ -80,53 +86,10 @@ def write_docs_by_parts(part: str, model: Model, project_settings: ProjectSettin
     answer = temp_answer.removesuffix("```")
     return answer
 
-async def async_write_docs_by_parts(part: str, async_model: AsyncModel, global_info: str, semaphore, prev_info: str = None, language: str = "en", update_progress = None):
-    logger = BaseLogger()
-    logger.log(InfoLog("Generating documentation for a part (async)..."))
-    async with semaphore:
 
-        prompt = [
-            {
-                "role": "system",
-                "content": f"For the following task use language {language}"
-            },
-            {
-                "role": "system",
-                "content": BASE_PART_COMPLITE_TEXT
-            },
-           
-            {
-                "role": "user",
-                "content": part
-            }
-        ]
 
-        if prev_info is not None:
-            prompt.append({
-                    "role": "system",
-                    "content": f"it is last part of documentation that you have write before {prev_info}"
-                })
 
-        prompt.append({
-                    "role": "user",
-                    "content": part
-                })
-        answer: str = await async_model.get_answer_without_history(prompt=prompt)
-
-        if update_progress is not None:
-            update_progress()
-
-        logger.log(InfoLog("Documentation for part generated. total length: " + str(len(answer))))
-        logger.log(InfoLog(f"Part Documentation: {answer}", level=2))
-        temp_answer = answer.removeprefix("```")
-        if answer == temp_answer:
-            return answer
-
-        answer = temp_answer.removesuffix("```")
-        return answer
-
-
-def gen_doc_parts(full_code_mix, max_symbols, model: Model, project_settings: ProjectSettings,  language, progress_bar: BaseProgress):
+def gen_doc_parts(full_code_mix, max_symbols, model: Model, project_settings: ProjectSettings,  language, progress_bar: BaseProgress, global_info = None):
     splited_data = split_data(full_code_mix, max_symbols)
     result = None
     logger = BaseLogger()
@@ -136,7 +99,7 @@ def gen_doc_parts(full_code_mix, max_symbols, model: Model, project_settings: Pr
     
     all_result = ""
     for i, el in enumerate(splited_data):
-        result = write_docs_by_parts(el, model, project_settings, result, language)
+        result = write_docs_by_parts(el, model, project_settings, result, language, global_info=global_info)
         all_result += result
         all_result += "\n\n"
 
@@ -148,28 +111,3 @@ def gen_doc_parts(full_code_mix, max_symbols, model: Model, project_settings: Pr
                        Total documentation length: {len(all_result)}"""))
     logger.log(InfoLog(f"Documentation: {all_result}", level=2))
     return all_result
-
-async def async_gen_doc_parts(full_code_mix, global_info, max_symbols, model: AsyncModel, language, progress_bar: BaseProgress):
-    splited_data = split_data(full_code_mix, max_symbols)
-    progress_bar.create_new_subtask(f"Generete doc parts (async)", len(splited_data))
-    
-    semaphore = asyncio.Semaphore(4)
-    logger = BaseLogger()
-    logger.log(InfoLog("Starting asynchronous documentation generation by parts..."))
-
-    tasks = []
-    for el in splited_data:
-        tasks.append(async_write_docs_by_parts(part=el, async_model=model, global_info=global_info, semaphore=semaphore, language=language, update_progress=lambda: progress_bar.update_task()))
-
-    gen_parts = await asyncio.gather(*tasks)
-    result = ""
-    for el in gen_parts:
-        result += el
-        result += "\n\n"
-
-    progress_bar.remove_subtask()
-    logger.log(InfoLog(f"""Asynchronous documentation generation by parts completed.\n
-                       Total documentation length: {len(result)}"""))
-    logger.log(InfoLog(f"Documentation: {result}", level=2))
-
-    return result