vibetype 0.1.0__tar.gz

vibetype-0.1.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: vibetype
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: textual>=8.2.7
+
+# VibeType
+
+An offline, keyboard-first typing application built with Python and Textual.
+
+VibeType is designed as a distraction-free space to type for fun, improve speed, and optionally learn through themed sentence packs.
+
+## Features
+
+### Typing Modes
+
+- Random word practice
+- Themed sentence packs
+  - DSA
+  - Pokémon
+  - Anime Quotes
+
+### Statistics
+
+- Persistent local statistics
+- Category-wise filtering
+- Stores WPM, Raw WPM and Accuracy
+- Average and maximum values
+  - All-time
+  - Latest 10 tests
+
+### Philosophy
+
+- Offline first
+- Keyboard-first interface
+- No accounts
+- No telemetry
+
+## Tech Stack
+
+- Python
+- Textual
+- Rich
+- SQLite
+
+## Installation
+
+Clone the repository:
+
+```bash
+git clone https://github.com/BartikaKumar/vibetype.git
+cd vibetype
+```
+
+### Using uv
+
+```bash
+uv sync
+uv run vibetype
+```
+
+### Using pip
+
+(venv optional but recommended)
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate   # Windows: .venv\Scripts\activate
+```
+
+Install and run:
+
+```bash
+pip install .
+vibetype
+```
+
+Alternatively, without installing the package:
+
+```bash
+pip install -r requirements.txt
+python3 -m vibetype
+```
+
+## Future Ideas
+
+- Custom sentence packs
+- Import/export custom csvs of sentence packs

vibetype-0.1.0/README.md

@@ -0,0 +1,82 @@
+# VibeType
+
+An offline, keyboard-first typing application built with Python and Textual.
+
+VibeType is designed as a distraction-free space to type for fun, improve speed, and optionally learn through themed sentence packs.
+
+## Features
+
+### Typing Modes
+
+- Random word practice
+- Themed sentence packs
+  - DSA
+  - Pokémon
+  - Anime Quotes
+
+### Statistics
+
+- Persistent local statistics
+- Category-wise filtering
+- Stores WPM, Raw WPM and Accuracy
+- Average and maximum values
+  - All-time
+  - Latest 10 tests
+
+### Philosophy
+
+- Offline first
+- Keyboard-first interface
+- No accounts
+- No telemetry
+
+## Tech Stack
+
+- Python
+- Textual
+- Rich
+- SQLite
+
+## Installation
+
+Clone the repository:
+
+```bash
+git clone https://github.com/BartikaKumar/vibetype.git
+cd vibetype
+```
+
+### Using uv
+
+```bash
+uv sync
+uv run vibetype
+```
+
+### Using pip
+
+(venv optional but recommended)
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate   # Windows: .venv\Scripts\activate
+```
+
+Install and run:
+
+```bash
+pip install .
+vibetype
+```
+
+Alternatively, without installing the package:
+
+```bash
+pip install -r requirements.txt
+python3 -m vibetype
+```
+
+## Future Ideas
+
+- Custom sentence packs
+- Import/export custom csvs of sentence packs

vibetype-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vibetype"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "textual>=8.2.7",
+]
+
+[project.scripts]
+vibetype="vibetype.tui:main"
+
+[tool.uv]
+package=true
+
+[tool.setuptools.packages.find]
+where=["."]
+include=["vibetype*"]
+
+[tool.setuptools.package-data]
+vibetype=[
+    "*.tcss",
+    "data/*.db",
+]

vibetype-0.1.0/setup.cfg

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

vibetype-0.1.0/vibetype/__main__.py

@@ -0,0 +1,3 @@
+from .tui  import main
+
+raise SystemExit(main())

vibetype-0.1.0/vibetype/base.py

@@ -0,0 +1,19 @@
+from textual.screen import Screen
+from textual.widgets import Footer, Static
+
+class BaseScreen(Screen):
+
+    def action_close_screen(self):
+        self.app.pop_screen()
+
+    BINDINGS=[
+        ('escape','close_screen','Return to Menu'),
+    ]
+
+    def compose(self):
+        yield Static("VibeType",classes='header')
+        yield from self.compose_body()
+        yield Footer()
+
+    def compose_body(self):
+        pass

