seqpad 1.1.0__tar.gz → 1.2.0__tar.gz

seqpad-1.2.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include run_tests.py
+recursive-include docs *.rst
+recursive-include src *.toml
+recursive-include tests *.toml

{seqpad-1.1.0/src/seqpad.egg-info → seqpad-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seqpad
-Version: 1.1.0
+Version: 1.2.0
 Summary: This project pads nucleotide sequences.
 Author-email: Johannes <johannes.programming@gmail.com>
 License-Expression: MIT
@@ -18,8 +18,6 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
-Requires-Dist: click<9,>=8.2
-Requires-Dist: preparse<2,>=1.1
 Dynamic: license-file
 
 ======

seqpad-1.2.0/docs/v1.2.rst

@@ -0,0 +1,112 @@
+Overview
+--------
+
+This project pads nucleotide sequences.
+
+Installation
+------------
+
+To install ``seqpad``, you can use ``pip``.
+Open your terminal and run:
+
+.. code-block:: shell
+
+    pip install seqpad
+
+Typing
+------
+
+The typing conforms strictly to ``mypy``.
+
+.. container:: versionadded
+
+    **Added in version 1.1.**
+
+Features
+--------
+
+``seqpad.core``
+~~~~~~~~~~~~~~~
+
+The functions in ``seqpad.core`` can also be imported from ``seqpad`` directly.
+
+``seqpad.core.main(args: Iterable[str] | None = None) -> int``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The project also provides a CLI that can also be accessed from within Python.
+For more information, read the help message that can be accessed through one of the two following ways.
+
+.. code-block:: shell
+
+    # bash
+    python3 -m seqpad -h
+
+.. code-block:: python
+
+    # python
+    import seqpad
+    seqpad.main(['-h'])
+
+``seqpad.core.parse_args(args: Iterable[str] | None = None) -> Namespace``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. container:: versionadded
+
+    **Added in version 1.2.**
+
+``seqpad.core.run(seq: str | None = None) -> None``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. container:: versionadded
+
+    **Added in version 1.2.**
+
+``seqpad.core.seqpad(seq: Any) -> Any``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The core function of this project is implemented as follows:
+
+.. code-block:: python
+
+    def seqpad(seq: Any) -> Any:
+        while len(seq) % 3 != 0:
+            seq += "N"
+        return seq
+
+``seqpad.tests``
+~~~~~~~~~~~~~~~~
+
+``seqpad.tests.test() -> unittest.TextTestResult``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This project can be tested through its ``test`` function.
+
+The following code can also be executed by running the project's ``run_tests.py``:
+
+.. code-block:: python
+
+    import seqpad.tests
+    seqpad.tests.test()
+
+License
+-------
+
+This project is licensed under the MIT License.
+
+Links
+-----
+
+- Download: https://pypi.org/project/seqpad/#files
+- Index: https://pypi.org/project/seqpad/
+- Source: https://github.com/johannes-programming/seqpad/
+- Website: https://seqpad.johannes-programming.online/
+
+Impressum
+---------
+
+**Johannes Programming**
+
+- Name: Johannes
+- Email: johannes.programming@gmail.com
+- Homepage: https://www.johannes-programming.online/
+- Gravatar: https://www.johannes-programming.fyi/

{seqpad-1.1.0 → seqpad-1.2.0}/pyproject.toml

@@ -17,10 +17,7 @@ classifiers = [
     "Programming Language :: Python :: 3 :: Only",
     "Typing :: Typed",
 ]
-dependencies = [
-    "click>=8.2,<9",
-    "preparse>=1.1,<2",
-]
+dependencies = []
 description = "This project pads nucleotide sequences."
 keywords = []
 license = "MIT"
@@ -30,7 +27,7 @@ license-files = [
 name = "seqpad"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "1.1.0"
+version = "1.2.0"
 
 [project.urls]
 Download = "https://pypi.org/project/seqpad/#files"

seqpad-1.2.0/run_tests.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+__all__: list[str] = []
+
+import sys
+
+import seqpad.tests
+
+sys.exit(1 - seqpad.tests.test().wasSuccessful())

seqpad-1.2.0/src/seqpad/__init__.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+__all__: list[str] = ["main", "parse_args", "run", "seqpad", "test"]
+
+import sys
+
+from seqpad.core import main, parse_args, run, seqpad
+from seqpad.tests import test
+
+if __name__ == "__main__":
+    sys.exit(main())

seqpad-1.2.0/src/seqpad/__main__.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+__all__: list[str] = []
+
+import sys
+
+from seqpad import main
+
+if __name__ == "__main__":
+    sys.exit(main())

seqpad-1.2.0/src/seqpad/core/__init__.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+__all__: list[str] = ["main", "parse_args", "run", "seqpad"]
+
+import argparse
+import logging
+from collections import abc
+from importlib import metadata
+from typing import Any
+
+
+def main(args: abc.Iterable[str] | None = None) -> int:
+    space: argparse.Namespace
+    try:
+        space = parse_args(args)
+    except SystemExit as exit:
+        if isinstance(exit.code, int):
+            return exit.code
+        else:
+            return int(bool(exit.code))
+    try:
+        run(space.seq)
+    except Exception as exc:
+        logging.exception(exc)
+        return 1
+    return 0
+
+
+def parse_args(args: abc.Iterable[str] | None = None) -> argparse.Namespace:
+    parser: argparse.ArgumentParser
+    version: str
+    parser = argparse.ArgumentParser(
+        add_help=False,
+        fromfile_prefix_chars="@",
+        prog="seqpad",
+    )
+    parser.add_argument(
+        "-h",
+        "--help",
+        action="help",
+        help="show this help message and exit",
+    )
+    version = "%(prog)s, version " + metadata.version("seqpad")
+    parser.add_argument("-V", "--version", action="version", version=version)
+    parser.add_argument("seq", nargs="?")
+    return parser.parse_args(args)
+
+
+def run(seq: str | None = None) -> None:
+    if seq is not None:
+        print(seqpad(seq))
+
+
+def seqpad(seq: Any) -> Any:
+    while len(seq) % 3 != 0:
+        seq += "N"
+    return seq

seqpad-1.2.0/src/seqpad/tests/__init__.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+__all__: list[str] = ["test"]
+
+import unittest
+
+
+def test() -> unittest.TextTestResult:
+    loader: unittest.TestLoader
+    runner: unittest.TextTestRunner
+    tests: unittest.TestSuite
+    loader = unittest.TestLoader()
+    tests = loader.discover(start_dir="seqpad.tests")
+    runner = unittest.TextTestRunner()
+    return runner.run(tests)

{seqpad-1.1.0 → seqpad-1.2.0}/src/seqpad/tests/test_triplets.py

@@ -1,18 +1,21 @@
+from __future__ import annotations
+
+__all__: list[str] = ["TestSeqPad"]
+
 import unittest
-from typing import *
+from typing import Self
 
-# Importing the function to be tested
 from seqpad import seqpad
 
 
 class TestSeqPad(unittest.TestCase):
 
-    def test_already_multiple_of_three(self: Self) -> None:
+    def test_already_multiple_of_three(self: Self, /) -> None:
         # Test case where sequence length is already a multiple of three
         self.assertEqual(seqpad("ATG"), "ATG")
         self.assertEqual(len(seqpad("ATG")), 3)
 
-    def test_not_multiple_of_three(self: Self) -> None:
+    def test_not_multiple_of_three(self: Self, /) -> None:
         # Test case where sequence length is not a multiple of three
         self.assertEqual(seqpad("AT"), "ATN")
         self.assertEqual(len(seqpad("AT")), 3)
@@ -22,13 +25,16 @@ class TestSeqPad(unittest.TestCase):
         self.assertEqual(len(seqpad("ATGCA")), 6)
         self.assertEqual(len(seqpad("ATGCAN")), 6)
 
-    def test_empty_sequence(self: Self) -> None:
+    def test_empty_sequence(self: Self, /) -> None:
         # Test case where input sequence is empty
         self.assertEqual(seqpad(""), "")
         self.assertEqual(len(seqpad("")), 0)
 
-    def test_length_of_result(self: Self) -> None:
+    def test_length_of_result(self: Self, /) -> None:
         # Check if the result has length that is a multiple of three
+        padded_seq: str
+        seq: str
+        test_sequences: list[str]
         test_sequences = ["A", "AT", "ATGCA", "ATGCGTACG"]
 
         for seq in test_sequences:
@@ -37,12 +43,13 @@ class TestSeqPad(unittest.TestCase):
                 len(padded_seq) % 3, 0, f"Failed for input: {seq}"
             )
 
-    def test_edge_cases(self: Self) -> None:
+    def test_edge_cases(self: Self, /) -> None:
         # Testing edge cases such as strings with non-standard nucleotides
         self.assertEqual(seqpad("NNN"), "NNN")
         self.assertEqual(seqpad("N"), "NNN")
         self.assertEqual(len(seqpad("N")), 3)
         self.assertEqual(len(seqpad("NNN")), 3)
+        self.assertListEqual(seqpad(["A"]), ["A", "N", "N"])
 
 
 if __name__ == "__main__":

seqpad-1.2.0/src/seqpad/tests/test_version.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+__all__: list[str] = ["TestVersion"]
+
+import unittest
+from collections import abc
+from contextlib import redirect_stdout
+from io import StringIO
+from typing import Self
+
+from seqpad import main
+
+
+class TestVersion(unittest.TestCase):
+    def go(self: Self, /, args: abc.Iterable[str]) -> str:
+        buffer: StringIO
+        text: str
+        buffer = StringIO()
+        with redirect_stdout(buffer):
+            main(args)
+        text = buffer.getvalue()
+        self.assertTrue(text.startswith("seqpad, "))
+        self.assertTrue(text.endswith("\n"))
+        self.assertEqual(text.count("\n"), 1)
+        return text[8:-1]
+
+    def test_0(self: Self, /) -> None:
+        versions: set[str]
+        versions = set()
+        versions.add(self.go(["-V"]))
+        versions.add(self.go(["--version"]))
+        self.assertEqual(len(versions), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

{seqpad-1.1.0 → seqpad-1.2.0/src/seqpad.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seqpad
-Version: 1.1.0
+Version: 1.2.0
 Summary: This project pads nucleotide sequences.
 Author-email: Johannes <johannes.programming@gmail.com>
 License-Expression: MIT
@@ -18,8 +18,6 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
-Requires-Dist: click<9,>=8.2
-Requires-Dist: preparse<2,>=1.1
 Dynamic: license-file
 
 ======

{seqpad-1.1.0 → seqpad-1.2.0}/src/seqpad.egg-info/SOURCES.txt

@@ -2,17 +2,19 @@ LICENSE.txt
 MANIFEST.in
 README.rst
 pyproject.toml
+run_tests.py
 setup.cfg
 docs/v1.0.rst
 docs/v1.1.rst
+docs/v1.2.rst
 src/seqpad/__init__.py
 src/seqpad/__main__.py
 src/seqpad/py.typed
 src/seqpad.egg-info/PKG-INFO
 src/seqpad.egg-info/SOURCES.txt
 src/seqpad.egg-info/dependency_links.txt
-src/seqpad.egg-info/requires.txt
 src/seqpad.egg-info/top_level.txt
 src/seqpad/core/__init__.py
 src/seqpad/tests/__init__.py
-src/seqpad/tests/test_triplets.py
+src/seqpad/tests/test_triplets.py
+src/seqpad/tests/test_version.py

seqpad-1.1.0/MANIFEST.in

@@ -1,2 +0,0 @@
-recursive-include docs *.rst
-recursive-include src/seqpad *.toml

seqpad-1.1.0/src/seqpad/__init__.py

@@ -1,5 +0,0 @@
-from seqpad.core import *
-from seqpad.tests import *
-
-if __name__ == "__main__":
-    main()

seqpad-1.1.0/src/seqpad/__main__.py

@@ -1,4 +0,0 @@
-from seqpad import main
-
-if __name__ == "__main__":
-    main()

seqpad-1.1.0/src/seqpad/core/__init__.py

@@ -1,23 +0,0 @@
-from typing import *
-
-import click
-import preparse
-
-__all__ = ["seqpad", "main"]
-
-
-def seqpad(seq: Any) -> Any:
-    while len(seq) % 3 != 0:
-        seq += "N"
-    return seq
-
-
-@preparse.PreParser().click()
-@click.command(add_help_option=False)
-@click.help_option("-h", "--help")
-@click.version_option(None, "-V", "--version")
-@click.argument("seq", type=str, required=False)
-def main(seq: Optional[str]) -> None:
-    "This program pads the given seq to a length that is a multiple of three."
-    if seq is not None:
-        click.echo(seqpad(seq))

seqpad-1.1.0/src/seqpad/tests/__init__.py

@@ -1,11 +0,0 @@
-import unittest
-
-__all__ = ["test"]
-
-
-def test() -> unittest.TextTestResult:
-    loader: unittest.TestLoader = unittest.TestLoader()
-    tests: unittest.TestSuite = loader.discover(start_dir="seqpad.tests")
-    runner: unittest.TextTestRunner = unittest.TextTestRunner()
-    result: unittest.TextTestResult = runner.run(tests)
-    return result

seqpad-1.1.0/src/seqpad.egg-info/requires.txt

@@ -1,2 +0,0 @@
-click<9,>=8.2
-preparse<2,>=1.1