penglang 0.1.1__tar.gz

penglang-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 bebeday10
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

penglang-0.1.1/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: penglang
+Version: 0.1.1
+Summary: a nonserious language module for penguins
+Author: bebeday10
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/bebeday10/penglang
+Project-URL: Repository, https://github.com/bebeday10/penglang
+Project-URL: Issues, https://github.com/bebeday10/penglang/issues
+Keywords: language,penguin,nonserious,fun,programming
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# PengLang, that one penguin language
+
+Hello and welcome to **PengLang**, this language is created by *Penguins*™, that's why it's called PengLang because *Penguins*™.  
+
+# Why does this exist
+
+I don't know either. Actually, the *Penguins*™ made it.  
+Ask them.  
+The python snake also helped.  
+Ask them.
+
+# Things you can do
+The main point is:  
+Dancing.
+
+Other usual *Penguin*™ things:
+- saying stuff
+- fishing stuff
+- assigning tasks
+- doing tasks
+
+These are the main things *Penguin*™ can do in order to *Survive*™.  
+Please do these *Things*™.
+
+---
+
+Things penguins might do in a while:
+
+- penguin do over
+- shouting
+- making a *List*™ to keep track of *Things*™
+- making a *Dictionary*™ because language is hard
+- making a variable because **why *not***
+
+These are probable *Things*™.
+
+---
+
+Things penguins would do if they had *Friends*™:
+
+- answering yes-no questions to help *Friends*™
+- doing a penguin noise because **why *not***
+
+---
+
+Errors
+
+- PenguinError: because penguin errorment
+
+
+# This is Python what are you thinking
+
+No it isn't this is a module of Python
+
+# Modules
+
+Here are some modules included in PengLang.
+
+## Pengmath
+
+A basic math module that let's you let *Penguins*™ count because they are *Smart*™.
+
+- addition
+- subtraction
+- multiplication
+- division
+
+## Pengwindow
+
+Make *Windows*™. Add things to *Window*™. Add child *Window*™.
+
+# Conclusion
+
+This is a penguin-made *"""language"""*.

penglang-0.1.1/README.md

@@ -0,0 +1,74 @@
+# PengLang, that one penguin language
+
+Hello and welcome to **PengLang**, this language is created by *Penguins*™, that's why it's called PengLang because *Penguins*™.  
+
+# Why does this exist
+
+I don't know either. Actually, the *Penguins*™ made it.  
+Ask them.  
+The python snake also helped.  
+Ask them.
+
+# Things you can do
+The main point is:  
+Dancing.
+
+Other usual *Penguin*™ things:
+- saying stuff
+- fishing stuff
+- assigning tasks
+- doing tasks
+
+These are the main things *Penguin*™ can do in order to *Survive*™.  
+Please do these *Things*™.
+
+---
+
+Things penguins might do in a while:
+
+- penguin do over
+- shouting
+- making a *List*™ to keep track of *Things*™
+- making a *Dictionary*™ because language is hard
+- making a variable because **why *not***
+
+These are probable *Things*™.
+
+---
+
+Things penguins would do if they had *Friends*™:
+
+- answering yes-no questions to help *Friends*™
+- doing a penguin noise because **why *not***
+
+---
+
+Errors
+
+- PenguinError: because penguin errorment
+
+
+# This is Python what are you thinking
+
+No it isn't this is a module of Python
+
+# Modules
+
+Here are some modules included in PengLang.
+
+## Pengmath
+
+A basic math module that let's you let *Penguins*™ count because they are *Smart*™.
+
+- addition
+- subtraction
+- multiplication
+- division
+
+## Pengwindow
+
+Make *Windows*™. Add things to *Window*™. Add child *Window*™.
+
+# Conclusion
+
+This is a penguin-made *"""language"""*.

penglang-0.1.1/penglang/__init__.py

@@ -0,0 +1,9 @@
+__version__ = "0.1.1"
+
+from .penglang import *
+from .modules import pengwindow, pengmath
+
+SHOW_LOGS = False
+
+if SHOW_LOGS:
+    print(f"PengLang initialized, version {__version__}")

