tenseleyflow/shtick / 4ced185

+SHTICK INTENSIVE PERFORMANCE BENCHMARK RESULTS

+Version: OPTIMIZED

+Timestamp: 2025-06-02 22:35:01

+================================================================================

+

+PERFORMANCE SUMMARY (all times in milliseconds)

+--------------------------------------------------------------------------------

+Category                  Operation                                      Mean    Items/sec

+--------------------------------------------------------------------------------

+Batch Operations          Batch add (10 items)                           3.28        3,048

+Batch Operations          Batch add (100 items)                          5.48       18,243

+Batch Operations          Batch add (50 items)                           4.03       12,405

+Batch Operations          Batch add (500 items)                         12.89       38,796

+Conflict Checking         Check 100 new items                            0.14             

+Conflict Checking         Check 50 existing items                        0.02             

+Conflict Checking         Repeated 200 checks                            0.05             

+File Generation           Generate 10 items                              0.52             

+File Generation           Generate 100 items                             1.06             

+File Generation           Generate 500 items                             3.37             

+File Generation           Incremental 10 items (1 change)                1.45             

+File Generation           Incremental 10 items (15 changes)              1.60             

+File Generation           Incremental 100 items (1 change)               2.77             

+File Generation           Incremental 100 items (15 changes)             2.78             

+File Generation           Incremental 500 items (1 change)               7.50             

+File Generation           Incremental 500 items (15 changes)             7.52             

+Key Validation            Validate 10000 keys                            3.07             

+List Operations           List all (2085 items)                          7.95      262,402

+List Operations           List group (250 items)                         0.94      267,013

+Stress Test               100 conflict checks                            0.70             

+Stress Test               Create 9220 items                          90802.51             

+Stress Test               List 9220 items                               38.16             

+

+

+OPTIMIZATION IMPACT

+================================================================================

+This version includes optimizations:

+✓ Pre-compiled regex patterns for key validation

+✓ LRU caching for conflict checks and lookups

+✓ Incremental file generation

+✓ Cached settings and shell detection

+

+

+DETAILED RESULTS

+================================================================================

+

+Batch Operations:

+----------------

+  Batch add (10 items):

+    Mean:   3.281ms

+    Median: 3.268ms

+    Min:    3.253ms

+    Max:    3.316ms

+    StdDev: 0.029ms

+

+  Batch add (100 items):

+    Mean:   5.482ms

+    Median: 5.542ms

+    Min:    5.126ms

+    Max:    5.809ms

+    StdDev: 0.268ms

+

+  Batch add (50 items):

+    Mean:   4.030ms

+    Median: 4.085ms

+    Min:    3.849ms

+    Max:    4.159ms

+    StdDev: 0.133ms

+

+  Batch add (500 items):

+    Mean:   12.888ms

+    Median: 13.003ms

+    Min:    11.317ms

+    Max:    14.222ms

+    StdDev: 1.313ms

+

+

+Conflict Checking:

+-----------------

+  Check 100 new items:

+    Mean:   0.141ms

+    Median: 0.136ms

+    Min:    0.131ms

+    Max:    0.178ms

+    StdDev: 0.014ms

+

+  Check 50 existing items:

+    Mean:   0.019ms

+    Median: 0.019ms

+    Min:    0.019ms

+    Max:    0.020ms

+    StdDev: 0.000ms

+

+  Repeated 200 checks:

+    Mean:   0.050ms

+    Median: 0.050ms

+    Min:    0.049ms

+    Max:    0.051ms

+    StdDev: 0.001ms

+    Notes:  With LRU cache

+

+

+File Generation:

+---------------

+  Generate 10 items:

+    Mean:   0.525ms

+    Median: 0.519ms

+    Min:    0.503ms

+    Max:    0.553ms

+    StdDev: 0.019ms

+

+  Generate 100 items:

+    Mean:   1.059ms

+    Median: 1.055ms

+    Min:    1.052ms

+    Max:    1.069ms

+    StdDev: 0.008ms

+

+  Generate 500 items:

+    Mean:   3.367ms

+    Median: 3.370ms

+    Min:    3.336ms

+    Max:    3.386ms

+    StdDev: 0.019ms

+

+  Incremental 10 items (1 change):

+    Mean:   1.447ms

+    Median: 1.425ms

+    Min:    1.404ms

+    Max:    1.636ms

+    StdDev: 0.070ms

+

+  Incremental 10 items (15 changes):

+    Mean:   1.603ms

+    Median: 1.484ms

+    Min:    1.446ms

+    Max:    1.956ms

+    StdDev: 0.217ms

+

+  Incremental 100 items (1 change):

+    Mean:   2.767ms

+    Median: 2.752ms

+    Min:    2.620ms

+    Max:    3.013ms

+    StdDev: 0.122ms

+

+  Incremental 100 items (15 changes):

+    Mean:   2.780ms

+    Median: 2.702ms

+    Min:    2.626ms

+    Max:    3.187ms

+    StdDev: 0.196ms

+

+  Incremental 500 items (1 change):

+    Mean:   7.498ms

+    Median: 7.466ms

+    Min:    7.402ms

+    Max:    7.677ms

+    StdDev: 0.095ms

+

+  Incremental 500 items (15 changes):

+    Mean:   7.518ms

+    Median: 7.511ms

+    Min:    7.454ms

+    Max:    7.593ms

+    StdDev: 0.049ms

+

+

+Key Validation:

+--------------

+  Validate 10000 keys:

+    Mean:   3.069ms

+    Median: 3.056ms

+    Min:    3.011ms

+    Max:    3.173ms

+    StdDev: 0.063ms

+

+

+List Operations:

+---------------

+  List all (2085 items):

+    Mean:   7.946ms

+    Median: 7.849ms

+    Min:    7.819ms

+    Max:    8.600ms

+    StdDev: 0.230ms

+

+  List group (250 items):

+    Mean:   0.936ms

+    Median: 0.929ms

+    Min:    0.924ms

+    Max:    1.016ms

+    StdDev: 0.018ms

+

+

+Stress Test:

+-----------

+  100 conflict checks:

+    Mean:   0.702ms

+    Median: 0.702ms

+    Min:    0.702ms

+    Max:    0.702ms

+

+  Create 9220 items:

+    Mean:   90802.510ms

+    Median: 90802.510ms

+    Min:    90802.510ms

+    Max:    90802.510ms

+

+  List 9220 items:

+    Mean:   38.159ms

+    Median: 38.159ms

+    Min:    38.159ms

+    Max:    38.159ms

+

+

+

+JSON DATA

+================================================================================

