pyinspect-cli 0.1.0__tar.gz

pyinspect_cli-0.1.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: pyinspect-cli
+Version: 0.1.0
+Summary: A CLI tool to inspect practical source codes
+Author-email: Developer <developer@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# pyinspect-cli
+
+A CLI tool to inspect practical source codes.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```bash
+pyinspect-cli list
+pyinspect-cli 1
+```

pyinspect_cli-0.1.0/README.md

@@ -0,0 +1,16 @@
+# pyinspect-cli
+
+A CLI tool to inspect practical source codes.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```bash
+pyinspect-cli list
+pyinspect-cli 1
+```

pyinspect_cli-0.1.0/pyinspect_cli/cli.py

@@ -0,0 +1,43 @@
+import sys
+import os
+
+def main():
+    args = sys.argv[1:]
+    
+    if not args:
+        print("Usage: pyinspect-cli <number> | pyinspect-cli list")
+        sys.exit(1)
+        
+    cmd = args[0]
+    
+    # Get the directory of this file
+    package_dir = os.path.dirname(os.path.abspath(__file__))
+    modules_dir = os.path.join(package_dir, 'modules')
+    
+    if cmd == 'list':
+        for i in range(1, 9):
+            print(f"{i} - Module {i}")
+        return
+
+    if cmd.isdigit():
+        module_num = int(cmd)
+        if 1 <= module_num <= 8:
+            file_name = f"m{module_num:02d}.py"
+            file_path = os.path.join(modules_dir, file_name)
+            
+            if os.path.exists(file_path):
+                with open(file_path, 'r') as f:
+                    print(f.read())
+            else:
+                print(f"Error: Module file {file_name} not found.")
+                sys.exit(1)
+        else:
+            print("Error: Please provide a module number between 1 and 8.")
+            sys.exit(1)
+    else:
+        print(f"Error: Invalid command or module number '{cmd}'.")
+        print("Usage: pyinspect-cli <number> | pyinspect-cli list")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

pyinspect_cli-0.1.0/pyinspect_cli/modules/m01.py

@@ -0,0 +1,41 @@
+import nltk
+from nltk.corpus import stopwords
+
+document1 = "The quick brown fox jumped over a lazy dog"
+document2 = "The lazy dog slept in the sun"
+
+nltk.download('stopwords')
+stopWords = stopwords.words('english')
+
+tokens1 = document1.lower().split()
+tokens2 = document2.lower().split()
+terms = list(set(tokens1 + tokens2))
+
+inverted_index = {}
+occ_num_doc1 = {}
+occ_num_doc2 = {}
+
+for term in terms:
+    if term in stopWords:
+        continue
+
+    document = []
+    
+    if term in tokens1:
+        document.append("Document 1")
+        occ_num_doc1[term] = tokens1.count(term)
+    
+    if term in tokens2:
+        document.append("Document 2")
+        occ_num_doc2[term] = tokens2.count(term)
+
+    inverted_index[term] = document
+
+for term, documents in inverted_index.items():
+    print(term, "->", end="")
+    for doc in documents:
+        if doc == "Document 1":
+            print(f"{doc}({occ_num_doc1.get(term, 0)})", end=", ")
+        else:
+            print(f"{doc}({occ_num_doc2.get(term, 0)})", end=", ")
+    print()

pyinspect_cli-0.1.0/pyinspect_cli/modules/m02.py

