pda-nlp-lab 0.1.0__tar.gz

pda_nlp_lab-0.1.0/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: pda-nlp-lab
+Version: 0.1.0
+Summary: NLP Lab programs package and Jupyter Notebook dynamic code loader
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: nltk>=3.8.1
+Requires-Dist: ipython>=8.0.0
+
+# PDA NLP Lab (`pda-nlp-lab`)
+
+An installable Python library for NLP Lab programs with dynamic source code injection for Jupyter Notebooks.
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install pda-nlp-lab
+```
+
+Or install in editable mode for local development:
+
+```bash
+pip install -e .
+```
+
+## Quick Start & Usage
+
+### Inside Jupyter Notebook
+
+Import `nlp_lab` and invoke any program function (`p1()` through `p7()`). The function loads the full source code directly into a new cell right below your active cell:
+
+```python
+import nlp_lab
+
+# List all available programs and their descriptions
+nlp_lab.list_programs()
+
+# Injects the p1 program code into a new cell below
+nlp_lab.p1()
+
+# Injects the p7 program code into a new cell below
+nlp_lab.p7()
+```
+
+### Outside Jupyter (Terminal / Standard Python)
+
+When executed in a standard script or terminal, calling any program function prints the source code cleanly to standard output:
+
+```python
+import nlp_lab
+
+nlp_lab.p1()
+```

pda_nlp_lab-0.1.0/README.md

@@ -0,0 +1,46 @@
+# PDA NLP Lab (`pda-nlp-lab`)
+
+An installable Python library for NLP Lab programs with dynamic source code injection for Jupyter Notebooks.
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install pda-nlp-lab
+```
+
+Or install in editable mode for local development:
+
+```bash
+pip install -e .
+```
+
+## Quick Start & Usage
+
+### Inside Jupyter Notebook
+
+Import `nlp_lab` and invoke any program function (`p1()` through `p7()`). The function loads the full source code directly into a new cell right below your active cell:
+
+```python
+import nlp_lab
+
+# List all available programs and their descriptions
+nlp_lab.list_programs()
+
+# Injects the p1 program code into a new cell below
+nlp_lab.p1()
+
+# Injects the p7 program code into a new cell below
+nlp_lab.p7()
+```
+
+### Outside Jupyter (Terminal / Standard Python)
+
+When executed in a standard script or terminal, calling any program function prints the source code cleanly to standard output:
+
+```python
+import nlp_lab
+
+nlp_lab.p1()
+```

pda_nlp_lab-0.1.0/nlp_lab/__init__.py

@@ -0,0 +1,123 @@
+"""
+nlp_lab: NLP Lab Programs and Dynamic Code Loader for Jupyter Notebooks.
+"""
+
+import importlib.resources
+from pathlib import Path
+from typing import Optional
+
+__all__ = [
+    "p1",
+    "p2",
+    "p3",
+    "p4",
+    "p5",
+    "p6",
+    "p7",
+    "load_program",
+    "get_program_code",
+    "list_programs",
+]
+
+PROGRAM_NAMES = [f"p{i}" for i in range(1, 8)]
+
+
+def _get_program_resource(name: str):
+    """Retrieve the Traversable or Path for a program file."""
+    filename = f"{name}.py"
+    try:
+        return importlib.resources.files("nlp_lab.programs").joinpath(filename)
+    except Exception:
+        return Path(__file__).resolve().parent / "programs" / filename
+
+
+def get_program_code(name: str) -> str:
+    """
+    Read the raw source code of the specified program (e.g. 'p1').
+    Reads directly dynamically so any updates to the file are immediately reflected.
+    """
+    resource = _get_program_resource(name)
+    try:
+        return resource.read_text(encoding="utf-8")
+    except AttributeError:
+        return Path(resource).read_text(encoding="utf-8")
+
+
+def load_program(name: str) -> None:
+    """
+    Loads the full source code of the program.
+    - In IPython / Jupyter Notebook: injects the code into a new cell directly below the active cell.
+    - Outside IPython: prints the code cleanly to stdout.
+    """
+    code = get_program_code(name).strip()
+
+    ip = None
+    try:
+        from IPython import get_ipython
+
+        ip = get_ipython()
+    except (ImportError, Exception):
+        ip = None
+
+    if ip is not None:
+        ip.set_next_input(code, replace=False)
+    else:
+        print(code)
+
+
+def p1() -> None:
+    """Load Program 1."""
+    load_program("p1")
+
+
+def p2() -> None:
+    """Load Program 2."""
+    load_program("p2")
+
+
+def p3() -> None:
+    """Load Program 3."""
+    load_program("p3")
+
+
+def p4() -> None:
+    """Load Program 4."""
+    load_program("p4")
+
+
+def p5() -> None:
+    """Load Program 5."""
+    load_program("p5")
+
+
+def p6() -> None:
+    """Load Program 6."""
+    load_program("p6")
+
+
+def p7() -> None:
+    """Load Program 7."""
+    load_program("p7")
+
+
+def list_programs() -> None:
+    """
+    Prints all available program functions and their first-line comments.
+    """
+    print("Available NLP Lab Programs:")
+    print("-" * 50)
+    for name in PROGRAM_NAMES:
+        try:
+            code = get_program_code(name)
+            first_line = ""
+            for line in code.splitlines():
+                stripped = line.strip()
+                if stripped:
+                    first_line = stripped
+                    break
+            comment = first_line if first_line.startswith("#") else f"(Comment: {first_line})"
+            print(f"nlp_lab.{name}()  ->  {comment}")
+        except Exception as e:
+            print(f"nlp_lab.{name}()  ->  [Error reading program: {e}]")
+    print("-" * 50)
+    print("In Jupyter Notebook: call nlp_lab.p<N>() to insert code into the next cell.")

