Removing module/packages inter-dependencies

[brupelo]

Below there is a fast analysis of module/packages inter-dependencies:

root
    __init__ ->                 {}
    __main__ ->                 {app}
    app.py ->                   {three, qt, __init__}
    colorutils.py ->            {three}
    connector.py ->             {qt, three, utils, __init__}
    consts.py ->                {}
    io.py ->                    {utils}
    lexers ->                   {}
    pathutils ->                {}
    procutils ->                {three, qt}
    qt ->                       {__init__}
    reutils ->                  {}
    structs ->                  {}
    three ->                    {}
    utils ->                    {}

    widgets
        dialog.py ->            {widgets.helpers}
        droparea.py ->          {}
        editor.py ->            {three, connector, widgets.helpers, qt, __init__}
        eval_console.py ->      {three, app, utils, qt, widgets.helpers}
        filechooser.py ->       {three, structs, consts, widgets.helpers, helpers}
        helpers.py ->           {connector, qt}
        locationlist ->         {three, widgets.helpers, consts, connector, qt, helpers.intent}
        minibuffer ->           {three, app, connector, qt, widgets.helpers}
        misc ->                 {app, qt, widgets.helpers}
        search ->               {three, consts, widgets.helpers, helpers, reutils, qt, widgets.locationlist}
        splitter ->             {consts, widgets.helpers, qt}
        tabs ->                 {consts, three, qt, connector, widgets.droparea, widgets.helpers, helpers}
        window ->               {connector, three, qt, consts, widgets.helpers, widgets.editor, widgets.tab, widgets.splitter, widgets.droparea}

    helpers
        _lexercolorgroups ->    {three}
        actions ->              {three, connector, qt, __init__}
        bookmarks ->            {connector, helpers.actions}
        buffers ->              {connector, app, widgets.helpers}
        build ->                {connector, procutils, pathutils, qt}
        build_annotations ->    {connector, pathutils, helpers.buffers, helpers.styles}
        build_locationlist ->   {connector, pathutils, app, consts, widgets.locationlist}
        confcache ->            {qt, three, helpers.file_monitor}
        editor_search ->        {connector, widgets.editor, widgets, three, qt, __init__, helpers.buffer}
        file_monitor ->         {three, qt, connector}
        file_search ->          {connector, reutils, app, helpers.file_search_plugins, helpers.intent}
        focus_light ->          {connector, app, colorutils, widgets.helpers}
        folding ->              {connector, widgets.editor, qt}
        intent ->               {connector, structs}
        keys ->                 {three, helpers.actions, pathutils}
        lexer ->                {connector, lexers}
        lexercolor ->           {three, connector, colorutils, lexers, helpers._lexercolourgroups, helpers.styles}
        macros ->               {connector}
        margins ->              {connector}
        minimap ->              {connector, widgets.editor, widgets.window, widgets.helpers, three, qt}
        nav_history ->          {app, connector}
        projects ->             {qt, connector, reutils, __init__, helpers.widgets}
        qt_all ->               {}
        qt_doc ->               {}
        quote_surround ->       {connector}
        remote_control ->       {three, connector, app, qt, __init__, helpers.intent}
        script_reload ->        {three, app, connector, qt, helpers.file_monitor}
        session ->              {three, connector, pathutils, widgets.window, widgets.splitter, widgets.tabs, widgets.editor}
        styles ->               {}

Comments:

• System packages or builtin python modules don't count like dependencies in the above analysis

• Less dependencies per module/package is ideal

• Modules with no dependencies (empty set) are perfectly testable in isolation

• If one or more modules from one package share common code think twice whether you want to factor out that code to live in the same package or maybe merging those modules in one file

• If one module from packageA is using code from packageB and it's only used by this module, maybe merge it

• Relative imports are hell... relative imports to parent directories are a symptom of bad package structuring, ie:

   apps
       libs
           lib1.py
           lib2.py
       app1.py
       app2.py
  

  Does it make sense lib1/lib2 using app1/app2 code?

[aurelVZ]

what i exectly need to compile this on my win7 32bit os i have portable py 3.8.2

[brupelo]

You've got the requirements listed here https://github.com/hydrargyrum/eye/blob/master/requirements.in , after that it should run out of the box.

I've found a problem with this project (which has some really great ideas)though), it was the same problem i've faced couple of years ago when I was trying to create my own sublimetext clone and failed miserably :) ... it's based on QScintilla, and while this widget has some goodies it's pretty limiting as it doesn't support properly multiple/selections, ie: try to undo/redo when making multiple selections and you'll see. Other than that, good luck ;)