chifisource / olive.jl Goto Github PK

With the configuration of new addable directories, there also comes the change to organize them into collapsible folders. Perhaps I add "olive.directories" to the Project.toml?

I want a new icon, for the title -- new title as well -- and for the loading screen on /.

TOML cells need to be added. Just some more build and evaluate functions 📦

I would like for it to be easier to tell which project is linked to each environment, and also make it easier to link them differently. Better system for creating a project and managing it's parametric type. New portion in dir home screen to open the environment as a project inside olivemain

All of these styles should be modular and written inside of the olivesheet.

This will be the first version of /doc. The route is already pretty far along, for 0.0.8 I just want to have a basic API, I will be adding more for 0.0.9

The input data pipeline is a bit messed up, as there are often ParseErrors and different types of issues with the data coming in. What we need to do is figure out what coming in is different from the code, and how we can mitigate it.

This module will hold some default common olive extensions:

• Styler
• Themes
• MOARCells

And more, they will be listed here as I add them.

Alongside this, I will also build new methods to go along with the projects, which will now hold all of the data for a given project, rather than multiple "projects" sharing one Project.

Hi @emmettgb ,

Just came across Olive recently and find it immensely fascinating! I mentioned having some issues in another issue but I find this idea really interesting. What I like about it is a few things from what I have seen:

1. Seems to run on top of Genie! That is really cool as you can now have a live website alongside notebooks running Julia all in one place. Plus, with the capacities built into Genie, you could pull up dashboards alongside live scripts. Really cool stuff
2. Having modules for each script is an interesting concept. I know that Pluto does something similar but Olive seems completely different as you can source a module in real-time or something? Either way, interesting idea -- curious as to how it pans out.
3. Sequential evaluation is nice. This was something that I wish Pluto supported as a mode.
4. I have been noticing the spread of people making custom tomls for projects within the Julia ecosystem. I don't mind that idea but am curious to see how it shakes out as a design decision to have an olive toml. At first glance it seems like a good idea so just curious how it evolves.
5. The fact that you can easily and readily style an Olive notebook to how you want it, is really cool. I like the additional cells you can have as well. It seems you have a really great interface set-up as well.
6. Curious how you encode things within the Julia files as comments. I think that isn't a bad idea at all and in fact, a pretty interesting one I find personally. You could make some really cool literate style documents within Olive like you could in Pluto.
7. Plugins is really exciting. As you know I've been a fan of the ecosystem you have been building and the way you have constructed things seems greatly composable which I am a huge fan of (kudos on the excellent work there).

In short, I am curious as to your thoughts about where Olive sits within the Julia ecosystem. It is almost like a hybrid of Genie, Franklin, and Pluto with influences from Jupyter as well -- the latter especially for your idea of the easy creation of plugins like the Python plugin you demoed. Really gives freedom to the user in a variety of ways! So, what is your opinion on where Olive sits?

I know that Olive is still in rapid development and not on the registry yet when I tried to download it. But I think this is a really great idea. A bit too early for me to try to adopt it or use it for anything in my work/studies yet, but I will be watching closely. Thanks @emmettgb and great work pushing the boundaries of what is possible within Julia!

~ tcp 🌳

Cells which hold all dependencies, default input cells will also send all uses of using up into this cell, which will also be an easy place to add packages.

There should actually be a set of tabs in between the top-bar and the current file, with different open file names inside.

The next step I think I'm going to be taking is moving ENVIRONMENTS into olivecore/open, then having projects be inside of the environments open dict. This will make it easier to customize projects, as then we could have like load(::Project{<:Any}} and things of that nature.

Clicking on "confirm" in the folders does nothing
Prints the following into the terminal:

julia> ┌ Error: handle_connection handler error
│   exception =
│    KeyError: key "" not found
│    Stacktrace:
│     [1] getindex
│       @ ./dict.jl:484 [inlined]
│     [2] document_linker(c::Toolips.Connection)
│       @ ToolipsSession ~/.julia/packages/ToolipsSession/xaxsW/src/ToolipsSession.jl:88
│     [3] (::Toolips.var"#serve#63"{Vector{Toolips.AbstractRoute}, String, Vector{Toolips.ServerExtension}, Vector{Toolips.ServerExtension}})(http::HTTP.Streams.Stream{HTTP.Messages.Request, HTTP.ConnectionPool.Connection{Sockets.TCPSocket}})
│       @ Toolips ~/.julia/packages/Toolips/L3oiV/src/server/Core.jl:1417
│     [4] #invokelatest#2
│       @ ./essentials.jl:816 [inlined]
│     [5] invokelatest
│       @ ./essentials.jl:813 [inlined]
│     [6] handle_connection(f::Function, c::HTTP.ConnectionPool.Connection{Sockets.TCPSocket}, listener::HTTP.Servers.Listener{Nothing, Sockets.TCPServer}, readtimeout::Int64, access_log::Nothing)
│       @ HTTP.Servers ~/.julia/packages/HTTP/z8l0i/src/Servers.jl:447
│     [7] macro expansion
│       @ ~/.julia/packages/HTTP/z8l0i/src/Servers.jl:385 [inlined]
│     [8] (::HTTP.Servers.var"#16#17"{Toolips.var"#serve#63"{Vector{Toolips.AbstractRoute}, String, Vector{Toolips.ServerExtension}, Vector{Toolips.ServerExtension}}, HTTP.Servers.Listener{Nothing, Sockets.TCPServer}, Set{HTTP.ConnectionPool.Connection}, Int64, Nothing, Base.Semaphore, HTTP.ConnectionPool.Connection{Sockets.TCPSocket}})()
│       @ HTTP.Servers ./task.jl:514
└ @ HTTP.Servers ~/.julia/packages/HTTP/z8l0i/src/Servers.jl:461

This is on Linux, on Olive 0.0.8 (main) on julia 1.9rc-1

The home directory is causing far too many issues -- I would like to remove this, olmod, and just instead have dependencies loading into Olive's environment itself. Hopefully this will work and make the dependencies and things work better.

Right now all kinds of stuff is loaded into the top bar, but I would prefer for just settings, cells, and the project explorer to show by default, with the one default extension being dark mode.
Pretty much, we need someone to define how extensions are handled in the first place, likely to be me, and then how they are loaded into the UI. After I get the extensions in OliveCore done, this portion will be really easy to make.

A considerable improvement, mid step between 0.0.8 and 0.1.0. this release will primarily be setting up the last bits of the UI, and convenience before 0.1.0 which will focus more on polish and garbage collection/client management

The biggest step in this regard will be the introduction of directory permissions, module cells, include cells, and conveniences such as cell selection, dragging, and controls.

I want to change the dir<:Any style up a bit -- making them smaller and changing up how the background works.

this is meant for IPy.jl, technically, but it is primarily created as a dependency for this.

So Toolips and ToolipsSession, the portion of dependencies that glues the actual web portion of this project together need an IO update -- all that really needs to be done is outgoing :text Component properties need to have replacements done to them. The same can be said for input, but this is of course the job of ToolipsSession. Overall, this is not difficult to implement, it is just a lot of typing characters.

I would like to have a stacking module system in each window, where modules are added to the tab container as new tabs which can be edited individually. This will be post IPyCells 0.1.1 because I'll need a split ends function.
Anyway this will just make it easier to work with modules and included files in olive.it will be pretty easy I just make a new Project{:module} type, populate it when the cell is ran. The module cell contains cells of its own then I write a string function that turns it into a normal module.
The hardest part of this will be getting cells out of the reader. Will need to find all of the modules and then sort the cells that belong into those modules properly into the modules.

Since Olive can print errors, a cool thing to have would be to
A good thing to have would be to:

1. Click on the filenames in the stacktrace and it opens that file in a pane in Olive, possibly directly on the given line number
2. If the file is already open, just point to the appropriate cell and line number

For some reason, there is some level of variance to the homedirectories on Windows and Linux; I suspect the cause of of this is \ ruining things like directory splits.

clipboard

I want to have a cell clipboard, where cells are stored inside of a Vector under clipboard in the OLIVECORE client data. This cannot go into project data, because the clipboard should be cross - project. I plan to make all sorts of neat reference cells and absolute windows and things. This will be a big change going into 0.1.0, where cells will become

cell selection

Cells will normally be copied with a binding to ctrl + shift + C by default. Paste bindings however will be in the window, just like many other bindings. So on the event someone double clicks a cell, "selection" will be put into the project keys. Once this key exists, double clicking will add to the current selection. We delete the key and populate at as it is used. If the key is there, we select.
The bigger challenge is Cell drag, which I will open an issue for -- this also will need to incorporate selection. All of this will make better cells that are easy to move around and reference.

Project{:reference}?

I am considering making a new type of project, one that sits in reference on the side. I am also planning to have a new environment project type. I might also make the clipboard its own window!

A simple way to get from Vector{Cell} to creating/establishing a Session. (A method that will put Session data into OliveCore)

The creator cell will become the new default cell. I want the setup to go something like this, you use creator cell key bindings to set the cell type. Inside of the cell itself I check for the key input. Have them register cells as hotkeys with buttons for other cells... It'll be pretty neat!