pda_nlp_lab-0.1.0/nlp_lab/my_corpus.txt

@@ -0,0 +1,2 @@
+This is a simple corpus
+It contains simple sentences

pda_nlp_lab-0.1.0/nlp_lab/programs/__init__.py

@@ -0,0 +1 @@
+"""NLP Lab Programs Package."""

pda_nlp_lab-0.1.0/nlp_lab/programs/my_corpus.txt

@@ -0,0 +1,2 @@
+This is a simple corpus
+It contains simple sentences

pda_nlp_lab-0.1.0/nlp_lab/programs/p1.py

@@ -0,0 +1,30 @@
+#program 1
+import re
+import nltk
+from nltk.tokenize import word_tokenize
+from nltk.corpus import stopwords
+from nltk.stem import PorterStemmer
+
+nltk.download('punkt')
+nltk.download('stopwords')
+
+text = """Natural Language Processing is a fascinating field of AI.
+It involves processing human languages, like English!"""
+print(f"Original Text:\n{text}\n")
+
+t = word_tokenize(text)
+print(f"Tokens:\n{t}\n")
+
+f = [w for w in [re.sub(r'[^\w\s]', '', x) for x in t] if w.isalpha()]
+print(f"Filtered Tokens:\n{f}\n")
+
+v = [w for w in f if re.match(r'^[a-zA-Z]+$', w)]
+print(f"Validated Tokens (English Only):\n{v}\n")
+
+sw = set(stopwords.words('english'))
+ns = [w for w in v if w.lower() not in sw]
+print(f"Tokens after Stop Word Removal:\n{ns}\n")
+
+ps = PorterStemmer()
+s = [ps.stem(w) for w in ns]
+print(f"Stemmed Tokens:\n{s}")

pda_nlp_lab-0.1.0/nlp_lab/programs/p2.py

@@ -0,0 +1,25 @@
+#program 2
+import nltk
+from nltk.util import ngrams
+from collections import Counter
+
+nltk.download('punkt')
+
+sentences = [
+    "The quick brown fox jumps over the lazy dog",
+    "The dog barks at the fox",
+    "The fox is quick and the dog is lazy",
+    "The quick dog jumps over the lazy fox"
+]
+
+toks = [nltk.word_tokenize(s.lower()) for s in sentences]
+
+for n in [1, 2, 3]:
+    print(f"\n{n}-Gram Probabilities:")
+    g = [x for t in toks for x in ngrams(t, n)]
+    p = [x for t in toks for x in ngrams(t, n-1)] if n > 1 else []
+    cg, cp = Counter(g), Counter(p)
+    
+    for k, v in cg.items():
+        prob = v / sum(cg.values()) if n == 1 else v / cp[k[:-1]]
+        print(f"{' '.join(k)}: {prob:.4f}")

pda_nlp_lab-0.1.0/nlp_lab/programs/p3.py