+{

+  "timestamp": "2025-06-02T22:35:01.255554",

+  "version": {

+    "optimized": true,

+    "version": "optimized"

+  },

+  "results": {

+    "Key Validation": {

+      "Validate 10000 keys": {

+        "mean_ms": 3.0689167993841693,

+        "median_ms": 3.0559580045519397,

+        "min_ms": 3.0106670019449666,

+        "max_ms": 3.172625001752749,

+        "stdev_ms": 0.0628303224591866,

+        "total_ms": 15.344583996920846,

+        "notes": null

+      }

+    },

+    "Conflict Checking": {

+      "Check 100 new items": {

+        "mean_ms": 0.14068739692447707,

+        "median_ms": 0.1360414971713908,

+        "min_ms": 0.1306249905610457,

+        "max_ms": 0.17833299352787435,

+        "stdev_ms": 0.014313103476473174,

+        "total_ms": 1.4068739692447707,

+        "notes": null

+      },

+      "Check 50 existing items": {

+        "mean_ms": 0.01943749957717955,

+        "median_ms": 0.019416504073888063,

+        "min_ms": 0.019041995983570814,

+        "max_ms": 0.02012499317061156,

+        "stdev_ms": 0.00031626079491064703,

+        "total_ms": 0.1943749957717955,

+        "notes": null

+      },

+      "Repeated 200 checks": {

+        "mean_ms": 0.04999979864805937,

+        "median_ms": 0.05008299194741994,

+        "min_ms": 0.04874999285675585,

+        "max_ms": 0.05095799861010164,

+        "stdev_ms": 0.0009614696328708676,

+        "total_ms": 0.24999899324029684,

+        "notes": "With LRU cache"

+      }

+    },

+    "List Operations": {

+      "List all (2085 items)": {

+        "mean_ms": 7.945835350255948,

+        "median_ms": 7.84912500239443,

+        "min_ms": 7.818583006155677,

+        "max_ms": 8.59962499816902,

+        "stdev_ms": 0.2298286627253673,

+        "total_ms": 158.91670700511895,

+        "notes": null

+      },

+      "List group (250 items)": {

+        "mean_ms": 0.9362847316272868,

+        "median_ms": 0.9289169975090772,

+        "min_ms": 0.9244999964721501,

+        "max_ms": 1.0164169943891466,

+        "stdev_ms": 0.018272351055007935,

+        "total_ms": 28.0885419488186,

+        "notes": null

+      }

+    },

+    "Batch Operations": {

+      "Batch add (10 items)": {

+        "mean_ms": 3.2811000011861324,

+        "median_ms": 3.268459011451341,

+        "min_ms": 3.252958005759865,

+        "max_ms": 3.3157500001834705,

+        "stdev_ms": 0.029424444786398975,

+        "total_ms": 16.405500005930662,

+        "notes": null

+      },

+      "Batch add (50 items)": {

+        "mean_ms": 4.030483600217849,

+        "median_ms": 4.085459004272707,

+        "min_ms": 3.8490839942824095,

+        "max_ms": 4.158708004979417,

+        "stdev_ms": 0.13261041492843492,

+        "total_ms": 20.152418001089245,

+        "notes": null

+      },

+      "Batch add (100 items)": {

+        "mean_ms": 5.481574995792471,

+        "median_ms": 5.541749997064471,

+        "min_ms": 5.125707990373485,

+        "max_ms": 5.808834001072682,

+        "stdev_ms": 0.26840105575350065,

+        "total_ms": 27.407874978962354,

+        "notes": null

+      },

+      "Batch add (500 items)": {

+        "mean_ms": 12.888050003675744,

+        "median_ms": 13.002833002246916,

+        "min_ms": 11.316834003082477,

+        "max_ms": 14.22179200744722,

+        "stdev_ms": 1.3130454879786941,

+        "total_ms": 64.44025001837872,

+        "notes": null

+      }

+    },

+    "File Generation": {

+      "Generate 10 items": {

+        "mean_ms": 0.5247916036751121,

+        "median_ms": 0.5186670023249462,

+        "min_ms": 0.5029159947298467,

+        "max_ms": 0.5527080065803602,

+        "stdev_ms": 0.018935922427035234,

+        "total_ms": 2.6239580183755606,

+        "notes": null

+      },

+      "Incremental 10 items (1 change)": {

+        "mean_ms": 1.4471749993390404,

+        "median_ms": 1.4251044922275469,

+        "min_ms": 1.4037080109119415,

+        "max_ms": 1.6364590119337663,

+        "stdev_ms": 0.06966702276462376,

+        "total_ms": 14.471749993390404,

+        "notes": null

+      },

+      "Incremental 10 items (15 changes)": {

+        "mean_ms": 1.6028916026698425,

+        "median_ms": 1.4838540009805001,

+        "min_ms": 1.4459999947575852,

+        "max_ms": 1.9561660010367632,

+        "stdev_ms": 0.216529302444539,

+        "total_ms": 16.028916026698425,

+        "notes": null

+      },

+      "Generate 100 items": {

+        "mean_ms": 1.0585084004560485,

+        "median_ms": 1.0547090059844777,

+        "min_ms": 1.051707993610762,

+        "max_ms": 1.0685000015655532,

+        "stdev_ms": 0.007718667723822919,

+        "total_ms": 5.292542002280243,

+        "notes": null

+      },

+      "Incremental 100 items (1 change)": {

+        "mean_ms": 2.7665791974868625,

+        "median_ms": 2.752457992755808,

+        "min_ms": 2.620250001200475,

+        "max_ms": 3.0131669918773696,

+        "stdev_ms": 0.1221665675248218,

+        "total_ms": 27.665791974868625,

+        "notes": null

+      },

+      "Incremental 100 items (15 changes)": {

+        "mean_ms": 2.7801917007309385,

+        "median_ms": 2.701541998249013,

+        "min_ms": 2.626375004183501,

+        "max_ms": 3.1865409982856363,

+        "stdev_ms": 0.19603674872801233,

+        "total_ms": 27.801917007309385,

+        "notes": null

+      },

+      "Generate 500 items": {

+        "mean_ms": 3.3670585980871692,

+        "median_ms": 3.3700420026434585,

+        "min_ms": 3.335874993354082,

+        "max_ms": 3.3855829969979823,

+        "stdev_ms": 0.018825527910995402,

+        "total_ms": 16.835292990435846,

+        "notes": null

+      },

+      "Incremental 500 items (1 change)": {

+        "mean_ms": 7.498041600047145,

+        "median_ms": 7.466208502592053,

+        "min_ms": 7.402292001643218,

+        "max_ms": 7.67700000142213,

+        "stdev_ms": 0.09482651625741934,

+        "total_ms": 74.98041600047145,

+        "notes": null

+      },

+      "Incremental 500 items (15 changes)": {

+        "mean_ms": 7.518220799101982,

+        "median_ms": 7.510957999329548,

+        "min_ms": 7.453875005012378,

+        "max_ms": 7.593207992613316,

+        "stdev_ms": 0.04879667079636522,

+        "total_ms": 75.18220799101982,

+        "notes": null

+      }

+    },

+    "Stress Test": {

+      "Create 9220 items": {

+        "mean_ms": 90802.50991698995,

+        "median_ms": 90802.50991698995,

+        "min_ms": 90802.50991698995,

+        "max_ms": 90802.50991698995,

+        "stdev_ms": 0,

+        "total_ms": 0,

+        "notes": null

+      },

+      "List 9220 items": {

+        "mean_ms": 38.15937500621658,

+        "median_ms": 38.15937500621658,

+        "min_ms": 38.15937500621658,

+        "max_ms": 38.15937500621658,

+        "stdev_ms": 0,

+        "total_ms": 0,

+        "notes": null

+      },

+      "100 conflict checks": {

+        "mean_ms": 0.7022499921731651,

+        "median_ms": 0.7022499921731651,

+        "min_ms": 0.7022499921731651,

+        "max_ms": 0.7022499921731651,

+        "stdev_ms": 0,

+        "total_ms": 0,

+        "notes": null

+      }

+    }

+  }

+}

