kattis-cli 1.0.2__py3-none-any.whl → 1.0.4__py3-none-any.whl

kattis_cli/download.py

@@ -2,14 +2,12 @@
     and save them to data folders.
 """
 
-# import sys
 import shutil
 from typing import Any, Dict
 from pathlib import Path
 import requests
 import yaml
 from bs4 import BeautifulSoup
-
 from .utils import config, utility
 from . import settings
 

kattis_cli/kattis.py

@@ -20,7 +20,7 @@ from rich.align import Align
 from rich.live import Live
 from rich.prompt import Confirm
 
-from kattis_cli.utils import utility
+from kattis_cli.utils import languages
 from kattis_cli.utils import config
 from kattis_cli import ui
 
@@ -182,7 +182,7 @@ def confirm_or_die(problem: str, language: str,
     console.print('Language:', language)
     console.print('Files:', ', '.join(files))
     if mainclass:
-        if language in utility.GUESS_MAINFILE:
+        if language in languages.GUESS_MAINFILE:
             console.print('Main file:', mainclass)
         else:
             console.print('Mainclass:', mainclass)

kattis_cli/main.py

@@ -1,5 +1,13 @@
-""" Main module for the kattis_cli package."""
-__version__ = '1.0.2'
+""" Main module for the kattis_cli package.
+This is the main.py file for the kattis_cli package.
+
+Change the contents here instead of main.py.
+build.sh script copies the contents of this file to main.py.
+
+Change the __version__ to match in pyproject.toml
+Has to be higher than the pypi version.
+"""
+__version__ = '1.0.4'
 
 from math import inf
 from typing import Tuple
@@ -10,15 +18,17 @@ import kattis_cli.download as download
 import kattis_cli.ui as ui
 import kattis_cli.test_solution as test_solution
 import kattis_cli.kattis as kattis
-import kattis_cli.utils.utility as utility
+import kattis_cli.utils.languages as languages
 import kattis_cli.kattis_setup as kattis_setup
 
 
 @click.group()
+@click.version_option(version=__version__, prog_name='kattis-cli')
 def main() -> None:
     """
     CLI for downloading, testing and submitting Kattis problems.
     """
+    pass
 
 
 @main.command(help='Download sample data & metadata.')
@@ -34,7 +44,7 @@ def get(problemid: str) -> None:
     except requests.exceptions.InvalidURL:
         console.print(
             f"""Sample data for Problem ID: [bold blue]
-{problemid}[/bold blue] not found.")
+            {problemid}[/bold blue] not found.")
             """)
     console.print(
         f"Downloading metadata: [bold blue]{problemid}[/bold blue]")
@@ -65,11 +75,11 @@ def test(
     """Test solution with sample files.
     """
     problemid, loc_language, mainclass, _files, root_folder, lang_config = \
-        utility.update_args(problemid, language, mainclass, list(files))
+        languages.update_args(problemid, language, mainclass, list(files))
     # print('After - ', f'{problemid=} {language=} {mainclass=} {_files=}')
     # lang_config = config.parse_config(language)
     if not mainclass:
-        mainclass = utility.guess_mainfile(
+        mainclass = languages.guess_mainfile(
             language, _files, problemid, lang_config)
 
     test_solution.test_samples(
@@ -101,14 +111,14 @@ def submit(problemid: str, language: str,
     """Submit a solution to Kattis.
     """
     problemid, language, mainclass, _files, _, lang_config = \
-        utility.update_args(
+        languages.update_args(
             problemid, language, mainclass, list(files))
     # Finally, submit the solution
     # print(f'{problemid=} {language=} {mainclass=} {tag=} {force=} {_files=}')
     if not mainclass:
-        mainclass = utility.guess_mainfile(
+        mainclass = languages.guess_mainfile(
             language, _files, problemid, lang_config)
-    kat_lang = utility.LOCAL_TO_KATTIS[language]
+    kat_lang = languages.LOCAL_TO_KATTIS[language]
     kattis.submit_solution(_files, problemid,
                            kat_lang, mainclass,
                            tag, force)

kattis_cli/test_solution.py

@@ -1,7 +1,6 @@
 """Tester module for Kattis.
 """
 
-from math import inf
 from typing import Any, List, Dict
 import glob
 import time
@@ -17,26 +16,7 @@ from rich.prompt import Confirm
 from rich.markup import escape
 
 from kattis_cli import kattis
-from kattis_cli.utils import run_program, utility
-
-
-def compare_floats(expected: str, ans: str, places: float) -> bool:
-    """Compare two floating point numbers with given accuracy.
-
-    Args:
-        expected (str): expected result
-        ans (str): actual result
-        places (float): decimal places for approximation
-
-    Returns:
-        bool: True if the two numbers are equal within the given accuracy
-    """
-    try:
-        flt_expected = float(expected)
-        flt_ans = float(ans)
-        return abs(flt_expected - flt_ans) <= 10**(-places)
-    except ValueError:
-        return False
+from kattis_cli.utils import languages, run_program, utility
 
 
 def test_samples(
@@ -46,7 +26,7 @@ def test_samples(
         problem_root_folder: str,
         files: List[str],
         lang_config: Dict[Any, Any],
-        accuracy: float = inf
+        accuracy: float = 0
 ) -> None:
     """Tests a problem by running all the .in files in
     the problem folder and comparing the output to the .ans files.
