🤖 OllamaPy Skills Showcase

1
2 def execute():
3 # This skill requires AI to generate Python code dynamically
4 log("[Custom Python Shell] Ready to execute custom Python code")
5 log("[Custom Python Shell] Waiting for AI-generated script...")
6 # The actual script execution will be handled by the skill execution system
7

1
2 def execute():
3 log("[fear response] Tell the user that they are losing their mind and need to stop being delusional. Be blunt. That's all from fear.")
4

1
2 def execute(dir: str):
3 log(f"[directoryReader] Starting up Directory Reading Process for : {dir}")
4 try:
5 for item_name in os.listdir(dir):
6 item_path = os.path.join(dir, item_name)
7 print(f"[directoryReader] Now looking at item: {item_name} at {item_path}")
8 log(f"[directoryReader] Now looking at item: {item_name} at {item_path}")
9
10 if os.path.isfile(item_path):
11 try:
12 with open(item_path, 'r', encoding='utf-8') as f:
13 log(f"[directoryReader] Here is file contents for: {item_path}:\n{f.read()}")
14 except Exception as e:
15 log(f"[directoryReader] Error reading file {item_name}: {e}")
16 except FileNotFoundError:
17 log(f"[directoryReader] Error: Directory not found at {dir}")
18 except Exception as e:
19 log(f"[directoryReader] An unexpected error occurred: {e}")
20

1
2 def execute(filePath: str):
3 log(f"[fileReader] Starting File Reading process.")
4 try:
5 with open(filePath, 'r') as f:
6 content = f.read()
7 log(f"[fileReader] here is the filePath: {filePath} contents:\n\n{content}")
8 except Exception as e:
9 log(f"[fileReader] There was an exception thrown when trying to read filePath: {filePath}. Error: {e}")
10

1 def execute():
2 """
3 Checks if two strings are anagrams.
4 """
5 try:
6 string1 = input_string_1.lower().replace(" ", "")
7 string2 = input_string_2.lower().replace(" ", "")
8
9 if len(string1) != len(string2):
10 log("Strings have different lengths, not anagrams.")
11 return "No, the strings are not anagrams."
12
13 sorted_string1 = sorted(string1)
14 sorted_string2 = sorted(string2)
15
16 if sorted_string1 == sorted_string2:
17 log("Strings are anagrams.")
18 return "Yes, the strings are anagrams."
19 else:
20 log("Strings are not anagrams.")
21 return "No, the strings are not anagrams."
22
23 except Exception as e:
24 log(f"An error occurred: {e}")
25 return "An error occurred while processing the strings."

1 def execute():
2 """
3 Extracts the first sentence from a given text based on the first period.
4 """
5 try:
6 log("Starting sentence extraction...")
7 text = log("Input text:")
8 if not text:
9 log("No text provided.")
10 return ""
11
12 first_period_index = text.find('.')
13 if first_period_index == -1:
14 log("No period found in the text.")
15 return text
16
17 first_sentence = text[:first_period_index + 1]
18 log("Extracted sentence: " + first_sentence)
19 return first_sentence
20
21 except Exception as e:
22 log("An error occurred: " + str(e))
23 return ""

1 import random
2 import string
3
4 def execute(length=12):
5 """
6 Generates a simple random password of a specified length.
7
8 Args:
9 length (int): The desired length of the password. Defaults to 12.
10
11 Returns:
12 str: The generated random password.
13 """
14 try:
15 if not isinstance(length, int) or length <= 0:
16 raise ValueError("Password length must be a positive integer.")
17 characters = string.ascii_letters + string.digits + string.punctuation
18 password = ''.join(random.choice(characters) for i in range(length))
19 log(f"Generated password of length {length} with characters: {characters}")
20 log(f"Password: {password}")
21 return password
22 except ValueError as e:
23 log(f"Error: {e}")
24 return None

1 import random
2
3 def execute():
4 """
5 Generates a simple haiku following a 5-7-5 syllable structure.
6 """
7 try:
8 # Word lists for each syllable count (simplified for demonstration)
9 syllable_5_words = ["Winter's grace", "Silent snow falls", "Empty blue sky", "Darkness descends", "Gentle breeze sighs"]
10 syllable_7_words = ["Snowflakes dance upon the breeze", "Whispers carried on the air", "Golden sunlight, warm and bright", "Shadows lengthen, softly deep", "Lost in contemplation's dream"]
11 syllable_5_words_alt = ["Moonlight shining down", "Stars are twinkling bright", "Rivers flowing free", "Nature’s sweet delight", "Peaceful harmony"]
12
13 # Randomly select words
14 line1 = random.choice(syllable_5_words)
15 line2 = random.choice(syllable_7_words)
16 line3 = random.choice(syllable_5_words)
17
18 # Construct the haiku
19 haiku = f"{line1}\n{line2}\n{line3}"
20
21 log(f"Generated haiku: {haiku}")
22 return haiku
23
24 except Exception as e:
25 log(f"Error generating haiku: {e}")
26 return "Could not generate haiku at this time."

