<jupyter_start><jupyter_text>Optimus Example This Notebook is a simple tutorial about DataFrameTransformer, DataFrameAnalyzer and Utilities modules.- DataFrameTransformer is a dedicated module to easily make dataframe transformations. - DataFrameProfiler is a dedicated module to run a basic profile of the dataframe.- DataFrameAnalyzer is a dedicated module to plot and see important features of a spark Dataframe.- Utilities module contains tool classes that support use of DataFrameTransformer and DataFrameAnalyzer modules.   Importing Modules<jupyter_code># Import optimus
import optimus as op<jupyter_output><empty_output><jupyter_text>Instantiation of Utility classThe utility class is a tool class that includes functions to read csv files, setting checkpoint issues (to save or temporally save dataFrames).<jupyter_code># Instance of Utilities class
tools = op.Utilities()<jupyter_output><empty_output><jupyter_text>Reading DataFrame<jupyter_code># Reading dataframe in this case, local file 
# system (hard drive of the pc) is used.

df = tools.read_csv(path="foo.csv", sep=',')<jupyter_output><empty_output><jupyter_text>General view of DataFrame Initially it is a good idea to see a general view of the DataFrame to be analyzed. In the following cell, a basic profile of the DataFrame is shown. This overview presents basic information about the DataFrame, like number of variable it has, how many are missing values and in which column, the types of each varaible, also some statistical information that describes the variable plus a frecuency plot. table that specifies the existing datatypes in each column dataFrame and other features. Also, for this particular case, the table of dataType is shown in order to visualize a sample of column content.<jupyter_code># Instance of profiler class
profiler = op.DataFrameProfiler(df)
profiler.profiler()<jupyter_output><empty_output><jupyter_text>Instantiation of analyzer class But if you want more information for data exploration, Optimus has the DataFrameAnalizer which has several functions for analyzing your dataset. It presents a table that specifies the existing datatypes in each column dataFrame and other features. Also, for this particular case, the table of dataType is shown in order to visualize a sample of column content.<jupyter_code># Instance of analyzer class
analyzer = op.DataFrameAnalyzer(df=df)<jupyter_output><empty_output><jupyter_text>DataFrameAnalizer has a method called columnAnalize. This method can check all rows ofdataFrame and tries to parse each element of each row to determine if the corresponding element is a string or a number. Besides, it can show 20 distinct values of each columnclassified according the possible datatype value, i.e: a number can be a string, so this function can recognize a number in a column of string dataType by trying to parse the string. Also the function can plot numerical or categorical histograms.  General view of DataFrame Initially it is a good idea to see a general view of the DataFrame to be analyzed. In the following cell, the basic results of analyzing the DataFrame are made are shown. Basic results include a table that specifies the existing datatypes in each column dataFrame and other features. Also, for this particular case, the table of dataType is shown in order to visualize a sample of column content.<jupyter_code>analyzer_tables = analyzer.column_analyze(column_list="*", print_type=True, plots=False)<jupyter_output><empty_output><jupyter_text>The results obtained by running the analyzer class, details the presence of special chars, string columns with possible numbers on them and None and empty string values in columns. You can also plot histograms for individual columns using the `plot_hist` function. This is an interesting feature because you are plotting from a Spark Dataframe:<jupyter_code>analyzer.plot_hist("price","numerical")<jupyter_output><empty_output><jupyter_text>Instantiation of DataFrameTransformerDataFrameTransformer is a specialized class to make dataFrame transformations. Transformations are optimized as much as possible to internally used native spark transformation functions.<jupyter_code># Instance of transformer class 
transformer = op.DataFrameTransformer(df)
transformer.show()<jupyter_output>+---+---------+--------------------+---------+--------+-----+----------+--------+
| id|firstName|            lastName|billingId| product|price|     birth|dummyCol|
+---+---------+--------------------+---------+--------+-----+----------+--------+
|  1|     Luis|         Alvarez$$%!|      123|    Cake|   10|1980/07/07|   never|
|  2|    André|              Ampère|      423|    piza|    8|1950/07/08|   gonna|
|  3|    NiELS|          Böhr//((%%|      551|   pizza|    8|1990/07/09|    give|
|  4|     PAUL|              dirac$|      521|   pizza|    8|1954/07/10|     you|
|  5|   Albert|            Einstein|      634|   pizza|    8|1990/07/11|      up|
|  6|  Galileo|             GALiLEI|      672|   arepa|    5|1930/08/12|   never|
|  7|     CaRL|            Ga%%%uss|      323|    taco|    3|1970/07/13|   gonna|
|  8|    David|          H$$$ilbert|      624|taaaccoo|    3|1950/07/14|     let|
|  9| Johannes|              KEPLER|      735|    taco|    3|1920/04/22|     you|
| 10|    JaMES| [...]<jupyter_text>Trimming blanck spaces at beginning and endings of cells dataFrames<jupyter_code># Printing of original dataFrame:
print('Original dataFrame:')
transformer.show(5)