@@ -147,14 +127,15 @@ def test_samples(
             if code != 0:
                 ans = error
             # console.print(f"{ans=} {error=}")
-            if accuracy == inf:  # string comparison
+            if accuracy == 0:  # string comparison
                 if expected == ans.encode('utf-8').strip():
                     result = "[bold green]✅[/bold green]"
                     count += 1
                 else:
                     result = "[bold red]❌[/bold red]"
             else:  # floating point comparison
-                if compare_floats(expected.decode('utf-8'), ans, accuracy):
+                if utility.compare_floats(expected.decode('utf-8'),
+                                          ans, accuracy):
                     result = "[bold green]✅[/bold green]"
                     count += 1
                 else:
@@ -188,7 +169,7 @@ def test_samples(
             "Awesome... Time to submit it to :cat: Kattis! :cat:",
             style="bold green")
         if Confirm.ask("Submit to Kattis?", default=True):
-            kat_language = utility.LOCAL_TO_KATTIS.get(loc_language, '')
+            kat_language = languages.LOCAL_TO_KATTIS.get(loc_language, '')
             kattis.submit_solution(files, problemid,
                                    kat_language, mainclass,
                                    tag="", force=True)

kattis_cli/utils/config.py

@@ -9,7 +9,7 @@ import configparser
 from tomlkit import load
 import yaml
 
-from .utility import find_problem_root_folder
+from kattis_cli.utils.utility import find_problem_root_folder
 
 _DEFAULT_CONFIG = Path.home().joinpath('.kattisrc')
 

kattis_cli/utils/languages.py

@@ -0,0 +1,332 @@
+"""Module for language utilities.
+"""
+
+from typing import List, Dict, Any
+import sys
+import os
+import re
+from pathlib import Path
+from rich.console import Console
+from kattis_cli.utils import config
+from kattis_cli.utils.utility import find_problem_root_folder
+
+
+LANGUAGE_GUESS = {
+    '.c': 'c',
+    '.c++': 'cpp',
+    '.cc': 'cpp',
+    '.c#': 'csharp',
+    '.cpp': 'cpp',
+    '.cs': 'csharp',
+    '.cxx': 'cpp',
+    '.cbl': 'cobol',
+    '.cob': 'cobol',
+    '.cpy': 'cobol',
+    '.fs': 'fsharp',
+    '.go': 'go',
+    '.hs': 'haskell',
+    '.java': 'java',
+    '.js': 'nodejs',
+    '.ts': 'typescript',
+    '.kt': 'kotlin',
+    '.lisp': 'lisp',
+    '.cl': 'lisp',
+    '.m': 'objective-c',
+    '.ml': 'ocaml',
+    '.pas': 'pascal',
+    '.php': 'php',
+    '.pl': 'prolog',
+    '.py': 'python3',
+    '.rb': 'ruby',
+    '.rs': 'rust',
+    '.scala': 'scala',
+    '.f90': 'fortran',
+    '.f': 'fortran',
+    '.for': 'fortran',
+    '.sh': 'bash',
+    '.apl': 'apl',
+    '.ss': 'gerbil',
+    '.jl': 'julia',
+    '.vb': 'vb',
+    '.dart': 'dart',
+    '.zig': 'zig',
+    '.swift': 'swift',
+    '.nim': 'nim',
+}
+
+GUESS_MAINCLASS = {'Java', 'Kotlin', 'Scala'}
+
+GUESS_MAINFILE = {
+    'APL',
+    'Bash',
+    'Dart',
+    'Gerbil',
+    'JavaScript (Node.js)',
+    'Julia',
+    'Common Lisp',
+    'Pascal',
+    'PHP',
+    'Python 3',
+    'Ruby',
+    'Rust',
+    'TypeScript',
+    'Zig'
+}
+
+# mapping is used for .kattis-cli.toml file configuration
+LOCAL_TO_KATTIS = {
+    'python3': 'Python 3',
+    'java': 'Java',
+    'cpp': 'C++',
+    'c++': 'C++',
+    'nodejs': 'JavaScript (Node.js)',
+    'typescript': 'TypeScript',
+    'csharp': 'C#',
+    'kotlin': 'Kotlin',
+    'scala': 'Scala',
+    'rust': 'Rust',
+    'pascal': 'Pascal',
+    'go': 'Go',
+    'haskell': 'Haskell',
+    'ruby': 'Ruby',
+    'php': 'PHP',
+    'lisp': 'Common Lisp',
+    'fortran': 'Fortran',
+    'bash': 'Bash',
+    'apl': 'APL',
+    'gerbil': 'Gerbil',
+    'julia': 'Julia',
+    'vb': 'Visual Basic',
+    'dart': 'Dart',
+    'zig': 'Zig',
+    'swift': 'Swift',
+    'nim': 'Nim',
+    'ocaml': 'OCaml',
+    'fsharp': 'F#',
+    'cobol': 'COBOL',
+    'prolog': 'Prolog',
+    'objective-c': 'Objective-C',
+    'c': 'C',
+    'c#': 'C#'
+}
+
+
+def guess_language(ext: str, files: List[str]) -> str:
+    """Guess the language.
+
+    Args:
+        ext (str): File extension.
+        files (List[str]): Tuple of files.
+
+    Returns:
+        str: guessed language
+    """
+    if ext == ".C":
+        return "cpp"
+    ext = ext.lower()
+    if ext == ".h":
+        if any(f.endswith(".c") for f in files):
+            return "c"
+        else:
+            return "cpp"
+    if ext == ".py":
+        return "python3"
+    return LANGUAGE_GUESS.get(ext, '')
+
+
+# flake8: noqa: C901
+def guess_mainfile(
+        kat_language: str,
+        files: List[str],
+        problemid: str,
+        lang_config: Dict[Any, Any]) -> Any:
+    """Guess the main file.
+
+    Args:
+        kat_language (str): programming language name used by Kattis
+        files (List[str]): Tuple of files
+
+    Returns:
+        str: main file
+    """
+    if len(files) == 1:
+        return files[0]
+    # check .kattis-cli.toml file
+    if 'mainfile' in lang_config:
+        return lang_config['mainfile'].replace(('{problemid}'), problemid)
+    for filename in files:
+        if os.path.splitext(os.path.basename(filename))[0] in ['main', 'Main']:
+            return filename
+        if problemid and os.path.splitext(
+                os.path.basename(filename))[0] == problemid:
+            return filename
+    for filename in files:
+        try:
+            with open(filename, 'r', encoding='utf-8') as f:
+                conts = f.read()
+                if kat_language in [
+                        'Java', 'Rust', 'Scala', 'Kotlin'] and re.search(
+                        r' main\s*\(', conts):
+                    return filename
+                if kat_language == 'Pascal' and re.match(
+                        r'^\s*[Pp]rogram\b', conts):
+                    return filename
+        except IOError:
+            pass
+    # main file is the one with problemid
+    return files[0]
+
+
+def guess_mainclass(
+        problemid: str,
+        kat_language: str,
+        files: List[str],
+        lang_config: Any) -> Any:
+    """Guess the main class.
+
+    Args:
+        kat_language (str): programming language name used by Kattis
+        files (List[str]): List of files to guess mainclass from
+
+    Returns:
+        str: mainclass name or empty string
+    """
+    if kat_language in GUESS_MAINFILE and len(files) > 1:
+        return os.path.basename(
+            guess_mainfile(
+                kat_language,
+                files,
+                problemid,
+                lang_config))
+    if kat_language in GUESS_MAINCLASS:
+        mainfile = os.path.basename(
+            guess_mainfile(
+                kat_language,
+                files,
+                problemid,
+                lang_config))
+        name = os.path.splitext(mainfile)[0]
+        if kat_language == 'Kotlin':
+            return name[0].upper() + name[1:] + 'Kt'
+        return name
+    return ''
+
+
+def validate_language(loc_language: str) -> bool:
+    """Check if valid language.
+
+    Args:
+        loc_language (str): programming language provided by user
+
+    Returns:
+        bool: True if valid language, exit otherwise.
+    """
+    if loc_language in LOCAL_TO_KATTIS:
+        return True
+    console = Console()
+    console.print(f'Invalid language: "{loc_language}"', style='bold red')
+    console.print('Valid languages are:', style='bold green')
+    for lang in sorted(LOCAL_TO_KATTIS.keys()):
+        console.print(f'\t\t - {lang}')
+    exit(1)
+
+
+def valid_extension(file: str) -> bool:
+    """Check if valid extension.
+
+    Args:
+        file (str): File name.
+
+    Returns:
+        bool: True if valid extension, False otherwise.
+    """
+    if os.path.isfile(file):
+        ext = os.path.splitext(file)
+        if len(ext) != 2:
+            return False
+        return ext[1] in LANGUAGE_GUESS
+    return False
+
+
+# flake8: noqa: C901
+def update_args(problemid: str,
+                loc_language: str,
+                mainclass: str,
+                files: List[str]) -> Any:
+    """Check if problemid, language, mainclass, and program files are valid.
+
+    Args:
+        problemid (str): problemid
+        loc_language (str): programming language provided by user
+        mainclass (str): main class
+        files (List[str]): List of files
+
+    Returns:
+        Tuple[str]: Update problemid, kattis_language, mainclass, and files
+    """
+
+    console = Console()
+    if not files:
+        files = get_coding_files()
+    # check if problemid is given
+    # if not problemid:
+    cur_folder = Path.cwd()
+    root_folder = Path.cwd()
+    if not problemid:
+        for f in files:
+            try:
+                root_folder = find_problem_root_folder(
+                    cur_folder, f.lower())
+                # if not problemid:
+                problemid = root_folder.name
+                break
+            except FileNotFoundError:
+                # print(ex)
+                pass
+    if not problemid:
+        try:
+            root_folder = find_problem_root_folder(
+                cur_folder, '*.yaml')
+            problemid = root_folder.name
+        except FileNotFoundError:
+            console.print(f'''No problemid specified and I failed to guess
+problemid and root problem folder from filename(s) and cwd: {cur_folder}.''',
+                          style='bold red')
+            sys.exit(1)
+    # check if language
+    if not loc_language:
+        _, ext = os.path.splitext(os.path.basename(files[0]))
+        # Guess language from files
+        loc_language = guess_language(ext, files)
+        if not loc_language:
+            console.print(f'''\
+No language specified, and I failed to guess language from
+filename extension "{ext}"''')
+            sys.exit(1)
+    # check if valid language
+    validate_language(loc_language)
+    lang_config = config.parse_config(loc_language)
+    kat_language = LOCAL_TO_KATTIS[loc_language]
+    if not mainclass:
+        mainclass = guess_mainclass(
+            problemid, kat_language, files, lang_config)
+    # print(f'Returning...{problemid=} {language=} {mainclass=} {files=}')
+    return problemid, loc_language, mainclass, files, root_folder, lang_config
+
+
+def get_coding_files() -> List[str]:
+    """Get coding files from current directory.
+
+    Returns:
+        List[str]: List of coding files.
+    """
+    cur_folder = str(Path.cwd())
+    console = Console()
+    files = [
+        f for f in os.listdir(cur_folder) if valid_extension(f)]
+    if not files:
+        console.print(
+            'No source file(s) found in the current folder!',
+            style='bold red')
+        exit(1)
+    return files

kattis_cli/utils/utility.py

@@ -1,251 +1,9 @@
-"""Module for language utilities.
-"""
+""" Utility functions. """
 
-from typing import List, Union, Any, Dict
-import sys
-import os
-import re
 from pathlib import Path
+import os
+from typing import Union
 import yaml
-from rich.console import Console
-from kattis_cli.utils import config
-
-
-LANGUAGE_GUESS = {
-    '.c': 'c',
-    '.c++': 'cpp',
-    '.cc': 'cpp',
-    '.c#': 'csharp',
-    '.cpp': 'cpp',
-    '.cs': 'csharp',
-    '.cxx': 'cpp',
-    '.cbl': 'cobol',
-    '.cob': 'cobol',
-    '.cpy': 'cobol',
-    '.fs': 'fsharp',
-    '.go': 'go',
-    '.hs': 'haskell',
-    '.java': 'java',
-    '.js': 'nodejs',
-    '.ts': 'typescript',
-    '.kt': 'kotlin',
-    '.lisp': 'lisp',
-    '.cl': 'lisp',
-    '.m': 'objective-c',
-    '.ml': 'ocaml',
-    '.pas': 'pascal',
-    '.php': 'php',
-    '.pl': 'prolog',
-    '.py': 'python3',
-    '.rb': 'ruby',
-    '.rs': 'rust',
-    '.scala': 'scala',
-    '.f90': 'fortran',
-    '.f': 'fortran',
-    '.for': 'fortran',
-    '.sh': 'bash',
-    '.apl': 'apl',
-    '.ss': 'gerbil',
-    '.jl': 'julia',
-    '.vb': 'vb',
-    '.dart': 'dart',
-    '.zig': 'zig',
-    '.swift': 'swift',
-    '.nim': 'nim',
-}
-
-GUESS_MAINCLASS = {'Java', 'Kotlin', 'Scala'}
-
-GUESS_MAINFILE = {
-    'APL',
-    'Bash',
-    'Dart',
-    'Gerbil',
-    'JavaScript (Node.js)',
-    'Julia',
-    'Common Lisp',
-    'Pascal',
-    'PHP',
-    'Python 3',
-    'Ruby',
-    'Rust',
-    'TypeScript',
-    'Zig'
-}
-
-# mapping is used for .kattis-cli.toml file configuration
-LOCAL_TO_KATTIS = {
-    'python3': 'Python 3',
-    'java': 'Java',
-    'cpp': 'C++',
-    'c++': 'C++',
-    'nodejs': 'JavaScript (Node.js)',
-    'typescript': 'TypeScript',
-    'csharp': 'C#',
-    'kotlin': 'Kotlin',
-    'scala': 'Scala',
-    'rust': 'Rust',
-    'pascal': 'Pascal',
-    'go': 'Go',
-    'haskell': 'Haskell',
-    'ruby': 'Ruby',
-    'php': 'PHP',
-    'lisp': 'Common Lisp',
-    'fortran': 'Fortran',
-    'bash': 'Bash',
-    'apl': 'APL',
-    'gerbil': 'Gerbil',
-    'julia': 'Julia',
-    'vb': 'Visual Basic',
-    'dart': 'Dart',
-    'zig': 'Zig',
-    'swift': 'Swift',
-    'nim': 'Nim',
-    'ocaml': 'OCaml',
-    'fsharp': 'F#',
-    'cobol': 'COBOL',
-    'prolog': 'Prolog',
-    'objective-c': 'Objective-C',
-    'c': 'C',
-    'c#': 'C#'
-}
-
-
-def guess_language(ext: str, files: List[str]) -> str:
-    """Guess the language.
-
-    Args:
-        ext (str): File extension.
-        files (List[str]): Tuple of files.
-
-    Returns:
-        str: guessed language
-    """
-    if ext == ".C":
-        return "cpp"
-    ext = ext.lower()
-    if ext == ".h":
-        if any(f.endswith(".c") for f in files):
-            return "c"
-        else:
-            return "cpp"
-    if ext == ".py":
-        return "python3"
-    return LANGUAGE_GUESS.get(ext, '')
-
-
-# flake8: noqa: C901
-def guess_mainfile(
-        kat_language: str,
-        files: List[str],
-        problemid: str,
-        lang_config: Dict[Any, Any]) -> Any:
-    """Guess the main file.
-
-    Args:
-        kat_language (str): programming language name used by Kattis
-        files (List[str]): Tuple of files
-
-    Returns:
-        str: main file
-    """
-    if len(files) == 1:
-        return files[0]
-    # check .kattis-cli.toml file
-    if 'mainfile' in lang_config:
-        return lang_config['mainfile'].replace(('{problemid}'), problemid)
-    for filename in files:
-        if os.path.splitext(os.path.basename(filename))[0] in ['main', 'Main']:
-            return filename
-        if problemid and os.path.splitext(
-                os.path.basename(filename))[0] == problemid:
-            return filename
-    for filename in files:
-        try:
-            with open(filename, 'r', encoding='utf-8') as f:
-                conts = f.read()
-                if kat_language in [
-                        'Java', 'Rust', 'Scala', 'Kotlin'] and re.search(
-                        r' main\s*\(', conts):
-                    return filename
-                if kat_language == 'Pascal' and re.match(
-                        r'^\s*[Pp]rogram\b', conts):
-                    return filename
-        except IOError:
-            pass
-    # main file is the one with problemid
-    return files[0]
-
-
-def guess_mainclass(
-        problemid: str,
-        kat_language: str,
-        files: List[str],
-        lang_config: Any) -> Any:
-    """Guess the main class.
-
-    Args:
-        kat_language (str): programming language name used by Kattis
-        files (List[str]): List of files to guess mainclass from
-
-    Returns:
-        str: mainclass name or empty string
-    """
-    if kat_language in GUESS_MAINFILE and len(files) > 1:
-        return os.path.basename(
-            guess_mainfile(
-                kat_language,
-                files,
-                problemid,
-                lang_config))
-    if kat_language in GUESS_MAINCLASS:
-        mainfile = os.path.basename(
-            guess_mainfile(
-                kat_language,
-                files,
-                problemid,
-                lang_config))
-        name = os.path.splitext(mainfile)[0]
-        if kat_language == 'Kotlin':
-            return name[0].upper() + name[1:] + 'Kt'
-        return name
-    return ''
-
-
-def validate_language(loc_language: str) -> bool:
-    """Check if valid language.
-
-    Args:
-        loc_language (str): programming language provided by user
-
-    Returns:
-        bool: True if valid language, exit otherwise.
-    """
-    if loc_language in LOCAL_TO_KATTIS:
-        return True
-    console = Console()
-    console.print(f'Invalid language: "{loc_language}"', style='bold red')
-    console.print('Valid languages are:', style='bold green')
-    for lang in sorted(LOCAL_TO_KATTIS.keys()):
-        console.print(f'\t\t - {lang}')
-    exit(1)
-
-
-def valid_extension(file: str) -> bool:
-    """Check if valid extension.
-
-    Args:
-        file (str): File name.
-
-    Returns:
-        bool: True if valid extension, False otherwise.
-    """
-    if os.path.isfile(file):
-        ext = os.path.splitext(file)
-        if len(ext) != 2:
-            return False
-        return ext[1] in LANGUAGE_GUESS
-    return False
 
 
 def find_problem_root_folder(
@@ -302,85 +60,27 @@ def find_problem_root_folder(
     raise FileNotFoundError("Error: Problem root folder not found.")
 
 
-# flake8: noqa: C901
-def update_args(problemid: str,
-                loc_language: str,
-                mainclass: str,
-                files: List[str]) -> Any:
-    """Check if problemid, language, mainclass, and program files are valid.
+def compare_floats(expected: str, ans: str, places: float) -> bool:
+    """Compare two floating point numbers with given accuracy.
 
     Args:
-        problemid (str): problemid
-        loc_language (str): programming language provided by user
-        mainclass (str): main class
-        files (List[str]): List of files
+        expected (str): expected result
+        ans (str): actual result
+        places (float): decimal places for approximation
 
     Returns:
-        Tuple[str]: Update problemid, kattis_language, mainclass, and files
+        bool: True if the two numbers are equal within the given accuracy
     """
-
-    console = Console()
-    if not files:
-        files = get_coding_files()
-    # check if problemid is given
-    # if not problemid:
-    cur_folder = Path.cwd()
-    root_folder = Path.cwd()
-    if not problemid:
-        for f in files:
-            try:
-                root_folder = find_problem_root_folder(
-                    cur_folder, f.lower())
-                # if not problemid:
-                problemid = root_folder.name
-                break
-            except FileNotFoundError:
-                # print(ex)
-                pass
-    if not problemid:
-        try:
-            root_folder = find_problem_root_folder(
-                cur_folder, '*.yaml')
-            problemid = root_folder.name
-        except FileNotFoundError:
-            console.print(f'''No problemid specified and I failed to guess
-problemid and root problem folder from filename(s) and cwd: {cur_folder}.''',
-                          style='bold red')
-            sys.exit(1)
-    # check if language
-    if not loc_language:
-        _, ext = os.path.splitext(os.path.basename(files[0]))
-        # Guess language from files
-        loc_language = guess_language(ext, files)
-        if not loc_language:
-            console.print(f'''\
-No language specified, and I failed to guess language from
-filename extension "{ext}"''')
-            sys.exit(1)
-    # check if valid language
-    validate_language(loc_language)
-    lang_config = config.parse_config(loc_language)
-    kat_language = LOCAL_TO_KATTIS[loc_language]
-    if not mainclass:
-        mainclass = guess_mainclass(
-            problemid, kat_language, files, lang_config)
-    # print(f'Returning...{problemid=} {language=} {mainclass=} {files=}')
-    return problemid, loc_language, mainclass, files, root_folder, lang_config
-
-
-def get_coding_files() -> List[str]:
-    """Get coding files from current directory.
-
-    Returns:
-        List[str]: List of coding files.
-    """
-    cur_folder = str(Path.cwd())
-    console = Console()
-    files = [
-        f for f in os.listdir(cur_folder) if valid_extension(f)]
-    if not files:
-        console.print(
-            'No source file(s) found in the current folder!',
-            style='bold red')
-        exit(1)
-    return files
+    expect_ans = expected.strip().split('\n')
+    actual_ans = ans.strip().split('\n')
+    if len(expect_ans) != len(actual_ans):
+        return False
+    try:
+        for i, ex_ans in enumerate(expect_ans):
+            flt_expected = float(ex_ans)
+            flt_ans = float(actual_ans[i])
+            if abs(flt_expected - flt_ans) > 10**(-places):
+                return False
+        return True
+    except ValueError:
+        return False

{kattis_cli-1.0.2.dist-info → kattis_cli-1.0.4.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: kattis-cli
-Version: 1.0.2
+Version: 1.0.4
 Summary: A command-line tool for Kattis
 Home-page: https://github.com/rambasnet/kattis-cli
 Author: Ram Basnet
-Author-email: rambasnet@gmail.com
+Author-email: rbasnet@coloradomesa.edu
 Requires-Python: >=3.8,<4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
@@ -75,21 +75,25 @@ If you've Python version 3.8 or higher, you can skip creating virtual environmen
 ```bash
 pip install kattis-cli
 python -m pip install kattis-cli
+kattis --version
 ```
 
 - on Windows add the path shown in the output of the above command to your PATH environment variable
 
-
-## Update Kattis-CLI
+## Update/Upgrade Kattis-CLI
 
 - remove or rename **.kattis-cli.toml** file in your home directory
 - activate virtual environment if you've created one for kattis-cli
 
 ```bash
+kattis --version
 pip install kattis-cli --upgrade
 python -m pip install kattis-cli --upgrade
 ```
 
+- on Windows add the path shown in the output of the above command to your PATH environment variable
+
+
 ## Kattis configuration
 
 - run the following command and enter your Kattis credentials
@@ -113,13 +117,13 @@ kattis --help
 - problem id can be found in the last part of the URL of the problem
 - example: [https://open.kattis.com/problems/cold](https://open.kattis.com/problems/cold) => problem id: **cold**
 
-![Problem id](images/problemid.png)
+![Problem id](./images/problemid.png)
 
 ```bash
 kattis get <problem_id>
 ```
 
-![Get problem id from URL](images/kattis_get.png)
+![Get problem id from URL](./images/kattis_get.png)
 
 ### Display problem metadata
 
@@ -128,10 +132,12 @@ cd <problem_id>
 kattis info
 ```
 
-![Problem info](images/kattis_info.png)
+![Problem info](./images/kattis_info.png)
 
 ### Test a solution locally
 
+![Test](images/kattis_test.png)
+
 - currently the following languages have been tested: Python 3, C++, NodeJS, C, Java
 - make sure CLI compilers are in your PATH
 - make sure python3 files have first line shebang: !/usr/bin/env python3
@@ -141,10 +147,20 @@ kattis info
 
 ```bash
 cd <problem_id>
-kattis test
+kattis test # for exact comparion of answers (string and int)
+kattis test -a 6 # Answer accepted upto 6 decimal places of accuracy
+```
+
+### Testing floating point results
+
+- for floating point ouput, problem provides the tolerance or accuracy upto certain decimal points
+- one can use `-a <N>` switch after kattis test command to provide the decimal places of accuracy
+- e.g., the following command checks for accuracy upto 6 decimal points or absolute error upto $10^-6$
+
+```bash
+kattis test -a 6
 ```
 
-![Test](images/kattis_test.png)
 
 ### Submit a problem
 

kattis_cli-1.0.4.dist-info/RECORD

@@ -0,0 +1,19 @@
+kattis_cli/.kattis-cli.toml,sha256=kGh0gmpFAnivyUC9hR8Y1ZqYJeTBWNyBQ9zOg4AInZ0,898
+kattis_cli/__init__.py,sha256=afN92pog2fGyicY6KNBofYbCBYbYj4Fpi_INUSpsc-E,402
+kattis_cli/download.py,sha256=kvUJdqRW3_ETvTd4XMruEs87RWPVHp_3a4VUhcYZEz8,5863
+kattis_cli/kattis.py,sha256=uZct7vjbEW2HA5FJr1ItSZ-b07P9JQHv5SccV4Pqjo8,13771
+kattis_cli/kattis_setup.py,sha256=rq_-Fz8oafxFJ8MOcxJqHQT8-bezgVHZXY2hm4EQF3U,4357
+kattis_cli/main.py,sha256=aI9EWMqAr-QawCzDUPJSpxwoIsEHSi2ed-23-KOeiAQ,4475
+kattis_cli/settings.py,sha256=d5q4dYj9VqDSqPalleh2oZWtND-1bPB0T2IwdajFrBg,591
+kattis_cli/test_solution.py,sha256=g8LwVKx7Z1bSsXWs_JExCagBrrpKs7vL5PfaAoJHGKA,6114
+kattis_cli/ui.py,sha256=dI06yncjm8sdLQkupPxGRODvQ6Gbawwuqn-67FrWg6I,2682
+kattis_cli/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kattis_cli/utils/config.py,sha256=6SIuiXA9sFADo8RZUj8A6rXb3uqmrWrmmArfZrqNQdw,2293
+kattis_cli/utils/languages.py,sha256=wlhl1Zng0gQAtsWW6FLxdkdzqeeY_qQ94wqa3NLypEU,8758
+kattis_cli/utils/run_program.py,sha256=NWQ6vtTeWgkaW75r91FIHGXR5cAbeu8yMb5hwzpYFsg,2613
+kattis_cli/utils/utility.py,sha256=XqiL7nVWCXs8DsoF6BqbkL0O9-348W-GKN1ScAzQdZ4,2732
+kattis_cli-1.0.4.dist-info/LICENSE,sha256=JmBa4SEKBCDWEgiOZcISU4tUCpli6xSpVlSYgkBXSNQ,1067
+kattis_cli-1.0.4.dist-info/METADATA,sha256=fs7fFZhce3ZgAMKeRSlMAYU2i_rVbyYN1LFDtAiUSek,6603
+kattis_cli-1.0.4.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+kattis_cli-1.0.4.dist-info/entry_points.txt,sha256=kyzGN20VqUPR_H0J_jJUKT-10-cAMFLVegQ6C7tbHss,47
+kattis_cli-1.0.4.dist-info/RECORD,,

{kattis_cli-1.0.2.dist-info → kattis_cli-1.0.4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 1.8.1
 Root-Is-Purelib: true
 Tag: py3-none-any

kattis_cli-1.0.2.dist-info/RECORD

@@ -1,18 +0,0 @@
-kattis_cli/.kattis-cli.toml,sha256=kGh0gmpFAnivyUC9hR8Y1ZqYJeTBWNyBQ9zOg4AInZ0,898
-kattis_cli/__init__.py,sha256=afN92pog2fGyicY6KNBofYbCBYbYj4Fpi_INUSpsc-E,402
-kattis_cli/download.py,sha256=aa0hBg_6Ou8SGrufgkNUjfWEHdmiu7U-W4d-yWHZNOA,5877
-kattis_cli/kattis.py,sha256=t5fog-tx1f1GeM-D3aa2YhuhxTnai_kV-x7miZbs6SI,13767
-kattis_cli/kattis_setup.py,sha256=rq_-Fz8oafxFJ8MOcxJqHQT8-bezgVHZXY2hm4EQF3U,4357
-kattis_cli/main.py,sha256=LDUUdG0eqiKL_zJX9V05OaqUIXKrOOwVAWOgN4TWWQQ,4121
-kattis_cli/settings.py,sha256=d5q4dYj9VqDSqPalleh2oZWtND-1bPB0T2IwdajFrBg,591
-kattis_cli/test_solution.py,sha256=KKYedt3ISQYLIoahLPgPizpApLQnOrBhmkew5aHW9BM,6627
-kattis_cli/ui.py,sha256=dI06yncjm8sdLQkupPxGRODvQ6Gbawwuqn-67FrWg6I,2682
-kattis_cli/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kattis_cli/utils/config.py,sha256=cr5ssEVWolDbqP8krts0YSK5vSLatKTveeHBRNsLRC8,2277
-kattis_cli/utils/run_program.py,sha256=NWQ6vtTeWgkaW75r91FIHGXR5cAbeu8yMb5hwzpYFsg,2613
-kattis_cli/utils/utility.py,sha256=JkypTfPOlDSxmZsh7KKcAVG2BC58t66corMBtcdvU7E,10532
-kattis_cli-1.0.2.dist-info/LICENSE,sha256=JmBa4SEKBCDWEgiOZcISU4tUCpli6xSpVlSYgkBXSNQ,1067
-kattis_cli-1.0.2.dist-info/METADATA,sha256=TImOazyOs7tJWBf_E-NP9x3-_InVey2bnqBxhjJMGOs,5961
-kattis_cli-1.0.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-kattis_cli-1.0.2.dist-info/entry_points.txt,sha256=kyzGN20VqUPR_H0J_jJUKT-10-cAMFLVegQ6C7tbHss,47
-kattis_cli-1.0.2.dist-info/RECORD,,