penglang-0.1.1/penglang/modules/__init__.py

@@ -0,0 +1,11 @@
+# __init__.py file for the penglang_language.modules package
+
+__version__ = "0.1.1"
+
+from .pengmath import *
+from .pengwindow import *
+
+SHOWLOGS = False
+
+if SHOWLOGS:
+    print(f"Loaded penglang_language.modules with version {__version__}")

penglang-0.1.1/penglang/modules/pengmath.py

@@ -0,0 +1,83 @@
+# this is the math module for the penguin language, it has functions for addition, subtraction, multiplication, division, etc. that use penguin words instead of python keywords
+from .. import penglang as peng
+
+def penguin_add(a, b, *args, log: bool = False):
+    """
+    add something with addition
+
+    Args:
+        a (int): The first number to add.
+        b (int): The second number to add.
+        *args (int): Additional numbers to add.
+        log (bool, optional): Whether to log the result. Defaults to False.
+
+    Returns:
+        int: The sum of the numbers.
+    """
+    total = a + b
+    for num in args:
+        total += num
+    if log:
+        peng.say(f"Sum: {total}")
+    return total
+
+def penguin_subtract(a, b, *args, log: bool = False):
+    """
+    subtract something with subtraction
+
+    Args:
+        a (int): The first number to subtract.
+        b (int): The second number to subtract.
+        *args (int): Additional numbers to subtract.
+        log (bool, optional): Whether to log the result. Defaults to False.
+
+    Returns:
+        int: The difference of the numbers.
+    """
+    total = a - b
+    for num in args:
+        total -= num
+    if log:
+        peng.say(f"Difference: {total}")
+    return total
+
+def penguin_multiply(a, b, *args, log: bool = False):
+    """
+    multiply something with multiplication
+
+    Args:
+        a (int): The first number to multiply.
+        b (int): The second number to multiply.
+        *args (int): Additional numbers to multiply.
+        log (bool, optional): Whether to log the result. Defaults to False.
+
+    Returns:
+        int: The product of the numbers.
+    """
+    total = a * b
+    for num in args:
+        total *= num
+    if log:
+        peng.say(f"Product: {total}")
+    return total
+
+def penguin_divide(a, b, *args, log: bool = False):
+    """
+    divide something with division
+
+    Args:
+        a (int): The first number to divide.
+        b (int): The second number to divide.
+        *args (int): Additional numbers to divide by.
+        log (bool, optional): Whether to log the result. Defaults to False.
+
+    Returns:
+        float: The quotient of the numbers.
+    """
+    total = a / b
+    for num in args:
+        total /= num
+    if log:
+        peng.say(f"Quotient: {total}")
+    return total
+

penglang-0.1.1/penglang/modules/pengwindow.py

