Metadata-Version: 1.1
Name: python-import-guardian
Version: 0.1.1
Summary: A static-analysis Python import guardian.
Home-page: https://gitlab.com/gmb/python-import-guardian
Author: Graham Binns
Author-email: graham@outcoded.uk
License: UNKNOWN
Download-URL: https://gitlab.com/gmb/python-import-guardian/-/archive/master/python-import-guardian-master.tar.gz
Description: # Python Import Guardian README
        
        ## What is it?
        
        `python-import-guardian` is a static-analysis import guardian for Python. It
        can be used to control explictly which Python modules and packages can be
        imported by a given set of modules and packages in your project.
        
        ## When is this useful?
        
        Let's say you have a project with two major components — a client and a server.
        Both of these components live in the same repository (for the sake of argument)
        and both use a common set of shared code for various functions — for example to
        determine how certain hashes are calculated or some such.
        
        The code may be laid out thus:
        
            /myproject
              |
              |- client/
              |- server/
              |- shared/
        
        Conceptually, you only ever want `client` and `shared` code to be installed on
        client machines and `server` and `shared` code on server machines. Modules in
        `client` and `server` may import from `shared`, but not from each other, and
        `shared` may import from neither — this ensures that you have a good separation
        of concerns between client and server code whilst maintaining some shared code
        and good DRY principles.
        
        `python-import-guardian` allows you to define how you want these modules to
        relate to each other when it comes to which module can import what from where.
        For our example project, a simple `importguardian.json` file at the top of the
        project tree might look like this:
        
            {
                "forbidden_modules": {
                    "server": [
                        "client",
                        "shared"
                    ],
                    "client": [
                        "server",
                        "shared"
                    ]
                    
                }
            }
            
        The `forbidden_modules` declaration here maps Python modules to a list of the
        modules or packages which may not import them. So in this case: `server` may
        not be imported by `client` or `shared`, and `client` may not be imported by
        `server` or `shared`. `forbidden_modules` is a blacklist, so `shared` can be
        imported by anything because it isn't mentioned as a forbidden module.
Keywords: import,guardian,static-analysis
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
