Merge remote-tracking branch 'origin/master'

# Conflicts:
#	string_py/string_py.py

Author: BabyEntchen

README.md

@@ -37,6 +37,15 @@ print(Str("Hello World!").first(5))
 ```
 Hello
 ```
+## Information Example
+```python
+from string_py import Str
+
+print(Str("Hello World!").get_upper(index=True))
+```
+```
+{0: 'H', 6: 'W'}
+```
 ## Printer Example
 ```python
 from string_py import Printer

examples/project_examples/password_checker.py

@@ -0,0 +1,46 @@
+from string_py import Str, Color
+import string
+
+
+class PasswordManager:
+    def __init__(self, password: Str):
+        self.password = password
+
+    @staticmethod
+    def generate_password() -> str:
+        return Str(string.ascii_letters + string.digits + ".,?!$#").generate(min_=20, max_=30)
+
+    def calc_strength(self, points: int):
+        print(points)
+        if points <= 15:
+            print("You password is okay. Maybe use a new password. Example: " + self.generate_password())
+        elif points <= 10:
+            print("Bad! You should use a new password. Example: " + Color.basic,
+                  self.generate_password())
+        if points < 5:
+            print("Very Bad! You should use a new password. Example: ", Color.basic,
+                  self.generate_password())
+        else:
+            print("Your password is fine!")
+
+    def check_password(self):
+        points = 0
+        if len(self.password) < 8:
+            return self.calc_strength(points)
+        else:
+            points += 0.5 * len(self.password)
+        if self.password.get_numeric(chars=False) == 0:
+            points -= 1
+        if self.password.get_upper(chars=False) == 0:
+            points -= 1
+        if self.password.get_lower(chars=False) == 0:
+            points -= 1
+        if self.password.get_punctuation(chars=False) == 0:
+            points -= 1
+        else:
+            points += 10
+        return self.calc_strength(round(points))
+
+
+if __name__ == "__main__":
+    PasswordManager(Str(input("Your password: "))).check_password()

examples/string_formatting.py

@@ -2,6 +2,24 @@
 
 print(Format.align(values={"Username:": "John", "Register Date:": "01.01.2001"}))
 # Output:
-
+#
 # Username:        John
 # Register Date:   01.01.2001
+
+print(Format.surround("Hello World", char="*"))
+# Output:
+#
+# ***************
+# * Hello World *
+# ***************
+
+print(Format.table([["Product", "Value", "Sold"], ["Carrot", "3.99$", "34"], ["Milk", "5$", "103"]]))
+# Output:
+#
+# ┌────────────────────────┐
+# │ Product │ Value │ Sold │
+# ├────────────────────────┤
+# │ Carrot  │ 3.99$ │ 34   │
+# │────────────────────────│
+# │ Milk    │ 5$    │ 103  │
+# └────────────────────────┘

examples/string_information.py

@@ -0,0 +1,12 @@
+from string_py import Str
+
+random_string = Str("qOUG5p5!6wq?.s,")
+
+print(random_string.get_upper())
+# Output: ['O', 'U', 'G']
+
+print(random_string.get_numeric(chars=False))
+# Output: 3
+
+print(random_string.get_punctuation(index=True))
+# Output: {7: '!', 11: '?', 12: '.', 14: ','}

pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools", "setuptools-scm"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "string_py"
+authors = [
+    {name = "BabyEntchen", email = "baby_entchen@web.de"},
+]
+description = "Utils for strings in python"
+readme = "README.md"
+requires-python = ">=3.7"
+keywords=['python', 'string', 'strings', 'utils', 'string utils', 'random', 'random strings', 'formatting', 'formatter']
+license = {text = "MIT"}
+classifiers = [
+    "Programming Language :: Python :: 3",
+]
+dependencies = []
+dynamic = ["version"]

setup.py

@@ -4,17 +4,19 @@
 from pathlib import Path
 
 
-VERSION = '0.0.2'
+VERSION = '0.1.0'
 DESCRIPTION = 'Utils for strings in python'
 this_directory = Path(__file__).parent
 LONG_DESCRIPTION = (this_directory / "README.md").read_text()
+URL = "https://github.com/BabyEntchen/string_py"
 
 # Setting up
 setup(
     name="string_py",
     version=VERSION,
     author="BabyEntchen",
     author_email="<baby_entchen@web.de>",
+    url=URL,
     description=DESCRIPTION,
     long_description_content_type="text/markdown",
     long_description=LONG_DESCRIPTION,

string_py/__init__.py

@@ -1,5 +1,5 @@
 __title__ = "string_py"
-__version__ = "0.0.2"
+__version__ = "0.1.0"
 __license__ = "MIT"
 __author__ = "BabyEntchen"
 __copyright__ = "Copyright 2023 BabyEntchen"

string_py/string_py.py

@@ -2,6 +2,7 @@
 from time import sleep
 from asyncio import sleep as aio_sleep
 from random import choices, randint
+import string
 
 
 class Color:
@@ -22,6 +23,7 @@ class Printer:
     :param active:`True`
         If set to False, no more prints are executed. Exception: force Parameter is set to True.
     """
+
     def __init__(self, active: bool = True):
         self.active = active
 
@@ -87,17 +89,24 @@ async def aio_slow(self, args: str, speed: float = 0.1, force: bool = False, err
                 await aio_sleep(speed)
 
 
-class Str:
+class Str(str):
     """Functions to work with strings
 
     Parameters
     ----------
     :param values: `str`
         The value you want to work with
     """
+
     def __init__(self, values: str):
         self.values = values
         self.chars = [*values]
+        self.ascii = {
+            "ascii_lowercase": string.ascii_lowercase,
+            "ascii_uppercase": string.ascii_uppercase,
+            "digits": string.digits,
+            "punctuation": string.punctuation
+        }
 
     def generate(self, length: int = None, min_: int = None, max_: int = None) -> str:
         """Generate a random string out of :class:`values`
@@ -121,6 +130,16 @@ def generate(self, length: int = None, min_: int = None, max_: int = None) -> st
         else:
             raise AttributeError("min_ and max_ or length must have a value")
 
+    def remove(self, chars: str) -> str:
+        """Remove chars from string
+
+        Parameters:
+        -----------
+        :param chars:
+            The chars you want to remove
+        """
+        return self.values.replace(chars, "")
+
     def split(self, each: int = None, chars: str = None) -> list[str]:
         """An extension of the built-in .split method. Also split on certain index
 
@@ -136,7 +155,7 @@ def split(self, each: int = None, chars: str = None) -> list[str]:
         if not each and not chars:
             raise AttributeError("each or chars must have a value")
         if each:
-            return [self.values[i:i+each] for i in range(0, len(self.values), each)]
+            return [self.values[i:i + each] for i in range(0, len(self.values), each)]
         else:
             return self.values.split(chars)
 
@@ -174,15 +193,81 @@ def last(self, length: int = 1, remove=False) -> str:
         else:
             return self.values[-length:]
 
-    def remove(self, chars: str) -> str:
-        """Remove chars from string
+    def __get(self, type_: str, index: bool) -> list[str] | dict[int, str]:
 
-        Parameters:
-        -----------
-        :param chars:
-            The chars you want to remove
+        gets = [] if index is False else {}
+        for num, char in enumerate(self.values):
+            if char in self.ascii[type_]:
+                if index is False:
+                    gets.append(char)
+                else:
+                    gets[num] = char
+        return gets
+
+    def get_upper(self, chars: bool = True, index: bool = False) -> int | list[str] | dict[int, str]:
+        """Get how many upper chars are in :class:`values`
+
+        Parameters
+        ----------
+        :param chars:`True`
+            If set to True, returns a list of all uppercase chars
+            If set to False, returns the number of uppercase chars
+        :param index:`False`
+            If set to True, also returns the Indexes of lower chars (`chars` MUST be `True`)
         """
-        return self.values.replace(chars, "")
+        upper = self.__get("ascii_uppercase", index)
+        return upper if chars else len(upper)
+
+    def get_lower(self, chars: bool = True, index: bool = False) -> int | list[str] | dict[int, str]:
+        """Get how many lower chars are in :class:`values`
+
+        Parameters
+        ----------
+        :param chars:`True`
+            If set to True, returns a list of all lower chars
+            If set to False, returns the number of lower chars
+        :param index:`False`
+            If set to True, also returns the Indexes of lower chars (`chars` MUST be `True`)
+        """
+        if not chars and index:
+            raise AttributeError("If index is set to True, chars can't be False")
+
+        lower = self.__get("ascii_lowercase", index)
+        return lower if chars else len(lower)
+
+    def get_numeric(self, chars: bool = True, index: bool = False) -> int | list[str] | dict[int, str]:
+        """Get how many numeric chars are in :class:`values`
+
+        Parameters
+        ----------
+        :param chars:`True`
+            If set to True, returns a list of all numeric chars
+            If set to False, returns the number of numeric chars
+        :param index:`False`
+            If set to True, also returns the Indexes of numeric chars (`chars` MUST be `True`)
+        """
+        if not chars and index:
+            raise AttributeError("If index is set to True, chars can't be False")
+
+        numeric = self.__get("digits", index)
+        return numeric if chars else len(numeric)
+
+    def get_punctuation(self, chars: bool = True, index: bool = False) -> int | list[str] | dict[int, str]:
+        """Get how many punctuation chars are in :class:`values`
+
+        Parameters
+        ----------
+        :param chars:`True`
+            If set to True, returns a list of all punctuation chars
+            If set to False, returns the number of punctuation chars
+        :param index:`False`
+            If set to True, also returns the Indexes of punctuation chars (`chars` MUST be `True`)
+        """
+        if not chars and index:
+            raise AttributeError("If index is set to True, chars can't be False")
+
+        punctuation = self.__get("punctuation", index)
+        return punctuation if chars else len(punctuation)
 
 
 class Format:
@@ -199,18 +284,18 @@ def surround(values: str, char: str = "*") -> str:
         :param char:`*`
             Char to surround with
         :return:
-            Returns a string with the text surrounded with chars
+            Returns a string with the text surrounded with certain chars
         """
         return f"{char * (len(values) + 4)}\n{char} {values} {char}\n{char * (len(values) + 4)}"
 
     @staticmethod
     def align(values: dict[str, str]):
-        """Algin a text
+        """Align a text
 
         Parameters
         ----------
         :param values:`dict[str, str]`
-            Texts to algin {"Left side": "Right side"}
+            Texts to align {"Left side": "Right side"}
         :return:
             Returns a string with the key aligned left and the value right dependent from the keys
 
@@ -226,16 +311,14 @@ def align(values: dict[str, str]):
             aligned_text += key + " " * ((length + 3) - len(key)) + values[key] + "\n"
         return aligned_text
 
-
-
     @staticmethod
     def table(values: list[list[str]], border: bool = True) -> str:
         """Create a table
 
         Parameters
         ----------
         :param values:`list[list[str]]`
-            The values you want to print
+            The values to create the table with
         :param border:`True`
             Set to `False` to remove the border
         :return:
@@ -264,5 +347,3 @@ def table(values: list[list[str]], border: bool = True) -> str:
                 if index != len(values) - 1:
                     table += "\n"
         return table
-
-