@@ -0,0 +1,158 @@
+import tkinter as tk
+from .. import penglang as peng
+
+def penguin_window(title="Penguin Window", width=400, height=300,color="lightgray", log: bool = False):
+    """
+    add a root window
+
+    Args:
+        title (str, optional): The title of the window. Defaults to "Penguin Window".
+        width (int, optional): The width of the window. Defaults to 400.
+        height (int, optional): The height of the window. Defaults to 300.
+        color (str, optional): The background color of the window. Defaults to "lightgray".
+        log (bool, optional): Whether to log the creation of the window. Defaults to False.
+
+    Returns:
+        tk.Tk: the window object that was created
+    """
+    window = tk.Tk()
+    window.title(title)
+    window.geometry(f"{width}x{height}")
+    window.configure(bg=color)
+    if log:
+     peng.say(f"Created a penguin window with title: {title}, width: {width}, height: {height}")
+    return window
+
+def wait_for_window(target_title, parent, action, log: bool = False, forever_check: bool = False, *action_args, **action_kwargs):
+    """
+    wait for a windows existance, then do the action
+
+    Args:
+        target_title (str): The title of the window to wait for.
+        parent (tk.Tk): The parent window.
+        action (callable): The function to call when the window is found.
+        log (bool, optional): Whether to log the process. Defaults to False.
+        forever_check (bool, optional): Whether to keep checking indefinitely. Defaults to False.
+        *action_args: Positional arguments to pass to the action function.
+        **action_kwargs: Keyword arguments to pass to the action function.
+    """
+    target_window = None
+    for child in parent.winfo_children():
+        if isinstance(child, tk.Toplevel) and child.wm_title() == target_title:
+            target_window = child
+            break
+
+    if target_window == None:
+        parent.after(100, lambda: wait_for_window(target_title, parent, action, log, forever_check, *action_args, **action_kwargs))
+    else:
+        if log:
+            peng.say(f"Found the target window with title: {target_title}")
+        try:
+         action(*action_args, **action_kwargs)
+        except Exception as e:
+            if log:
+                peng.say(f"tried to run the action, but the window closed before it could run.")
+        if forever_check:
+            parent.after(100, lambda: wait_for_window(target_title, parent, action, log, forever_check, *action_args, **action_kwargs))
+
+def penguin_label(window, text="Penguin Label", log: bool = False):
+    """
+    make a label
+
+    Args:
+        window (tk.Tk): The window to add the label to.
+        text (str, optional): The text for the label. Defaults to "Penguin Label".
+        log (bool, optional): Whether to log the creation of the label. Defaults to False.
+
+    Returns:
+        tk.Label: The created label widget.
+    """
+    label = tk.Label(window, text=text)
+    label.pack()
+    if log:
+        peng.say(f"Created a penguin label with text: {text}")
+    return label
+
+def penguin_button(window, text="Penguin Button", command=None, log: bool = False):
+    """
+    make a button
+
+    Args:
+        window (tk.Tk): The window to add the button to.
+        text (str, optional): The text for the button. Defaults to "Penguin Button".
+        command (callable, optional): The function to call when the button is clicked. Defaults to None.
+        log (bool, optional): Whether to log the creation of the button. Defaults to False.
+
+    Returns:
+        tk.Button: The created button widget.
+    """
+    button = tk.Button(window, text=text, command=command)
+    button.pack()
+    if log:
+        peng.say(f"Created a penguin button with text: {text}, command: {command}")
+    return button
+
+def color_widget(widget, color, log: bool = False):
+    widget.configure(bg=color)
+    if log:
+        peng.say(f"Changed the penguin widget color to: {color}")
+
+def penguin_extra_window(title="Penguin Extra Window", width=400, height=300,color="lightgray", log: bool = False): # the problem is you can't add a widget to this window because we don't know if the window exists or not, but we can still create the window and show it!
+    """
+    add an extra window
+
+    Args:
+        title (str, optional): The title of the extra window. Defaults to "Penguin Extra Window".
+        width (int, optional): The width of the extra window. Defaults to 400.
+        height (int, optional): The height of the extra window. Defaults to 300.
+        color (str, optional): The background color of the extra window. Defaults to "lightgray".
+        log (bool, optional): Whether to log the creation of the extra window. Defaults to False.
+
+    Returns:
+        tk.Toplevel: The created extra window.
+
+    Note:
+        This function cannot be assigned to a variable from a button command, for that, use penguin_window_maker instead.
+    """
+    # how do we add a widget once it is created without having to use this function to edit the window
+    # i know we can wait for the widget to make it when the window is created so the other funcs like color_widget can find it, but that is a bit hacky, but it is the best I can do with this language
+    window = tk.Toplevel()
+    window.title(title)
+    window.geometry(f"{width}x{height}")
+    window.configure(bg=color)
+    if log:
+        peng.say(f"Created a penguin extra window with title: {title}, width: {width}, height: {height}")
+    return window
+
+def penguin_window_maker(parent, name, sendfunc,width=400, height=300, log: bool = False):
+    """
+    make a window that's assigned to a dictionary
+
+    Args:
+        parent (tk.Tk): The parent window.
+        name (str): The name of the window.
+        sendfunc (callable): The function to send the window reference.
+        width (int, optional): The width of the window. Defaults to 400.
+        height (int, optional): The height of the window. Defaults to 300.
+        log (bool, optional): Whether to log the creation of the window. Defaults to False.
+    """
+    w = tk.Toplevel(parent)
+    w.title(name)
+    w.geometry(f"{width}x{height}")
+    sendfunc(name, w)
+    if log:
+        peng.say(f"Created a penguin window with name: {name}, sendfunc: {sendfunc}")
+
+def penguin_spacing(window, spacing=10, log: bool = False):
+    """
+    add spacing to all widgets in a window
+
+    Args:
+        window (tk.Toplevel | tk.Tk): The window to add spacing to.
+        spacing (int, optional): The amount of spacing to add. Defaults to 10.
+        log (bool, optional): Whether to log the action. Defaults to False.
+    """
+    for widget in window.winfo_children():
+        widget.pack_configure(padx=spacing, pady=spacing)
+    if log:
+        peng.say(f"Added spacing of {spacing} to all penguin widgets in the window")