# Triming string blank spaces:
transformer.trim_col("*")

# Printing trimmed dataFrame:
print('Trimmed dataFrame:')
transformer.show(5)<jupyter_output>Original dataFrame:
+---+---------+-----------+---------+-------+-----+----------+--------+
| id|firstName|   lastName|billingId|product|price|     birth|dummyCol|
+---+---------+-----------+---------+-------+-----+----------+--------+
|  1|     Luis|Alvarez$$%!|      123|   Cake|   10|1980/07/07|   never|
|  2|    André|     Ampère|      423|   piza|    8|1950/07/08|   gonna|
|  3|    NiELS| Böhr//((%%|      551|  pizza|    8|1990/07/09|    give|
|  4|     PAUL|     dirac$|      521|  pizza|    8|1954/07/10|     you|
|  5|   Albert|   Einstein|      634|  pizza|    8|1990/07/11|      up|
+---+---------+-----------+---------+-------+-----+----------+--------+
only showing top 5 rows

Trimmed dataFrame:
+---+---------+-----------+---------+-------+-----+----------+--------+
| id|firstName|   lastName|billingId|product|price|     birth|dummyCol|
+---+---------+-----------+---------+-------+-----+----------+--------+
|  1|     Luis|Alvarez$$%!|      123|   Cake|   10|1980/07/07|   never|
[...]<jupyter_text>Removing especial chars and accents:<jupyter_code># Printing of original dataFrame:
print('Original dataFrame:')
transformer.show(5)

# Remove special chars:
transformer.remove_special_chars("*").clear_accents("*")

# This can also be done by passing a Regex if you want something more personalized

#####################################################################

#transformer.remove_special_chars_regex("*",'[^\w\s]').clear_accents("*")

#####################################################################

# Printing trimmed dataFrame:
print('Removing special chars and accents dataFrame:')
transformer.show(5)<jupyter_output>Original dataFrame:
+---+---------+-----------+---------+-------+-----+----------+--------+
| id|firstName|   lastName|billingId|product|price|     birth|dummyCol|
+---+---------+-----------+---------+-------+-----+----------+--------+
|  1|     Luis|Alvarez$$%!|      123|   Cake|   10|1980/07/07|   never|
|  2|    André|     Ampère|      423|   piza|    8|1950/07/08|   gonna|
|  3|    NiELS| Böhr//((%%|      551|  pizza|    8|1990/07/09|    give|
|  4|     PAUL|     dirac$|      521|  pizza|    8|1954/07/10|     you|
|  5|   Albert|   Einstein|      634|  pizza|    8|1990/07/11|      up|
+---+---------+-----------+---------+-------+-----+----------+--------+
only showing top 5 rows

Removing special chars and accents dataFrame:
+---+---------+--------+---------+-------+-----+--------+--------+
| id|firstName|lastName|billingId|product|price|   birth|dummyCol|
+---+---------+--------+---------+-------+-----+--------+--------+
|  1|     Luis| Alvarez|      123|   Cake|   10|19800707|   [...]<jupyter_text>Drop dummy column<jupyter_code># Printing of original dataFrame:
print('Original dataFrame:')
transformer.show(5)

# Droping a column:
transformer.drop_col("dummyCol")

