markdown-analysis 0.0.3__tar.gz → 0.0.4__tar.gz

markdown_analysis-0.0.4/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.1
+Name: markdown_analysis
+Version: 0.0.4
+Summary: UNKNOWN
+Home-page: https://github.com/yannbanas/mrkdwn_analysis
+Author: yannbanas
+Author-email: yannbanas@gmail.com
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# mrkdwn_analysis
+
+`mrkdwn_analysis` is a Python library designed to analyze Markdown files. With its powerful parsing capabilities, it can extract and categorize various elements within a Markdown document, including headers, sections, links, images, blockquotes, code blocks, and lists. This makes it a valuable tool for anyone looking to parse Markdown content for data analysis, content generation, or for building other tools that utilize Markdown.
+
+## Features
+
+- File Loading: The MarkdownAnalyzer can load any given Markdown file provided through the file path.
+
+- Header Identification: The tool can extract all headers from the markdown file, ranging from H1 to H6 tags. This allows users to have a quick overview of the document's structure.
+
+- Section Identification: The analyzer can recognize different sections of the document. It defines a section as a block of text followed by a line composed solely of = or - characters.
+
+- Paragraph Identification: The tool can distinguish between regular text and other elements such as lists, headers, etc., thereby identifying all the paragraphs present in the document.
+
+- Blockquote Identification: The analyzer can identify and extract all blockquotes in the markdown file.
+
+- Code Block Identification: The tool can extract all code blocks defined in the document, allowing you to separate the programming code from the regular text easily.
+
+- List Identification: The analyzer can identify both ordered and unordered lists in the markdown file, providing information about the hierarchical structure of the points.
+
+- Table Identification: The tool can identify and extract tables from the markdown file, enabling users to separate and analyze tabular data quickly.
+
+- Link Identification and Validation: The analyzer can identify all links present in the markdown file, categorizing them into text and image links. Moreover, it can also verify if these links are valid or broken.
+
+- Todo Identification: The tool is capable of recognizing and extracting todos (tasks or action items) present in the document.
+
+- Element Counting: The analyzer can count the total number of a specific element type in the file. This can help in quantifying the extent of different elements in the document.
+
+- Word Counting: The tool can count the total number of words in the file, providing an estimate of the document's length.
+
+- Character Counting: The analyzer can count the total number of characters (excluding spaces) in the file, giving a detailed measure of the document's size.
+
+## Installation
+You can install `mrkdwn_analysis` from PyPI:
+
+```bash
+pip install mrkdwn_analysis
+```
+
+We hope `mrkdwn_analysis` helps you with all your Markdown analyzing needs!
+
+## Usage
+Using `mrkdwn_analysis` is simple. Just import the `MarkdownAnalyzer` class, create an instance with your Markdown file, and you're good to go!
+
+```python
+from mrkdwn_analysis import MarkdownAnalyzer
+
+analyzer = MarkdownAnalyzer("path/to/your/markdown.md")
+
+headers = analyzer.identify_headers()
+sections = analyzer.identify_sections()
+...
+```
+
+### Class MarkdownAnalyzer
+
+The `MarkdownAnalyzer` class is designed to analyze Markdown files. It has the ability to extract and categorize various elements of a Markdown document.
+
+### `__init__(self, file_path)`
+
+The constructor of the class. It opens the specified Markdown file and stores its content line by line.
+
+- `file_path`: the path of the Markdown file to analyze.
+
+### `identify_headers(self)`
+
+Analyzes the file and identifies all headers (from h1 to h6). Headers are returned as a dictionary where the key is "Header" and the value is a list of all headers found.
+
+### `identify_sections(self)`
+
+Analyzes the file and identifies all sections. Sections are defined as a block of text followed by a line composed solely of `=` or `-` characters. Sections are returned as a dictionary where the key is "Section" and the value is a list of all sections found.
+
+### `identify_paragraphs(self)`
+
+Analyzes the file and identifies all paragraphs. Paragraphs are defined as a block of text that is not a header, list, blockquote, etc. Paragraphs are returned as a dictionary where the key is "Paragraph" and the value is a list of all paragraphs found.
+
+### `identify_blockquotes(self)`
+
+Analyzes the file and identifies all blockquotes. Blockquotes are defined by a line starting with the `>` character. Blockquotes are returned as a dictionary where the key is "Blockquote" and the value is a list of all blockquotes found.
+
+### `identify_code_blocks(self)`
+
+Analyzes the file and identifies all code blocks. Code blocks are defined by a block of text surrounded by lines containing only the "```" text. Code blocks are returned as a dictionary where the key is "Code block" and the value is a list of all code blocks found.
+
+### `identify_ordered_lists(self)`
+
+Analyzes the file and identifies all ordered lists. Ordered lists are defined by lines starting with a number followed by a dot. Ordered lists are returned as a dictionary where the key is "Ordered list" and the value is a list of all ordered lists found.
+
+### `identify_unordered_lists(self)`
+
+Analyzes the file and identifies all unordered lists. Unordered lists are defined by lines starting with a `-`, `*`, or `+`. Unordered lists are returned as a dictionary where the key is "Unordered list" and the value is a list of all unordered lists found.
+
+### `identify_tables(self)`
+
+Analyzes the file and identifies all tables. Tables are defined by lines containing `|` to delimit cells and are separated by lines containing `-` to define the borders. Tables are returned as a dictionary where the key is "Table" and the value is a list of all tables found.
+
+### `identify_links(self)`
+
+Analyzes the file and identifies all links. Links are defined by the format `[text](url)`. Links are returned as a dictionary where the keys are "Text link" and "Image link" and the values are lists of all links found.
+
+### `check_links(self)`
+
+Checks all links identified by `identify_links` to see if they are broken (return a 404 error). Broken links are returned as a list, each item being a dictionary containing the line number, link text, and URL.
+
+### `identify_todos(self)`
+
+Analyzes the file and identifies all todos. Todos are defined by lines starting with `- [ ] `. Todos are returned as a list, each item being a dictionary containing the line number and todo text.
+
+### `count_elements(self, element_type)`
+
+Counts the total number of a specific element type in the file. The `element_type` should match the name of one of the identification methods (for example, "headers" for `identify_headers`). Returns the total number of elements of this type.
+
+### `count_words(self)`
+
+Counts the total number of words in the file. Returns the word count.
+
+### `count_characters(self)`
+
+Counts the total number of characters (excluding spaces) in the file. Returns the character count.
+
+## Contributions
+Contributions are always welcome! If you have a feature request, bug report, or just want to improve the code, feel free to create a pull request or open an issue.
+
+