@@ -0,0 +1,111 @@
+#Part A
+documents = {
+    1: "apple banana orange",
+    2: "apple banana",
+    3: "banana orange",
+    4: "apple"
+}
+
+def build_index(docs):
+    index = {}
+    for doc_id, text in docs.items():
+        terms = set(text.split())
+        for term in terms:
+            if term not in index:
+                index[term] = {doc_id}
+            else:
+                index[term].add(doc_id)
+    return index
+
+inverted_index = build_index(documents)
+
+def boolean_and(operands, index):
+    if not operands:
+        return list(range(1, len(documents) + 1))
+    
+    result = index.get(operands[0], set())
+    for term in operands[1:]:
+        result = result.intersection(index.get(term, set()))
+    
+    return list(result)
+
+def boolean_or(operands, index):
+    result = set()
+    for term in operands:
+        result = result.union(index.get(term, set()))
+    
+    return list(result)
+
+def boolean_not(operand, index, total_docs):
+    operand_set = set(index.get(operand, set()))
+    all_docs_set = set(range(1, total_docs + 1))
+    return list(all_docs_set.difference(operand_set))
+
+query1 = ["apple", "banana"]
+query2 = ["apple", "orange"]
+
+result1 = boolean_and(query1, inverted_index)
+result2 = boolean_or(query2, inverted_index)
+result3 = boolean_not("orange", inverted_index, len(documents))
+
+print("Documents containing 'apple' and 'banana':", result1)
+print("Documents containing 'apple' and 'orange':", result2)
+print("Documents not containing 'orange':", result3)
+
+
+
+
+
+
+
+
+# Part B:
+from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer
+import nltk
+from nltk.corpus import stopwords
+import numpy as np
+from numpy.linalg import norm
+
+# Training and testing datasets
+train_set = ["The sky is blue.", "The sun is bright."]
+test_set = ["The sun in the sky is bright."]
+
+# Download stopwords and set them
+nltk.download('stopwords')
+stopWords = stopwords.words('english')
+
+# Create CountVectorizer and TfidfTransformer
+vectorizer = CountVectorizer(stop_words=stopWords)
+transformer = TfidfTransformer()
+
+# Fit and transform the training set
+trainVectorizerArray = vectorizer.fit_transform(train_set).toarray()
+testVectorizerArray = vectorizer.transform(test_set).toarray()
+
+# Print vectorized results
+print("Fit Vectorizer to train set:", trainVectorizerArray)
+print("Transformer Vectorizer to test set:", testVectorizerArray)
+
+# Cosine similarity function
+cx = lambda a, b: round(np.inner(a, b) / (norm(a) * norm(b)), 3)
+
+# Compute cosine similarity
+for vector in trainVectorizerArray:
+    print(vector)
+
+    for testV in testVectorizerArray:
+        print(testV)
+        cosine = cx(vector, testV)
+        print(cosine)
+
+# Fit the TF-IDF transformer
+transformer.fit(testVectorizerArray)
+print()
+print(transformer.transform(trainVectorizerArray).toarray())
+
+transformer.fit(testVectorizerArray)
+print()
+
+# Transform test set using TF-IDF
+tfidf = transformer.transform(testVectorizerArray)
+print(tfidf.todense())

pyinspect_cli-0.1.0/pyinspect_cli/modules/m03.py

@@ -0,0 +1,19 @@
+def editDistance(str1, str2, m, n):
+    if m == 0:
+        return n
+    if n == 0:
+        return m
+    if str1[m - 1] == str2[n - 1]:
+        return editDistance(str1, str2, m - 1, n - 1)
+    
+    return 1 + min(
+        editDistance(str1, str2, m, n - 1),    # Insert
+        editDistance(str1, str2, m - 1, n),    # Remove
+        editDistance(str1, str2, m - 1, n - 1) # Replace
+    )
+
+# Test case
+str1 = "sunday"
+str2 = "saturday"
+
+print("Edit Distance is:", editDistance(str1, str2, len(str1), len(str2)))

pyinspect_cli-0.1.0/pyinspect_cli/modules/m04.py

@@ -0,0 +1,24 @@
+def calculate_metrics(retrieved_set, relevant_set):
+    true_positive = len(retrieved_set.intersection(relevant_set))
+    false_positive = len(retrieved_set.difference(relevant_set))
+    false_negative = len(relevant_set.difference(retrieved_set))
+
+    print("True Positive:", true_positive,
+          "\nFalse Positive:", false_positive,
+          "\nFalse Negative:", false_negative, "\n")
+
+    precision = true_positive / (true_positive + false_positive) if (true_positive + false_positive) > 0 else 0
+    recall = true_positive / (true_positive + false_negative) if (true_positive + false_negative) > 0 else 0
+    f_measure = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
+
+    return precision, recall, f_measure
+
+# Example data
+retrieved_set = set(["doc1", "doc2", "doc3"])
+relevant_set = set(["doc1", "doc4"])
+
+precision, recall, f_measure = calculate_metrics(retrieved_set, relevant_set)
+
+print(f"Precision: {precision}")
+print(f"Recall: {recall}")
+print(f"F-measure: {f_measure}")