# Printing trimmed dataFrame:
print('Dataframe without dummy column:')
transformer.show(5)<jupyter_output>Original dataFrame:
+---+---------+--------+---------+-------+-----+--------+--------+
| id|firstName|lastName|billingId|product|price|   birth|dummyCol|
+---+---------+--------+---------+-------+-----+--------+--------+
|  1|     Luis| Alvarez|      123|   Cake|   10|19800707|   never|
|  2|    Andre|  Ampere|      423|   piza|    8|19500708|   gonna|
|  3|    NiELS|    Bohr|      551|  pizza|    8|19900709|    give|
|  4|     PAUL|   dirac|      521|  pizza|    8|19540710|     you|
|  5|   Albert|Einstein|      634|  pizza|    8|19900711|      up|
+---+---------+--------+---------+-------+-----+--------+--------+
only showing top 5 rows

Dataframe without dummy column:
+---+---------+--------+---------+-------+-----+--------+
| id|firstName|lastName|billingId|product|price|   birth|
+---+---------+--------+---------+-------+-----+--------+
|  1|     Luis| Alvarez|      123|   Cake|   10|19800707|
|  2|    Andre|  Ampere|      423|   piza|    8|19500708|
|  3|    NiELS|    Bohr|      [...]<jupyter_text>Setting all letters to lowerCase<jupyter_code># Printing of original dataFrame:
print('Original dataFrame:')
transformer.show(5)

print('Setting all letters to lowerCase:')
transformer.lower_case("*")
transformer.show(5)<jupyter_output>Original dataFrame:
+---+---------+--------+---------+-------+-----+--------+
| id|firstName|lastName|billingId|product|price|   birth|
+---+---------+--------+---------+-------+-----+--------+
|  1|     Luis| Alvarez|      123|   Cake|   10|19800707|
|  2|    Andre|  Ampere|      423|   piza|    8|19500708|
|  3|    NiELS|    Bohr|      551|  pizza|    8|19900709|
|  4|     PAUL|   dirac|      521|  pizza|    8|19540710|
|  5|   Albert|Einstein|      634|  pizza|    8|19900711|
+---+---------+--------+---------+-------+-----+--------+
only showing top 5 rows

Setting all letters to lowerCase:
+---+---------+--------+---------+-------+-----+--------+
| id|firstName|lastName|billingId|product|price|   birth|
+---+---------+--------+---------+-------+-----+--------+
|  1|     luis| alvarez|      123|   cake|   10|19800707|
|  2|    andre|  ampere|      423|   piza|    8|19500708|
|  3|    niels|    bohr|      551|  pizza|    8|19900709|
|  4|     paul|   dirac|      521|  pizza|    8|195[...]<jupyter_text>Date Transformation (Format of date is changed)<jupyter_code># Printing of original dataFrame:
print('Original dataFrame:')
transformer.show(5)

# Priting the new date format:
print('Dataframe without dummy column:')
transformer.date_transform("birth", "yyyyMMdd", "dd-MM-YYYY") \
           .show(5)<jupyter_output>Original dataFrame:
+---+---------+--------+---------+-------+-----+--------+
| id|firstName|lastName|billingId|product|price|   birth|
+---+---------+--------+---------+-------+-----+--------+
|  1|     luis| alvarez|      123|   cake|   10|19800707|
|  2|    andre|  ampere|      423|   piza|    8|19500708|
|  3|    niels|    bohr|      551|  pizza|    8|19900709|
|  4|     paul|   dirac|      521|  pizza|    8|19540710|
|  5|   albert|einstein|      634|  pizza|    8|19900711|
+---+---------+--------+---------+-------+-----+--------+
only showing top 5 rows

Dataframe without dummy column:
+---+---------+--------+---------+-------+-----+----------+
| id|firstName|lastName|billingId|product|price|     birth|
+---+---------+--------+---------+-------+-----+----------+
|  1|     luis| alvarez|      123|   cake|   10|07-07-1980|
|  2|    andre|  ampere|      423|   piza|    8|08-07-1950|
|  3|    niels|    bohr|      551|  pizza|    8|09-07-1990|
|  4|     paul|   dirac|      521|  pizza[...]<jupyter_text>Age calculation from birth date client<jupyter_code># Printing of original dataFrame:
print('Original dataFrame:')
transformer.show(5)

print("Printing calculation of age born date client")
transformer.age_calculate("birth", "dd-MM-YYYY", "clientAge") \
           .show(5)<jupyter_output>Original dataFrame:
+---+---------+--------+---------+-------+-----+----------+
| id|firstName|lastName|billingId|product|price|     birth|
+---+---------+--------+---------+-------+-----+----------+
|  1|     luis| alvarez|      123|   cake|   10|07-07-1980|
|  2|    andre|  ampere|      423|   piza|    8|08-07-1950|
|  3|    niels|    bohr|      551|  pizza|    8|09-07-1990|
|  4|     paul|   dirac|      521|  pizza|    8|10-07-1954|
|  5|   albert|einstein|      634|  pizza|    8|11-07-1990|
+---+---------+--------+---------+-------+-----+----------+
only showing top 5 rows

Printing calculation of age born date client
+---+---------+--------+---------+-------+-----+----------+---------+
| id|firstName|lastName|billingId|product|price|     birth|clientAge|
+---+---------+--------+---------+-------+-----+----------+---------+
|  1|     luis| alvarez|      123|   cake|   10|07-07-1980|  37.7823|
|  2|    andre|  ampere|      423|   piza|    8|08-07-1950|  67.7769|
|  3|    niels|    b[...]<jupyter_text>Renaming columns:<jupyter_code># Printing original dataframe:
print ("Original dataframe")
transformer.show(5)
print ("Renaming some columns of dataFrame")
transformer.rename_col(columns=[("clientAge", "age")])
transformer.show(5)<jupyter_output>Original dataframe
+---+---------+--------+---------+-------+-----+----------+---------+
| id|firstName|lastName|billingId|product|price|     birth|clientAge|
+---+---------+--------+---------+-------+-----+----------+---------+
|  1|     luis| alvarez|      123|   cake|   10|07-07-1980|  37.7823|
|  2|    andre|  ampere|      423|   piza|    8|08-07-1950|  67.7769|
|  3|    niels|    bohr|      551|  pizza|    8|09-07-1990|  27.7796|
|  4|     paul|   dirac|      521|  pizza|    8|10-07-1954|  63.7903|
|  5|   albert|einstein|      634|  pizza|    8|11-07-1990|  27.7796|
+---+---------+--------+---------+-------+-----+----------+---------+
only showing top 5 rows

Renaming some columns of dataFrame
+-------+---+---------+--------+---------+-------+-----+----------+
|    age| id|firstName|lastName|billingId|product|price|     birth|
+-------+---+---------+--------+---------+-------+-----+----------+
|37.7823|  1|     luis| alvarez|      123|   cake|   10|07-07-1980|
|67.7769|  2|    an[...]<jupyter_text>Changing positions of columns dataframe:<jupyter_code># Printing original dataframe:
print ("Original dataframe")
transformer.show(5)

# This action is to move column age, just after the lastName column
print ("age column moved")
transformer.move_col("age", "lastName", "after")
transformer.show(5)<jupyter_output>Original dataframe
+-------+---+---------+--------+---------+-------+-----+----------+
|    age| id|firstName|lastName|billingId|product|price|     birth|
+-------+---+---------+--------+---------+-------+-----+----------+
|37.7823|  1|     luis| alvarez|      123|   cake|   10|07-07-1980|
|67.7769|  2|    andre|  ampere|      423|   piza|    8|08-07-1950|
|27.7796|  3|    niels|    bohr|      551|  pizza|    8|09-07-1990|
|63.7903|  4|     paul|   dirac|      521|  pizza|    8|10-07-1954|
|27.7796|  5|   albert|einstein|      634|  pizza|    8|11-07-1990|
+-------+---+---------+--------+---------+-------+-----+----------+
only showing top 5 rows

age column moved
+---+---------+--------+-------+---------+-------+-----+----------+
| id|firstName|lastName|    age|billingId|product|price|     birth|
+---+---------+--------+-------+---------+-------+-----+----------+
|  1|     luis| alvarez|37.7823|      123|   cake|   10|07-07-1980|
|  2|    andre|  ampere|67.7769|      423|   piza|    8[...]<jupyter_text>Setting a custom transformationThe core of this function is base on the user define function provide from the lambda function provided in the 'func' argument. In this example, cells that are not greater than 20, are multiplied by 20, the rest of them stay intact.<jupyter_code># Printing original dataframe:
print ("Original dataframe")
transformer.show(5)

