Merged changes from original repo, changed '--dynamic' to '--mode'

* fixed MySQL + krbV mappings to be reversed

* Working on issue #88

* More --clean tests.

* Fixed #88

* mapping aws-sam-translator

https://pypi.org/project/aws-sam-translator/
https://github.com/awslabs/serverless-application-model

* Fixed#133

Sorted `imports` based on `lowercase` package's `name`, similar to `pip freeze`.

* Tweak formatting

* Add pyAFQ Mapping

* Add discord mapping

Map discord to discord.py

* Add PyFunctional mapping

Maps `functional` to `pyfunctional`. Fixes #232.

* Upgrade pip before running tests on travis

This should ensure that all tests use the same version of pip and this should hopefully fix the pypy build that is using pip 19

* Upgrading pypy to pypy3

Maybe forcing pypy to use python 3 will solve the issue (although it works fine with python 2.7 at the moment)

* Remove unecessary pip upgrade step

* Mapping for github3

* changes based on discussions w maintainer

* remove obsolete '=='

Co-authored-by: Hari Sekhon <harisekhon@gmail.com>
Co-authored-by: AlexPHorta <alexandre.horta@gmail.com>
Co-authored-by: Pat Myron <PatMyron@users.noreply.github.com>
Co-authored-by: Abhishek Kumar Singh <toanant@users.noreply.github.com>
Co-authored-by: Ben Bodenmiller <bbodenmiller@gmail.com>
Co-authored-by: John Kruper <36000@users.noreply.github.com>
Co-authored-by: Paweł Kalemba <5924586+pkalemba@users.noreply.github.com>
Co-authored-by: SwiftWinds <12981958+SwiftWinds@users.noreply.github.com>
Co-authored-by: Alan Barzilay <alan-barzilay@users.noreply.github.com>
Co-authored-by: alan-barzilay <alan.barzilay@gmail.com>
Co-authored-by: ryan-rozario <ryan.rozario1999@gmail.com>
Co-authored-by: Siyang <teo_siyang@imda.gov.sg>

.travis.yml

@@ -12,8 +12,8 @@ matrix:
       env: TOX_ENV=py34
     - python: 2.7
       env: TOX_ENV=py27
-    - python: pypy
+    - python: pypy3
-      env: TOX_ENV=pypy
+      env: TOX_ENV=pypy3
     - python: 3.6
       env: TOX_ENV=flake8
 

HISTORY.rst

@@ -3,6 +3,11 @@
 History
 -------
 
+0.4.11 (2020-03-29)
+--------------------
+
+* Implement '--mode' (Jake Teo, Jerome Chan)
+
 0.4.8 (2017-06-30)
 --------------------
 

README.rst

@@ -49,7 +49,10 @@ Usage
         --force               Overwrite existing requirements.txt
         --diff <file>         Compare modules in requirements.txt to project imports.
         --clean <file>        Clean up requirements.txt by removing modules that are not imported in project.
-        --dynamic <scheme>    Enables dynamic version updates by 'minor', 'micro' or 'all' schemes.
+        --mode <scheme>       Enables dynamic versioning with <compat>, <gt> or <non-pin> schemes.
+                              <compat> | e.g. Flask~=1.1.2
+                              <gt>     | e.g. Flask>=1.1.2
+                              <no-pin> | e.g. Flask
 Example
 -------
 
@@ -70,5 +73,5 @@ Why not pip freeze?
 -------------------
 
 - ``pip freeze`` only saves the packages that are installed with ``pip install`` in your environment. 
-- ``pip freeze`` saves all packages in the environment including those that you don't use in your current project. (if you don't have virtualenv)
+- ``pip freeze`` saves all packages in the environment including those that you don't use in your current project (if you don't have ``virtualenv``).
-- and sometimes you just need to create requirements.txt for a new project without installing modules.
+- and sometimes you just need to create ``requirements.txt`` for a new project without installing modules.

pipreqs/mapping

