Metadata-Version: 2.1
Name: alexlib
Version: 0.0.4
Summary: Making Python even more convenient by extending list and dict and pathlib and more.
Home-page: https://github.com/thisismygitrepo/alexlib
Author: Alex Al-Saffar
Author-email: programmer@usa.com
License: Apache 2.0
Description: 
        # Welcome to alexlib
        
        This package extends many native Python classes to equip you with an uneasy to tame power. Beside many minor extensions, the major classes extended are:
         
         * `list` is  extended to `List`
            * Forget that for loops exist in your life, because with this class, for loops are implicitly applied to all items.
          * `dict` is  extended to `Strcut`.
            * Combines the power of dot notation like classes and key access like dictionaries.
            
           * `pathlib` is  extended to `P`
                * `P` objects are increbily powerful for parsing paths, *no* more than one line of code is required to do **any** operation.
                
            * Some other classes that make honorable mention here are `Read` and `Save` classes. Together with `P`, they provide comprehensible support for file management. Life cannot get easier with those.
        
           
        Furthermore, those classes are inextericably connected. Example, globbing a path `P` object returns a `List` object. You can move back and forth between `List` and `Struct` with one method, and so on.
        
        You can read the details in the code to grapple the motivation and the philosophy behind its implementation mechanics. Fill your life with one-liners, take your code to artistic level of brevity and readability while simulataneously being more productive by typing less boilerplate lines of code that are needless to say.
        
        
        # Install
        just do this in your command line
        `pip install alexlib`
        
        # Getting Started
        That's as easy as taking candy from a baby; whenever you start a Python file, preface it with following in order to unleash the library:
        
        ```
        import alexlib.toolbox as tb
        ```
        
        
        # A Taste of Power
        Suppose you want to know how many lines of code in your repository. The procedure is to glob all `.py` files recursively, read string code, split each one of them by lines, count the the lines, add up everything from all strings of code.
        
        
        To achieve this, all you need is a imminently readable one-liner.
        ```
        tb.P.cwd().myglob("*.py", r=True).read_text().split('\n').apply(len).np.sum()
        ```
        
        How does this make perfect sense?
        * `myglob` returns `List` of `P` path objects
        * `read_text` is a `P` method, but it is being run against `List` object. Behind the scense **responsible black magic** fails to find such a method in `List` and realizes it is a method of items inside the list, so it reads all files and containerize them in another `List` object and returns it.
        * Similar story applies to `split` which is a method of strings in Python.
        * Next, `apply` is a method of `List`. Sure enough, it lives up to its apt name and applies the passed function `len` to all items in the list and returns another `List` object that contains the results.
        * `.np` converts `List` to `numpy` array, then `.sum` is a method of `numpy`, which gives the final result.
        
        # Other use cases
        Invitably in life, you will encounter objects of the same type and you are struggling to get a tough grab on them. `List` gives you a handle so tough, that the objects behave like one object.
        
        This is the power of implicit for loops. Share with us your one-liner snippets to add it to use-cases of this package.
        
        
Platform: UNKNOWN
Description-Content-Type: text/markdown