markdown_analysis-0.0.4/README.md

@@ -0,0 +1,122 @@
+# mrkdwn_analysis
+
+`mrkdwn_analysis` is a Python library designed to analyze Markdown files. With its powerful parsing capabilities, it can extract and categorize various elements within a Markdown document, including headers, sections, links, images, blockquotes, code blocks, and lists. This makes it a valuable tool for anyone looking to parse Markdown content for data analysis, content generation, or for building other tools that utilize Markdown.
+
+## Features
+
+- File Loading: The MarkdownAnalyzer can load any given Markdown file provided through the file path.
+
+- Header Identification: The tool can extract all headers from the markdown file, ranging from H1 to H6 tags. This allows users to have a quick overview of the document's structure.
+
+- Section Identification: The analyzer can recognize different sections of the document. It defines a section as a block of text followed by a line composed solely of = or - characters.
+
+- Paragraph Identification: The tool can distinguish between regular text and other elements such as lists, headers, etc., thereby identifying all the paragraphs present in the document.
+
+- Blockquote Identification: The analyzer can identify and extract all blockquotes in the markdown file.
+
+- Code Block Identification: The tool can extract all code blocks defined in the document, allowing you to separate the programming code from the regular text easily.
+
+- List Identification: The analyzer can identify both ordered and unordered lists in the markdown file, providing information about the hierarchical structure of the points.
+
+- Table Identification: The tool can identify and extract tables from the markdown file, enabling users to separate and analyze tabular data quickly.
+
+- Link Identification and Validation: The analyzer can identify all links present in the markdown file, categorizing them into text and image links. Moreover, it can also verify if these links are valid or broken.
+
+- Todo Identification: The tool is capable of recognizing and extracting todos (tasks or action items) present in the document.
+
+- Element Counting: The analyzer can count the total number of a specific element type in the file. This can help in quantifying the extent of different elements in the document.
+
+- Word Counting: The tool can count the total number of words in the file, providing an estimate of the document's length.
+
+- Character Counting: The analyzer can count the total number of characters (excluding spaces) in the file, giving a detailed measure of the document's size.
+
+## Installation
+You can install `mrkdwn_analysis` from PyPI:
+
+```bash
+pip install mrkdwn_analysis
+```
+
+We hope `mrkdwn_analysis` helps you with all your Markdown analyzing needs!
+
+## Usage
+Using `mrkdwn_analysis` is simple. Just import the `MarkdownAnalyzer` class, create an instance with your Markdown file, and you're good to go!
+
+```python
+from mrkdwn_analysis import MarkdownAnalyzer
+
+analyzer = MarkdownAnalyzer("path/to/your/markdown.md")
+
+headers = analyzer.identify_headers()
+sections = analyzer.identify_sections()
+...
+```
+
+### Class MarkdownAnalyzer
+
+The `MarkdownAnalyzer` class is designed to analyze Markdown files. It has the ability to extract and categorize various elements of a Markdown document.
+
+### `__init__(self, file_path)`
+
+The constructor of the class. It opens the specified Markdown file and stores its content line by line.
+
+- `file_path`: the path of the Markdown file to analyze.
+
+### `identify_headers(self)`
+
+Analyzes the file and identifies all headers (from h1 to h6). Headers are returned as a dictionary where the key is "Header" and the value is a list of all headers found.
+
+### `identify_sections(self)`
+
+Analyzes the file and identifies all sections. Sections are defined as a block of text followed by a line composed solely of `=` or `-` characters. Sections are returned as a dictionary where the key is "Section" and the value is a list of all sections found.
+
+### `identify_paragraphs(self)`
+
+Analyzes the file and identifies all paragraphs. Paragraphs are defined as a block of text that is not a header, list, blockquote, etc. Paragraphs are returned as a dictionary where the key is "Paragraph" and the value is a list of all paragraphs found.
+
+### `identify_blockquotes(self)`
+
+Analyzes the file and identifies all blockquotes. Blockquotes are defined by a line starting with the `>` character. Blockquotes are returned as a dictionary where the key is "Blockquote" and the value is a list of all blockquotes found.
+
+### `identify_code_blocks(self)`
+
+Analyzes the file and identifies all code blocks. Code blocks are defined by a block of text surrounded by lines containing only the "```" text. Code blocks are returned as a dictionary where the key is "Code block" and the value is a list of all code blocks found.
+
+### `identify_ordered_lists(self)`
+
+Analyzes the file and identifies all ordered lists. Ordered lists are defined by lines starting with a number followed by a dot. Ordered lists are returned as a dictionary where the key is "Ordered list" and the value is a list of all ordered lists found.
+
+### `identify_unordered_lists(self)`
+
+Analyzes the file and identifies all unordered lists. Unordered lists are defined by lines starting with a `-`, `*`, or `+`. Unordered lists are returned as a dictionary where the key is "Unordered list" and the value is a list of all unordered lists found.
+
+### `identify_tables(self)`
+
+Analyzes the file and identifies all tables. Tables are defined by lines containing `|` to delimit cells and are separated by lines containing `-` to define the borders. Tables are returned as a dictionary where the key is "Table" and the value is a list of all tables found.
+
+### `identify_links(self)`
+
+Analyzes the file and identifies all links. Links are defined by the format `[text](url)`. Links are returned as a dictionary where the keys are "Text link" and "Image link" and the values are lists of all links found.
+
+### `check_links(self)`
+
+Checks all links identified by `identify_links` to see if they are broken (return a 404 error). Broken links are returned as a list, each item being a dictionary containing the line number, link text, and URL.
+
+### `identify_todos(self)`
+
+Analyzes the file and identifies all todos. Todos are defined by lines starting with `- [ ] `. Todos are returned as a list, each item being a dictionary containing the line number and todo text.
+
+### `count_elements(self, element_type)`
+
+Counts the total number of a specific element type in the file. The `element_type` should match the name of one of the identification methods (for example, "headers" for `identify_headers`). Returns the total number of elements of this type.
+
+### `count_words(self)`
+
+Counts the total number of words in the file. Returns the word count.
+
+### `count_characters(self)`
+
+Counts the total number of characters (excluding spaces) in the file. Returns the character count.
+
+## Contributions
+Contributions are always welcome! If you have a feature request, bug report, or just want to improve the code, feel free to create a pull request or open an issue.