pyinspect_cli-0.1.0/pyinspect_cli/modules/m05.py

@@ -0,0 +1,82 @@
+import numpy as np
+import re
+
+class NaiveBayesClassifier:
+    def __init__(self):
+        self.vocab = []
+        self.positive_counts = None
+        self.negative_counts = None
+        self.positive_prior = 0
+        self.negative_prior = 0
+
+    def preprocess_review(self, review):
+        tokens = re.findall(r'\b\w+\b', review.lower())
+        return tokens
+
+    def vectorize_review(self, review):
+        vector = np.zeros(len(self.vocab))
+        for word in review:
+            if word in self.vocab:
+                vector[self.vocab.index(word)] += 1
+        return vector
+
+    def train(self, X_train, Y_train):
+        all_tokens = []
+        for review in X_train:
+            tokens = self.preprocess_review(review)
+            all_tokens.extend(tokens)
+        self.vocab = list(set(all_tokens))  # Unique words
+
+        self.positive_counts = np.zeros(len(self.vocab))
+        self.negative_counts = np.zeros(len(self.vocab))
+
+        X_train_vectorized = [self.vectorize_review(self.preprocess_review(review)) for review in X_train]
+
+        positive_count = 0
+        for i in range(len(X_train_vectorized)):
+            if Y_train[i] == 'positive':
+                self.positive_counts += X_train_vectorized[i]
+                positive_count += 1
+            else:
+                self.negative_counts += X_train_vectorized[i]
+
+        self.positive_prior = positive_count / len(Y_train)
+        self.negative_prior = 1 - self.positive_prior
+
+    def predict(self, X_test):
+        predictions = []
+        for review in X_test:
+            review_vectorized = self.vectorize_review(self.preprocess_review(review))
+
+            positive_prob = (self.positive_counts + 1) / (sum(self.positive_counts) + len(self.vocab))
+            negative_prob = (self.negative_counts + 1) / (sum(self.negative_counts) + len(self.vocab))
+
+            positive_likelihood = np.prod(positive_prob ** review_vectorized) * self.positive_prior
+            negative_likelihood = np.prod(negative_prob ** review_vectorized) * self.negative_prior
+
+            if positive_likelihood > negative_likelihood:
+                predictions.append('positive')
+            else:
+                predictions.append('negative')
+
+        return predictions
+
+# Training Data
+positive_review = ["The movie was amazing, I like great acting and an engaging plot"]
+negative_review = ["I hate this movie so much, it's terrible!"]
+X_train = positive_review + negative_review
+Y_train = ['positive'] * len(positive_review) + ['negative'] * len(negative_review)
+X_test = ["The acting was superb!"]
+Y_test = ['positive']
+
+# Train the classifier
+classifier = NaiveBayesClassifier()
+classifier.train(X_train, Y_train)
+
+# Predictions
+predictions = classifier.predict(X_test)
+print("Predicted class for the new review:", predictions[0])
+
+# Accuracy Calculation
+accuracy = sum(1 for true_label, predicted_label in zip(Y_test, predictions) if true_label == predicted_label) / len(Y_test)
+print("Accuracy of the model:", accuracy)

pyinspect_cli-0.1.0/pyinspect_cli/modules/m06.py

