A few weeks ago we started building a Section 16 Data Scraper with the intention of a user being able to enter a CIK and Legato downloading all of the CIK’s Section 16 filings, putting the data together into a spreadsheet, and then being able to start a Section 16 filing by using that data as an entry point. At the end of the last post we had a script that would go out and download all of a singular CIK’s filings. It would also cache any filings it saw so that we were only downloading each individual filing once. This week we are going to continue onward and code a system to scrape useful data out of the filings and put it together into a CSV file.Continue reading "LDC #122: Building a Section 16 Data Scraper,..." »
Friday, February 08. 2019
Friday, February 01. 2019
In our recent blog series discussing Bulk Filings, we used a couple of functions to open and save files, EDACOpenFile and EDACSaveFile. EDAC, or the EDGAR Data Access Class, is a method to interact with EDGAR submission files (as defined by the SEC’s EDGAR Form XML specifications) using Legato. We used EDAC functions to open the submission files and to save them, but EDAC is much more powerful than that. In fact, using the EDAC functions to open and save files is like using a chainsaw to trim a finger nail.Continue reading "LDC #121: An Introduction to the EDGAR Data..." »
Friday, January 25. 2019
Scripts can share a data pool that transcends the life of a script and can therefore be shared by multiple other scripts. There are other methods of storing what we usually call “meta” data, but session data is specifically designed to allow scripts to communicate and share information over time and threads. In this blog, we will explore session data and, as a side discussion, atomic operations.Continue reading "LDC #120: Quickly Sharing and Managing Data..." »
Friday, January 18. 2019
Last week, Dave added to our Bulk Filing script, giving it the ability to add folders and to detect if it’s going over the maximum allowable size from the SEC. This week, we’re going to do our final update on this script and develop its ability to actually file to the SEC. As part of this, we’re going to read back the SEC’s response, determine if it’s an error or a success, and if it’s a success we’ll parse the accession notices out and create an output file that maps the accession number to the original file. This will be very handy in case one of the filings comes back suspended, so you can just look up the accession number of the file to see which one failed.
Continue reading "LDC #119: Bulk Filings Part 4" »
Friday, January 11. 2019
This week we will add a few more features to the bulk filing script. Now that Steve has filled in the code to create a bulk filing we can add the finishing touches to increase performance, check that the filing size is within acceptable limits, and improve the user interface. If you haven’t read the previous posts, here are the links to part one and two.Continue reading "LDC #118: Bulk Filings Part 3" »
Friday, January 04. 2019
If you are not familiar with the term Section 16, Section 16 is a section of the Securities Exchange Act of 1934. In fact, it is section 16 of the act. Section 16 is a way to attempt to mitigate insider trading at companies. It states that any person who is a director of the company, an officer of the company, or a 10% or more beneficial owner, directly or indirectly, they must file Forms 3, 4, and 5. These forms report the level of equity interests whenever a significant change occurs. The terms that you will see referenced here are reporting owner, who is the person of interest here, and issuer, who is the company that in which the reporting owner has equity.
Continue reading "LDC #117: Building a Section 16 Data Scraper,..." »
Thursday, December 27. 2018
When a program presents textual data to a user, it is usually (and hopefully) formatted for easy consumption. As the programmer, understanding how to format strings will make the process of making text presentable significantly faster and smoother. Legato offers an arsenal of tools to make formatting text simple and easy.Continue reading "LDC #116: Getting Text into Shape" »
Friday, December 21. 2018
Last week, Dave went over how to build a basic UI for our Bulk Filing function. This week, we’re expanding that a little bit by adding a “clear all” function to drop all items from the list, a “LIVE” checkbox to mark our submission as a live filing, and a setting to store the previously chosen files to reload if we need to rebuild the filing.
Continue reading "LDC #115: Bulk Filings Part 2" »
Friday, December 14. 2018
For this week’s blog post we are going to start creating a script that will allow users to create a bulk filing for submission to EDGAR. In order to accomplish this we are going to split the blog into three parts: interface, project file processing, and finally the submission creation. Since this is the first blog in the series we are going to start with the interface.
Continue reading "LDC #114: Bulk Filings Part 1" »
Friday, December 07. 2018
Well, may be. When the house of cards you are in begins to fall, wouldn’t it be nice to grab Fluffy the cat, your wallet, phone, and perhaps the car keys? Sometimes a program engages in operations that just cannot be casually aborted without an orderly shutdown. Within Legato, there is a function that help you to just that. This can even apply when a run-time error occurs within your script.Continue reading "LDC #113: Time to Relax and Unwind" »
Friday, November 30. 2018
EDGAR 18.3 was released on October 1st, 2018, and while most of its features are clearly documented, one change that was made seems to have flown under the radar of most people. Starting with this version, all facts created with elements of data type StringItemType are no longer rendered as HTML. Instead they are rendered as plain old strings. While this makes sense (and does close some potential security risks on the SEC’s side), it does effect how people are doing XBRL. For example, most people doing Risk Return taxonomy filings use <B> tags to make their heading items bold. This is no longer possible, because it would come out rendered like:
Continue reading "LDC #112: XBRL Rendering of Strings, Untangled!" »
Friday, November 16. 2018
About a year ago I wrote a blog with the basics of how logs work with GoFiler and Legato. At the end I mentioned that in a future blog post we would talk more about what you can do with log objects. Today we are going to do just that. This blog assumes that you have read the previous blog and understand the basics of the log object.
Continue reading "LDC #111: Back To The Log" »
Friday, November 09. 2018
Sorting pictures can be a time consuming task. Many devices such as cell phones and cameras save pictures with sequential numbers. While this is great because we, as the users, don’t need to name our photos as we take them. However, it does mean that sorting the resulting photos can be time consuming. Luckily we can use Legato to create a basic sorting interface. Unlike many of the scripts in this blog this script is intentionally incomplete. It is a basic framework in which you can build your own image processing. You could edit the script to move all of the images into folders based on the specified names. This would sort the pictures into events or groups. You could also edit the script to run a program on the images with names. You could create thumbnails of named images. There are many possibilities including reworking the script to work with more than images.
Continue reading "LDC #110: Organizing Pictures" »
Friday, November 02. 2018
A term often used in programming that sometimes leaves new developers flummoxed is the “handle”. Handles are a convenient way to identify complex objects like windows, files, etc. In this blog, we’re going to get a “handle” on handles by explaining what they are, how Legato creates and manages them, and what you need to know to properly use them.
Continue reading "LDC #109: Getting a Handle on Handles" »
Friday, October 26. 2018
Writing new scripts can make tasks faster and easier than ever. Back in July, we talked about a script that can map endnotes in an HTML file to the correct page from which they came and move them there. This makes moving the endnotes to their proper positions faster and significantly easier than copy/pasting text around by hand. As we automate functions, we begin to rely on those functions working a specific, predictable way. If our scripts cannot be counted on to work correctly, then we didn’t really make anything faster or easier, did we?
Continue reading "LDC #108: Using DVTs To Create Reliable Software" »