@@ -1,3 +1,4 @@
+AFQ:pyAFQ
 AG_fft_tools:agpy
 ANSI:pexpect
 Adafruit:Adafruit_Libraries
@@ -13,6 +14,7 @@ Crypto:pycryptodome
 Cryptodome:pycryptodomex
 FSM:pexpect
 FiftyOneDegrees:51degrees_mobile_detector_v3_wrapper
+functional:pyfunctional
 GeoBaseMain:GeoBasesDev
 GeoBases:GeoBasesDev
 Globals:Zope2
@@ -22,6 +24,7 @@ Kittens:astro_kittens
 Levenshtein:python_Levenshtein
 Lifetime:Zope2
 MethodObject:ExtensionClass
+MySQLdb:MySQL-python
 OFS:Zope2
 OpenGL:PyOpenGL
 OpenSSL:pyOpenSSL
@@ -592,6 +595,7 @@ devtools:tg.devtools
 dgis:2gis
 dhtmlparser:pyDHTMLParser
 digitalocean:python_digitalocean
+discord:discord.py
 distribute_setup:ez_setup
 distutils2:Distutils2
 django:Django
@@ -675,6 +679,7 @@ geventwebsocket:gevent_websocket
 gflags:python_gflags
 git:GitPython
 github:PyGithub
+github3:github3.py
 gitpy:git_py
 globusonline:globusonline_transfer_api_client
 google:protobuf
@@ -701,7 +706,6 @@ html:pies2overrides
 htmloutput:nosehtmloutput
 http:pies2overrides
 hvad:django_hvad
-krbV:krbv
 i99fix:199Fix
 igraph:python_igraph
 imdb:IMDbPY
@@ -727,6 +731,7 @@ keyczar:python_keyczar
 keyedcache:django_keyedcache
 keystoneclient:python_keystoneclient
 kickstarter:kickstart
+krbv:krbV
 kss:kss.core
 kuyruk:Kuyruk
 langconv:AdvancedLangConv
@@ -798,7 +803,6 @@ msgpack:msgpack_python
 mutations:aino_mutations
 mws:amazon_mws
 mysql:mysql_connector_repackaged
-MySQL-python:MySQLdb
 native_tags:django_native_tags
 ndg:ndg_httpsclient
 nereid:trytond_nereid
@@ -999,6 +1003,7 @@ ruamel:ruamel.base
 s2repoze:pysaml2
 saga:saga_python
 saml2:pysaml2
+samtranslator:aws-sam-translator
 sass:libsass
 sassc:libsass
 sasstests:libsass

pipreqs/pipreqs.py

@@ -31,8 +31,11 @@ Options:
                           imports.
     --clean <file>        Clean up requirements.txt by removing modules
                           that are not imported in project.
-    --dynamic <scheme>    Enables dynamic version updates by 'minor',
+    --mode <scheme>       Enables dynamic versioning with <compat>,
-                          'micro' or 'all' schemes.
+                          <gt> or <non-pin> schemes.
+                          <compat> | e.g. Flask~=1.1.2
+                          <gt>     | e.g. Flask>=1.1.2
+                          <no-pin> | e.g. Flask
 """
 from __future__ import print_function, absolute_import
 from contextlib import contextmanager
@@ -162,21 +165,21 @@ def filter_line(line):
     return len(line) > 0 and line[0] != "#"
 
 
-def generate_requirements_file(path, imports):
+def generate_requirements_file(path, imports, symbol):
     with _open(path, "w") as out_file:
         logging.debug('Writing {num} requirements: {imports} to {file}'.format(
             num=len(imports),
             file=path,
             imports=", ".join([x['name'] for x in imports])
         ))
-        fmt = '{name}=={version}'
+        fmt = '{name}' + symbol + '{version}'
         out_file.write('\n'.join(
             fmt.format(**item) if item['version'] else '{name}'.format(**item)
             for item in imports) + '\n')
 
 
-def output_requirements(imports):
+def output_requirements(imports, symbol):
-    generate_requirements_file('-', imports)
+    generate_requirements_file('-', imports, symbol)
 
 
 def get_imports_info(
@@ -369,6 +372,11 @@ def diff(file_, imports):
 def clean(file_, imports):
     """Remove modules that aren't imported in project from file."""
     modules_not_imported = compare_modules(file_, imports)
