MODULES

[koo1140]

abc
if message has this emoji then its added: "🚀"

[koo1140]

random

random.int(min, max)

• Random number in the range [min, max].
  Example: random.int(1, 10) -> 7

random.bin

• Random float between 0 and 1.
  Example: random.bin() -> 0.4

random.shuffle("text")

• Shuffled version of the input text.
  Example: random.shuffle("hello") -> "lehlo"

random.shuffle(["apple", "pineapple"])

• Shuffled list.
  Example: random.shuffle(["apple", "pineapple"]) -> ["pineapple", "apple"]

random.choice(["pineapple", "apple"])

• Randomly chosen item from the list.
  Example: random.choice(["pineapple", "apple"]) -> "apple"

[Mistium]

[1,10].random <- find a random integer

[0.0,1.0].random <- a random float between 0 and 1

shuffling could be interesting but i also need to make random syntax easier

[koo1140]

ASCII

ASCII.to_binary(char)

• Converts the given character to its ASCII binary representation.
  Example: ASCII.to_binary('A') -> '01000001'

ASCII.to_decimal(binary)

• Converts the given binary string to its ASCII decimal representation.
  Example: ASCII.to_decimal('01000001') -> 65

ASCII.to_character(decimal)

• Converts the given ASCII decimal value to its corresponding character.
  Example: ASCII.to_character(65) -> 'A'

ASCII.to_hexadecimal(char)

• Converts the given character to its ASCII hexadecimal representation.
  Example: ASCII.to_hexadecimal('A') -> '41'

ASCII.to_character_from_hex(hexadecimal)

• Converts the given ASCII hexadecimal value to its corresponding character.
  Example: ASCII.to_character_from_hex('41') -> 'A'

[Mistium]

"A".to("binary") <- convert to binary from text

100001.from("binary") <- convert to text from binary

65.from("unicode") <- convert 65 into a character from a unicode index

(No hexadecimal yet)

[Mistium]

I added

.to("hex")

[koo1140]

Time

Time.current_time()

• Retrieves the current time.
  Example: Time.current_time() -> '2024-02-19 15:30:45'

Time.current_date()

• Retrieves the current date.
  Example: Time.current_date() -> '2024-02-19'

Time.timestamp()

• Generates a timestamp for the current moment.
  Example: Time.timestamp() -> 1645306245

Time.format_time(time_object, format_str)

• Formats the given time object according to the provided format string.
  Example: Time.format_time(datetime.now(), '%Y-%m-%d %H:%M:%S') -> '2024-02-19 15:30:45'

Time.time_difference(start_time, end_time)

• Calculates the time difference between two time objects.
  Example: Time.time_difference(datetime(2024, 2, 19, 15, 30, 0), datetime(2024, 2, 19, 16, 0, 0)) -> '0:30:00'

[Mistium]

timestamp.timestamp("convert-full") <- gets the full date and time

timestamp.timestamp("convert-date") <- gets the current date

timestamp <- variable of the current unicode timestamp

formatting time specially and time differences are something i'll need to think about

[koo1140]

Math Module

math.pi

• A mathematical constant representing the ratio of a circle's circumference to its diameter (approximately 3.14159).

math.e

• A mathematical constant representing the base of the natural logarithm (approximately 2.71828).

math.sqrt(x)

• Returns the square root of x.

math.pow(x, y)

• Returns x raised to the power y.

math.exp(x)

• Returns the exponential of x (e**x).

math.log(x, base)

• Returns the logarithm of x with the specified base. If base is not specified, returns the natural logarithm (base e).

math.sin(x)

• Returns the sine of x (measured in radians).

math.cos(x)

• Returns the cosine of x (measured in radians).

math.tan(x)

• Returns the tangent of x (measured in radians).

math.degrees(x)

• Converts angle x from radians to degrees.

math.radians(x)

• Converts angle x from degrees to radians.

math.ceil(x)

• Returns the ceiling of x, the smallest integer greater than or equal to x.

math.floor(x)

• Returns the floor of x, the largest integer less than or equal to x.

math.factorial(x)

• Returns the factorial of x.

math.gcd(a, b)

• Returns the greatest common divisor of a and b.

math.isclose(a, b, rel_tol=1e-09, abs_tol=0.0)

• Returns True if the values a and b are close to each other, and False otherwise.

math.isinf(x)

• Returns True if x is positive or negative infinity, and False otherwise.

math.isnan(x)

• Returns True if x is a NaN (Not a Number), and False otherwise.

math.trunc(x)

• Returns the truncated integer value of x (the integral part).

[Mistium]

variable: pi

variable: e

value.sqrt <- method to square root a value

value ^ value <- operator to find power of

(exponential does not exist yet)

(logarithm does not exist yet)

value.sin <- method to find sine

value.cos <- method to find cosine

value.cos <- method to find tangent

radians * 57.2958 <- maths to convert radians to degrees

degrees / 57.2958 <- maths to convert degrees to radians

value.ceiling <- round up

value.floor <- round down

(factorial does not exist yet)

(greatest common divisor does not exist yet)

(is close does exists but not as a method and is complex)

if value.abs === "infinity".destr <- check if a value is positive or negative infinity

if value === "NaN".destr <- check if a value is a "NaN"

(truncate does not exist but ill look into it)

[Mistium]

Added .log

[koo1140]

JSON Module

json.dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)

• Serialize obj to a JSON formatted str.
  Example: json.dumps({'key': 'value'}) -> '{"key": "value"}'

json.loads(s, *, encoding=None, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

• Deserialize s to a Python object.
  Example: json.loads('{"key": "value"}') -> {'key': 'value'}

json.dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)

• Serialize obj as a JSON formatted stream to fp (a .write()-supporting file-like object).
  Example: json.dump({'key': 'value'}, open('file.json', 'w'))

json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

• Deserialize fp (a .read()-supporting file-like object containing a JSON document) to a Python object.
  Example: json.load(open('file.json'))

[koo1140]

re Module

re.compile(pattern, flags=0)

• Compiles a regular expression pattern into a regular expression object.
  Example: regex = re.compile(r'\d+')

re.match(pattern, string, flags=0)

• Attempts to match the pattern at the beginning of the string.
  Example: match = re.match(r'hello', 'hello world')

re.search(pattern, string, flags=0)

• Searches for the first occurrence of the pattern in the string.
  Example: match = re.search(r'world', 'hello world')

re.findall(pattern, string, flags=0)

• Returns a list of all non-overlapping matches of the pattern in the string.
  Example: matches = re.findall(r'\d+', 'There are 123 apples and 456 oranges')

re.finditer(pattern, string, flags=0)

• Returns an iterator yielding match objects over all non-overlapping matches of the pattern in the string.
  Example: matches = re.finditer(r'\d+', 'There are 123 apples and 456 oranges')

re.sub(pattern, repl, string, count=0, flags=0)

• Returns a new string with all occurrences of the pattern replaced by the replacement string.
  Example: new_string = re.sub(r'\d+', 'X', 'There are 123 apples and 456 oranges')

re.split(pattern, string, maxsplit=0, flags=0)

• Splits the string by occurrences of the pattern.
  Example: parts = re.split(r'\s+', 'split this string by spaces')

re.IGNORECASE

• Flag to make matching case-insensitive.

re.MULTILINE

• Flag to make ^ and $ match the beginning and end of each line in a multiline string.

re.DOTALL

• Flag to make . match any character, including newline.

re.VERBOSE

• Flag to allow whitespace and comments within the pattern for better readability.