linguistics-evolution-simulator 0.1.0__tar.gz

linguistics_evolution_simulator-0.1.0/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: linguistics-evolution-simulator
+Version: 0.1.0
+Summary: A small civilisation and language evolution simulator.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+## Features
+This is an attempt at representing linguistic evolution in a human civilisation! It evolves 20 words through 100-year iterations.
+
+The game loop is in main; at the beginning, a "civilisation" is generated with random parameters so as to give it unique words for resources; this might also become a game mechanic in the future. Afterwards, a quantity of words "evolve" depending on the modifiers that randomly selected events produce.
+
+With regards to the string of "plague" messages, this is to ensure that the population doesn't spiral out of control and lead to many word mutations all at once.
+
+
+## AI use declaration
+As I said in the project description, virtually none of the code had AI input; as far as I can remember, all the code was written myself, with AI only acting occasionally as a tool that I use for better-quality brainstorming and planning.
+
+However, there was one major task that I had to rely on AI for guidance, which is the publishing to PyPI step in preparation for shipping. I am personally very inexperienced with the whole project lifecycle, and especially shipping, so I had to rely on it to guide me through this process of packing everything in and replacing some file paths in the source code. In any case, this is good project experience and something that I learned!
+
+
+## Installation
+Install with pipx:
+
+```bash
+pipx install linguistics-evolution-simulator

linguistics_evolution_simulator-0.1.0/linguistics_evolution_simulator/data/civilisation.json

@@ -0,0 +1,74 @@
+{
+    "geographies": [
+        "Forest",
+        "Plains",
+        "Desert/Steppe",
+        "Mountains/Valley",
+        "Wetlands (Ocean, River)"
+    ],
+
+    "resources": {
+        "specific": {
+            "Forest": [
+                "Timber",
+                "Furs",
+                "Honey"
+            ],
+
+            "Plains": [
+                "Wheat",
+                "Barley",
+                "Oats",
+                "Horses",
+                "Cattle"
+            ],
+
+            "Desert/Steppe": [
+                "Dates",
+                "Ivory",
+                "Camels"
+            ],
+
+            "Mountains/Valley": [
+                "Stone",
+                "Marble",
+                "Limestone",
+                "Goats"
+            ],
+
+            "Wetlands (Ocean, River)": [
+                "Fish",
+                "Rice",
+                "Papyrus",
+                "Clay"
+            ]
+        },
+
+        "general": [
+            "Olives",
+            "Grapes",
+            "Salt",
+            "Iron",
+            "Copper",
+            "Tin",
+            "Lead",
+            "Silver",
+            "Gold",
+            "Coal",
+            "Charcoal",
+            "Wool",
+            "Leather",
+            "Sheep",
+            "Pigs",
+            "Spices",
+            "Herbs",
+            "Dyes",
+            "Silk",
+            "Cotton"
+        ]
+    },
+
+    "quirks": {
+        "empty": "so far"
+    }
+}

linguistics_evolution_simulator-0.1.0/linguistics_evolution_simulator/data/civilisation_init.json

@@ -0,0 +1,12 @@
+{
+    "population": 719,
+    "geography": "Wetlands (Ocean, River)",
+    "mobility_level": 6,
+    "resources": [
+        "Clay",
+        "Fish",
+        "Gold",
+        "Spices",
+        "Dyes"
+    ]
+}

linguistics_evolution_simulator-0.1.0/linguistics_evolution_simulator/data/events.json

@@ -0,0 +1,75 @@
+{ 
+    "events": [
+        {
+            "event": "Conquest - the conquerors have introduced new words.",
+            "word_shift_modifier": 3,
+            "word_addition_modifier": 0,
+            "grammar_shift_modifier": 0,
+            "population_shift_modifier": -0.02
+        },
+
+        {
+            "event": "Slang - the youngsters, adding new vocabulary!",
+            "word_shift_modifier": 4,
+            "word_addition_modifier": 0,
+            "grammar_shift_modifier": 0,
+            "population_shift_modifier": 0
+        },
+
+        {
+            "event": "Trade - traders from all across the region bring their words.",
+            "word_shift_modifier": 1,
+            "word_addition_modifier": 0,
+            "grammar_shift_modifier": 0,
+            "population_shift_modifier": 0.01
+        },
+
+        {
+            "event": "Migration - other tribes and peoples have brought their tongues with them.",
+            "word_shift_modifier": 2,
+            "word_addition_modifier": 0,
+            "grammar_shift_modifier": 0,
+            "population_shift_modifier": 0.1
+        },
+
+        {
+            "event": "Isolation - less people to talk with, less words get made up.",
+            "word_shift_modifier": -1,
+            "word_addition_modifier": 0,
+            "grammar_shift_modifier": 0,
+            "population_shift_modifier": 0
+        },
+
+        {
+            "event": "Writing - words being written down offer a spelling that is less modifiable.",
+            "word_shift_modifier": -1,
+            "word_addition_modifier": 0,
+            "grammar_shift_modifier": 0,
+            "population_shift_modifier": 0
+        },
+
+        {
+            "event": "Political Unification - the new regime is making efforts to unify the language.",
+            "word_shift_modifier": -2,
+            "word_addition_modifier": 0,
+            "grammar_shift_modifier": 0,
+            "population_shift_modifier": 0
+        },    
+        
+        {
+            "event": "Education - More people know how to read and write standard words, and they don't change as much.",
+            "word_shift_modifier": -4,
+            "word_addition_modifier": 0,
+            "grammar_shift_modifier": 0,
+            "population_shift_modifier": 0
+        },
+
+        {
+            "event": "Plague - People are dying in droves, and many words are dying off.",
+            "word_shift_modifier": -3,
+            "word_addition_modifier": 0,
+            "grammar_shift_modifier": 0,
+            "population_shift_modifier": -0.2
+        }
+    ]
+}

linguistics_evolution_simulator-0.1.0/linguistics_evolution_simulator/data/intro.txt

@@ -0,0 +1,6 @@
+Welcome to the Linguistics Simulator!
+This is a little mockup of how linguistics evolution can occur within human populations.
+But a disclaimer first.
+I am not a linguistics professor, so there probably are issues in terms of evolutionary accuracy.
+I am open to any feedback if that's the case.
+But sit back, relax, and see a little civilisation evolve!

linguistics_evolution_simulator-0.1.0/linguistics_evolution_simulator/data/outro.txt

@@ -0,0 +1,2 @@
+Year 3000 is where this simulation ends. Nowhere near a realistic timescale, but here we are.
+Hopefully you enjoyed this rudimentary demo! Perhaps consider trying it out again.

linguistics_evolution_simulator-0.1.0/linguistics_evolution_simulator/data/words.json

@@ -0,0 +1,41 @@
+{
+    "general": [
+        "water",
+        "food",
+        "house",
+        "way",
+        "person",
+        "sleep",
+        "hand",
+        "world",
+        "life",
+        "day",
+        "time"
+    ],
+
+    "antiquity": [
+        "slave",
+        "forum",
+        "gods",
+        "chief",
+        "tribe"
+    ],
+
+    "medieval": [
+        "merchant",
+        "castle",
+        "king",
+        "village",
+        "knight"
+    ],
+
+    "modern": [
+        "factory",
+        "machine",
+        "country",
+        "city",
+        "clock"
+    ]
+
+
+}

linguistics_evolution_simulator-0.1.0/linguistics_evolution_simulator/main.py

@@ -0,0 +1,281 @@
+import random
+import json
+import time
+
+from pathlib import Path
+DATA_DIR = Path(__file__).parent / "data"
+
+word_shift_modifier = 0 # number of words that are shifted per iteration
+vowels = str()
+consonants = str()
+modified_words = list()
+
+#loading some needed files
+with open(DATA_DIR / "civilisation.json") as file:
+    data = json.load(file) #loading all potential environment data
+with open(DATA_DIR / "words.json") as file:
+    word_pool = json.load(file)
+with open(DATA_DIR / "events.json") as file:
+    all_events = json.load(file)
+
+with open(DATA_DIR / "intro.txt", "r") as file:
+    intro_lines = file.readlines()
+with open(DATA_DIR / "outro.txt", "r") as file:
+    outro_lines = file.readlines()
+
+
+
+class Civilisation():
+    def __init__(self):
+        self.population = random.randint(100, 1000) # Sets beginning population of the civilisation
+        self.geography, self.mobility_level = set_geography() # Sets geographical features of the generated civilisation
+        self.resources = get_resources(self.geography) # Gets civilisation resources 
+        self.words = generate_words(self.resources) # Generates word-like words + hardwired to initialise 20 words
+
+        self.events = None # variable for events - list of event dicts
+
+        self.write_to_json()
+
+    def write_to_json(self):
+        civilisation_data = {
+            "population": self.population,
+            "geography": self.geography,
+            "mobility_level": self.mobility_level,
+            "resources": self.resources,
+        }
+
+        with open(DATA_DIR / "civilisation_init.json", "w") as file:
+            json.dump(civilisation_data, file, indent=4)
+
+    def display_init(self):
+        print("\n--- CIVILISATION ---")
+        print(f"Population: {self.population}")
+        print(f"Geography: {self.geography}")
+        print(f"Mobility: {self.mobility_level}/10")
+        print(f"Resources: {', '.join(self.resources)}")
+
+    def display(self, year):
+        print("\n--- DASHBOARD ---")
+        print(f"Population: {self.population}")
+
+        if year < 1000:
+            era = "Antiquity"
+        elif 1000 < year < 2000:
+            era = "Medieval"
+        else: 
+            era = "Modern"
+        print(f"Era: {era}")
+
+        print("\nWORDS")
+        for i, word in enumerate(self.words):
+            if i == 0:
+                print("--> General words")
+            elif i == 11:
+                print("\n--> Resource Words")
+            elif i == 16:
+                print("\n--> Era-Specific words")
+            print(f"{word}: {self.words[word]}")
+
+        print("\nCHANGES")
+        print(f"{word_shift_modifier} words were modified in this iteration.")
+        for i, word in enumerate(modified_words):
+            print(f"{i + 1}. {word["original"]} --> {word["changed"]}")
+
+        for i, event in enumerate(self.events):
+            print(f"\n{i + 1}.", event["event"])
+            print(f"Population change: {round(event["population_shift_modifier"] * 100)}%")
+
+    def iterate_event(self):
+        a = 0
+        self.events = []
+
+        for event in all_events["events"]:
+            if self.population > 3000:
+                self.events.append(all_events["events"][8])
+                continue
+            a = random.randint(0, 1)
+            if a == 1 and len(self.events) < 3:
+                self.events.append(event)
+                
+    def iterate_population(self):
+        self.population += round(0.2 * self.population)
+        for event in self.events:
+            self.population += round(event["population_shift_modifier"] * self.population)
+
+    def iterate_words(self, year):
+        global word_shift_modifier
+        word_shift_modifier = 0
+
+        for event in self.events:
+            word_shift_modifier += event["word_shift_modifier"]
+
+        word_shift_modifier = max(0, min(word_shift_modifier, 10))  # Maximum 10 words changed per iteration
+
+
+        new_era_words = None
+
+        if year == 1000 or year == 2000:
+            if year == 1000:
+                new_era_words = word_pool["medieval"]
+            else:
+                new_era_words = word_pool["modern"]
+
+            old_words = list(self.words.keys())[-5:]
+
+            for word in old_words:
+                self.words.pop(word)
+
+            for word in new_era_words[:5]:
+                global vowels
+                global consonants
+                self.words[word] = make_word(vowels, consonants)
+
+            self.events.append({
+                "event": "New era, new words - Change of era! Last 5 era-specific words have changed.",
+                "population_shift_modifier": 0,
+                "word_shift_modifier": 0
+            })
+
+
+        count = 0
+        global modified_words
+        modified_words = []
+
+        words_to_change = random.sample(
+            list(self.words.keys()),
+            min(word_shift_modifier, len(self.words))
+        )
+
+        for word in words_to_change:
+            change = {
+                "original": self.words[word],
+                "changed": None
+            }
+
+            self.words[word] = mutate_word(self.words[word])
+
+            change["changed"] = self.words[word]
+            modified_words.append(change)
+
+            count += 1
+
+
+            
+#----------------------------------------------------------------------------------------
+        
+
+
+def set_geography():
+    geography = random.choice(data["geographies"])
+
+    if geography == "Forest":
+        mobility_level = random.randint(3, 6)
+    elif geography == "Plains":
+        mobility_level = random.randint(6, 9)
+    elif geography == "Desert/Steppe":
+        mobility_level = random.randint(7, 10)
+    elif geography == "Mountains/Valley":
+        mobility_level = random.randint(0, 3)
+    elif geography == "Wetlands (Ocean, River)":
+        mobility_level = random.randint(4, 7)
+    return geography, mobility_level
+
+def get_resources(geography):
+    resource_count = 5
+
+    specific_resources = data["resources"]["specific"][geography]
+    general_resources = data["resources"]["general"]
+
+    resources = random.sample(specific_resources, 2)
+
+    remaining = resource_count - 2
+
+    resources += random.sample(general_resources, remaining)
+
+    return resources
+
+def generate_words(resources):
+    words = dict()
+    for word in word_pool["general"]:
+        words[word] = None
+    for resource in resources:
+        words[resource] = None
+    for word in word_pool["antiquity"]:
+        words[word] = None
+
+    all_vowels = "aeiou"
+    all_consonants = "bcdfghjklmnpqrstvwxyz"
+
+    global vowels
+    global consonants
+    vowels = random.sample(all_vowels, 3)
+    consonants = random.sample(all_consonants, 10)
+
+    for word in words:
+        words[word] = make_word(vowels, consonants)
+
+    return words
+
+def make_word(vowels, consonants):
+    word = ""
+    for _ in range(random.randint(2, 3)):
+        word += random.choice(consonants)
+        word += random.choice(vowels) 
+
+    return word
+
+def mutate_word(word):
+    vowels = "aeiou"
+    consonants = "bcdfghjklmnpqrstvwxyz"
+
+    index = random.randint(0, len(word) - 1)
+    old_letter = word[index]
+
+    if old_letter in vowels:
+        possible_letters = vowels
+    else:
+        possible_letters = consonants
+
+    new_letter = random.choice(possible_letters)
+
+    while new_letter == old_letter:
+        new_letter = random.choice(possible_letters)
+
+    return word[:index] + new_letter + word[index + 1:]
+
+
+
+def main():
+    civilisation = Civilisation()
+    running = True
+    year = 0
+    
+    while running:
+        if year == 0:
+            for line in intro_lines:
+                print(line, end="")
+                time.sleep(3)
+            print("\n")
+            print(f"\nYEAR {year}")
+            civilisation.display_init()
+            time.sleep(5)
+            year += 100
+
+        print(f"\nYEAR {year}")         
+        civilisation.iterate_event() # Randomly gets events that are happening this iteration cycle
+        civilisation.iterate_population() # Changes civilisation population (mechanic related to some events)
+        civilisation.iterate_words(year) # Changes the words in the dashboard
+        civilisation.display(year) # Displays a dashboard
+        time.sleep(10) # 10 seconds for you to review the word changes in the dashboard
+
+        if year == 3000:
+            print("\n")
+            for line in outro_lines:
+                print(line, end="")
+                time.sleep(3)
+            break 
+
+        year += 100
+
+if __name__ == "__main__":
+    main()

linguistics_evolution_simulator-0.1.0/linguistics_evolution_simulator.egg-info/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: linguistics-evolution-simulator
+Version: 0.1.0
+Summary: A small civilisation and language evolution simulator.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+## Features
+This is an attempt at representing linguistic evolution in a human civilisation! It evolves 20 words through 100-year iterations.
+
+The game loop is in main; at the beginning, a "civilisation" is generated with random parameters so as to give it unique words for resources; this might also become a game mechanic in the future. Afterwards, a quantity of words "evolve" depending on the modifiers that randomly selected events produce.
+
+With regards to the string of "plague" messages, this is to ensure that the population doesn't spiral out of control and lead to many word mutations all at once.
+
+
+## AI use declaration
+As I said in the project description, virtually none of the code had AI input; as far as I can remember, all the code was written myself, with AI only acting occasionally as a tool that I use for better-quality brainstorming and planning.
+
+However, there was one major task that I had to rely on AI for guidance, which is the publishing to PyPI step in preparation for shipping. I am personally very inexperienced with the whole project lifecycle, and especially shipping, so I had to rely on it to guide me through this process of packing everything in and replacing some file paths in the source code. In any case, this is good project experience and something that I learned!
+
+
+## Installation
+Install with pipx:
+
+```bash
+pipx install linguistics-evolution-simulator