+
+    if len(modules_not_imported) == 0:
+        logging.info("Nothing to clean in " + file_)
+        return
+
     re_remove = re.compile("|".join(modules_not_imported))
     to_write = []
 
@@ -394,25 +402,15 @@ def clean(file_, imports):
 
 
 def dynamic_versioning(scheme, imports):
-    """Enables dynamic versioning by minor, micro or all scheme."""
+    """Enables dynamic versioning with <compat>, <gt> or <non-pin> schemes."""
-    if scheme == "all":
+    if scheme == "no-pin":
         imports = [{"name": item["name"], "version": ""} for item in imports]
-    else:
+        symbol = ""
-        for item in imports:
+    elif scheme == "gt":
-            version = item["version"]
+        symbol = ">="
-            arr = version.split(".")
+    elif scheme == "compat":
-            length = len(arr)
+        symbol = "~="
-            if length != 1:
+    return imports, symbol
-                if scheme == "minor":
-                    arr = arr[0]
-
-                elif scheme == "micro" and length >= 2:
-                    arr = arr[:2]
-                    arr = ".".join(arr)
-
-                arr = arr + ".*"
-                item["version"] = arr
-    return imports
 
 
 def init(args):
@@ -453,6 +451,8 @@ def init(args):
         imports = local + get_imports_info(difference,
                                            proxy=proxy,
                                            pypi_server=pypi_server)
+    # sort imports based on lowercase name of package, similar to `pip freeze`.
+    imports = sorted(imports, key=lambda x: x['name'].lower())
 
     path = (args["--savepath"] if args["--savepath"] else
             os.path.join(input_path, "requirements.txt"))
@@ -473,19 +473,21 @@ def init(args):
                         "use --force to overwrite it")
         return
 
-    if args["--dynamic"]:
+    if args["--mode"]:
-        scheme = args.get("--dynamic")
+        scheme = args.get("--mode")
-        if scheme in ["minor", "micro", "all"]:
+        if scheme in ["compat", "gt", "no-pin"]:
-            imports = dynamic_versioning(scheme, imports)
+            imports, symbol = dynamic_versioning(scheme, imports)
         else:
-            raise ValueError("Invalid argument for dynamic scheme, "
+            raise ValueError("Invalid argument for mode flag, "
-                             "use 'minor', 'micro' or 'all' instead")
+                             "use 'compat', 'gt' or 'no-pin' instead")
+    else:
+        symbol = "=="
 
     if args["--print"]:
-        output_requirements(imports)
+        output_requirements(imports, symbol)
         logging.info("Successfully output requirements")
     else:
-        generate_requirements_file(path, imports)
+        generate_requirements_file(path, imports, symbol)
         logging.info("Successfully saved requirements file in " + path)
 
 

tests/_data/test.py

@@ -31,6 +31,10 @@ from pyflakes.test.test_imports import Test as TestImports
 # Nose
 from nose.importer import Importer, add_path, remove_path  # loader.py
 
+# see issue #88
+import analytics
+import flask_seasurf
+
 import atexit
 from __future__ import print_function
 from docopt import docopt

tests/_data_clean/test.py