+SHTICK INTENSIVE PERFORMANCE BENCHMARK RESULTS

+Version: STANDARD

+Timestamp: 2025-06-02 22:36:32

+================================================================================

+

+PERFORMANCE SUMMARY (all times in milliseconds)

+--------------------------------------------------------------------------------

+Category                  Operation                                      Mean    Items/sec

+--------------------------------------------------------------------------------

+Batch Operations          Batch add (10 items)                           0.39       25,535

+Batch Operations          Batch add (100 items)                          1.24       80,535

+Batch Operations          Batch add (50 items)                           0.79       63,479

+Batch Operations          Batch add (500 items)                          4.61      108,525

+Conflict Checking         Check 100 new items                            0.20             

+Conflict Checking         Check 50 existing items                        0.06             

+Conflict Checking         Repeated 200 checks                            0.22             

+File Generation           Generate 10 items                              0.37             

+File Generation           Generate 100 items                             0.66             

+File Generation           Generate 500 items                             1.63             

+List Operations           List all (2085 items)                          7.89      264,109

+List Operations           List group (250 items)                         0.96      259,960

+Stress Test               100 conflict checks                            0.59             

+Stress Test               Create 9220 items                          30126.58             

+Stress Test               List 9220 items                               43.68             

+

+

+OPTIMIZATION IMPACT

+================================================================================

+This is the standard version without optimizations.

+Compare with optimized version to see improvements.

+

+

+DETAILED RESULTS

+================================================================================

+

+Batch Operations:

+----------------

+  Batch add (10 items):

+    Mean:   0.392ms

+    Median: 0.392ms

+    Min:    0.381ms

+    Max:    0.411ms

+    StdDev: 0.012ms

+

+  Batch add (100 items):

+    Mean:   1.242ms

+    Median: 1.185ms

+    Min:    1.106ms

+    Max:    1.583ms

+    StdDev: 0.193ms

+

+  Batch add (50 items):

+    Mean:   0.788ms

+    Median: 0.718ms

+    Min:    0.692ms

+    Max:    1.081ms

+    StdDev: 0.165ms

+

+  Batch add (500 items):

+    Mean:   4.607ms

+    Median: 4.424ms

+    Min:    4.196ms

+    Max:    5.317ms

+    StdDev: 0.432ms

+

+

+Conflict Checking:

+-----------------

+  Check 100 new items:

+    Mean:   0.200ms

+    Median: 0.200ms

+    Min:    0.199ms

+    Max:    0.203ms

+    StdDev: 0.001ms

+

+  Check 50 existing items:

+    Mean:   0.063ms

+    Median: 0.063ms

+    Min:    0.059ms

+    Max:    0.068ms

+    StdDev: 0.002ms

+

+  Repeated 200 checks:

+    Mean:   0.224ms

+    Median: 0.225ms

+    Min:    0.211ms

+    Max:    0.234ms

+    StdDev: 0.008ms

+    Notes:  No cache

+

+

+File Generation:

+---------------

+  Generate 10 items:

+    Mean:   0.366ms

+    Median: 0.363ms

+    Min:    0.362ms

+    Max:    0.377ms

+    StdDev: 0.006ms

+

+  Generate 100 items:

+    Mean:   0.658ms

+    Median: 0.658ms

+    Min:    0.648ms

+    Max:    0.666ms

+    StdDev: 0.007ms

+

+  Generate 500 items:

+    Mean:   1.626ms

+    Median: 1.569ms

+    Min:    1.564ms

+    Max:    1.834ms

+    StdDev: 0.117ms

+

+

+List Operations:

+---------------

+  List all (2085 items):

+    Mean:   7.894ms

+    Median: 7.894ms

+    Min:    7.844ms

+    Max:    7.976ms

+    StdDev: 0.027ms

+

+  List group (250 items):

+    Mean:   0.962ms

+    Median: 0.942ms

+    Min:    0.916ms

+    Max:    1.155ms

+    StdDev: 0.053ms

+

+

+Stress Test:

+-----------

+  100 conflict checks:

+    Mean:   0.588ms

+    Median: 0.588ms

+    Min:    0.588ms

+    Max:    0.588ms

+

+  Create 9220 items:

+    Mean:   30126.585ms

+    Median: 30126.585ms

+    Min:    30126.585ms

+    Max:    30126.585ms

+

+  List 9220 items:

+    Mean:   43.679ms

+    Median: 43.679ms

+    Min:    43.679ms

+    Max:    43.679ms

+

+

+

+JSON DATA

+================================================================================