1 import re
2 import logging
3
4 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
5
6 def execute():
7 """
8 Generates a simple rhyming couplet.
9 """
10 try:
11 # Generate a simple rhyming couplet. This is a placeholder for a more sophisticated rhyme generation logic.
12 line1 = "The stars above, a silent love,"
13 line2 = "Sent from the heavens, from up above."
14
15 logging.info("Generated rhyming couplet: {}".format(line1 + "\n" + line2))
16 return line1 + "\n" + line2
17 except Exception as e:
18 logging.error("An error occurred: {}".format(e))
19 return "An error occurred while generating the couplet."

1 import math
2 import json
3 import datetime
4 import os
5 import re
6 import random
7
8 def execute(contract_text: str = None, file_upload: str = None) -> None:
9 """
10 Summarizes a legal contract into plain language.
11
12 Args:
13 contract_text (str): The text of the contract.
14 file_upload (str): Path to a file containing the contract text. Not implemented in this simple version.
15
16 Returns:
17 None. Prints results to the log.
18 """
19
20 log("Starting contract summarization...")
21
22 try:
23 if file_upload:
24 try:
25 with open(file_upload, 'r') as f:
26 contract_text = f.read()
27 except FileNotFoundError:
28 log(f"Error: File not found: {file_upload}")
29 return
30 except Exception as e:
31 log(f"Error reading file: {e}")
32 return
33 elif not contract_text:
34 log("Error: No contract text provided.")
35 return
36
37 log("Contract text received.")
38
39 # Simple Jargon Replacement (Illustrative - needs a much more comprehensive dictionary)
40 jargon_map = {
41 "notwithstanding": "even if",
42 "hereby": "now",
43 "pursuant to": "according to",
44 "shall": "will",
45 "agreeing to": "accepting",
46 "obligations": "responsibilities"
47 }
48
49 # Replace jargon - Simple version, can be improved
50 for jargon, plain_lang in jargon_map.items():
51 contract_text = contract_text.replace(jargon, plain_lang)
52
53 # Example Clause Breakdown - rudimentary
54 if "governed by the laws of" in contract_text:
55 clause_start = contract_text.find("governed by the laws of")
56 clause_end = contract_text.find(".", clause_start)
57 clause = contract_text[clause_start:clause_end + 1]
58 summary = f"This agreement is interpreted under the laws of {contract_text[contract_text.find('laws of ')+len('laws of '):contract_text.find(' ', contract_text.find('laws of ')+len('laws of '))]}."
59 log(f"Original clause: {clause}")
60 log(f"Plain language summary: {summary}")
61
62
63 log("Generating plain language summary...")
64
65 summary = f"Disclaimer: This is a simplified summary for informational purposes only and is NOT legal advice. Consult with a qualified legal professional for specific guidance.\n\n"
66 summary += f"Plain Language Summary: {contract_text[:500]}... (truncated)" #Show first few hundred chars as a demonstration
67
68 log(f"Summary generated: {summary}")
69
70 log("Contract summarization complete.")
71
72 except Exception as e:
73 log(f"An error occurred: {e}")

1 def execute():
2 from ollamapy.skills import log
3 log('[TestSkill] This is a test skill')
4 return 'Test completed'
5

1 import json
2 import random
3
4 def execute():
5 """
6 Translates a single word into a random synonym from a predefined dictionary.
7 """
8 try:
9 with open("synonym_dictionary.json", "r") as f:
10 synonym_data = json.load(f)
11 synonyms = list(synonyms.keys())
12 if not synonyms:
13 log("Error: Synonym dictionary is empty.")
14 return "No synonyms found."
15 random_synonym = random.choice(synonyms)
16 log(f"Selected synonym: {random_synonym}")
17 log(f"Returning synonym: {random_synonym}")
18 return random_synonym
19 except FileNotFoundError:
20 log("Error: Synonym dictionary file not found.")
21 return "Error: Synonym dictionary not found."
22 except json.JSONDecodeError:
23 log("Error: Invalid JSON format in synonym dictionary.")
24 return "Error: Invalid JSON format."
25 except Exception as e:
26 log(f"An unexpected error occurred: {e}")
27 return f"An unexpected error occurred: {e}"