vibetype-0.1.0/vibetype/data/script.py

@@ -0,0 +1,96 @@
+import csv
+import sqlite3
+
+def main():
+
+    conn_data=sqlite3.connect('vibetype_data.db')
+
+    cursor=conn_data.cursor()
+
+    with open("random.csv", newline="", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+
+        rows = [
+            (r["word"],)
+            for r in reader
+        ]
+
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS random(
+        id INTEGER PRIMARY KEY,
+        word TEXT
+    )
+    """)
+
+    cursor.executemany("""
+    INSERT INTO random(word)
+    VALUES (?)
+    """, rows)
+
+    with open("anime.csv", newline="", encoding="utf-8") as f:
+        reader1 = csv.DictReader(f)
+
+        rows1 = [
+            (r["sentence"],r["details"])
+            for r in reader1
+        ]
+
+    with open("dsa.csv", newline="", encoding="utf-8") as f:
+        reader2 = csv.DictReader(f)
+
+        rows2 = [
+            (r["sentence"],"")
+            for r in reader2
+        ]
+
+    with open("pokemon.csv", newline="", encoding="utf-8") as f:
+        reader3 = csv.DictReader(f)
+
+        rows3 = [
+            (r["sentence"],"")
+            for r in reader3
+        ]
+
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS anime(
+        id INTEGER PRIMARY KEY,
+        sentence TEXT,
+        details TEXT
+    )
+    """)
+
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS dsa(
+        id INTEGER PRIMARY KEY,
+        sentence TEXT,
+        details TEXT
+    )
+    """)
+
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS pokemon(
+        id INTEGER PRIMARY KEY,
+        sentence TEXT,
+        details TEXT
+    )
+    """)
+
+    cursor.executemany("""
+    INSERT INTO dsa(sentence,details)
+    VALUES (?,?)
+    """, rows2)
+
+    cursor.executemany("""
+    INSERT INTO pokemon(sentence,details)
+    VALUES (?,?)
+    """, rows3)
+
+    cursor.executemany("""
+    INSERT INTO anime(sentence,details)
+    VALUES (?,?)
+    """, rows1)
+
+    conn_data.commit()
+
+if __name__=="__main__":
+    main()

vibetype-0.1.0/vibetype/screens/about.py

@@ -0,0 +1,15 @@
+from vibetype.base import BaseScreen
+
+from textual.containers import VerticalScroll
+from textual.widgets import Static
+
+class ShowAbout(BaseScreen):
+
+    def compose_body(self):
+        with VerticalScroll(classes='cont about'):
+                yield Static(
+                    "Welcome to VibeType!\n\n"
+                    "Here you can type away with themed sentence packs, or just random words that make no sense. This is an offline, keyboard-first space that's entirely yours.\n\n"
+                    "P.S. For learning-based themes, typing is not enough! Read and sit with the sentence and its related fact before moving on to the next one :)",
+                    classes='welcome'
+                )

vibetype-0.1.0/vibetype/screens/menu.py

@@ -0,0 +1,53 @@
+from vibetype.base import BaseScreen
+
+from textual.containers import Vertical, CenterMiddle
+from textual.widgets import OptionList
+from textual.widgets.option_list import Option
+
+from .about import ShowAbout
+from .mode import ChooseMode
+from .show_stat import ShowStat
+
+class MenuScreen(BaseScreen):
+
+    def action_show_about(self):
+        self.app.push_screen(ShowAbout())
+
+    def action_choose_mode(self):
+        self.app.push_screen(ChooseMode())
+
+    def action_show_stat(self):
+        self.app.push_screen(ShowStat())
+
+    def action_close_app(self):
+        self.app.conn_data.close()
+        self.app.conn_stats.close()
+        self.app.exit()
+
+    BINDINGS=[
+        ('escape','close_app','Exit'),
+    ]
+
+    def on_option_list_option_selected(self,event: OptionList.OptionSelected):
+        option_id=event.option.id
+        if option_id=='exit_app':
+            self.action_close_app()
+        elif option_id=='show_about':
+            self.action_show_about()
+        elif option_id=='show_stat':
+            self.action_show_stat()
+        elif option_id=='start_type':
+            self.action_choose_mode()
+
+    def compose_body(self):
+        with CenterMiddle():
+            with Vertical(classes='cont'):
+                yield OptionList(
+                    Option('About',id='show_about'),
+                    None,
+                    Option('Start',id='start_type'),
+                    None,
+                    Option('Statistics',id='show_stat'),
+                    None,
+                    Option('Exit',id='exit_app'),
+                )

