bycelium / pyflow Goto Github PK
View Code? Open in Web Editor NEWAn open-source tool for visual and modular block programming in python
License: GNU General Public License v3.0
An open-source tool for visual and modular block programming in python
License: GNU General Public License v3.0
Block should be widgets instead of QGraphicsItem.
This would enable several things:
This would reduce the amount of ui code we have to implement are reduce ui bugs.
It just changes the name of the file and the location of the save to be made
We should be able to represent a class with a node where methods are nodes themselves.
Currently, saving and loading a scene removes the outputs because they are not saved. Copy-pasting a code block does not copy its output. Saving and copying should conserve output.
It isn't of much use, and it makes ipyg files obtained from markdown files not very neat.
Hey, great work!!
I couldn't understand how to add chain between new blocks?
Thanks in advance.
Most of the time, in other contexts, text wraps around in markdown (editing mode, not the output). Making it wrap around removes the need for the user to add artificial line breaks (which might be destroyed when the block is resized) or to scroll horizontally to see the whole text being written.
We should be able to rename blocks by double-clicking on the title
The commands:
python -m opencodeblocks
opencodeblocks
should run main.py
Might be solved by replacing main.py by main.py and placing it inside the opencodeblocks folder
Running a cell causes the app to freeze for a few seconds
Could be fixed by running pyqt and the kernel on different threads
When starting the python kernel, the current working directory should be set relative to the path of the file loaded, not relative to the opencodeblocks program.
This means that when doing:
print(open("data.txt").read())
data.txt
should be located next to the .ipyg
file, not next to the opencodeblocks
folder.
We should be able to encapsulate nodes interactions in nodes.
Once #48 is done, we might want to add some visuals, like edges lighting up when execution is transferred and blocks highlighting when blocks are running (multi-thread would look incredible with this)
We should have the choice of either creating a new instance of a node representing a class, or to reuse a already built instance.
Nodes should be in a database allowing to sort them by popularity/benchmark filtered by some contextual tags.
The user should be able to click the run cell button again to cancel a run. The button should show a loading animation when a cell is running
Currently, when copy-pasting, the selection stays on the copied object. It should switch to the pasted object.
We should be able to edit a node color from the UI.
Socket should have a flowtype argument that would modify either the socket color or/and shape.
Currently, to execute a code block, the user needs to modify the code and put the block out of focus. The user should instead be able to execute the code by pressing a "run cell" button.
Currently, errors are displayed in plain white instead of having their proper ANSI color coding as sent by the kernel.
Ideally error tracebacks should be color coded.
This might help:
https://pygments.org/docs/lexers/#lexers-for-python-and-related-languages
https://github.com/marcus-oscarsson/pyqtconsole
Just like in simulink, it would be nice to center and scale the view to see the whole graph when pressing spacebar
Currently the display of Tensorflow loading bars is preceded by a chain of weird symbols and errors are not displayed properly. Switching to another widget (something similar to a console) would be better to display output.
Serialized object don't have default fields. This can be an issue, for example when converting from a less data-rich format such as ipynb.
Currently, when a code block goes out of focus, it loses its undo history which means that pressing Ctrl+Z to undo its code does nothing. Ideally, the undo history should be saved per block. The user should be able to undo on a newly focused block.
We should be able to navigate from block to block using only the keyboard arrows
Executing a cell should trigger other cells depending of the graph.
This should be sequentially at first, in a depth-first or breadth-first manner (this could be a user choice for both before and after cells).
We should be able to:
We should be able to "fork" a node and modify it's behavior with a python code interface in the UI.
We should be able to create a new node from the UI
Currently, when loading a file, the view of the graph defaults to an arbitrary position.
Ideally, saving should also save the current view zoom and position, and loading should modify the view window.
The user should be able to collapse/hide the code part of a code block to only display the output of the block.
A proper code editor needs autocompletion.
This is supported by QScintilla:
https://qscintilla.com/#autocompletion/general_autocompletion
Currently, executing a block while another one is running displays the output of the running block. It should instead display nothing as output and show a loading animation to signal that the block will run when the other one has finished.
After feature/multithreading, this also crashes the application
Only the last Tensorflow loading bar is showed when model.fit is called which means that the epoch number and the previous epochs are not shown
A VSCode extension could be created.
It would open ipynb files with the OpenCodeBlocks interface, save it as ipynb (with all the metadata secretly stored), making the transition between Jupyter and OCB very easy, allowing the collaboration between people using Jupyter and people using OCB.
One issue I see is that for additional blocks, the ipyg-ipynb compatibility isn't easy (in the ipyg->ipynb direction).
Just like the global view, but for selected blocks
The user should be able to group a group of blocks into one block. Running the block should run the sequence of blocks inside it.
A widget block that outputs a variable could be useful.
Examples:
The user should be able to vertically resize the output part of a code block to fully display images and text outputs
The font size of some elements inside code blocks (like strings, or comments) is uncorrect.
Moreover, the default font used (Courier) is ugly. Consolas, Inconsolata or Roboto Mono would look better.
I would recommend Roboto Mono as it is license under the Apache 2 License.
We are also compatible with the Inconsolata license.
A declarative, efficient, and flexible JavaScript library for building user interfaces.
๐ Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. ๐๐๐
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google โค๏ธ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.