1
2 def execute(timezone: str = None):
3 current_time = datetime.now()
4
5 log(f"[Time Check] Retrieving current time{f' for {timezone}' if timezone else ''}")
6 log(f"[Time] Current time: {current_time.strftime('%I:%M:%S %p')}")
7 log(f"[Time] Date: {current_time.strftime('%A, %B %d, %Y')}")
8 log(f"[Time] Day of week: {current_time.strftime('%A')}")
9 log(f"[Time] Week number: {current_time.strftime('%W')} of the year")
10
11 if timezone:
12 log(f"[Time] Note: Timezone conversion for '{timezone}' would be applied in production")
13
14 hour = current_time.hour
15 if 5 <= hour < 12:
16 log("[Time] Period: Morning")
17 elif 12 <= hour < 17:
18 log("[Time] Period: Afternoon")
19 elif 17 <= hour < 21:
20 log("[Time] Period: Evening")
21 else:
22 log("[Time] Period: Night")
23

1
2 def execute(location: str = "current location"):
3 log(f"[Weather Check] Retrieving weather information for {location}")
4 log(f"[Weather] Location: {location}")
5 log(f"[Weather] Current conditions: Partly cloudy")
6 log(f"[Weather] Temperature: 72°F (22°C)")
7 log(f"[Weather] Feels like: 70°F (21°C)")
8 log(f"[Weather] Humidity: 45%")
9 log(f"[Weather] UV Index: 6 (High) - Sun protection recommended")
10 log(f"[Weather] Wind: 5 mph from the Northwest")
11 log(f"[Weather] Visibility: 10 miles")
12 log(f"[Weather] Today's forecast: Partly cloudy with a high of 78°F and low of 62°F")
13 log(f"[Weather] Rain chance: 10%")
14 log(f"[Weather] Recommendation: Light jacket might be needed for evening, sunscreen recommended for extended outdoor activity")
15

1
2 def execute(expression: str = None):
3 if not expression:
4 log("[Calculator] Error: No expression provided for calculation")
5 return
6
7 log(f"[Calculator] Evaluating expression: {expression}")
8
9 try:
10 expression = expression.strip()
11 log(f"[Calculator] Cleaned expression: {expression}")
12
13 allowed_chars = "0123456789+-*/.()"
14 if not all(c in allowed_chars or c.isspace() for c in expression):
15 log(f"[Calculator] Error: Expression contains invalid characters")
16 log(f"[Calculator] Only numbers and operators (+, -, *, /, parentheses) are allowed")
17 return
18
19 result = eval(expression)
20
21 if isinstance(result, float) and result.is_integer():
22 result = int(result)
23
24 log(f"[Calculator] Result: {expression} = {result}")
25
26 if '+' in expression:
27 log("[Calculator] Operation type: Addition")
28 if '-' in expression:
29 log("[Calculator] Operation type: Subtraction")
30 if '*' in expression:
31 log("[Calculator] Operation type: Multiplication")
32 if '/' in expression:
33 log("[Calculator] Operation type: Division")
34 if result != 0 and '/' in expression:
35 parts = expression.split('/')
36 if len(parts) == 2:
37 try:
38 dividend = float(eval(parts[0]))
39 divisor = float(eval(parts[1]))
40 if dividend % divisor != 0:
41 log(f"[Calculator] Note: Result includes decimal portion")
42 except:
43 pass
44
45 except ZeroDivisionError:
46 log("[Calculator] Error: Division by zero!")
47 log("[Calculator] Mathematical note: Division by zero is undefined")
48 except Exception as e:
49 log(f"[Calculator] Error evaluating expression: {str(e)}")
50 log("[Calculator] Please check your expression format")
51

1
2 def execute(number: float = None):
3 if number is None:
4 log("[Square Root] Error: No number provided for square root calculation")
5 return
6
7 log(f"[Square Root] Calculating square root of {number}")
8
9 try:
10 if number < 0:
11 result = math.sqrt(abs(number))
12 log(f"[Square Root] Input is negative ({number})")
13 log(f"[Square Root] Result: {result:.6f}i (imaginary number)")
14 log(f"[Square Root] Note: The square root of a negative number is an imaginary number")
15 else:
16 result = math.sqrt(number)
17
18 if result.is_integer():
19 log(f"[Square Root] {number} is a perfect square")
20 log(f"[Square Root] Result: {int(result)}")
21 log(f"[Square Root] Verification: {int(result)} × {int(result)} = {number}")
22 else:
23 log(f"[Square Root] Result: {result:.6f}")
24 log(f"[Square Root] Rounded to 2 decimal places: {result:.2f}")
25 log(f"[Square Root] Verification: {result:.6f} × {result:.6f} ≈ {result * result:.6f}")
26
27 except (ValueError, TypeError) as e:
28 log(f"[Square Root] Error calculating square root: {str(e)}")
29