@@ -0,0 +1,65 @@
+"""unused import"""
+# pylint: disable=undefined-all-variable, import-error, no-absolute-import, too-few-public-methods, missing-docstring
+import xml.etree  # [unused-import]
+import xml.sax  # [unused-import]
+import os.path as test  # [unused-import]
+from sys import argv as test2  # [unused-import]
+from sys import flags  # [unused-import]
+# +1:[unused-import,unused-import]
+from collections import deque, OrderedDict, Counter
+# All imports above should be ignored
+import requests  # [unused-import]
+
+# setuptools
+import zipimport  # command/easy_install.py
+
+# twisted
+from importlib import invalidate_caches  # python/test/test_deprecate.py
+
+# astroid
+import zipimport  # manager.py
+# IPython
+from importlib.machinery import all_suffixes  # core/completerlib.py
+import importlib  # html/notebookapp.py
+
+from IPython.utils.importstring import import_item  # Many files
+
+# pyflakes
+# test/test_doctests.py
+from pyflakes.test.test_imports import Test as TestImports
+
+# Nose
+from nose.importer import Importer, add_path, remove_path  # loader.py
+
+# see issue #88
+import analytics
+import flask_seasurf
+
+import atexit
+from __future__ import print_function
+from docopt import docopt
+import curses, logging, sqlite3
+import logging
+import os
+import sqlite3
+import time
+import sys
+import signal
+import bs4
+import nonexistendmodule
+import boto as b, peewee as p
+# import django
+import flask.ext.somext  # # #
+# from sqlalchemy import model
+try:
+    import ujson as json
+except ImportError:
+    import json
+
+import models
+
+
+def main():
+    pass
+
+import after_method_is_valid_even_if_not_pep8

tests/test_pipreqs.py

@@ -18,22 +18,40 @@ from pipreqs import pipreqs
 class TestPipreqs(unittest.TestCase):
 
     def setUp(self):
-        self.modules = ['flask', 'requests', 'sqlalchemy',
+        self.modules = [
-                        'docopt', 'boto', 'ipython', 'pyflakes', 'nose',
+            'flask', 'requests', 'sqlalchemy', 'docopt', 'boto', 'ipython',
-                        'peewee', 'ujson', 'nonexistendmodule', 'bs4', 'after_method_is_valid_even_if_not_pep8' ]
+            'pyflakes', 'nose', 'analytics', 'flask_seasurf', 'peewee',
+            'ujson', 'nonexistendmodule', 'bs4',
+            'after_method_is_valid_even_if_not_pep8'
+            ]
         self.modules2 = ['beautifulsoup4']
         self.local = ["docopt", "requests", "nose", 'pyflakes']
         self.project = os.path.join(os.path.dirname(__file__), "_data")
-        self.project_invalid = os.path.join(os.path.dirname(__file__), "_invalid_data")
+        self.project_clean = os.path.join(
-        self.project_with_ignore_directory = os.path.join(os.path.dirname(__file__), "_data_ignore")
+            os.path.dirname(__file__),
-        self.project_with_duplicated_deps = os.path.join(os.path.dirname(__file__), "_data_duplicated_deps")
+            "_data_clean"
+            )
+        self.project_invalid = os.path.join(
+            os.path.dirname(__file__),
+            "_invalid_data"
+            )
+        self.project_with_ignore_directory = os.path.join(
+            os.path.dirname(__file__),
+            "_data_ignore"
+            )
+        self.project_with_duplicated_deps = os.path.join(
+            os.path.dirname(__file__),
+            "_data_duplicated_deps"
+            )
         self.requirements_path = os.path.join(self.project, "requirements.txt")
         self.alt_requirement_path = os.path.join(
-            self.project, "requirements2.txt")
+            self.project,
+            "requirements2.txt"
+            )
 
     def test_get_all_imports(self):
         imports = pipreqs.get_all_imports(self.project)
-        self.assertEqual(len(imports), 13)
+        self.assertEqual(len(imports), 15)
         for item in imports:
             self.assertTrue(
                 item.lower() in self.modules, "Import is missing: " + item)
@@ -54,7 +72,8 @@ class TestPipreqs(unittest.TestCase):
         """
         Test that invalid python files cannot be imported.
         """
-        self.assertRaises(SyntaxError, pipreqs.get_all_imports, self.project_invalid)
+        self.assertRaises(
+            SyntaxError, pipreqs.get_all_imports, self.project_invalid)
 
     def test_get_imports_info(self):
         """
@@ -62,8 +81,9 @@ class TestPipreqs(unittest.TestCase):
         """
         imports = pipreqs.get_all_imports(self.project)
         with_info = pipreqs.get_imports_info(imports)