vibetype-0.1.0/vibetype/screens/mode.py

@@ -0,0 +1,49 @@
+from vibetype.base import BaseScreen
+
+from textual.containers import Vertical, CenterMiddle
+from textual.widgets import OptionList
+from textual.widgets.option_list import Option
+
+
+from .type_space import StartType
+
+class ChooseMode(BaseScreen):
+
+    def opentype(self,mode='random'):
+        self.app.switch_screen(StartType(mode))
+
+    def on_option_list_option_selected(self,event: OptionList.OptionSelected):
+        list_id=event.option_list.id
+        option_id=event.option.id
+
+        if list_id=='main_modes':
+            if option_id=='mode_random':
+                self.opentype('random')
+            elif option_id=='mode_themed':
+                event.option_list.add_class('hidden')
+                self.query_one('#theme_modes').remove_class('hidden')
+        
+        elif list_id=='theme_modes':
+            if option_id=='mode_dsa':
+                self.opentype('dsa')
+            elif option_id=='mode_pokemon':
+                self.opentype('pokemon')
+            elif option_id=='mode_anime':
+                self.opentype('anime')
+
+    def compose_body(self):
+        with CenterMiddle():
+            with Vertical(classes='cont'):
+                yield OptionList(
+                    Option('Random Words',id='mode_random'),
+                    None,
+                    Option('Themed Sentence Packs',id='mode_themed'),
+                id='main_modes')
+
+                yield OptionList(
+                    Option('DSA',id='mode_dsa'),
+                    None,
+                    Option('Pokemon',id='mode_pokemon'),
+                    None,
+                    Option('Anime',id='mode_anime'),
+                id='theme_modes',classes='hidden')

vibetype-0.1.0/vibetype/screens/results.py

@@ -0,0 +1,38 @@
+from vibetype.base import BaseScreen
+
+from textual.containers import VerticalScroll, CenterMiddle
+from textual.widgets import Static
+from .type_space import StartType
+
+class ResultScreen(BaseScreen):
+
+    def action_close_screen(self):
+        self.app.sesh_max=None
+        self.app.sesh_min=None
+        super().action_close_screen()
+
+    def action_next(self):
+        from .type_space import StartType # lazy import
+        self.app.switch_screen(StartType(self.mode))
+
+    BINDINGS=[
+        ('enter','next','Next Sentence'),
+    ]
+
+    def __init__(self,mode,sentence='',details='',*,raw_wpm,wpm,accuracy):
+        super().__init__()
+        self.mode=mode
+
+        self.sentence=sentence
+        self.details=details
+        self.raw_wpm=raw_wpm
+        self.wpm=wpm
+        self.accuracy=accuracy
+
+    def compose_body(self):
+        with CenterMiddle():
+            with VerticalScroll(classes='cont results'):
+                yield Static(self.sentence)
+                if(self.details):
+                    yield Static(self.details)
+                yield Static(f'WPM: {self.wpm}\nRaw WPM: {self.raw_wpm}\nAccuracy: {self.accuracy}%')

vibetype-0.1.0/vibetype/screens/show_stat.py