@@ -0,0 +1,40 @@
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.cluster import KMeans
+from sklearn.metrics import silhouette_score
+
+# Sample documents
+documents = [
+    "Machine learning is the study of computer algorithms that improve automatically through experience.",
+    "Deep learning is a subset of machine learning.",
+    "Natural language processing is a field of artificial intelligence.",
+    "Computer vision is a field of study that enables computers to interpret and understand the visual world.",
+    "Reinforcement learning is a type of machine learning algorithm that teaches an agent how to make decisions in an environment by rewarding desired behaviors.",
+    "Information retrieval is the process of obtaining information from a collection of documents.",
+    "Text mining is the process of deriving high-quality information from text.",
+    "Data clustering is the task of dividing a set of objects into groups.",
+    "Hierarchical clustering builds a tree of clusters.",
+    "K-means clustering is a method of vector quantization."
+]
+
+# Convert documents into TF-IDF vectors
+vectorizer = TfidfVectorizer()
+X = vectorizer.fit_transform(documents)
+
+# Perform K-means clustering
+k = 3  # Number of clusters
+kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
+kmeans.fit(X)
+
+# Evaluate clustering results
+silhouette_avg = silhouette_score(X, kmeans.labels_)
+print("Silhouette Score:", silhouette_avg)
+
+# Print clusters
+for i in range(k):
+    cluster_docs_indices = np.where(kmeans.labels_ == i)[0]
+    cluster_docs = [documents[idx] for idx in cluster_docs_indices]
+
+    print(f"\nCluster {i+1}:")
+    for doc in cluster_docs:
+        print("-", doc)

pyinspect_cli-0.1.0/pyinspect_cli/modules/m07.py

@@ -0,0 +1,117 @@
+# Part A:
+import requests
+from bs4 import BeautifulSoup
+
+class WebCrawler:
+    def __init__(self):
+        self.visited_urls = set()
+
+    def crawl(self, url, depth=3):
+        if depth == 0 or url in self.visited_urls:
+            return
+
+        try:
+            response = requests.get(url, timeout=5)
+            if response.status_code == 200:
+                soup = BeautifulSoup(response.text, 'html.parser')
+                self.index_page(url, soup)
+                self.visited_urls.add(url)
+
+                for link in soup.find_all('a', href=True):
+                    new_url = link.get('href')
+                    if new_url.startswith('http'):  # Ensure it's a valid URL
+                        print(f"Crawling: {new_url}")
+                        self.crawl(new_url, depth - 1)
+        
+        except Exception as e:
+            print(f"Error crawling {url}: {e}")
+
+    def index_page(self, url, soup):
+        """Extracts and indexes the page title and first paragraph."""
+        title = soup.title.string if soup.title else "No title"
+        paragraph = soup.find('p').get_text() if soup.find('p') else "No paragraph found"
+
+        print(f"\nIndexing: {url}")
+        print(f"Title: {title}")
+        print(f"First Paragraph: {paragraph}\n")
+if __name__ == "__main__":
+    start_url = "https://example.com"  
+    crawler = WebCrawler()
+    crawler.crawl(start_url, depth=2)
+
+
+
+
+
+# Part B:
+import requests
+from bs4 import BeautifulSoup
+import time
+from urllib.parse import urlparse
+
+class WebCrawler:
+    def __init__(self):
+        self.visited_urls = set()
+
+    def crawl(self, url, depth=3, delay=1):
+        if depth == 0 or url in self.visited_urls:
+            return
+
+        try:
+            # Check robots.txt
+            if not self.is_allowed_by_robots(url):
+                print(f"Skipping {url} due to robots.txt rules")
+                return
+
+            response = requests.get(url, timeout=5)
+            if response.status_code == 200:
+                soup = BeautifulSoup(response.text, 'html.parser')
+                self.index_page(url, soup)
+                self.visited_urls.add(url)
+
+                for link in soup.find_all('a', href=True):
+                    new_url = link.get('href')
+                    if new_url.startswith('http'):
+                        time.sleep(delay)  # Delay between requests
+                        self.crawl(new_url, depth - 1, delay)
+            else:
+                print(f"Failed to fetch {url}: Status code {response.status_code}")
+
+        except Exception as e:
+            print(f"Error crawling {url}: {e}")
+
+    def is_allowed_by_robots(self, url):
+        parsed_url = urlparse(url)
+        robots_url = f"{parsed_url.scheme}://{parsed_url.netloc}/robots.txt"
+
+        try:
+            response = requests.get(robots_url, timeout=5)
+            if response.status_code == 200:
+                robots_txt = response.text
+                if "User-agent: *" in robots_txt:
+                    start_index = robots_txt.find("User-agent: *")
+                    end_index = robots_txt.find("User-agent:", start_index + 1)
+
+                    if end_index == -1:
+                        end_index = len(robots_txt)
+
+                    relevant_section = robots_txt[start_index:end_index]
+
+                    if "Disallow: /" in relevant_section:
+                        return False
+            return True
+        except requests.RequestException:
+            return True  # If robots.txt is unreachable, assume allowed
+
+    def index_page(self, url, soup):
+        title = soup.title.string if soup.title else "No title"
+        paragraph = soup.find('p').get_text() if soup.find('p') else "No paragraph found"
+        print(f"\nIndexing: {url}")
+        print(f"Title: {title}")
+        print(f"First Paragraph: {paragraph}")
+        print("-------------------------------------------------")
+
+# Example usage
+if __name__ == "__main__":
+    crawler = WebCrawler()
+    crawler.crawl("https://www.mercedes-benz.com")