-        # Should contain 10 items without the "nonexistendmodule" and "after_method_is_valid_even_if_not_pep8"
+        # Should contain 10 items without the "nonexistendmodule" and
-        self.assertEqual(len(with_info), 11)
+        # "after_method_is_valid_even_if_not_pep8"
+        self.assertEqual(len(with_info), 13)
         for item in with_info:
             self.assertTrue(
                 item['name'].lower() in self.modules,
@@ -77,10 +97,12 @@ class TestPipreqs(unittest.TestCase):
 
     def test_get_use_local_only(self):
         """
-        Test without checking PyPI, check to see if names of local imports matches what we expect
+        Test without checking PyPI, check to see if names of local
+        imports matches what we expect
 
         - Note even though pyflakes isn't in requirements.txt,
-          It's added to locals since it is a development dependency for testing
+          It's added to locals since it is a development dependency
+          for testing
         """
         # should find only docopt and requests
         imports_with_info = pipreqs.get_import_local(self.modules)
@@ -89,24 +111,28 @@ class TestPipreqs(unittest.TestCase):
 
     def test_init(self):
         """
-        Test that all modules we will test upon, are in requirements file
+        Test that all modules we will test upon are in requirements file
         """
         pipreqs.init({'<path>': self.project, '--savepath': None, '--print': False,
                       '--use-local': None, '--force': True, '--proxy':None, '--pypi-server':None,
-                      '--diff': None, '--clean': None, '--dynamic': None})
+                      '--diff': None, '--clean': None, '--mode': None})
         assert os.path.exists(self.requirements_path) == 1
         with open(self.requirements_path, "r") as f:
             data = f.read().lower()
             for item in self.modules[:-3]:
                 self.assertTrue(item.lower() in data)
+        # It should be sorted based on names.
+        data = data.strip().split('\n')
+        self.assertEqual(data, sorted(data))
 
     def test_init_local_only(self):
         """
-        Test that items listed in requirements.text are the same as locals expected
+        Test that items listed in requirements.text are the same
+        as locals expected
         """
         pipreqs.init({'<path>': self.project, '--savepath': None, '--print': False,
                       '--use-local': True, '--force': True, '--proxy':None, '--pypi-server':None,
-                      '--diff': None, '--clean': None, '--dynamic': None})
+                      '--diff': None, '--clean': None, '--mode': None})
         assert os.path.exists(self.requirements_path) == 1
         with open(self.requirements_path, "r") as f:
             data = f.readlines()
@@ -116,11 +142,12 @@ class TestPipreqs(unittest.TestCase):
 
     def test_init_savepath(self):
         """
-        Test that we can save requiremnts.tt correctly to a different path
+        Test that we can save requirements.txt correctly
+        to a different path
         """
-        pipreqs.init({'<path>': self.project, '--savepath':
+        pipreqs.init({'<path>': self.project, '--savepath': self.alt_requirement_path, 
-                      self.alt_requirement_path, '--use-local': None, '--proxy':None, '--pypi-server':None,  '--print': False,
+                      '--use-local': None, '--proxy':None, '--pypi-server':None,  '--print': False,
-                      "--diff": None, "--clean": None, '--dynamic': None})
+                      '--diff': None, '--clean': None, '--mode': None})
         assert os.path.exists(self.alt_requirement_path) == 1
         with open(self.alt_requirement_path, "r") as f:
             data = f.read().lower()
@@ -131,13 +158,14 @@ class TestPipreqs(unittest.TestCase):
 
     def test_init_overwrite(self):
         """
-        Test that if requiremnts.txt exists, it will not automatically be overwritten
+        Test that if requiremnts.txt exists, it will not be
+        automatically overwritten
         """
         with open(self.requirements_path, "w") as f:
             f.write("should_not_be_overwritten")