+{

+  "timestamp": "2025-06-02T22:36:32.468423",

+  "version": {

+    "optimized": false,

+    "version": "standard"

+  },

+  "results": {

+    "Conflict Checking": {

+      "Check 100 new items": {

+        "mean_ms": 0.20017069909954444,

+        "median_ms": 0.19999950018245727,

+        "min_ms": 0.1986250135814771,

+        "max_ms": 0.20287500228732824,

+        "stdev_ms": 0.001198303071867976,

+        "total_ms": 2.0017069909954444,

+        "notes": null

+      },

+      "Check 50 existing items": {

+        "mean_ms": 0.06296659994404763,

+        "median_ms": 0.06306199793471023,

+        "min_ms": 0.05908399180043489,

+        "max_ms": 0.06754200148861855,

+        "stdev_ms": 0.002397014817112448,

+        "total_ms": 0.6296659994404763,

+        "notes": null

+      },

+      "Repeated 200 checks": {

+        "mean_ms": 0.22413360129576176,

+        "median_ms": 0.22483400243800133,

+        "min_ms": 0.21091700182296336,

+        "max_ms": 0.23350000265054405,

+        "stdev_ms": 0.008347898035451077,

+        "total_ms": 1.1206680064788088,

+        "notes": "No cache"

+      }

+    },

+    "List Operations": {

+      "List all (2085 items)": {

+        "mean_ms": 7.894462651893264,

+        "median_ms": 7.8942085019662045,

+        "min_ms": 7.843583007343113,

+        "max_ms": 7.97624999540858,

+        "stdev_ms": 0.02673801806206058,

+        "total_ms": 157.88925303786527,

+        "notes": null

+      },

+      "List group (250 items)": {

+        "mean_ms": 0.9616861333294461,

+        "median_ms": 0.9419584966963157,

+        "min_ms": 0.9160000045085326,

+        "max_ms": 1.154749988927506,

+        "stdev_ms": 0.05308687229361325,

+        "total_ms": 28.850583999883384,

+        "notes": null

+      }

+    },

+    "Batch Operations": {

+      "Batch add (10 items)": {

+        "mean_ms": 0.3916165995178744,

+        "median_ms": 0.3918750007869676,

+        "min_ms": 0.38058299105614424,

+        "max_ms": 0.4108749999431893,

+        "stdev_ms": 0.012071888040208655,

+        "total_ms": 1.958082997589372,

+        "notes": null

+      },

+      "Batch add (50 items)": {

+        "mean_ms": 0.7876666000811383,

+        "median_ms": 0.7182910048868507,

+        "min_ms": 0.6916669954080135,

+        "max_ms": 1.0805000056279823,

+        "stdev_ms": 0.1651712699869281,

+        "total_ms": 3.9383330004056916,

+        "notes": null

+      },

+      "Batch add (100 items)": {

+        "mean_ms": 1.2417002028087154,

+        "median_ms": 1.1849159927805886,

+        "min_ms": 1.1060840042773634,

+        "max_ms": 1.5825840091565624,

+        "stdev_ms": 0.19347071555544915,

+        "total_ms": 6.208501014043577,

+        "notes": null

+      },

+      "Batch add (500 items)": {

+        "mean_ms": 4.607216801377945,

+        "median_ms": 4.423749996931292,

+        "min_ms": 4.19579200388398,

+        "max_ms": 5.317332994309254,

+        "stdev_ms": 0.4317639295676596,

+        "total_ms": 23.036084006889723,

+        "notes": null

+      }

+    },

+    "File Generation": {

+      "Generate 10 items": {

+        "mean_ms": 0.365991800208576,

+        "median_ms": 0.36345800617709756,

+        "min_ms": 0.3617089969338849,

+        "max_ms": 0.37733299541287124,

+        "stdev_ms": 0.00642998838481809,

+        "total_ms": 1.8299590010428801,

+        "notes": null

+      },

+      "Generate 100 items": {

+        "mean_ms": 0.6577169959200546,

+        "median_ms": 0.6584169896086678,

+        "min_ms": 0.6480839947471395,

+        "max_ms": 0.6663340027444065,

+        "stdev_ms": 0.006563855201346565,

+        "total_ms": 3.288584979600273,

+        "notes": null

+      },

+      "Generate 500 items": {

+        "mean_ms": 1.6263416007859632,

+        "median_ms": 1.5686249971622601,

+        "min_ms": 1.5641250065527856,

+        "max_ms": 1.8341660033911467,

+        "stdev_ms": 0.1168928398687913,

+        "total_ms": 8.131708003929816,

+        "notes": null

+      }

+    },

+    "Stress Test": {

+      "Create 9220 items": {

+        "mean_ms": 30126.584999990882,

+        "median_ms": 30126.584999990882,

+        "min_ms": 30126.584999990882,

+        "max_ms": 30126.584999990882,

+        "stdev_ms": 0,

+        "total_ms": 0,

+        "notes": null

+      },

+      "List 9220 items": {

+        "mean_ms": 43.678833011654206,

+        "median_ms": 43.678833011654206,

+        "min_ms": 43.678833011654206,

+        "max_ms": 43.678833011654206,

+        "stdev_ms": 0,

+        "total_ms": 0,

+        "notes": null

+      },

+      "100 conflict checks": {

+        "mean_ms": 0.587959002587013,

+        "median_ms": 0.587959002587013,

+        "min_ms": 0.587959002587013,

+        "max_ms": 0.587959002587013,

+        "stdev_ms": 0,

+        "total_ms": 0,

+        "notes": null

+      }

+    }

+  }

+}

+#!/usr/bin/env python3

+"""

+Intensive shtick performance benchmark

+Tests with larger datasets to show real performance differences

+"""

+

+import time

+import tempfile

+import os

+import sys

+import shutil

+from pathlib import Path

+import statistics

+from datetime import datetime

+import json

+import random

+import string

+

+# Fix import paths

+current_file = Path(__file__).resolve()

+shtick_dir = current_file.parent

+src_dir = shtick_dir.parent

+project_root = src_dir.parent

+

+sys.path.insert(0, str(shtick_dir))

+sys.path.insert(0, str(src_dir))

+sys.path.insert(0, str(project_root))

+

+# Import handling

+SHTICK_AVAILABLE = False

+OPTIMIZED_VERSION = False

+

+try:

+    from shtick import ShtickManager

+    from shtick.config import Config

+    from shtick.generator import Generator

+

+    SHTICK_AVAILABLE = True

+    print("✓ Successfully imported shtick modules")

+

+    if hasattr(ShtickManager, "_get_all_items_by_type"):

+        OPTIMIZED_VERSION = True

+        print("✓ Detected OPTIMIZED version with caching")

+    else:

+        print("✓ Detected STANDARD version without optimizations")

+

+except ImportError:

+    try:

+        import shtick

+        from config import Config

+        from generator import Generator

+

+        class ShtickManager(shtick.ShtickManager):

+            pass

+

+        SHTICK_AVAILABLE = True

+        print("✓ Successfully imported shtick modules directly")

+

+    except ImportError as e:

+        print(f"✗ Could not import shtick modules: {e}")

+        sys.exit(1)

+

+

+def time_operation(func, iterations=10, warmup=2):

+    """Time an operation with proper warmup"""

+    # Warmup

+    for _ in range(warmup):

+        try:

+            func()

+        except:

+            pass

+

+    times = []

+    for _ in range(iterations):

+        start = time.perf_counter()

+        func()

+        end = time.perf_counter()

+        times.append((end - start) * 1000)  # ms

+

+    return {

+        "mean": statistics.mean(times),

+        "median": statistics.median(times),

+        "min": min(times),

+        "max": max(times),

+        "stdev": statistics.stdev(times) if len(times) > 1 else 0,

+        "total": sum(times),

+    }

+

+

+def generate_random_key(prefix="key", length=8):

+    """Generate random key for testing"""

+    suffix = "".join(random.choices(string.ascii_lowercase + string.digits, k=length))

+    return f"{prefix}_{suffix}"

+

+

+class IntensiveBenchmark:

+    """Intensive benchmark suite with larger datasets"""

+

+    def __init__(self):

+        self.temp_dir = None

+        self.config_path = None

+        self.manager = None

+        self.results = {}

+        self.version_info = {

+            "optimized": OPTIMIZED_VERSION,

+            "version": "optimized" if OPTIMIZED_VERSION else "standard",

+        }