markdown_analysis-0.0.4/markdown_analysis.egg-info/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.1
+Name: markdown-analysis
+Version: 0.0.4
+Summary: UNKNOWN
+Home-page: https://github.com/yannbanas/mrkdwn_analysis
+Author: yannbanas
+Author-email: yannbanas@gmail.com
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# mrkdwn_analysis
+
+`mrkdwn_analysis` is a Python library designed to analyze Markdown files. With its powerful parsing capabilities, it can extract and categorize various elements within a Markdown document, including headers, sections, links, images, blockquotes, code blocks, and lists. This makes it a valuable tool for anyone looking to parse Markdown content for data analysis, content generation, or for building other tools that utilize Markdown.
+
+## Features
+
+- File Loading: The MarkdownAnalyzer can load any given Markdown file provided through the file path.
+
+- Header Identification: The tool can extract all headers from the markdown file, ranging from H1 to H6 tags. This allows users to have a quick overview of the document's structure.
+
+- Section Identification: The analyzer can recognize different sections of the document. It defines a section as a block of text followed by a line composed solely of = or - characters.
+
+- Paragraph Identification: The tool can distinguish between regular text and other elements such as lists, headers, etc., thereby identifying all the paragraphs present in the document.
+
+- Blockquote Identification: The analyzer can identify and extract all blockquotes in the markdown file.
+
+- Code Block Identification: The tool can extract all code blocks defined in the document, allowing you to separate the programming code from the regular text easily.
+
+- List Identification: The analyzer can identify both ordered and unordered lists in the markdown file, providing information about the hierarchical structure of the points.
+
+- Table Identification: The tool can identify and extract tables from the markdown file, enabling users to separate and analyze tabular data quickly.
+
+- Link Identification and Validation: The analyzer can identify all links present in the markdown file, categorizing them into text and image links. Moreover, it can also verify if these links are valid or broken.
+
+- Todo Identification: The tool is capable of recognizing and extracting todos (tasks or action items) present in the document.
+
+- Element Counting: The analyzer can count the total number of a specific element type in the file. This can help in quantifying the extent of different elements in the document.
+
+- Word Counting: The tool can count the total number of words in the file, providing an estimate of the document's length.
+
+- Character Counting: The analyzer can count the total number of characters (excluding spaces) in the file, giving a detailed measure of the document's size.
+
+## Installation
+You can install `mrkdwn_analysis` from PyPI:
+
+```bash
+pip install mrkdwn_analysis
+```
+
+We hope `mrkdwn_analysis` helps you with all your Markdown analyzing needs!
+
+## Usage
+Using `mrkdwn_analysis` is simple. Just import the `MarkdownAnalyzer` class, create an instance with your Markdown file, and you're good to go!
+
+```python
+from mrkdwn_analysis import MarkdownAnalyzer
+
+analyzer = MarkdownAnalyzer("path/to/your/markdown.md")
+
+headers = analyzer.identify_headers()
+sections = analyzer.identify_sections()
+...
+```
+
+### Class MarkdownAnalyzer
+
+The `MarkdownAnalyzer` class is designed to analyze Markdown files. It has the ability to extract and categorize various elements of a Markdown document.
+
+### `__init__(self, file_path)`
+
+The constructor of the class. It opens the specified Markdown file and stores its content line by line.
+
+- `file_path`: the path of the Markdown file to analyze.
+
+### `identify_headers(self)`
+
+Analyzes the file and identifies all headers (from h1 to h6). Headers are returned as a dictionary where the key is "Header" and the value is a list of all headers found.
+
+### `identify_sections(self)`
+
+Analyzes the file and identifies all sections. Sections are defined as a block of text followed by a line composed solely of `=` or `-` characters. Sections are returned as a dictionary where the key is "Section" and the value is a list of all sections found.
+
+### `identify_paragraphs(self)`
+
+Analyzes the file and identifies all paragraphs. Paragraphs are defined as a block of text that is not a header, list, blockquote, etc. Paragraphs are returned as a dictionary where the key is "Paragraph" and the value is a list of all paragraphs found.
+
+### `identify_blockquotes(self)`
+
+Analyzes the file and identifies all blockquotes. Blockquotes are defined by a line starting with the `>` character. Blockquotes are returned as a dictionary where the key is "Blockquote" and the value is a list of all blockquotes found.
+
+### `identify_code_blocks(self)`
+
+Analyzes the file and identifies all code blocks. Code blocks are defined by a block of text surrounded by lines containing only the "```" text. Code blocks are returned as a dictionary where the key is "Code block" and the value is a list of all code blocks found.
+
+### `identify_ordered_lists(self)`
+
+Analyzes the file and identifies all ordered lists. Ordered lists are defined by lines starting with a number followed by a dot. Ordered lists are returned as a dictionary where the key is "Ordered list" and the value is a list of all ordered lists found.
+
+### `identify_unordered_lists(self)`
+
+Analyzes the file and identifies all unordered lists. Unordered lists are defined by lines starting with a `-`, `*`, or `+`. Unordered lists are returned as a dictionary where the key is "Unordered list" and the value is a list of all unordered lists found.
+
+### `identify_tables(self)`
+
+Analyzes the file and identifies all tables. Tables are defined by lines containing `|` to delimit cells and are separated by lines containing `-` to define the borders. Tables are returned as a dictionary where the key is "Table" and the value is a list of all tables found.
+
+### `identify_links(self)`
+
+Analyzes the file and identifies all links. Links are defined by the format `[text](url)`. Links are returned as a dictionary where the keys are "Text link" and "Image link" and the values are lists of all links found.
+
+### `check_links(self)`
+
+Checks all links identified by `identify_links` to see if they are broken (return a 404 error). Broken links are returned as a list, each item being a dictionary containing the line number, link text, and URL.
+
+### `identify_todos(self)`
+
+Analyzes the file and identifies all todos. Todos are defined by lines starting with `- [ ] `. Todos are returned as a list, each item being a dictionary containing the line number and todo text.
+
+### `count_elements(self, element_type)`
+
+Counts the total number of a specific element type in the file. The `element_type` should match the name of one of the identification methods (for example, "headers" for `identify_headers`). Returns the total number of elements of this type.
+
+### `count_words(self)`
+
+Counts the total number of words in the file. Returns the word count.
+
+### `count_characters(self)`
+
+Counts the total number of characters (excluding spaces) in the file. Returns the character count.
+
+## Contributions
+Contributions are always welcome! If you have a feature request, bug report, or just want to improve the code, feel free to create a pull request or open an issue.
+
+