linguistics_evolution_simulator-0.1.0/linguistics_evolution_simulator.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+pyproject.toml
+readme.md
+linguistics_evolution_simulator/__init__.py
+linguistics_evolution_simulator/main.py
+linguistics_evolution_simulator.egg-info/PKG-INFO
+linguistics_evolution_simulator.egg-info/SOURCES.txt
+linguistics_evolution_simulator.egg-info/dependency_links.txt
+linguistics_evolution_simulator.egg-info/entry_points.txt
+linguistics_evolution_simulator.egg-info/top_level.txt
+linguistics_evolution_simulator/data/civilisation.json
+linguistics_evolution_simulator/data/civilisation_init.json
+linguistics_evolution_simulator/data/events.json
+linguistics_evolution_simulator/data/intro.txt
+linguistics_evolution_simulator/data/outro.txt
+linguistics_evolution_simulator/data/words.json

linguistics_evolution_simulator-0.1.0/linguistics_evolution_simulator.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

linguistics_evolution_simulator-0.1.0/linguistics_evolution_simulator.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+linguistics-sim = linguistics_evolution_simulator.main:main

linguistics_evolution_simulator-0.1.0/linguistics_evolution_simulator.egg-info/top_level.txt

@@ -0,0 +1 @@
+linguistics_evolution_simulator

