Metadata-Version: 2.1
Name: python-import-guardian
Version: 0.1.3
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
Keywords: import,guardian,static-analysis
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Description-Content-Type: text/markdown

# 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.