-        pipreqs.init({'<path>': self.project, '--savepath': None,
+        pipreqs.init({'<path>': self.project, '--savepath': None, '--use-local': None, 
-                      '--use-local': None, '--force': None, '--proxy':None, '--pypi-server':None, '--print': False,
+                      '--force': None, '--proxy':None, '--pypi-server':None, '--print': False,
-                      "--diff": None, "--clean": None, '--dynamic': None})
+                      '--diff': None, '--clean': None, '--mode': None})
         assert os.path.exists(self.requirements_path) == 1
         with open(self.requirements_path, "r") as f:
             data = f.read().lower()
@@ -145,36 +173,43 @@ class TestPipreqs(unittest.TestCase):
 
     def test_get_import_name_without_alias(self):
         """
-        Test that function get_name_without_alias() will work on a string.
+        Test that function get_name_without_alias()
-        - Note: This isn't truly needed when pipreqs is walking the AST to find imports
+        will work on a string.
+        - Note: This isn't truly needed when pipreqs is walking
+          the AST to find imports
         """
         import_name_with_alias = "requests as R"
         expected_import_name_without_alias = "requests"
         import_name_without_aliases = pipreqs.get_name_without_alias(
             import_name_with_alias)
         self.assertEqual(
-            import_name_without_aliases, expected_import_name_without_alias)
+            import_name_without_aliases,
+            expected_import_name_without_alias
+            )
 
     def test_custom_pypi_server(self):
         """
         Test that trying to get a custom pypi sever fails correctly
         """