+

+    def record_result(self, category, operation, stats, notes=None):

+        """Record benchmark results"""

+        if category not in self.results:

+            self.results[category] = {}

+        self.results[category][operation] = {

+            "mean_ms": stats["mean"],

+            "median_ms": stats["median"],

+            "min_ms": stats["min"],

+            "max_ms": stats["max"],

+            "stdev_ms": stats["stdev"],

+            "total_ms": stats.get("total", 0),

+            "notes": notes,

+        }

+

+    def setup(self):

+        """Setup test environment"""

+        self.temp_dir = tempfile.mkdtemp(prefix="shtick_bench_")

+        self.config_path = os.path.join(self.temp_dir, "config.toml")

+

+        with open(self.config_path, "w") as f:

+            f.write("[persistent]\n")

+

+        # Create manager with debug=False to disable logging

+        self.manager = ShtickManager(config_path=self.config_path, debug=False)

+

+        # Disable all logging during benchmarks

+        import logging

+

+        logging.disable(logging.CRITICAL)

+

+        # Disable auto-generation

+        if hasattr(self.manager, "_save_and_regenerate"):

+            original_save = self.manager._save_and_regenerate

+

+            def minimal_save(affected_groups=None, changed_items=None):

+                config = self.manager._get_config()

+                config.save()

+                if hasattr(self.manager, "_clear_caches"):

+                    self.manager._clear_caches()

+

+            self.manager._original_save_and_regenerate = original_save

+            self.manager._save_and_regenerate = minimal_save

+

+        if hasattr(Config, "clear_all_caches"):

+            Config.clear_all_caches()

+

+        print(f"✓ Test environment created (logging disabled)")

+

+    def cleanup(self):

+        """Cleanup test environment"""

+        if self.temp_dir and os.path.exists(self.temp_dir):

+            shutil.rmtree(self.temp_dir)

+

+        shtick_dir = os.path.expanduser("~/.config/shtick")

+        # Clean up all test groups

+        for prefix in ["bench_", "stress_", "large_"]:

+            for entry in os.listdir(shtick_dir) if os.path.exists(shtick_dir) else []:

+                if entry.startswith(prefix):

+                    path = os.path.join(shtick_dir, entry)

+                    if os.path.isdir(path):

+                        shutil.rmtree(path)

+

+    def benchmark_key_validation_intensive(self):

+        """Test key validation with many keys"""

+        print("\n=== INTENSIVE Key Validation (10,000 keys) ===")

+

+        # Generate test keys

+        valid_keys = [generate_random_key("valid", 12) for _ in range(5000)]

+

+        # Generate various invalid keys

+        invalid_keys = []

+        for i in range(1000):

+            invalid_keys.extend(

+                [

+                    f"{i}invalid",  # starts with number

+                    f"invalid-{i}!",  # invalid character

+                    f"inv alid{i}",  # space

+                    f"-invalid{i}",  # starts with dash

+                    f"inv@lid{i}",  # invalid character

+                ]

+            )

+

+        all_keys = valid_keys + invalid_keys

+        random.shuffle(all_keys)

+

+        # Import validate_key if available

+        try:

+            from shtick.commands import validate_key

+        except:

+            try:

+                from commands import validate_key

+            except:

+                print("Could not import validate_key function")

+                return

+

+        def validate_all():

+            valid_count = 0

+            for key in all_keys:

+                try:

+                    validate_key(key)

+                    valid_count += 1

+                except ValueError:

+                    pass

+            return valid_count

+

+        print(f"Validating {len(all_keys)} keys...")

+        stats = time_operation(validate_all, iterations=5)

+        print(f"Total time for {len(all_keys)} validations: {stats['total']:.1f}ms")

+        print(f"Average per 1000 keys: {stats['mean']/10:.2f}ms")

+        print(f"Per-key validation: {stats['mean']/len(all_keys)*1000:.3f}μs")

+

+        self.record_result("Key Validation", f"Validate {len(all_keys)} keys", stats)

+

+    def benchmark_conflict_checking_intensive(self):

+        """Test conflict checking with large dataset"""

+        print("\n=== INTENSIVE Conflict Checking ===")

+

+        # Create a large dataset across multiple groups

+        print("Creating large dataset...")

+        groups = ["work", "dev", "test", "prod", "staging"]

+        items_per_group = 200

+

+        start = time.perf_counter()

+        for group in groups:

+            for i in range(items_per_group):

+                self.manager.add_alias(

+                    f"{group}_alias_{i}", f"echo {group}_{i}", f"stress_{group}"

+                )

+                if i % 3 == 0:

+                    self.manager.add_env(

+                        f"{group}_var_{i}", f"value_{i}", f"stress_{group}"

+                    )

+        setup_time = (time.perf_counter() - start) * 1000

+

+        total_items = len(groups) * items_per_group * 4 // 3  # aliases + 1/3 env vars

+        print(f"Created {total_items} items in {setup_time:.0f}ms")

+

+        # Test 1: Check for non-existent items (no conflicts)

+        print("\nTesting conflict checks for new items...")

+        check_counter = 0

+

+        def check_new_items():

+            nonlocal check_counter

+            for _ in range(100):

+                key = generate_random_key("newitem", 10)

+                self.manager.check_conflicts("alias", key, "stress_work")

+                check_counter += 1

+

+        stats = time_operation(check_new_items, iterations=10)

+        print(

+            f"Check 100 new items: {stats['mean']:.2f}ms total, {stats['mean']/100:.3f}ms per check"

+        )

+        self.record_result("Conflict Checking", "Check 100 new items", stats)

+

+        # Test 2: Check for existing items (with conflicts)

+        print("\nTesting conflict checks for existing items...")

+

+        def check_existing_items():

+            for group in groups:

+                for i in range(0, 100, 10):  # Check every 10th item

+                    self.manager.check_conflicts(

+                        "alias", f"{group}_alias_{i}", "new_group"

+                    )

+

+        stats = time_operation(check_existing_items, iterations=10)

+        checks = len(groups) * 10

+        print(

+            f"Check {checks} existing items: {stats['mean']:.2f}ms total, {stats['mean']/checks:.3f}ms per check"

+        )

+        self.record_result("Conflict Checking", f"Check {checks} existing items", stats)

+

+        # Test 3: Repeated checks (cache effectiveness)

+        print("\nTesting repeated conflict checks (cache test)...")

+        test_keys = [f"work_alias_{i}" for i in range(20)]

+

+        def check_repeated():

+            for _ in range(10):  # Repeat 10 times

+                for key in test_keys:

+                    self.manager.check_conflicts("alias", key, "test_group")

+

+        # Clear caches if available

+        if hasattr(self.manager, "_clear_caches"):

+            self.manager._clear_caches()

+

+        stats = time_operation(check_repeated, iterations=5)

+        total_checks = 10 * len(test_keys)