linguistics_evolution_simulator-0.1.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "linguistics-evolution-simulator"
+version = "0.1.0"
+description = "A small civilisation and language evolution simulator."
+readme = "readme.md"
+requires-python = ">=3.10"
+
+[project.scripts]
+linguistics-sim = "linguistics_evolution_simulator.main:main"
+
+[tool.setuptools.package-data]
+linguistics_evolution_simulator = ["data/*.json", "data/*.txt"]

linguistics_evolution_simulator-0.1.0/readme.md

@@ -0,0 +1,19 @@
+## Features
+This is an attempt at representing linguistic evolution in a human civilisation! It evolves 20 words through 100-year iterations.
+
+The game loop is in main; at the beginning, a "civilisation" is generated with random parameters so as to give it unique words for resources; this might also become a game mechanic in the future. Afterwards, a quantity of words "evolve" depending on the modifiers that randomly selected events produce.
+
+With regards to the string of "plague" messages, this is to ensure that the population doesn't spiral out of control and lead to many word mutations all at once.
+
+
+## AI use declaration
+As I said in the project description, virtually none of the code had AI input; as far as I can remember, all the code was written myself, with AI only acting occasionally as a tool that I use for better-quality brainstorming and planning.
+
+However, there was one major task that I had to rely on AI for guidance, which is the publishing to PyPI step in preparation for shipping. I am personally very inexperienced with the whole project lifecycle, and especially shipping, so I had to rely on it to guide me through this process of packing everything in and replacing some file paths in the source code. In any case, this is good project experience and something that I learned!
+
+
+## Installation
+Install with pipx:
+
+```bash
+pipx install linguistics-evolution-simulator

linguistics_evolution_simulator-0.1.0/setup.cfg

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