@@ -0,0 +1,137 @@
+from vibetype.base import BaseScreen
+
+from textual.containers import VerticalScroll, Vertical, CenterMiddle, HorizontalScroll
+from textual.widgets import Static, Select
+
+from rich.table import Table
+
+class ShowStat(BaseScreen):
+
+    def action_focus_filter(self):
+        select=self.query_one(".dropdown")
+        #select.focus()
+        select.action_show_overlay()
+
+    BINDINGS=[
+        ("tab","focus_filter","Open Stats Filter")
+    ]
+
+    def load_stats(self,mode=None):
+        cursor=self.app.conn_stats.cursor()
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS stats (
+                id INTEGER PRIMARY KEY,
+                mode TEXT NOT NULL,
+                wpm REAL NOT NULL,
+                raw_wpm REAL NOT NULL,
+                accuracy REAL NOT NULL,
+                created_at TEXT DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        self.app.conn_stats.commit()
+        if mode is None or mode=="all":
+            all_stats=cursor.execute("""
+                SELECT
+                    ROUND(AVG(wpm),2),
+                    MAX(wpm),
+                    ROUND(AVG(raw_wpm),2),
+                    MAX(raw_wpm),
+                    ROUND(AVG(accuracy),2),
+                    MAX(accuracy),
+                    COUNT(*)
+                FROM stats;
+            """).fetchone()
+            latest_stats=cursor.execute("""
+                SELECT
+                    ROUND(AVG(wpm),2),
+                    MAX(wpm),
+                    ROUND(AVG(raw_wpm),2),
+                    MAX(raw_wpm),
+                    ROUND(AVG(accuracy),2),
+                    MAX(accuracy),
+                    COUNT(*)
+                FROM(
+                    SELECT *
+                    FROM stats
+                    ORDER BY created_at DESC
+                    LIMIT 10
+                );
+            """).fetchone()
+        else:
+            all_stats=cursor.execute("""
+                SELECT
+                    ROUND(AVG(wpm),2),
+                    MAX(wpm),
+                    ROUND(AVG(raw_wpm),2),
+                    MAX(raw_wpm),
+                    ROUND(AVG(accuracy),2),
+                    MAX(accuracy),
+                    COUNT(*)
+                FROM stats
+                WHERE mode=?;
+            """,(mode,)).fetchone()
+            latest_stats=cursor.execute("""
+                SELECT
+                    ROUND(AVG(wpm),2),
+                    MAX(wpm),
+                    ROUND(AVG(raw_wpm),2),
+                    MAX(raw_wpm),
+                    ROUND(AVG(accuracy),2),
+                    MAX(accuracy),
+                    COUNT(*)
+                FROM(
+                    SELECT *
+                    FROM stats
+                    WHERE mode=?
+                    ORDER BY created_at DESC
+                    LIMIT 10
+                );
+            """,(mode,)).fetchone()
+
+        self.count.update(f"Tests: {all_stats[6]}")
+
+        all_table = Table(title="All-time")
+        all_table.add_column("Metric", justify="left")
+        all_table.add_column("Avg", justify="right")
+        all_table.add_column("Max", justify="right")
+
+        l_table = Table(title="Latest 10")
+        l_table.add_column("Metric", justify="left")
+        l_table.add_column("Avg", justify="right")
+        l_table.add_column("Max", justify="right")
+
+        all_table.add_row("WPM",str(all_stats[0]),str(all_stats[1]))
+        all_table.add_row("Raw WPM",str(all_stats[2]),str(all_stats[3]))
+        all_table.add_row("Accuracy",str(all_stats[4]),str(all_stats[5]))
+
+        l_table.add_row("WPM",str(latest_stats[0]),str(latest_stats[1]))
+        l_table.add_row("Raw WPM",str(latest_stats[2]),str(latest_stats[3]))
+        l_table.add_row("Accuracy",str(latest_stats[4]),str(latest_stats[5]))
+
+        self.all_time.update(all_table)
+        self.latest.update(l_table)
+
+    def on_mount(self) -> None:
+        self.count=self.query_one("#count")
+        self.all_time=self.query_one("#all_time")
+        self.latest=self.query_one("#latest")
+        self.load_stats()
+
+    def on_select_changed(self,event:Select.Changed):
+        self.load_stats(event.value)
+
+    def compose_body(self):
+        with CenterMiddle():
+            with VerticalScroll(classes='stats cont'):
+                with Vertical():
+                    yield Select([
+                        ("All modes","all"),
+                        ("Random","random"),
+                        ("DSA","dsa"),
+                        ("Pokemon","pokemon"),
+                        ("Anime","anime")
+                    ],value="all",allow_blank=False,classes="dropdown",compact=True)
+                yield Static("",id="count")
+                with HorizontalScroll(classes="horizontal"):
+                    yield Static("",id="all_time")
+                    yield Static("",id="latest")

vibetype-0.1.0/vibetype/screens/type_space.py

@@ -0,0 +1,199 @@
+from vibetype.base import BaseScreen
+
+from textual.containers import Vertical, CenterMiddle
+from textual.widgets import Static
+from rich.text import Text
+
+import random
+import time
+
+class StartType(BaseScreen):
+
+    def action_close_screen(self):
+        self.app.sesh_max=None
+        self.app.sesh_min=None
+        super().action_close_screen()
+
+    def load_screen(self,wpm=None,raw_wpm=None,accuracy=None):
+        self.curr=''
+        self.word=Text()
+
+        cursor=self.app.conn_data.cursor()
+        if self.app.sesh_min is None:
+            self.app.sesh_min,self.app.sesh_max= cursor.execute(f"SELECT MIN(id), MAX(id) FROM {self.mode}").fetchone()
+
+        if self.mode=='random':
+            ids=random.sample(range(self.app.sesh_min,self.app.sesh_max+1),self.app.random_words)
+            placeholders=",".join("?"*len(ids))
+            rows=cursor.execute(f"SELECT word FROM {self.mode} WHERE id IN ({placeholders})",ids).fetchall()
+            self.sentence=" ".join(row[0] for row in rows)
+            self.details=""
+
+        else:  
+            id=random.randint(self.app.sesh_min,self.app.sesh_max)
+            row=cursor.execute(f"SELECT * FROM {self.mode} WHERE id={id}").fetchone()
+            self.sentence=row[1]
+            self.details=row[2]
+
+        self.target=self.sentence.split(' ')
+        self.typed=[None]*len(self.target)
+        self.typed_str=['']*len(self.target)
+            
+        self.at_word=0
+
+        self.correct=0
+        self.incorrect=0
+
+        self.start_time=None
+
+        if wpm is not None:
+            self.query_one(".header").update(f"VibeType | WPM: {wpm} | Raw WPM: {raw_wpm} | Accuracy: {accuracy}")
+
+        self.target_widget.update(Text(self.sentence+' ',style=str(self.app.theme_variables['primary-muted'])))
+
+    def save_stats(self,wpm,raw_wpm,accuracy):
+        cursor=self.app.conn_stats.cursor()
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS stats (
+                id INTEGER PRIMARY KEY,
+                mode TEXT NOT NULL,
+                wpm REAL NOT NULL,
+                raw_wpm REAL NOT NULL,
+                accuracy REAL NOT NULL,
+                created_at TEXT DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        cursor.execute("""
+            INSERT INTO stats(mode,wpm,raw_wpm,accuracy) 
+            VALUES(?,?,?,?)
+        """,(self.mode,wpm,raw_wpm,accuracy))
+        self.app.conn_stats.commit()
+
+    def __init__(self, mode='random'): # runs before compose
+            super().__init__()
+            self.mode=mode
+
+    def on_mount(self): # runs after compose
+        self.target_widget=self.query_one("#target")
+        self.load_screen()
+
+    def render_text(self):
+
+        full=Text()
+        to_match=self.target[self.at_word]
+
+        pword=0
+
+        while(pword<len(self.target)):
+
+            if pword<self.at_word:
+                full.append_text(self.typed[pword])
+                    
+            elif pword==self.at_word:
+
+                p=0
+                self.word=Text()
+
+                while(p<len(self.curr)):
+                    if(p<len(to_match)):
+                        if(self.curr[p]!=self.target[self.at_word][p]):
+                            self.word.append(self.curr[p],style=str(self.app.theme_variables['error']))
+                
+                        else:
+                            self.word.append(self.curr[p],style=str(self.app.theme_variables['primary']))
+
+                    else:
+                        self.word.append(self.curr[p],style=str(self.app.theme_variables['error-muted']))
+
+                    p+=1
+
+                while(p<len(to_match)):
+                    self.word.append(to_match[p],style=str(self.app.theme_variables['primary-muted']))
+                    p+=1
+                
+                full.append_text(self.word)
+
+            else:
+                full.append(self.target[pword],style=str(self.app.theme_variables['primary-muted']))
+            
+            full.append(' ')
+            pword+=1
+
+        self.target_widget.update(full)
+
+
+
+    def on_key(self,event):
+
+        modified=False
+
+        if event.key=='backspace':
+            if len(self.curr)>0:
+                self.curr = self.curr[:-1]
+                modified=True
+
+            elif len(self.curr)==0 and self.at_word>0:
+
+                self.at_word-=1
+
+                self.word=self.typed[self.at_word].copy()
+                self.curr=self.typed_str[self.at_word]
+
+                modified=True
+
+        elif event.key=='space':
+            if self.curr and self.at_word<len(self.target)-1:
+
+                if len(self.curr)>=len(self.target[self.at_word]):
+                    self.correct+=1
+                else:
+                    self.incorrect+=1
+
+                self.typed[self.at_word]=self.word.copy()
+                self.typed_str[self.at_word]=self.curr
+
+                self.curr=''
+
+                self.word=Text()
+                self.at_word+=1
+
+                modified=True
+                
+        elif event.character and event.character.isprintable():
+            self.curr=self.curr+event.character
+
+            if len(self.curr)<=len(self.target[self.at_word]) and event.character==self.target[self.at_word][len(self.curr)-1]:
+                self.correct+=1
+            else:
+                self.incorrect+=1
+        
+            modified=True
+
+        self.render_text()
+
+        if modified and self.start_time is None:
+            self.start_time=time.perf_counter()
+
+        if self.at_word==len(self.target)-1 and self.curr==self.target[-1]:
+
+            duration=time.perf_counter()-self.start_time
+
+            raw_wpm=round((self.correct+self.incorrect)*12/duration,2)
+            wpm=round(self.correct*12/duration,2)
+            accuracy=round(self.correct*100/(self.correct+self.incorrect),2)
+
+            self.typed[self.at_word] = self.word.copy()
+            self.typed_str[self.at_word]=self.curr
+
+            self.save_stats(wpm,raw_wpm,accuracy)
+
+            if(self.mode=="random"):
+                self.load_screen(wpm,raw_wpm,accuracy)
+            else:
+                from .results import ResultScreen # lazy import to prevent circular import issue
+                self.app.switch_screen(ResultScreen(self.mode,self.sentence,self.details,raw_wpm=raw_wpm,wpm=wpm,accuracy=accuracy))
+
+    def compose_body(self):
+        with CenterMiddle():
+            with Vertical(classes='cont'):
+                    yield Static('',id='target')

vibetype-0.1.0/vibetype/tui.py

@@ -0,0 +1,32 @@
+from textual.app import App
+
+from pathlib import Path
+import sqlite3
+
+from .screens.menu import MenuScreen
+
+class VibeType(App):
+    ENABLE_COMMAND_PALETTE=False
+    TITLE = "VibeType"
+
+    def on_mount(self) -> None:
+        self.theme = "catppuccin-mocha"
+
+        self.conn_data=sqlite3.connect(Path(__file__).parent / 'data' / 'vibetype_data.db')
+        self.conn_stats=sqlite3.connect(Path(__file__).parent / 'data' / 'vibetype_stats.db')
+
+        self.sesh_min=None
+        self.sesh_max=None
+
+        self.random_words=10
+
+        self.push_screen(MenuScreen())
+
+    CSS_PATH='typelearn.tcss'
+
+def main():
+    app = VibeType()
+    app.run()
+
+if __name__=="__main__":
+    raise SystemExit(main())

vibetype-0.1.0/vibetype/typelearn.tcss

@@ -0,0 +1,70 @@
+.cont{
+    width:100%;
+    margin:1;
+    align:center middle;
+}
+
+.about{
+    height:auto;
+}
+
+.header{
+    dock: top;
+    height: auto;
+    content-align: center middle;
+    background: $footer-background;
+    color:$footer-foreground;
+    text-align:center;
+}
+
+OptionList{
+    height:auto;
+    width:auto;
+    align:center middle;
+    background:transparent;
+    border:none;
+    text-align:center;
+    text-style:none;
+}
+
+OptionList .option-list--option-highlighted{
+    text-style:bold;
+}
+
+.hidden{
+    display:None;
+}
+
+#target{
+    text-align:center;
+}
+
+.results Static{
+    text-align:center;
+    margin:1;
+}
+
+.stats Vertical{
+    align:center middle;
+    height:auto;
+    margin-bottom:1;
+}
+
+.stats Static{
+    text-align:center;
+    margin:1;
+}
+
+.horizontal Static{
+    margin-left:1;
+    margin-right:1;
+    width:auto;
+}
+
+.horizontal{
+    align:center middle;
+    height:auto;
+}
+.dropdown{
+    width:20;
+}

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

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: vibetype
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: textual>=8.2.7
+
+# VibeType
+
+An offline, keyboard-first typing application built with Python and Textual.
+
+VibeType is designed as a distraction-free space to type for fun, improve speed, and optionally learn through themed sentence packs.
+
+## Features
+
+### Typing Modes
+
+- Random word practice
+- Themed sentence packs
+  - DSA
+  - Pokémon
+  - Anime Quotes
+
+### Statistics
+
+- Persistent local statistics
+- Category-wise filtering
+- Stores WPM, Raw WPM and Accuracy
+- Average and maximum values
+  - All-time
+  - Latest 10 tests
+
+### Philosophy
+
+- Offline first
+- Keyboard-first interface
+- No accounts
+- No telemetry
+
+## Tech Stack
+
+- Python
+- Textual
+- Rich
+- SQLite
+
+## Installation
+
+Clone the repository:
+
+```bash
+git clone https://github.com/BartikaKumar/vibetype.git
+cd vibetype
+```
+
+### Using uv
+
+```bash
+uv sync
+uv run vibetype
+```
+
+### Using pip
+
+(venv optional but recommended)
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate   # Windows: .venv\Scripts\activate
+```
+
+Install and run:
+
+```bash
+pip install .
+vibetype
+```
+
+Alternatively, without installing the package:
+
+```bash
+pip install -r requirements.txt
+python3 -m vibetype
+```
+
+## Future Ideas
+
+- Custom sentence packs
+- Import/export custom csvs of sentence packs

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

@@ -0,0 +1,22 @@
+README.md
+pyproject.toml
+vibetype/__init__.py
+vibetype/__main__.py
+vibetype/base.py
+vibetype/tui.py
+vibetype/typelearn.tcss
+vibetype.egg-info/PKG-INFO
+vibetype.egg-info/SOURCES.txt
+vibetype.egg-info/dependency_links.txt
+vibetype.egg-info/entry_points.txt
+vibetype.egg-info/requires.txt
+vibetype.egg-info/top_level.txt
+vibetype/data/script.py
+vibetype/data/vibetype_data.db
+vibetype/screens/__init__.py
+vibetype/screens/about.py
+vibetype/screens/menu.py
+vibetype/screens/mode.py
+vibetype/screens/results.py
+vibetype/screens/show_stat.py
+vibetype/screens/type_space.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+vibetype = vibetype.tui:main

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

@@ -0,0 +1 @@
+textual>=8.2.7

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

@@ -0,0 +1 @@
+vibetype