+        print(f"Repeated checks ({total_checks} total): {stats['mean']:.2f}ms")

+        print(f"Per-check (with potential caching): {stats['mean']/total_checks:.3f}ms")

+

+        cache_note = "With LRU cache" if OPTIMIZED_VERSION else "No cache"

+        self.record_result(

+            "Conflict Checking",

+            f"Repeated {total_checks} checks",

+            stats,

+            notes=cache_note,

+        )

+

+    def benchmark_list_operations_intensive(self):

+        """Test listing with large datasets"""

+        print("\n=== INTENSIVE List Operations ===")

+

+        # Add more items if needed

+        print("Ensuring large dataset...")

+        groups = ["large_alpha", "large_beta", "large_gamma"]

+        for group in groups:

+            for i in range(100):

+                self.manager.add_alias(f"{group}_alias_{i}", f"echo {i}", group)

+                self.manager.add_env(f"{group}_env_{i}", f"{i}", group)

+                if i % 2 == 0:

+                    self.manager.add_function(

+                        f"{group}_func_{i}", f"echo func {i}", group

+                    )

+

+        # Activate some groups

+        self.manager.activate_group("large_alpha")

+        self.manager.activate_group("large_beta")

+

+        # Test listing all items

+        def list_all():

+            items = self.manager.list_items()

+            return len(items)

+

+        print("\nTesting list all items...")

+        stats = time_operation(list_all, iterations=20)

+        item_count = list_all()

+        print(f"List {item_count} items: {stats['mean']:.2f}ms")

+        print(f"Processing rate: {item_count/stats['mean']*1000:.0f} items/second")

+        self.record_result("List Operations", f"List all ({item_count} items)", stats)

+

+        # Test listing by group

+        def list_large_group():

+            items = self.manager.list_items("large_alpha")

+            return len(items)

+

+        print("\nTesting list single large group...")

+        stats = time_operation(list_large_group, iterations=30)

+        group_count = list_large_group()

+        print(f"List group ({group_count} items): {stats['mean']:.2f}ms")

+        self.record_result(

+            "List Operations", f"List group ({group_count} items)", stats

+        )

+

+    def benchmark_batch_operations(self):

+        """Test batch operations if available"""

+        print("\n=== Batch Operations Performance ===")

+

+        if not hasattr(self.manager, "add_items_batch"):

+            print("Batch operations not available in this version")

+            return

+

+        # Test different batch sizes

+        batch_sizes = [10, 50, 100, 500]

+

+        for size in batch_sizes:

+            print(f"\nTesting batch size: {size}")

+

+            # Create batch

+            def add_batch():

+                items = [

+                    {

+                        "type": "alias",

+                        "group": "batch_test",

+                        "key": generate_random_key(f"batch{size}", 8),

+                        "value": f"echo batch_{i}",

+                    }

+                    for i in range(size)

+                ]

+                self.manager.add_items_batch(items)

+

+            stats = time_operation(add_batch, iterations=5)

+            print(f"Add batch of {size}: {stats['mean']:.2f}ms total")

+            print(f"Per-item in batch: {stats['mean']/size:.3f}ms")

+            print(f"Items/second: {size/stats['mean']*1000:.0f}")

+

+            self.record_result("Batch Operations", f"Batch add ({size} items)", stats)

+

+            # Compare with individual adds

+            def add_individual():

+                for i in range(min(size, 20)):  # Limit to 20 for time

+                    key = generate_random_key(f"indiv{size}", 8)

+                    self.manager.add_alias(key, f"echo {i}", "batch_test")

+

+            stats_indiv = time_operation(add_individual, iterations=3)

+            per_item_indiv = stats_indiv["mean"] / min(size, 20)

+

+            print(f"Individual adds: {per_item_indiv:.3f}ms per item")

+            print(f"Batch speedup: {per_item_indiv/(stats['mean']/size):.1f}x")

+

+    def benchmark_file_generation_intensive(self):

+        """Test file generation with large groups"""

+        print("\n=== INTENSIVE File Generation ===")

+

+        # Re-enable generation

+        if hasattr(self.manager, "_original_save_and_regenerate"):

+            self.manager._save_and_regenerate = (

+                self.manager._original_save_and_regenerate

+            )

+

+        # Create groups of different sizes

+        group_sizes = {"small_gen": 10, "medium_gen": 100, "large_gen": 500}

+

+        generator = Generator()

+        config = self.manager._get_config()

+

+        if hasattr(generator, "set_config_for_shells"):

+            generator.set_config_for_shells(config)

+

+        for group_name, size in group_sizes.items():

+            print(f"\nTesting generation for {group_name} ({size} items)...")

+

+            # Add items

+            for i in range(size):

+                self.manager.add_alias(f"alias_{i}", f"echo {i}", group_name)

+                if i % 3 == 0:

+                    self.manager.add_env(f"var_{i}", f"value_{i}", group_name)

+

+            # Test full generation

+            group = config.get_group(group_name)

+            if group:

+

+                def generate_full():

+                    generator.generate_for_group(group)

+

+                stats = time_operation(generate_full, iterations=5)

+                print(f"Full generation: {stats['mean']:.2f}ms")

+                self.record_result("File Generation", f"Generate {size} items", stats)

+

+                # Test incremental if available

+                if hasattr(generator, "update_group_incrementally"):

+                    # Single change

+                    def incremental_single():

+                        changed_items = {

+                            "added": [],

+                            "modified": [("alias", "alias_0", "echo modified")],

+                            "removed": [],

+                        }

+                        generator.update_group_incrementally(group, changed_items)

+

+                    stats_single = time_operation(incremental_single, iterations=10)

+                    print(f"Incremental (1 change): {stats_single['mean']:.2f}ms")

+                    print(f"Speedup: {stats['mean']/stats_single['mean']:.1f}x")

+

+                    # Multiple changes

+                    def incremental_multi():

+                        changed_items = {

+                            "added": [

+                                ("alias", f"new_{i}", f"echo new_{i}") for i in range(5)

+                            ],

+                            "modified": [

+                                ("alias", f"alias_{i}", f"echo mod_{i}")

+                                for i in range(5)

+                            ],

+                            "removed": [

+                                ("alias", f"alias_{i+5}", f"echo {i+5}")

+                                for i in range(5)

+                            ],

+                        }

+                        generator.update_group_incrementally(group, changed_items)

+

+                    stats_multi = time_operation(incremental_multi, iterations=10)

+                    print(f"Incremental (15 changes): {stats_multi['mean']:.2f}ms")

+                    print(f"Speedup: {stats['mean']/stats_multi['mean']:.1f}x")

+

+                    self.record_result(

+                        "File Generation",

+                        f"Incremental {size} items (1 change)",

+                        stats_single,

+                    )

+                    self.record_result(

+                        "File Generation",

+                        f"Incremental {size} items (15 changes)",

+                        stats_multi,

+                    )

+

+    def benchmark_stress_test(self):