penglang-0.1.1/penglang/penglang.py

@@ -0,0 +1,259 @@
+# this is a funny penguin language using python as syntax, but with penguin words instead of python keywords
+"""This is a funny penguin language using python as syntax.
+    This language is not meant to be taken seriously, it's just for fun!
+    You can use this language to write code that looks like it's written by a penguin, but it's still valid python code!
+    things you can do with this language:
+    - say things
+    - make lists and dictionaries
+    - make variables
+    - make functions that do things
+    - make functions that do things if a condition is true"""
+
+def say(message):
+    """
+    This is a task that makes penguins say stuff
+
+    Args:
+        message (Any): the message to say, can be any type, it will be converted to a string before being printed
+    """
+    print(message)
+
+def fish(thing):
+    """
+    fish something (returns item)
+
+    Args:
+        thing (Any): the item to fish out
+
+    Returns:
+        Any: the item that was fished out
+    """
+    return thing # this is a function that does nothing, just for fun
+
+def task(function):
+    """
+    do a task
+
+    Args:
+        function (Callable): the function to execute
+
+    Returns:
+        Any: the result of the function execution
+    """
+    return function # this is a decorator that does nothing, just for fun
+
+def do(function):
+    """
+    does a task
+
+    Args:
+        function (Callable): the function to execute
+    """
+    function()
+
+# what else to add?
+
+def penguin_do_over(iterable):
+    """
+    says each item in the iterable
+
+    Args:
+        iterable (Iterable): the iterable to iterate over
+    """
+    if isinstance(iterable, dict):
+        for key, value in iterable.items():
+            say(f"{key}: {value}")
+    else:
+        for item in iterable:
+            say(item)
+
+def shout(message):
+    """
+    shout a message
+
+    Args:
+        message (Any): the message to shout, can be any type, it will be converted to a string before being printed
+    """
+    str(message) # convert message to string just in case it's not already a string
+    print(message.upper() + "!!!")
+
+# how to make a rhing that makes a list using a function? how about this:
+def penguin_list(*items):
+    """
+    make a list of items
+
+    Args:
+        *items: the items to include in the list
+
+    Returns:
+        list: the list containing the items
+    """
+    return list(items)
+
+def penguin_dict(**kwargs):
+    """
+    make a dictionary
+
+    Args:
+        **kwargs: the key-value pairs for the dictionary
+
+    Returns:
+        dict: the dictionary containing the key-value pairs
+    """
+    return dict(kwargs)
+
+def penguin_variable(name, value):
+    """
+    make a variable
+
+    Args:
+        name (str): the name of the variable
+        value (Any): the value of the variable
+    """
+    globals()[name] = value # how to make a thing that makes a variable? this is a hacky way to do it, but it works! # this doesn't declare the variable though, so anywhere else you want to use it, you have to use the same name as a string, which is not ideal, but it's the best I can do with this language
+
+
+# sadly you can't make statements like if, for, while, etc. in this language, but you can make functions that do things!
+
+def penguin_yesno_question(thing, condition = True, log: bool = False):
+    """
+    ask the penguin a question
+
+    Args:
+        thing (Any): the thing to check
+        condition (Any, optional): the condition to check against. Defaults to True.
+        log (bool, optional): whether to log the result. Defaults to False.
+
+    Returns:
+        bool: True if the condition is met, False otherwise
+    """
+    if thing == condition:
+        if log:
+            say(f"{thing} is {condition}!")
+        return True
+    else:
+        if log:
+            say(f"{thing} is not {condition}!")
+        return False
+    
+# what if we want to make a function that does something if a condition is true? we can use the penguin_yesno_question function for that!
+# do we want to make modules for this language? maybe we can make a module for math functions, a module for string functions, etc. that use penguin words instead of python keywords? that could be fun!
+# what should we make first? maybe a math module? we can make functions for addition, subtraction, multiplication, division, etc. that use penguin words instead of python keywords!
+
+# should we make error messages that are more penguin-like? maybe we can make a function that raises an error with a penguin message instead of a python message? that could be fun!
+class PenguinError(Exception):
+    """
+    the basic penguinerror when you decide it
+
+    Args:
+        Exception (str): the error message to raise
+    """
+    pass
+def penguin_error(type, message):
+    """
+    raise a penguin error
+
+    Args:
+        type (str): the type of error
+        message (str): the error message
+
+    Raises:
+        PenguinError: the penguin error
+    """
+    raise PenguinError(f"{type} - {message}")
+
+# what other fun things can we add to this language? maybe we can make a function that makes a penguin noise? or a function that makes a penguin dance? the possibilities are endless!
+
+def dance(dance_style = "penguin", shouting: bool = False):
+    """
+    make a penguin dance.
+
+    Args:
+        dance_style (str, optional): the style of dance. Defaults to "penguin".
+        shouting (bool, optional): whether the penguin should shout while dancing. Defaults to False.
+    """
+    say(f"The penguin is dancing the {dance_style} dance!")
+    if shouting:
+        shout("Penguin dance!")
+
+def penguin_noise(noise = "penguin", shouting: bool = False, times: int = 1):
+    """
+    make a penguin make a noise.
+
+    Args:
+        noise (str, optional): the noise to make. Defaults to "penguin".
+        shouting (bool, optional): whether the penguin should shout the noise. Defaults to False.
+        times (int, optional): how many times to make the noise. Defaults to 1.
+    """
+    for _ in range(times):
+        say(f"The penguin says: {noise}!")
+        if shouting:
+            shout(f"{noise}!")
+
+# could we make like a tkinter type of module for this language? that would be fun! we could make functions for creating windows, buttons, labels, etc. that use penguin words instead of python keywords! maybe we can call it pengtkinter or something like that!
+# let's call it pengwindow! we can make functions for creating windows, buttons, labels, etc. that use penguin words instead of python keywords! that could be fun!
+# i just did that just now, check it out!
+
+# make a help function
+
+def penguin_help(function):
+    """
+    get help on a function
+
+    Args:
+        function (Callable): the function to get help on
+    """
+    if hasattr(function, "__doc__") and function.__doc__:
+        say(f"here is the help for {function.__name__}:")
+        say(function.__doc__)
+    else:
+        say(f"penguin scoured the depths of the ocean but couldn't find any help for {function.__name__}!")
+
+
+# make a function factory
+# what else can we add to the factory?
+
+def penguin_function_maker(typeofthing, log_: bool = False, **funcargs):
+    """
+    make a function
+
+    Args:
+        typeofthing (str): the type of function to create
+        log_ (bool, optional): whether to log the creation of the function. Defaults to False.
+
+    Returns:
+        Callable: the created function
+    """
+    if log_:
+        say(f"Creating a penguin function of type: {typeofthing} with message: {funcargs.get('message', 'No message provided')}")
+    def inner():
+        if typeofthing == "dance":
+
+            return dance(funcargs.get("dance_style", "penguin"), funcargs.get("shouting", False))
+        elif typeofthing == "noise":
+
+            return penguin_noise(funcargs.get("noise", "penguin"), funcargs.get("shouting", False), funcargs.get("times", 1))
+        elif typeofthing == "shout":
+
+            return shout(funcargs.get("message", "Penguin Shout!"))
+        elif typeofthing == "say":
+
+            return say(funcargs.get("message", "Penguin says something!"))
+        
+        elif typeofthing == "help":
+
+            return penguin_help(funcargs.get("function", lambda: None))
+        
+    return inner
+
+# multi command func
+
+def penguin_multi_command(*commands):
+    """
+    execute multiple commands in sequence
+
+    Args:
+        *commands (Callable): the commands to execute, each command should be a callable
+    """
+    for command in commands:
+        command()