@@ -0,0 +1,36 @@
+#program 3
+def med(w1, w2):
+    m, n = len(w1), len(w2)
+    dp = [[0] * (n + 1) for _ in range(m + 1)]
+    
+    for i in range(m + 1):
+        for j in range(n + 1):
+            if i == 0: 
+                dp[i][j] = j
+            elif j == 0: 
+                dp[i][j] = i
+            elif w1[i-1] == w2[j-1]: 
+                dp[i][j] = dp[i-1][j-1]
+            else: 
+                dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])
+                
+    print(f"Comparing: '{w1}' -> '{w2}'\nMinimum Edit Distance: {dp[-1][-1]}\n")
+    print("Edit Distance Table:")
+    print("     #" + "".join(f"{'#'+c:>5}" for c in w2))
+    
+    for i in range(m + 1):
+        ch = '#' if i == 0 else w1[i-1]
+        print(f"{ch:<4}" + "".join(f"{x:>5}" for x in dp[i]))
+    print()
+
+pairs = [
+    ("kitten", "sitting"), 
+    ("flaw", "lawn"), 
+    ("intention", "execution"), 
+    ("apple", "aple"), 
+    ("", "hello"), 
+    ("hello", "")
+]
+
+for w1, w2 in pairs:
+    med(w1, w2)

pda_nlp_lab-0.1.0/nlp_lab/programs/p4.py

@@ -0,0 +1,32 @@
+#program 4
+g = [('S', ['NP', 'VP']), ('NP', ['Det', 'N']), ('VP', ['V', 'NP']), ('VP', ['V']), 
+     ('Det', ['a']), ('Det', ['the']), ('N', ['cat']), ('N', ['dog']), 
+     ('V', ['chases']), ('V', ['eats'])]
+
+rules = {}
+for k, v in g:
+    rules.setdefault(k, []).append(v)
+
+def top_down_parse(s): 
+    return None
+
+def bottom_up_parse(s, stack=None):
+    if stack is None: stack = []
+    if not s: return stack or None
+    
+    w, s = s[0], s[1:]
+    for l, rhs in rules.items():
+        if [w] in rhs:
+            stack.append(l)
+            break
+            
+    for l, rhs in rules.items():
+        for r in rhs:
+            if stack[-len(r):] == r:
+                return bottom_up_parse(s, stack[:-len(r)] + [l])
+                
+    return bottom_up_parse(s, stack)
+
+sen = ['the', 'cat', 'chases', 'a', 'dog']
+print("Top-Down Parse Result:", top_down_parse(sen))
+print("Bottom-Up Parse Result:", bottom_up_parse(sen))

pda_nlp_lab-0.1.0/nlp_lab/programs/p5.py

@@ -0,0 +1,35 @@
+#program 5
+reviews = [
+    ("fun, couple, love, love", "comedy"),
+    ("fast, furious, shoot", "action"),
+    ("couple, fly, fast, fun", "comedy"),
+    ("furious, shoot, shoot, fun", "action"),
+    ("fly, fast, shoot, love", "action")
+]
+
+c_words, a_words = [], []
+c_docs, a_docs = 0, 0
+
+for text, label in reviews:
+    if label == "comedy":
+        c_words.extend(text.split(", "))
+        c_docs += 1
+    else:
+        a_words.extend(text.split(", "))
+        a_docs += 1
+
+V = len(set(c_words + a_words))
+post_c = c_docs / (c_docs + a_docs)
+post_a = a_docs / (c_docs + a_docs)
+
+for word in ["fast", "couple", "shoot", "fly"]:
+    post_c *= (c_words.count(word) + 1) / (len(c_words) + V)
+    post_a *= (a_words.count(word) + 1) / (len(a_words) + V)
+
+print(f"Posterior for comedy: {post_c}")
+print(f"Posterior for action: {post_a}")
+
+if post_c > post_a:
+    print("\nThe most likely class for the document is: Comedy")
+else:
+    print("\nThe most likely class for the document is: Action")

pda_nlp_lab-0.1.0/nlp_lab/programs/p6.py