+        """Ultimate stress test - simulate real heavy usage"""

+        print("\n=== STRESS TEST - Simulating Heavy Usage ===")

+

+        print("This simulates a power user with many groups and items...")

+

+        # Setup: Create a realistic large configuration

+        departments = ["engineering", "devops", "data", "security", "qa"]

+        environments = ["dev", "staging", "prod"]

+

+        total_start = time.perf_counter()

+

+        # Create many items

+        print("Creating large configuration...")

+        for dept in departments:

+            for env in environments:

+                group_name = f"{dept}_{env}"

+

+                # Add various items

+                for i in range(50):

+                    self.manager.add_alias(

+                        f"{dept}_cmd_{i}", f"{dept} command {i}", group_name

+                    )

+

+                for i in range(30):

+                    self.manager.add_env(

+                        f"{dept.upper()}_VAR_{i}", f"{env}_{i}", group_name

+                    )

+

+                for i in range(10):

+                    func_body = f"echo Running {dept} function {i} in {env}"

+                    self.manager.add_function(f"{dept}_func_{i}", func_body, group_name)

+

+        creation_time = (time.perf_counter() - total_start) * 1000

+

+        # Now run typical operations

+        print("\nRunning typical operations...")

+

+        # 1. List everything

+        list_start = time.perf_counter()

+        all_items = self.manager.list_items()

+        list_time = (time.perf_counter() - list_start) * 1000

+

+        # 2. Check many conflicts

+        conflict_start = time.perf_counter()

+        for _ in range(100):

+            key = generate_random_key("check", 10)

+            self.manager.check_conflicts("alias", key, "engineering_dev")

+        conflict_time = (time.perf_counter() - conflict_start) * 1000

+

+        # 3. Activate/deactivate groups

+        activate_start = time.perf_counter()

+        for dept in departments:

+            self.manager.activate_group(f"{dept}_dev")

+        for dept in departments[:3]:

+            self.manager.deactivate_group(f"{dept}_dev")

+        activate_time = (time.perf_counter() - activate_start) * 1000

+

+        # 4. Get status

+        status_start = time.perf_counter()

+        status = self.manager.get_status()

+        status_time = (time.perf_counter() - status_start) * 1000

+

+        # Results

+        print(f"\nStress Test Results:")

+        print(f"Total items created: {len(all_items)}")

+        print(

+            f"Creation time: {creation_time:.0f}ms ({len(all_items)/creation_time*1000:.0f} items/sec)"

+        )

+        print(f"List all items: {list_time:.1f}ms")

+        print(

+            f"100 conflict checks: {conflict_time:.1f}ms ({conflict_time/100:.2f}ms each)"

+        )

+        print(f"Group operations: {activate_time:.1f}ms")

+        print(f"Status check: {status_time:.1f}ms")

+

+        self.record_result(

+            "Stress Test",

+            f"Create {len(all_items)} items",

+            {

+                "mean": creation_time,

+                "median": creation_time,

+                "min": creation_time,

+                "max": creation_time,

+                "stdev": 0,

+            },

+        )

+        self.record_result(

+            "Stress Test",

+            f"List {len(all_items)} items",

+            {

+                "mean": list_time,

+                "median": list_time,

+                "min": list_time,

+                "max": list_time,

+                "stdev": 0,

+            },

+        )

+        self.record_result(

+            "Stress Test",

+            "100 conflict checks",

+            {

+                "mean": conflict_time,

+                "median": conflict_time,

+                "min": conflict_time,

+                "max": conflict_time,

+                "stdev": 0,

+            },

+        )

+

+    def write_results_to_file(self):

+        """Write comprehensive results"""

+        timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")

+        version_suffix = "opt" if OPTIMIZED_VERSION else "std"

+        filename = f"bench-intensive-{version_suffix}-{timestamp}.out"

+

+        with open(filename, "w") as f:

+            f.write("SHTICK INTENSIVE PERFORMANCE BENCHMARK RESULTS\n")

+            f.write(f"Version: {self.version_info['version'].upper()}\n")

+            f.write(f"Timestamp: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")

+            f.write("=" * 80 + "\n\n")

+

+            # Summary table

+            f.write("PERFORMANCE SUMMARY (all times in milliseconds)\n")

+            f.write("-" * 80 + "\n")

+            f.write(

+                f"{'Category':<25} {'Operation':<40} {'Mean':>10} {'Items/sec':>12}\n"

+            )

+            f.write("-" * 80 + "\n")

+

+            for category, operations in sorted(self.results.items()):

+                for operation, stats in sorted(operations.items()):

+                    # Calculate items/sec if applicable

+                    items_per_sec = ""

+                    if "items)" in operation:

+                        # Extract number from operation name

+                        import re

+

+                        match = re.search(r"(\d+) items", operation)

+                        if match:

+                            item_count = int(match.group(1))

+                            items_per_sec = f"{item_count/stats['mean_ms']*1000:,.0f}"

+

+                    f.write(

+                        f"{category:<25} {operation:<40} {stats['mean_ms']:>10.2f} {items_per_sec:>12}\n"

+                    )

+

+            # Version comparison section

+            f.write("\n\nOPTIMIZATION IMPACT\n")

+            f.write("=" * 80 + "\n")

+

+            if OPTIMIZED_VERSION:

+                f.write("This version includes optimizations:\n")

+                f.write("✓ Pre-compiled regex patterns for key validation\n")

+                f.write("✓ LRU caching for conflict checks and lookups\n")

+                f.write("✓ Incremental file generation\n")

+                f.write("✓ Cached settings and shell detection\n")

+            else:

+                f.write("This is the standard version without optimizations.\n")

+                f.write("Compare with optimized version to see improvements.\n")

+

+            # Detailed results

+            f.write("\n\nDETAILED RESULTS\n")

+            f.write("=" * 80 + "\n")

+

+            for category, operations in sorted(self.results.items()):

+                f.write(f"\n{category}:\n")

+                f.write("-" * len(category) + "\n")

+                for operation, stats in sorted(operations.items()):

+                    f.write(f"  {operation}:\n")

+                    f.write(f"    Mean:   {stats['mean_ms']:.3f}ms\n")

+                    f.write(f"    Median: {stats['median_ms']:.3f}ms\n")

+                    f.write(f"    Min:    {stats['min_ms']:.3f}ms\n")

+                    f.write(f"    Max:    {stats['max_ms']:.3f}ms\n")

+                    if stats["stdev_ms"] > 0:

+                        f.write(f"    StdDev: {stats['stdev_ms']:.3f}ms\n")

+                    if stats.get("notes"):

+                        f.write(f"    Notes:  {stats['notes']}\n")

+                    f.write("\n")

+

+            # JSON for analysis

+            json_data = {

+                "timestamp": datetime.now().isoformat(),

+                "version": self.version_info,

+                "results": self.results,

+            }

+

+            f.write("\n\nJSON DATA\n")