The project explorer should load the file cells (which open the file upon evaluation) for the current project's working directory into the sidebar on the left, along with some other options in a menu that allow for adding of directories and such.

I'll put a bit more here later... Here is a quick note... but this goes along with cell drag and cell clipboards, cell Select is just the part that gets the cells to the clipboard. I think I'm going to create selection cells with custom controls, it will be easy I think I just register cell events with a component modifier !

The Olive Python extension! This will be surprisingly easy to write... I am just putting this here.. it's basically just some build functions, a highlight function, an evaluate function, and a read/write system for Python.

It seems that build is broken by incompatibilities in the dependencies.

The current Olive main branch have calls that does not exist in the Toolips and IpyJL code :

• Toolips.sheet() -> does not exist
• Cell{:md} -> no type abstraction in Cell definition (ctype stores a string : "md" or "code")
• Cell contructor takes a Dict but an Array is passed in the code

You may have forget to commit some changes during development one these packages.

Also, it would be great to register IpyJL for automatic update and installation in the Repl.

I would like to contrinute to the project but it currently cannot start properly in my web browser.

I saw this repository via Logan Kilpatrick and his contributions to the Julia community. Since I loved the idea of this novel notebook format, and given that the project is in pre-release, is it possible to think about parallel-like execution blocks?

The idea is that some scientific situations and code are better represented as parallel blocks (like Simulink block diagrams). The blocks themselves don't need to execute strictly in parallel, but at least have some sort of semaphore in which the execution flow only proceeds once all proceeds.

Thank you so much for the hard work :) I'm loving to read about the project.

In setup, I need to have the downloads for OliveDefaults and icons setup. Also need to add PKG.

I would like for cells to be draggable and droppable into other windows and cells. Doing this is pretty easy, actually... All I want to do is bind this drag button to put the cells onto the clipboard... We give a nice little drag icon. Then we use on on our ComponentModiifer in order to bind the drag event on each cell, this will need to check what position the mouse is in every cell, by id. Pretty easy stuff I think. Set something to follow the mouse, probably. This will be going along with the Cell Clipboard #23

This is meant to be labeled Release ... I digress. 0.1.x will demonstrate basic functionality of Olive. With this will also come a few choice extensions and way to customize such things. As of right now, here is a list of things we need to get there...

• More cell controls; right now there is new, evaluate, and delete -- new needs to be fixed and I need to work a better append system into toolips session.
• Settings overhaul. Many settings will be stored inside of the Project.toml file, and I need to create a loader/saver for that and have such things load into the OliveCore appropriately on startup.
• I would like to be able to add two windows.
• There needs to be an expansion of tabs.
• The start/create functions all need to be worked appropriately to serve things correctly.
• Custom (UI) directories for home, wd, and things of that nature.
• The file cells for the files you are working on can go in the top left of the top-bar.
• A more luxurious interface for working with components of a topbar.
• Syntax highlighting (it's a nightmare)
• Completion of IPyRW (this is really close, read is essentially done I just need to mostly just test it and add write -- the easier of the two. Another thing that might be needed is to
• Pkg/environment cells -- both controls for using ] much like in the REPL and controls for a larger cell that controls the environment.
• The file menu
• Build function for Cell{:dir}, which will make cells for a given directory and then be able to set the children along with having a bumper to go up. All the while this is of course.
• Settings panel
• Progress

This is a lot, but in the grand scope of things isn't too much work -- there are still a lot of small things.

Instead of in-line windowing, I would like to switch the main pages to do more dual tab layout like most text-editors have.

All of the Olive files themselves should be improved with IPyCells written cells -- making it really easy to learn a lot about olive from olive. Also need to finish doc-strings. :)

Need to finish the keymap syntax so i can have the separate bindings a bit annoying, but I digress; everything is annoying. This will be accompanied by icons.

Add command to the save as menu button (the only one that is really missing)

When you create a file in a subdirectory, the directory populates without a returner..

Okay -- so a box over a box IS in fact the best choice when it comes to casting things like syntax highlighting. I will come back to this and explain more, but a prominent example which this will be based on is the password box here, which uses a similar technique with images.

There should be something in the explorer indicating to go back, as well as the current environments and their projects.

0.0.8 Will be the first registered version of Olive, consisting of a working pre-release version of Olive. This release will be a preview of what is to come in 0.1.0, as well as an easy way to iron out any bugs that are expected with a project of this magnitude.

cell types

• :code
• :pkgrepl
• :helprepl
• shell
• olive
• todo
• creator
• module