penglang-0.1.1/penglang.egg-info/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: penglang
+Version: 0.1.1
+Summary: a nonserious language module for penguins
+Author: bebeday10
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/bebeday10/penglang
+Project-URL: Repository, https://github.com/bebeday10/penglang
+Project-URL: Issues, https://github.com/bebeday10/penglang/issues
+Keywords: language,penguin,nonserious,fun,programming
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# PengLang, that one penguin language
+
+Hello and welcome to **PengLang**, this language is created by *Penguins*™, that's why it's called PengLang because *Penguins*™.  
+
+# Why does this exist
+
+I don't know either. Actually, the *Penguins*™ made it.  
+Ask them.  
+The python snake also helped.  
+Ask them.
+
+# Things you can do
+The main point is:  
+Dancing.
+
+Other usual *Penguin*™ things:
+- saying stuff
+- fishing stuff
+- assigning tasks
+- doing tasks
+
+These are the main things *Penguin*™ can do in order to *Survive*™.  
+Please do these *Things*™.
+
+---
+
+Things penguins might do in a while:
+
+- penguin do over
+- shouting
+- making a *List*™ to keep track of *Things*™
+- making a *Dictionary*™ because language is hard
+- making a variable because **why *not***
+
+These are probable *Things*™.
+
+---
+
+Things penguins would do if they had *Friends*™:
+
+- answering yes-no questions to help *Friends*™
+- doing a penguin noise because **why *not***
+
+---
+
+Errors
+
+- PenguinError: because penguin errorment
+
+
+# This is Python what are you thinking
+
+No it isn't this is a module of Python
+
+# Modules
+
+Here are some modules included in PengLang.
+
+## Pengmath
+
+A basic math module that let's you let *Penguins*™ count because they are *Smart*™.
+
+- addition
+- subtraction
+- multiplication
+- division
+
+## Pengwindow
+
+Make *Windows*™. Add things to *Window*™. Add child *Window*™.
+
+# Conclusion
+
+This is a penguin-made *"""language"""*.

penglang-0.1.1/penglang.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+penglang/__init__.py
+penglang/penglang.py
+penglang.egg-info/PKG-INFO
+penglang.egg-info/SOURCES.txt
+penglang.egg-info/dependency_links.txt
+penglang.egg-info/top_level.txt
+penglang/modules/__init__.py
+penglang/modules/pengmath.py
+penglang/modules/pengwindow.py

penglang-0.1.1/penglang.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

penglang-0.1.1/penglang.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+penglang

penglang-0.1.1/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "penglang"
+version = "0.1.1"
+description = "a nonserious language module for penguins"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [
+    {name = "bebeday10"}
+]
+license = "MIT"
+keywords = ["language", "penguin", "nonserious", "fun", "programming"]
+
+[project.urls]
+Homepage = "https://github.com/bebeday10/penglang"
+Repository = "https://github.com/bebeday10/penglang"
+Issues = "https://github.com/bebeday10/penglang/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]

penglang-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+