-        self.assertRaises(requests.exceptions.MissingSchema, pipreqs.init, {'<path>': self.project, '--savepath': None, '--print': False,
+        self.assertRaises(
-                          '--use-local': None, '--force': True, '--proxy': None, '--pypi-server': 'nonexistent'})
+            requests.exceptions.MissingSchema, pipreqs.init,
+            {'<path>': self.project, '--savepath': None, '--print': False,
+             '--use-local': None, '--force': True, '--proxy': None,
+             '--pypi-server': 'nonexistent'}
+            )
 
     def test_ignored_directory(self):
         """
         Test --ignore parameter
         """
         pipreqs.init(
-            {'<path>': self.project_with_ignore_directory, '--savepath': None, '--print': False,
+            {'<path>': self.project_with_ignore_directory, '--savepath': None, 
-                      '--use-local': None, '--force': True,
+                      '--print': False, '--use-local': None, '--force': True,
-                      '--proxy':None,
+                      '--proxy':None, '--pypi-server':None,
-                      '--pypi-server':None,
                       '--ignore':'.ignored_dir,.ignore_second',
                       '--diff': None,
                       '--clean': None,
-                      '--dynamic': None
+                      '--mode': None
              }
         )
         with open(os.path.join(self.project_with_ignore_directory, "requirements.txt"), "r") as f:
@@ -182,18 +217,17 @@ class TestPipreqs(unittest.TestCase):
             for item in ['click', 'getpass']:
                 self.assertFalse(item.lower() in data)
 
-    def test_dynamic_version_all_scheme(self):
+    def test_dynamic_version_no_pin_scheme(self):
         """
-        Test --dynamic=all
+        Test --mode=no-pin
         """
         pipreqs.init(
-            {'<path>': self.project_with_ignore_directory, '--savepath': None, '--print': False,
+            {'<path>': self.project_with_ignore_directory, '--savepath': None, 
-             '--use-local': None, '--force': True,
+             '--print': False, '--use-local': None, '--force': True,
-             '--proxy': None,
+             '--proxy': None, '--pypi-server': None,
-             '--pypi-server': None,
              '--diff': None,
              '--clean': None,
-             '--dynamic': 'all'
+             '--mode': 'no-pin'
              }
         )
         with open(os.path.join(self.project_with_ignore_directory, "requirements.txt"), "r") as f:
@@ -201,9 +235,9 @@ class TestPipreqs(unittest.TestCase):
             for item in ['beautifulsoup4', 'boto']:
                 self.assertTrue(item.lower() in data)
 
-    def test_dynamic_version_micro_scheme(self):
+    def test_dynamic_version_gt_scheme(self):
         """
-        Test --dynamic=micro
+        Test --mode=gt
         """
         pipreqs.init(
             {'<path>': self.project_with_ignore_directory, '--savepath': None, '--print': False,
@@ -212,18 +246,19 @@ class TestPipreqs(unittest.TestCase):
              '--pypi-server': None,
              '--diff': None,
              '--clean': None,
-             '--dynamic': 'micro'
+             '--mode': 'gt'
              }
         )
         with open(os.path.join(self.project_with_ignore_directory, "requirements.txt"), "r") as f:
             data = f.readlines()
             for item in data:
-                asterisk = item.strip().split(".")[2]
+                symbol = '>='
-                self.assertEqual(asterisk, "*",)
+                message = 'symbol is not in item'
+                self.assertIn(symbol, item, message)
 
-    def test_dynamic_version_minor_scheme(self):
+    def test_dynamic_version_compat_scheme(self):
         """
-        Test --dynamic=minor
+        Test --mode=compat
         """
         pipreqs.init(
             {'<path>': self.project_with_ignore_directory, '--savepath': None, '--print': False,
@@ -232,14 +267,60 @@ class TestPipreqs(unittest.TestCase):
              '--pypi-server': None,
              '--diff': None,
              '--clean': None,
-             '--dynamic': 'minor'
+             '--mode': 'compat'
              }
         )
         with open(os.path.join(self.project_with_ignore_directory, "requirements.txt"), "r") as f:
             data = f.readlines()
             for item in data:
-                asterisk = item.strip().split(".")[1]
+                symbol = '~='
-                self.assertEqual(asterisk, "*",)
+                message = 'symbol is not in item'
+                self.assertIn(symbol, item, message)
+
+    def test_clean(self):
+        """
+        Test --clean parameter
+        """
+        pipreqs.init(
+            {'<path>': self.project, '--savepath': None, '--print': False,
+             '--use-local': None, '--force': True, '--proxy': None,
+             '--pypi-server': None, '--diff': None, '--clean': None,
+             '--mode': None}
+            )
+        assert os.path.exists(self.requirements_path) == 1
+        pipreqs.init(
+            {'<path>': self.project, '--savepath': None, '--print': False,
+            '--use-local': None, '--force': None, '--proxy': None,
+            '--pypi-server': None, '--diff': None,
+            '--clean': self.requirements_path, '--mode': 'non-pin'}
+            )
+        with open(self.requirements_path, "r") as f:
+            data = f.read().lower()
+            for item in self.modules[:-3]:
+                self.assertTrue(item.lower() in data)
+
+    def test_clean_with_imports_to_clean(self):
+        """
+        Test --clean parameter when there are imports to clean
+        """
+        cleaned_module = 'sqlalchemy'
+        pipreqs.init(
+            {'<path>': self.project, '--savepath': None, '--print': False,
+            '--use-local': None, '--force': True, '--proxy': None,
+            '--pypi-server': None, '--diff': None, '--clean': None,
+            '--mode': None}
+            )
+        assert os.path.exists(self.requirements_path) == 1
+        modules_clean = [m for m in self.modules if m != cleaned_module]
+        pipreqs.init(
+            {'<path>': self.project_clean, '--savepath': None,
+            '--print': False, '--use-local': None, '--force': None,
+            '--proxy': None, '--pypi-server': None, '--diff': None,
+            '--clean': self.requirements_path, '--mode': 'non-pin'}
+            )
+        with open(self.requirements_path, "r") as f:
+            data = f.read().lower()
+            self.assertTrue(cleaned_module not in data)
 
     def tearDown(self):
         """

tox.ini

@@ -1,5 +1,5 @@
 [tox]
-envlist = py27, py34, py35, py36, pypy, flake8
+envlist = py27, py34, py35, py36, pypy3, flake8
 
 [testenv]
 setenv =