{markdown_analysis-0.0.3 → markdown_analysis-0.0.4}/markdown_analysis.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ setup.py
 markdown_analysis.egg-info/PKG-INFO
 markdown_analysis.egg-info/SOURCES.txt
 markdown_analysis.egg-info/dependency_links.txt
+markdown_analysis.egg-info/requires.txt
 markdown_analysis.egg-info/top_level.txt
 mrkdwn_analysis/__init__.py
 mrkdwn_analysis/markdown_analyzer.py

markdown_analysis-0.0.4/markdown_analysis.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests
+urllib3

markdown_analysis-0.0.4/mrkdwn_analysis/markdown_analyzer.py

@@ -0,0 +1,283 @@
+import re
+import requests
+from collections import defaultdict, Counter
+
+class MarkdownAnalyzer:
+    def __init__(self, file_path):
+        with open(file_path, 'r') as file:
+            self.lines = file.readlines()
+            
+    def identify_headers(self):
+        result = defaultdict(list)
+        pattern = r'^(#{1,6})\s(.*)'
+        pattern_image = r'!\[.*?\]\((.*?)\)'  # pattern to identify images
+        for i, line in enumerate(self.lines):
+            line_without_images = re.sub(pattern_image, '', line)  # remove images from the line
+            match = re.match(pattern, line_without_images)
+            if match:
+                cleaned_line = re.sub(r'^#+', '', line_without_images).strip()
+                result["Header"].append(cleaned_line)
+        return dict(result)  # Convert defaultdict to dict before returning
+
+    def identify_sections(self):
+        result = defaultdict(list)
+        pattern = r'^.*\n[=-]{2,}$'
+        for i, line in enumerate(self.lines):
+            if i < len(self.lines) - 1:
+                match = re.match(pattern, line + self.lines[i+1])
+            else:
+                match = None
+            if match:
+                if self.lines[i+1].strip().startswith("===") or self.lines[i+1].strip().startswith("---"):
+                    result["Section"].append(line.strip())
+        return dict(result)  # Convert defaultdict to dict before returning
+    
+    def identify_paragraphs(lines):
+        result = defaultdict(list)
+        pattern = r'^(?!#)(?!\n)(?!>)(?!-)(?!=)(.*\S)'
+        pattern_underline = r'^.*\n[=-]{2,}$'
+        in_code_block = False
+        for i, line in enumerate(lines):
+            if line.strip().startswith('```'):
+                in_code_block = not in_code_block
+            if in_code_block:
+                continue
+            if i < len(lines) - 1:
+                match_underline = re.match(pattern_underline, line + lines[i+1])
+                if match_underline:
+                    continue
+            match = re.match(pattern, line)
+            if match and line.strip() != '```':  # added a condition to skip lines that are just ```
+                result["Paragraph"].append(line.strip())
+        return dict(result)
+
+    def identify_blockquotes(lines):
+        result = defaultdict(list)
+        pattern = r'^(>{1,})\s(.*)'
+        blockquote = None
+        in_code_block = False
+        for i, line in enumerate(lines):
+            if line.strip().startswith('```'):
+                in_code_block = not in_code_block  # Flip the flag
+            if in_code_block:
+                continue  # Skip processing for code blocks
+            match = re.match(pattern, line)
+            if match:
+                depth = len(match.group(1))  # depth is determined by the number of '>' characters
+                text = match.group(2).strip()
+                if depth > 2:
+                    raise ValueError(f"Encountered a blockquote of depth {depth} at line {i+1}, but the maximum allowed depth is 2")
+                if blockquote is None:
+                    # Start of a new blockquote
+                    blockquote = text
+                else:
+                    # Continuation of the current blockquote, regardless of depth
+                    blockquote += " " + text
+            elif blockquote is not None:
+                # End of the current blockquote
+                result["Blockquote"].append(blockquote)
+                blockquote = None
+
+        if blockquote is not None:
+            # End of the last blockquote
+            result["Blockquote"].append(blockquote)
+
+        return dict(result)
+
+    def identify_code_blocks(lines):
+        result = defaultdict(list)
+        pattern = r'^```'
+        in_code_block = False
+        code_block = None
+        for i, line in enumerate(lines):
+            match = re.match(pattern, line.strip())
+            if match:
+                if in_code_block:
+                    # End of code block
+                    in_code_block = False
+                    code_block += "\n" + line.strip()  # Add the line to the code block before ending it
+                    result["Code block"].append(code_block)
+                    code_block = None
+                else:
+                    # Start of code block
+                    in_code_block = True
+                    code_block = line.strip()
+            elif in_code_block:
+                code_block += "\n" + line.strip()
+
+        if code_block is not None:
+            result["Code block"].append(code_block)
+        
+        return dict(result)
+
+    def identify_ordered_lists(lines):
+        result = defaultdict(list)
+        pattern = r'^\s*\d+\.\s'
+        in_list = False
+        list_items = []
+        for i, line in enumerate(lines):
+            match = re.match(pattern, line)
+            if match:
+                if not in_list:
+                    # Start of a new list
+                    in_list = True
+                # Add the current line to the current list
+                list_items.append(line.strip())
+            elif in_list:
+                # End of the current list
+                in_list = False
+                result["Ordered list"].append(list_items)
+                list_items = []
+
+        if list_items:
+            # End of the last list
+            result["Ordered list"].append(list_items)
+
+        return dict(result)
+
+    def identify_unordered_lists(lines):
+        result = defaultdict(list)
+        pattern = r'^\s*((\d+\\\.|[-*+])\s)'
+        in_list = False
+        list_items = []
+        for i, line in enumerate(lines):
+            match = re.match(pattern, line)
+            if match:
+                if not in_list:
+                    # Start of a new list
+                    in_list = True
+                # Add the current line to the current list
+                list_items.append(line.strip())
+            elif in_list:
+                # End of the current list
+                in_list = False
+                result["Unordered list"].append(list_items)
+                list_items = []
+
+        if list_items:
+            # End of the last list
+            result["Unordered list"].append(list_items)
+
+        return dict(result)
+    
+    def identify_tables(self):
+        result = defaultdict(list)
+        table_pattern = re.compile(r'^ {0,3}\|(?P<table_head>.+)\|[ \t]*\n' +
+                                   r' {0,3}\|(?P<table_align> *[-:]+[-| :]*)\|[ \t]*\n' +
+                                   r'(?P<table_body>(?: {0,3}\|.*\|[ \t]*(?:\n|$))*)\n*')
+        nptable_pattern = re.compile(r'^ {0,3}(?P<nptable_head>\S.*\|.*)\n' +
+                                     r' {0,3}(?P<nptable_align>[-:]+ *\|[-| :]*)\n' +
+                                     r'(?P<nptable_body>(?:.*\|.*(?:\n|$))*)\n*')
+        
+        text = "".join(self.lines)
+        matches_table = re.findall(table_pattern, text)
+        matches_nptable = re.findall(nptable_pattern, text)
+        for match in matches_table + matches_nptable:
+            result["Table"].append(match)
+            
+        return dict(result)
+    
+    def identify_links(self):
+        result = defaultdict(list)
+        text_link_pattern = r'\[([^\]]+)\]\(([^)]+)\)'
+        image_link_pattern = r'!\[([^\]]*)\]\((.*?)\)'
+        for i, line in enumerate(self.lines):
+            text_links = re.findall(text_link_pattern, line)
+            image_links = re.findall(image_link_pattern, line)
+            for link in text_links:
+                result["Text link"].append({"line": i+1, "text": link[0], "url": link[1]})
+            for link in image_links:
+                result["Image link"].append({"line": i+1, "alt_text": link[0], "url": link[1]})
+        return dict(result)
+    
+    def check_links(self):
+        broken_links = []
+        link_pattern = r'\[([^\]]+)\]\(([^)]+)\)'
+        for i, line in enumerate(self.lines):
+            links = re.findall(link_pattern, line)
+            for link in links:
+                try:
+                    response = requests.head(link[1], timeout=3)
+                    if response.status_code != 200:
+                        broken_links.append({'line': i+1, 'text': link[0], 'url': link[1]})
+                except (requests.ConnectionError, requests.Timeout):
+                    broken_links.append({'line': i+1, 'text': link[0], 'url': link[1]})
+        return broken_links
+
+    def identify_todos(self):
+        todos = []
+        todo_pattern = r'^\-\s\[ \]\s(.*)'
+        for i, line in enumerate(self.lines):
+            match = re.match(todo_pattern, line)
+            if match:
+                todos.append({'line': i+1, 'text': match.group(1)})
+        return todos
+    
+    def count_elements(self, element_type):
+        identify_func = getattr(self, f'identify_{element_type}', None)
+        if not identify_func:
+            raise ValueError(f"No method to identify {element_type} found.")
+        elements = identify_func()
+        return len(elements.get(element_type.capitalize(), []))
+
+    def count_words(self):
+        text = " ".join(self.lines)
+        words = text.split()
+        return len(words)
+
+    def count_characters(self):
+        text = " ".join(self.lines)
+        # Exclude white spaces
+        characters = [char for char in text if not char.isspace()]
+        return len(characters)
+    
+    def get_text_statistics(self):
+        statistics = []
+        for i, line in enumerate(self.lines):
+            words = line.split()
+            if words:
+                statistics.append({
+                    'line': i+1,
+                    'word_count': len(words),
+                    'char_count': sum(len(word) for word in words),
+                    'average_word_length': sum(len(word) for word in words) / len(words),
+                })
+        return statistics
+    
+    def get_word_frequency(self):
+        word_frequency = Counter()
+        for line in self.lines:
+            word_frequency.update(line.lower().split())
+        return dict(word_frequency.most_common())
+    
+    def search(self, search_string):
+        result = []
+        for i, line in enumerate(self.lines):
+            if search_string in line:
+                element_types = [func for func in dir(self) if func.startswith('identify_')]
+                found_in_element = None
+                for etype in element_types:
+                    element = getattr(self, etype)()
+                    for e, content in element.items():
+                        if any(search_string in c for c in content):
+                            found_in_element = e
+                            break
+                    if found_in_element:
+                        break
+                result.append({"line": i+1, "text": line.strip(), "element": found_in_element})
+        return result
+    
+    def analyse(self):
+        analysis = {
+            'headers': self.count_elements('headers'),
+            'sections': self.count_elements('sections'),
+            'paragraphs': self.count_elements('paragraphs'),
+            'blockquotes': self.count_elements('blockquotes'),
+            'code_blocks': self.count_elements('code_blocks'),
+            'ordered_lists': self.count_elements('ordered_lists'),
+            'unordered_lists': self.count_elements('unordered_lists'),
+            'tables': self.count_elements('tables'),
+            'words': self.count_words(),
+            'characters': self.count_characters(),
+        }
+        return analysis