print (' Multiplying by 20 a number if value in cell is greater than 20:')
# Replacing a number:   
func = lambda cell: (cell * 20) if ((cell != None) and (cell < 20)) else cell
transformer.set_col(['price'], func, 'integer')
transformer.show(20)<jupyter_output>Original dataframe
+---+---------+--------+-------+---------+-------+-----+----------+
| id|firstName|lastName|    age|billingId|product|price|     birth|
+---+---------+--------+-------+---------+-------+-----+----------+
|  1|     luis| alvarez|37.7823|      123|   cake|   10|07-07-1980|
|  2|    andre|  ampere|67.7769|      423|   piza|    8|08-07-1950|
|  3|    niels|    bohr|27.7796|      551|  pizza|    8|09-07-1990|
|  4|     paul|   dirac|63.7903|      521|  pizza|    8|10-07-1954|
|  5|   albert|einstein|27.7796|      634|  pizza|    8|11-07-1990|
+---+---------+--------+-------+---------+-------+-----+----------+
only showing top 5 rows

 Multiplying by 20 a number if value in cell is greater than 20:
+---+------------+--------+--------+---------+----------+-----+----------+
| id|   firstName|lastName|     age|billingId|   product|price|     birth|
+---+------------+--------+--------+---------+----------+-----+----------+
|  1|        luis| alvarez| 37.7823|      123|      ca[...]<jupyter_text>After the transformation process detailed in the previous cells. It is a good idea toanalyze to see if the transformations have solved issued related with special characters, presence of number in column where is to supposed only letters, etc.  Analyzing columns after transformations<jupyter_code># Setting the new dataFrame transformed into the analyzer class
analyzer.set_data_frame(transformer.get_data_frame)
analyzer_table = analyzer.column_analyze("*", print_type=True, plots=True)<jupyter_output><empty_output><jupyter_text>It can be seen from output of the analyzer object, that there are columns with numberseven when ceratin column (for example) is supposed to be only of words or letters. In order to solve this problem, operationInType function of DataFrameTransformer class can be used. operationInType function is useful to make operations in a certain element of one dataType. In this particular example, it can be seen in the last output cell (specifically in 'product' column' that are values that don't fit the rest of the data, the aren't strings but they are numbers or empty strings. operationInType can take care about them and clean the column dataFrame. In the following example, operationInType of function of DataFrameTransformer class is run in order to converts all posible parsables strings to integer into a null or none value. Notice how the 110790 value in productcolumn have been changed, but the rest of the column has remained intact.  Making transformation in the inferred dataType elements of a certains columns<jupyter_code># This function makes changes or transformation in the column specified only in the cells
# that are recognized as the dataType specified. 
transformer.operation_in_type([('product', 'integer', None)]).show()<jupyter_output>+---+---------+--------+-------+---------+-----+----------+--------+
| id|firstName|lastName|    age|billingId|price|     birth| product|
+---+---------+--------+-------+---------+-----+----------+--------+
|  1|     luis| alvarez|37.7823|      123|  200|07-07-1980|    cake|
|  2|    andre|  ampere|67.7769|      423|  160|08-07-1950|    piza|
|  3|    niels|    bohr|27.7796|      551|  160|09-07-1990|   pizza|
|  4|     paul|   dirac|63.7903|      521|  160|10-07-1954|   pizza|
|  5|   albert|einstein|27.7796|      634|  160|11-07-1990|   pizza|
|  6|  galileo| galilei|87.7849|      672|  100|12-08-1930|   arepa|
|  7|     carl|   gauss|47.7876|      323|   60|13-07-1970|    taco|
|  8|    david| hilbert|67.7769|      624|   60|14-07-1950|taaaccoo|
|  9| johannes|  kepler|97.7876|      735|   60|22-04-1920|    taco|
| 10|    james| maxwell|94.7796|      875|   60|12-03-1923|    taco|
+---+---------+--------+-------+---------+-----+----------+--------+
only showing top 10 rows<jupyter_text>Sometimes there a some values that are different but actually are the same. In the productcolumn for example, there are the following values: 'taaaccoo', 'piza'. It can be inferred that the correct value is taco and piza and not the rest of them. This problem canbe solved with the lookup function of the DataFrameTransformer class.  Replacing multiple string values to a single string<jupyter_code>transformer.lookup('product', str_to_replace='taco', list_str=['taaaccoo']) 
transformer.lookup('product', str_to_replace='pizza', list_str=['piza', 'pizzza']) 
transformer.show(20)<jupyter_output>+---+------------+--------+--------+---------+-----+----------+----------+
| id|   firstName|lastName|     age|billingId|price|     birth|   product|
+---+------------+--------+--------+---------+-----+----------+----------+
|  1|        luis| alvarez| 37.7823|      123|  200|07-07-1980|      cake|
|  2|       andre|  ampere| 67.7769|      423|  160|08-07-1950|     pizza|
|  3|       niels|    bohr| 27.7796|      551|  160|09-07-1990|     pizza|
|  4|        paul|   dirac| 63.7903|      521|  160|10-07-1954|     pizza|
|  5|      albert|einstein| 27.7796|      634|  160|11-07-1990|     pizza|
|  6|     galileo| galilei| 87.7849|      672|  100|12-08-1930|     arepa|
|  7|        carl|   gauss| 47.7876|      323|   60|13-07-1970|      taco|
|  8|       david| hilbert| 67.7769|      624|   60|14-07-1950|      taco|
|  9|    johannes|  kepler| 97.7876|      735|   60|22-04-1920|      taco|
| 10|       james| maxwell| 94.7796|      875|   60|12-03-1923|      taco|
| 11|       isaac|  newto[...]<jupyter_text>As can be notice above, string specified in the list argument 'list_str' have beenreplaced to 'str_to_replace' value.   Chaining and lazy evaluation The past transformations were done step by step, but this can be achieved by chainingall operations into one line of code, like the cell below. This way is much more efficient and scalable because it uses all optimization issues from the lazy evaluation approach. All the transformation set before can be done into a single line of code thanks to the chaining feature of the DataFrameTransformer class. This option is a optimal way to make different transformations, because it uses as much as possible all advantages ofthe lazy evaluation approach.<jupyter_code># Instanciate DataFrameTransfomer
transformer = op.DataFrameTransformer(df)
# Get original dataFrame to show it.
transformer.show(20)

# Chaining function transformations
transformer.trim_col("*") \
           .remove_special_chars("*") \
           .clear_accents("*") \
           .lower_case("*") \
           .drop_col("dummyCol") \
           .date_transform("birth", "yyyyMMdd", "dd-MM-YYYY") \
           .age_calculate("birth", "dd-MM-YYYY", "clientAge") \
           .operation_in_type([('product', 'integer', None)]) \
           .lookup('product', str_to_replace='taco', list_str=['taaaccoo']) \
           .lookup('product', str_to_replace='pizza', list_str=['piza', 'pizzza'])  \
        
        
transformer.show(20)<jupyter_output>+---+--------------------+--------------------+---------+----------+-----+----------+--------+
| id|           firstName|            lastName|billingId|   product|price|     birth|dummyCol|
+---+--------------------+--------------------+---------+----------+-----+----------+--------+
|  1|                Luis|         Alvarez$$%!|      123|      Cake|   10|1980/07/07|   never|
|  2|               André|              Ampère|      423|      piza|    8|1950/07/08|   gonna|
|  3|               NiELS|          Böhr//((%%|      551|     pizza|    8|1990/07/09|    give|
|  4|                PAUL|              dirac$|      521|     pizza|    8|1954/07/10|     you|
|  5|              Albert|            Einstein|      634|     pizza|    8|1990/07/11|      up|
|  6|             Galileo|             GALiLEI|      672|     arepa|    5|1930/08/12|   never|
|  7|                CaRL|            Ga%%%uss|      323|      taco|    3|1970/07/13|   gonna|
|  8|               David|          H$$$ilbert|   [...]
{'fraction_non_alphanumeric': 0.24325093511140022, 'fraction_numerical': 0.06623028134656042, 'mean_word_length': 2.0389177168272794, 'pattern_counts': {'":': 0, '<': 73, '<?xml version=': 0, '>': 72, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '21', 'dir': 'jupyter-structured-clean-dedup', 'id': '236682', 'license': 'Apache-2.0', 'n_tokens_mistral': 8842, 'n_tokens_neox': 7868, 'n_words': 2126, 'path': 'examples/Optimus_Main_Example.ipynb', 'repo_name': 'ironmussa/optimus-examples', 'size': '24596'}