pyinspect_cli-0.1.0/pyinspect_cli/modules/m08.py

@@ -0,0 +1,44 @@
+# link analysis
+
+def pagerank(graph, damping_factor=0.85, epsilon=1.0e-8, max_iterations=100):
+    # Initialize PageRank scores
+    num_nodes = len(graph)
+    pagerank_scores = {node: 1.0 / num_nodes for node in graph}
+
+    for _ in range(max_iterations):
+        new_pagerank_scores = {}
+        max_diff = 0
+
+        for node in graph:
+            new_pagerank = (1 - damping_factor) / num_nodes
+            for referring_page, links in graph.items():
+                if node in links:
+                    num_outlinks = len(links)
+                    new_pagerank += damping_factor * (pagerank_scores[referring_page] / num_outlinks)
+
+            new_pagerank_scores[node] = new_pagerank
+            max_diff = max(max_diff, abs(new_pagerank - pagerank_scores[node]))
+
+        pagerank_scores = new_pagerank_scores
+
+        if max_diff < epsilon:
+            break
+
+    return pagerank_scores
+
+# Create a small web graph
+web_graph = {
+    'A': ['B', 'C'],
+    'B': ['C'],
+    'C': ['A']
+}
+
+# Compute PageRank scores
+pagerank_scores = pagerank(web_graph)
+
+# Analyze the results
+sorted_scores = sorted(pagerank_scores.items(), key=lambda x: x[1], reverse=True)
+
+print("PageRank scores:")
+for node, score in sorted_scores:
+    print(f"{node}: {score:.6f}")

pyinspect_cli-0.1.0/pyinspect_cli.egg-info/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: pyinspect-cli
+Version: 0.1.0
+Summary: A CLI tool to inspect practical source codes
+Author-email: Developer <developer@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# pyinspect-cli
+
+A CLI tool to inspect practical source codes.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```bash
+pyinspect-cli list
+pyinspect-cli 1
+```

pyinspect_cli-0.1.0/pyinspect_cli.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+pyinspect_cli/__init__.py
+pyinspect_cli/cli.py
+pyinspect_cli.egg-info/PKG-INFO
+pyinspect_cli.egg-info/SOURCES.txt
+pyinspect_cli.egg-info/dependency_links.txt
+pyinspect_cli.egg-info/entry_points.txt
+pyinspect_cli.egg-info/top_level.txt
+pyinspect_cli/modules/__init__.py
+pyinspect_cli/modules/m01.py
+pyinspect_cli/modules/m02.py
+pyinspect_cli/modules/m03.py
+pyinspect_cli/modules/m04.py
+pyinspect_cli/modules/m05.py
+pyinspect_cli/modules/m06.py
+pyinspect_cli/modules/m07.py
+pyinspect_cli/modules/m08.py

pyinspect_cli-0.1.0/pyinspect_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyinspect_cli-0.1.0/pyinspect_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyinspect-cli = pyinspect_cli.cli:main

pyinspect_cli-0.1.0/pyinspect_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyinspect_cli

pyinspect_cli-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyinspect-cli"
+version = "0.1.0"
+description = "A CLI tool to inspect practical source codes"
+authors = [
+    { name = "Developer", email = "developer@example.com" }
+]
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.scripts]
+pyinspect-cli = "pyinspect_cli.cli:main"
+
+[tool.setuptools]
+packages = ["pyinspect_cli", "pyinspect_cli.modules"]

pyinspect_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+