{markdown_analysis-0.0.3 → markdown_analysis-0.0.4}/setup.py

@@ -6,16 +6,16 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name='markdown_analysis',
-    version='0.0.3',
+    version='0.0.4',
     long_description=long_description,
     long_description_content_type="text/markdown",
-    description='A library to analyze markdown files',
     author='yannbanas',
     author_email='yannbanas@gmail.com',
     url='https://github.com/yannbanas/mrkdwn_analysis',
     packages=find_packages(),
     install_requires=[
-        # list your dependencies here
+        'urllib3',
+        'requests'
     ],
     classifiers=[
         'Development Status :: 2 - Pre-Alpha',

markdown_analysis-0.0.3/PKG-INFO

@@ -1,54 +0,0 @@
-Metadata-Version: 2.1
-Name: markdown_analysis
-Version: 0.0.3
-Summary: A library to analyze markdown files
-Home-page: https://github.com/yannbanas/mrkdwn_analysis
-Author: yannbanas
-Author-email: yannbanas@gmail.com
-License: UNKNOWN
-Platform: UNKNOWN
-Classifier: Development Status :: 2 - Pre-Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# mrkdwn_analysis
-
-`mrkdwn_analysis` is a Python library designed to analyze Markdown files. With its powerful parsing capabilities, it can extract and categorize various elements within a Markdown document, including headers, sections, links, images, blockquotes, code blocks, and lists. This makes it a valuable tool for anyone looking to parse Markdown content for data analysis, content generation, or for building other tools that utilize Markdown.
-
-## Features
-- Extract and categorize various elements of a Markdown file.
-- Handle both inline and reference-style links and images.
-- Recognize different types of headers and sections.
-- Identify and extract code blocks, even nested ones.
-- Handle both ordered and unordered lists, nested or otherwise.
-- A simple API that makes parsing Markdown documents a breeze.
-
-## Usage
-Using `mrkdwn_analysis` is simple. Just import the `MarkdownAnalyzer` class, create an instance with your Markdown file, and you're good to go!
-
-```python
-from mrkdwn_analysis import MarkdownAnalyzer
-
-analyzer = MarkdownAnalyzer("path/to/your/markdown.md")
-
-headers = analyzer.identify_headers()
-sections = analyzer.identify_sections()
-...
-```
-
-## Installation
-You can install `mrkdwn_analysis` from PyPI:
-
-```bash
-pip install mrkdwn_analysis
-```
-
-We hope `mrkdwn_analysis` helps you with all your Markdown analyzing needs!
-
-## Contributions
-Contributions are always welcome! If you have a feature request, bug report, or just want to improve the code, feel free to create a pull request or open an issue.
-
-

markdown_analysis-0.0.3/README.md

@@ -1,36 +0,0 @@
-# mrkdwn_analysis
-
-`mrkdwn_analysis` is a Python library designed to analyze Markdown files. With its powerful parsing capabilities, it can extract and categorize various elements within a Markdown document, including headers, sections, links, images, blockquotes, code blocks, and lists. This makes it a valuable tool for anyone looking to parse Markdown content for data analysis, content generation, or for building other tools that utilize Markdown.
-
-## Features
-- Extract and categorize various elements of a Markdown file.
-- Handle both inline and reference-style links and images.
-- Recognize different types of headers and sections.
-- Identify and extract code blocks, even nested ones.
-- Handle both ordered and unordered lists, nested or otherwise.
-- A simple API that makes parsing Markdown documents a breeze.
-
-## Usage
-Using `mrkdwn_analysis` is simple. Just import the `MarkdownAnalyzer` class, create an instance with your Markdown file, and you're good to go!
-
-```python
-from mrkdwn_analysis import MarkdownAnalyzer
-
-analyzer = MarkdownAnalyzer("path/to/your/markdown.md")
-
-headers = analyzer.identify_headers()
-sections = analyzer.identify_sections()
-...
-```
-
-## Installation
-You can install `mrkdwn_analysis` from PyPI:
-
-```bash
-pip install mrkdwn_analysis
-```
-
-We hope `mrkdwn_analysis` helps you with all your Markdown analyzing needs!
-
-## Contributions
-Contributions are always welcome! If you have a feature request, bug report, or just want to improve the code, feel free to create a pull request or open an issue.

markdown_analysis-0.0.3/markdown_analysis.egg-info/PKG-INFO

@@ -1,54 +0,0 @@
-Metadata-Version: 2.1
-Name: markdown-analysis
-Version: 0.0.3
-Summary: A library to analyze markdown files
-Home-page: https://github.com/yannbanas/mrkdwn_analysis
-Author: yannbanas
-Author-email: yannbanas@gmail.com
-License: UNKNOWN
-Platform: UNKNOWN
-Classifier: Development Status :: 2 - Pre-Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# mrkdwn_analysis
-
-`mrkdwn_analysis` is a Python library designed to analyze Markdown files. With its powerful parsing capabilities, it can extract and categorize various elements within a Markdown document, including headers, sections, links, images, blockquotes, code blocks, and lists. This makes it a valuable tool for anyone looking to parse Markdown content for data analysis, content generation, or for building other tools that utilize Markdown.
-
-## Features
-- Extract and categorize various elements of a Markdown file.
-- Handle both inline and reference-style links and images.
-- Recognize different types of headers and sections.
-- Identify and extract code blocks, even nested ones.
-- Handle both ordered and unordered lists, nested or otherwise.
-- A simple API that makes parsing Markdown documents a breeze.
-
-## Usage
-Using `mrkdwn_analysis` is simple. Just import the `MarkdownAnalyzer` class, create an instance with your Markdown file, and you're good to go!
-
-```python
-from mrkdwn_analysis import MarkdownAnalyzer
-
-analyzer = MarkdownAnalyzer("path/to/your/markdown.md")
-
-headers = analyzer.identify_headers()
-sections = analyzer.identify_sections()
-...
-```
-
-## Installation
-You can install `mrkdwn_analysis` from PyPI:
-
-```bash
-pip install mrkdwn_analysis
-```
-
-We hope `mrkdwn_analysis` helps you with all your Markdown analyzing needs!
-
-## Contributions
-Contributions are always welcome! If you have a feature request, bug report, or just want to improve the code, feel free to create a pull request or open an issue.
-
-

markdown_analysis-0.0.3/mrkdwn_analysis/markdown_analyzer.py

@@ -1,34 +0,0 @@
-# core.py
-
-import re
-from collections import defaultdict
-
-class MarkdownAnalyzer:
-    def __init__(self, file_path):
-        with open(file_path, 'r') as file:
-            self.lines = file.readlines()
-            
-    def identify_headers(self):
-        result = defaultdict(list)
-        pattern = r'^(#{1,6})\s(.*)'
-        pattern_image = r'!\[.*?\]\((.*?)\)'  # pattern to identify images
-        for i, line in enumerate(self.lines):
-            line_without_images = re.sub(pattern_image, '', line)  # remove images from the line
-            match = re.match(pattern, line_without_images)
-            if match:
-                cleaned_line = re.sub(r'^#+', '', line_without_images).strip()
-                result["Header"].append(cleaned_line)
-        return result
-
-    def identify_sections(self):
-        result = defaultdict(list)
-        pattern = r'^.*\n[=-]{2,}$'
-        for i, line in enumerate(self.lines):
-            if i < len(self.lines) - 1:
-                match = re.match(pattern, line + self.lines[i+1])
-            else:
-                match = None
-            if match:
-                if self.lines[i+1].strip().startswith("===") or self.lines[i+1].strip().startswith("---"):
-                    result["Section"].append(line.strip())
-        return result