+            f.write("=" * 80 + "\n")

+            f.write(json.dumps(json_data, indent=2))

+

+        print(f"\n✓ Results written to: {filename}")

+        return filename

+

+

+def main():

+    """Run intensive benchmarks"""

+    print("=" * 70)

+    print("SHTICK INTENSIVE PERFORMANCE BENCHMARKS")

+    print(f"Version: {'OPTIMIZED' if OPTIMIZED_VERSION else 'STANDARD'}")

+    print("=" * 70)

+    print("Running with larger datasets to show real performance differences...")

+    print()

+

+    benchmark = IntensiveBenchmark()

+

+    try:

+        benchmark.setup()

+

+        # Run intensive benchmarks

+        benchmark.benchmark_key_validation_intensive()

+        benchmark.benchmark_conflict_checking_intensive()

+        benchmark.benchmark_list_operations_intensive()

+        benchmark.benchmark_batch_operations()

+        benchmark.benchmark_file_generation_intensive()

+        benchmark.benchmark_stress_test()

+

+        # Summary

+        print("\n" + "=" * 70)

+        print("INTENSIVE BENCHMARK COMPLETE")

+        print("=" * 70)

+

+        # Write results

+        output_file = benchmark.write_results_to_file()

+

+        print("\nNext steps:")

+        print("1. Run this on the other branch to compare")

+        print("2. Compare results:")

+        print(f"   diff bench-intensive-std-*.out bench-intensive-opt-*.out")

+        print("3. Look for:")

+        print("   - Conflict checking improvements (caching)")

+        print("   - Batch operation speedups")

+        print("   - File generation improvements (incremental)")

+        print("   - Overall items/second processing rates")

+

+    finally:

+        benchmark.cleanup()

+        print("\n✓ Cleanup complete")

+

+

+if __name__ == "__main__":

+    main()

+✓ Successfully imported shtick modules

+✓ OPTIMIZED version detected

+============================================================

+PERFORMANCE DIAGNOSTICS - OPTIMIZED VERSION

+============================================================

+

+Profiling: Single alias add

+--------------------------------------------------

+Time: 5.63ms

+

+Top 10 time consumers:

+         1695 function calls (1687 primitive calls) in 0.002 seconds

+

+   Ordered by: cumulative time

+   List reduced from 154 to 10 due to restriction <10>

+

+   ncalls  tottime  percall  cumtime  percall filename:lineno(function)

+        1    0.000    0.000    0.002    0.002 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/performanc_diagnostic.py:88(add_single)

+        1    0.000    0.000    0.002    0.002 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/shtick.py:218(add_alias)

+        1    0.000    0.000    0.002    0.002 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/shtick.py:343(_add_item)

+        1    0.000    0.000    0.002    0.002 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/shtick.py:107(_save_and_regenerate)

+        1    0.000    0.000    0.002    0.002 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/generator.py:381(generate_loader)

+       19    0.000    0.000    0.001    0.000 {built-in method io.open}

+        9    0.000    0.000    0.001    0.000 /Users/matthewwolffe/.asdf/installs/python/3.11.6/lib/python3.11/tempfile.py:522(NamedTemporaryFile)

+        1    0.000    0.000    0.001    0.001 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/generator.py:96(generate_for_group)

+        9    0.001    0.000    0.001    0.000 {built-in method posix.replace}

+        9    0.000    0.000    0.001    0.000 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/generator.py:179(_generate_group_file)

+

+

+

+Profiling: Batch add (100 items)

+--------------------------------------------------

+Time: 3.29ms

+

+Top 10 time consumers:

+         15000 function calls (14788 primitive calls) in 0.006 seconds

+

+   Ordered by: cumulative time

+   List reduced from 154 to 10 due to restriction <10>

+

+   ncalls  tottime  percall  cumtime  percall filename:lineno(function)

+        1    0.000    0.000    0.006    0.006 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/performanc_diagnostic.py:97(add_batch)

+        1    0.000    0.000    0.006    0.006 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/shtick.py:441(add_items_batch)

+        1    0.000    0.000    0.004    0.004 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/shtick.py:107(_save_and_regenerate)

+        2    0.000    0.000    0.002    0.001 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/generator.py:96(generate_for_group)

+       18    0.000    0.000    0.002    0.000 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/generator.py:179(_generate_group_file)

+        1    0.000    0.000    0.001    0.001 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/generator.py:381(generate_loader)

+      100    0.000    0.000    0.001    0.000 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/config.py:226(is_group_active)

+      101    0.000    0.000    0.001    0.000 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/config.py:159(load_active_groups)

+       28    0.000    0.000    0.001    0.000 {built-in method io.open}

+        9    0.001    0.000    0.001    0.000 {built-in method posix.replace}

+

+

+

+Profiling: Conflict checking (50 checks)

+--------------------------------------------------

+Time: 0.03ms

+

+Top 10 time consumers:

+         102 function calls in 0.000 seconds

+

+   Ordered by: cumulative time

+

+   ncalls  tottime  percall  cumtime  percall filename:lineno(function)

+        1    0.000    0.000    0.000    0.000 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/performanc_diagnostic.py:111(check_conflicts)

+       50    0.000    0.000    0.000    0.000 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/shtick.py:168(check_conflicts)

+       50    0.000    0.000    0.000    0.000 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/shtick.py:184(<listcomp>)

+        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

+

+

+

+Profiling: List all items

+--------------------------------------------------

+Time: 0.82ms

+

+Top 10 time consumers:

+         6708 function calls in 0.002 seconds

+

+   Ordered by: cumulative time

+   List reduced from 33 to 10 due to restriction <10>

+

+   ncalls  tottime  percall  cumtime  percall filename:lineno(function)

+        1    0.000    0.000    0.002    0.002 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/performanc_diagnostic.py:118(list_all)

+        1    0.000    0.000    0.002    0.002 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/shtick.py:704(list_items)

+      202    0.000    0.000    0.002    0.000 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/config.py:226(is_group_active)

+      202    0.000    0.000    0.002    0.000 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/config.py:159(load_active_groups)

+      202    0.000    0.000    0.001    0.000 /Users/matthewwolffe/Documents/GithubOrgs/tenselyflow/shtickpy/src/shtick/config.py:115(get_active_groups_file)

+      202    0.000    0.000    0.001    0.000 <frozen posixpath>:229(expanduser)

+      404    0.001    0.000    0.001    0.000 {built-in method posix.stat}

+      404    0.000    0.000    0.000    0.000 <frozen os>:674(__getitem__)

+      202    0.000    0.000    0.000    0.000 <frozen genericpath>:16(exists)

+      202    0.000    0.000    0.000    0.000 <frozen genericpath>:53(getmtime)

+

+

+

+============================================================

+OPTIMIZED VERSION SPECIFIC CHECKS

+============================================================

+

+LRU Cache stats:

+  Hits: 49

+  Misses: 1

+  Hit rate: 98.0%