@@ -0,0 +1,45 @@
+#program 6
+import nltk
+from nltk.corpus import brown, inaugural, reuters, udhr
+from nltk.probability import FreqDist, ConditionalFreqDist
+from nltk import word_tokenize
+from nltk.tag import UnigramTagger, RegexpTagger
+
+nltk.download(['brown', 'inaugural', 'reuters', 'udhr', 'punkt'])
+
+print(f"Brown Corpus Categories: {brown.categories()}")
+print(f"Brown Corpus Words: {brown.words(categories='news')[:10]}")
+print(f"Brown Corpus Sentences: {brown.sents(categories='news')[:2]}")
+print(f"\nInaugural Corpus Raw Text: {inaugural.raw('1789-Washington.txt')[:100]}")
+print(f"\nReuters Corpus Categories: {reuters.categories()}")
+print(f"Reuters Corpus Words: {reuters.words(categories='trade')[:10]}")
+
+with open('my_corpus.txt', 'w') as f:
+    f.write("This is a simple corpus\nIt contains simple sentences\n")
+
+custom_corpus = open('my_corpus.txt', 'r').read()
+word_tokenize(custom_corpus)
+
+cfd = ConditionalFreqDist((c, w) for c in brown.categories() for w in brown.words(categories=c))
+
+ts = brown.tagged_sents(categories='news')
+tw = brown.tagged_words(categories='news')
+freq_dist_nouns = FreqDist(tag for word, tag in tw if tag.startswith('NN'))
+
+patterns = [(r'.*ed$', 'VBD'), (r'.*ing$', 'VBG'), (r'\b\w{3,}\b', 'NN')]
+rule_based_tagger = RegexpTagger(patterns)
+unigram_tagger = UnigramTagger(ts)
+
+text = "fastcoupleshootfly"
+corpus_set = set(brown.words())
+words = []
+i = 0
+
+while i < len(text):
+    for j in range(i + 1, len(text) + 1):
+        if text[i:j] in corpus_set:
+            words.append(text[i:j])
+            i = j
+            break
+    else:
+        i += 1

pda_nlp_lab-0.1.0/nlp_lab/programs/p7.py

@@ -0,0 +1,18 @@
+#program 7
+import nltk
+from nltk.corpus import wordnet
+
+nltk.download('wordnet')
+nltk.download('omw-1.4')
+
+synonyms = set()
+antonyms = set()
+
+for syn in wordnet.synsets('active'):
+    for lemma in syn.lemmas():
+        synonyms.add(lemma.name())
+        if lemma.antonyms():
+            antonyms.add(lemma.antonyms()[0].name())
+
+print("Synonyms of 'active':", list(synonyms))
+print("Antonyms of 'active':", list(antonyms))

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

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: pda-nlp-lab
+Version: 0.1.0
+Summary: NLP Lab programs package and Jupyter Notebook dynamic code loader
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: nltk>=3.8.1
+Requires-Dist: ipython>=8.0.0
+
+# PDA NLP Lab (`pda-nlp-lab`)
+
+An installable Python library for NLP Lab programs with dynamic source code injection for Jupyter Notebooks.
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install pda-nlp-lab
+```
+
+Or install in editable mode for local development:
+
+```bash
+pip install -e .
+```
+
+## Quick Start & Usage
+
+### Inside Jupyter Notebook
+
+Import `nlp_lab` and invoke any program function (`p1()` through `p7()`). The function loads the full source code directly into a new cell right below your active cell:
+
+```python
+import nlp_lab
+
+# List all available programs and their descriptions
+nlp_lab.list_programs()
+
+# Injects the p1 program code into a new cell below
+nlp_lab.p1()
+
+# Injects the p7 program code into a new cell below
+nlp_lab.p7()
+```
+
+### Outside Jupyter (Terminal / Standard Python)
+
+When executed in a standard script or terminal, calling any program function prints the source code cleanly to standard output:
+
+```python
+import nlp_lab
+
+nlp_lab.p1()
+```

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

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+nlp_lab/__init__.py
+nlp_lab/my_corpus.txt
+nlp_lab/programs/__init__.py
+nlp_lab/programs/my_corpus.txt
+nlp_lab/programs/p1.py
+nlp_lab/programs/p2.py
+nlp_lab/programs/p3.py
+nlp_lab/programs/p4.py
+nlp_lab/programs/p5.py
+nlp_lab/programs/p6.py
+nlp_lab/programs/p7.py
+pda_nlp_lab.egg-info/PKG-INFO
+pda_nlp_lab.egg-info/SOURCES.txt
+pda_nlp_lab.egg-info/dependency_links.txt
+pda_nlp_lab.egg-info/requires.txt
+pda_nlp_lab.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

pda_nlp_lab-0.1.0/pda_nlp_lab.egg-info/requires.txt

@@ -0,0 +1,2 @@
+nltk>=3.8.1
+ipython>=8.0.0

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

@@ -0,0 +1 @@
+nlp_lab

pda_nlp_lab-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pda-nlp-lab"
+version = "0.1.0"
+description = "NLP Lab programs package and Jupyter Notebook dynamic code loader"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "nltk>=3.8.1",
+    "ipython>=8.0.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["nlp_lab*"]
+
+[tool.setuptools.package-data]
+"nlp_lab" = ["*.txt"]
+"nlp_lab.programs" = ["*.py", "*.txt"]

pda_nlp_lab-0.1.0/setup.cfg

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