Python pandas

import pandas

#Table from a list
list_of_vals = [1,200,300,400]
series = pandas.Series(list_of_vals)


# Table with index
series_vals = [500,600,700,800]
series_index = ['five','six','seven','eight']
series_with_label = pandas.Series(data=series_vals,index=series_index)

print(f"{series}\n----------\n{series_with_label}")

import pandas

dicker = {'a': 2.1,'b': 3.2, 'c': 7.7}

serie =pandas.Series(dicker)

print(serie)

import pandas

def calc_num_times(n: int) -> int:
    num = 0
    while num < n:
        yield num *2
        num += 1
     
     
series = pandas.Series(calc_num_times(8))
print(series)

 1: import pandas
 2: 
 3: 
 4: class Person:
 5:     def __init__(self, name, age, weight):
 6:         self.name = name
 7:         self.age = age
 8:         self.weight = weight
 9:      
10:     def __str__(self):
11:         return f"Person(name={self.name}, age={self.age}, weight={self.weight})"
12:      
13:     def __eq__(self, other):
14:         return (self.name, self.age, self.weight) == (other.name, other.age, other.weight)
15:      
16:      
17:      
18:      
19: persons = [
20:     Person("Alice", 30, 60),
21:     Person("Bob", 25, 70),
22:     Person("Charlie", 35, 80),
23:     Person("David", 40, 75),
24:     Person("Eve", 28, 65)
25: ]
26: 
27: index = [person.name for person in persons]
28: series = pandas.Series(data=persons, index=index)
29: print(f"{series}\n----------")
30: 
31: series['Bob'].age=4 #Change age of Bob!
32: 
33: print(f"{series}\n----------")
34: [print(f"{person}") for person in persons]

 1: import pandas
 2: import copy
 3: 
 4: class Person:
 5:     def __init__(self, name, age, weight):
 6:         self.name = name
 7:         self.age = age
 8:         self.weight = weight
 9:      
10:     def __str__(self):
11:         return f"Person(name={self.name}, age={self.age}, weight={self.weight})"
12:      
13:     def __eq__(self, other):
14:         return (self.name, self.age, self.weight) == (other.name, other.age, other.weight)
15:      
16:      
17: persons = [
18:     Person("Alice", 30, 60),
19:     Person("Bob", 25, 70),
20:     Person("Charlie", 35, 80),
21:     Person("David", 40, 75),
22:     Person("Eve", 28, 65)
23: ]
24: 
25: index = [person.name for person in persons]
26: series = pandas.Series(data=[copy.copy(person) for person in persons]
27:                        , index=index, copy=True)
28: print(f"{series}\n----------")
29: 
30: series['Bob'].age=4 #Change name of bob in series
31: 
32: print(f"{series}\n----------")
33: [print(f"{person}") for person in persons]
34: 

 1: import pandas
 2: import copy
 3: from pprint import pprint
 4: 
 5: class Person:
 6:     def __init__(self, name, age, tags):
 7:         self.name = name
 8:         self.age = age
 9:         self.tags = tags
10:      
11:     def __str__(self):
12:         return f"Person(name={self.name}, age={self.age}, tags={', '.join(self.tags)})"
13:      
14:     def __eq__(self, other):
15:         return (self.name, self.age, self.tags) == (other.name, other.age, other.tags)
16:      
17:      
18: Alice_tags = ["friendly", "creative"]
19: # generate a list of 5 persons with different names and tags , a tag is a list of attribute for a person
20: persons = [
21:     Person("Alice", 30, Alice_tags),
22:     Person("Bob", 25, ["analytical", "quiet"]),
23:     Person("Charlie", 35, ["outgoing", "adventurous"]),
24:     Person("Diana", 28, ["organized", "detail-oriented"]),
25:     Person("Eve", 32, ["curious", "independent"])
26: ]
27: 
28: #Make a shallow copy
29: series_copy = pandas.Series(data=[copy.copy(person) for person in persons]
30:                             ,index=[person.name for person in persons], copy=True)
31:      
32: Alice_tags.append('fishy')
33: 
34: series_copy['Alice'].age = 12
35: pprint([f"{person.name}: {person.tags}, {person.age}" for person in series_copy])
36: pprint("----------")
37: pprint([f"{person.name}: {person.tags}, {person.age}" for person in persons])

import pandas
import copy


class Person:
    def __init__(self, name, age, tags):
        self.name = name
        self.age = age
        self.tags = tags
     
    def __str__(self):
        return f"Person(name={self.name}, age={self.age}, tags={', '.join(self.tags)})"
     
    def __eq__(self, other):
        return (self.name, self.age, self.tags) == (other.name, other.age, other.tags)
     
     
Alice_tags = ["friendly", "creative"]
# generate a list of 5 persons with different names and tags , a tag is a list of attribute for a person
persons = [
    Person("Alice", 30, Alice_tags),
    Person("Bob", 25, ["analytical", "quiet"]),
    Person("Charlie", 35, ["outgoing", "adventurous"]),
    Person("Diana", 28, ["organized", "detail-oriented"]),
    Person("Eve", 32, ["curious", "independent"])
]

index = [person.name for person in persons]
series = pandas.Series(data=copy.deepcopy(persons)
                       , index=index)
print(f"{series}\n----------")

series['Alice'].tags = ['angry']
Alice_tags.append("sad")

print(f"{series}\n----------")
[print(f"{person}") for person in persons]

[
    ["a1", "b1", "c1", "d1", "e1"],
    ["a2", "b2", "c2", "d2", "e2"],
    ["a3", "b3", "c3", "d3", "e3"],
    ["a4", "b4", "c4", "d4", "e4"]
]

import pandas
from tabulate import tabulate

df = pandas.DataFrame(data=table, columns=headers, index=['row1','row2','row3','row4'])
org_table = tabulate(df, headers='keys', tablefmt='orgtbl', showindex=True)

print(org_table)

 1: import pandas
 2: 
 3: 
 4: df = pandas.DataFrame(data=table, columns=headers)
 5: 
 6: gt_50 = df['Score'] > 50
 7: print(f"{gt_50}\n----------")
 8: print(f">50\n {df[gt_50]}\n----------")
 9: 
10: test = [True, False, False,  True]
11: print(df[ test])

import functools
import itertools
import pandas
import operator

df = pandas.DataFrame(data=table, columns=headers)


def f(lst, elem):
    lst.append(elem)
    return lst

# Filter out length > 1.7
def filter_length(length:float)->bool:
    return length>1.7

# create a list of all lengths.
length_lst = functools.reduce( f,df['Length'], [])
print(f"Lengths {length_lst}")
# Filter out all that has length > 1.7
length_filtered=filter(filter_length, length_lst )
# add 20 to the length_filtered items.
def add_20(elem):
    return elem+20
add_20_res = map(  add_20, length_filtered)

# Sum of all the ages.
it = itertools.accumulate(df['Age'],operator.add)
print(f"Sum of ages (step wise) {list(it)}")


print(list(add_20_res))

from enum import Enum
import pandas
from pymonad.maybe import Maybe, Just, Nothing
import requests
import pprint
import json
import matplotlib.pyplot as plt

class PositionData:
    def __init__(self, latitude, longitude):
        self.lat = latitude
        self.lon = longitude
     
    def __eq__(self, other):
        return isinstance(other, PositionData) and self.lat == other.lat and self.lon == other.lon
     
    def __repr__(self):
        return f"PositionData(lat={self.lat}, lon={self.lon})"
     
class WindSpeed(Enum):
    MS = 'ms'
    KMH = 'kmh'
    MPH = 'mph'
    KNOTS = 'knots'

class Temperature(Enum):
    FAHRENHEIT = 'fahrenheit'
    CELSIUS = 'celsius'

class TimeFormat(Enum):
    UNIX = 'unixtime'
    ISO8601 = 'ISO8601'

class PrecipitationType(Enum):
    MM = 'mm'
    INCH = 'inch'

class UnitTypes:
    def __init__(self,
                 wind_speed: WindSpeed = WindSpeed.MS,
                 temperature: Temperature = Temperature.CELSIUS,
                 time_format: TimeFormat = TimeFormat.UNIX,
                 precipitation: PrecipitationType = PrecipitationType.MM):
     
        self.wind_speed = wind_speed
        self.temperature = temperature
        self.time_format = time_format
        self.precipitation = precipitation
     
    def __str__(self):
        return (f'Wind Speed: {self.wind_speed.value}, '
                f'Temperature: {self.temperature.value}, '
                f'Time Format: {self.time_format.value}, '
                f'Precipitation: {self.precipitation.value}')
         
         
def create_unit_params(unit_types: UnitTypes):
    return {
        "wind_speed_unit": unit_types.wind_speed.value,
        #"timeformat": unit_types.time_format.value,
        "precipitation_unit": unit_types.precipitation.value,
        "temperature_unit": unit_types.temperature.value}
     
     
class WeatherData:
    def __init__(self, position: PositionData,
                 parameters: list[str],
                 types: UnitTypes,
                 forcast_days: int = 1):
        self.variables = parameters
        self.types = types
        self.position = position
        self.forcast_days = forcast_days
     
     
    def __repr__(self):
        return (f"WeatherData(variables={self.variables}, "
                f"types={self.types})")
         
    def __str__(self):
        return (f"Weather Data:\n"
                f"Position {self.position}\n"
                f"Variables: {', '.join(self.variables)}\n"
                f"Types: {self.types}"
                f"Forcast days: {self.forcast_days}")
         
         
def create_weather_params(weather: WeatherData):
    return {
        "latitude": weather.position.lat,
        "longitude": weather.position.lon,
        "hourly": weather.variables,
        "forecast_days": weather.forcast_days,
    }

def create_request_params(weather: WeatherData):
    weather_params = create_weather_params(weather)
    unit_params = create_unit_params(weather.types)
    return {**weather_params, **unit_params}

def send_request(url: str) -> callable:
    def send_fn(weather: WeatherData):
        params = create_request_params(weather)
        response = requests.get(url, params=params,verify=False, timeout=10)
        if response.status_code == 200:
            return Just(response.json())
        else:
            return Nothing
         
    return send_fn

def transform_to_df(json_str:str) -> pandas.DataFrame:
    return Just(pandas.DataFrame(json_str))

weather_data = WeatherData(PositionData(57.707,11.95),
                           ["temperature_2m",
                            "apparent_temperature",
                            "rain",
                            "showers",
                            "wind_speed_10m",
                            "wind_direction_180m"],
                           UnitTypes(),
                           2
                           )
     
api_ret_json = Just(weather_data).bind(send_request("https://api.open-meteo.com/v1/forecast")) \
                                 .bind(transform_to_df)
                                 
df = api_ret_json.value

df = api_ret_json.value
x_axis = df.loc['time']['hourly']
y_axis = df.loc['temperature_2m']['hourly']
rain = df.loc['rain']['hourly']
wind = df.loc['wind_speed_10m']['hourly']

plt.figure(figsize=(10, 5))
plt.plot(x_axis, y_axis, marker='o', color='blue', label='Temperature 2m')
plt.bar(x_axis, rain, alpha=0.5, color='orange', label='rain')
plt.bar(x_axis, wind, alpha=0.5, color='red', label='Wind')

plt.title('Temperature and rain over Time')
plt.xlabel('Time')
plt.ylabel('Values')
plt.xticks(x_axis, rotation=45)
plt.legend()
plt.tight_layout()

plot_path = 'temperature_rain_plot.png'
plt.savefig(plot_path)
plt.close()

plot_link = f'[[file:{plot_path}]]'
print(plot_link)

import requests
import json
import pandas

response = requests.post(
  url="https://openrouter.ai/api/v1/chat/completions",
  headers={
    "Authorization": f"Bearer {API_KEY}",
  },
  data=json.dumps({
    "model": "mistralai/ministral-8b",
    "messages": [
        {"role": "system", "content": "Ha Ha Ha! Step right up, folks!" \
         "The Clown Prince of Crime turns..." \
         "Meteorologist? 😜 "
         },
        {
            "role": "user",
            "content": "Why does it rain?"
        }
     
    ]
  })
)

# Check if the request was successful
if response.status_code == 200:
    data = response.json()
    print("ID:", data['id'])
    print("Content:")
    for choice in data['choices']:
        print(choice['message']['content'])
else:
    print("Failed to retrieve data. Status code:", response.status_code)

ID: gen-1730053950-DQ7PIC1cHbqSi2cP8eWb
Content:
Oh, boy, here we go! 🌧️ So, you're asking why it rains?

Let's imagine you're standing at the Clown Prince of Crime's meteorology lab in his sanctuary on the edge of Moistdale:

1. **Evaporation and Condensation**: You know when you leave a glass of water outside, and it sometimes gets stuck with air bubbles inside? Imagine our entire Earth does something similar on a bigger scale. Water from oceans, lakes, rivers, and even plants *evaporates* into the air, leaving tiny, watery droplet clusters.

2. **Condensation**: When these water vapor droplets start to come back together, they join with other tiny particles, like dust and smoke, and start to the form Clouds. The air cools (maybe because of a highFront Meadow) and those droplets cool off until they can't hold as much moisture. That means they start to fall back to Earth as rain!

3. **Convective Rain**: Sometimes, this rain starts from top to bottom — those clock-hands aren't just doodled on a pie chart for show! — The sun heats up the ground and air, and it begins to rise, causing clouds to form where it's cooler.

4. **Dumping**: Pay attention to the clouds, and you'll see dark innings on the horizon before the rain comes down. These are thunderstorm clouds, and they usually mean it's time to get inside (unless you want to dance in the downpour — I hear Mongo madness can be quite exhilarating)!

In short, rain forms when water vapor condenses into clouds, and these clouds release water —  Water evaporates 🚿 to make clouds, and the clouds release it back as rain showers 🌧️! Expert work for a Clown Prince turned Meteorologist, huh? ☺️ Try not to “drench” me with jokes about it, okay?  And remember - you can't catch rain, it's always done quite genetics by the clouds. (Get it?ობაში**、**🍇** )**

#!/usr/bin/env python
import pandas
from enum import Enum
import pandas
from pymonad.maybe import Maybe, Just, Nothing
import requests
import pprint
import json
import matplotlib.pyplot as plt


class Headers:
    def __init__(self, headers_dict: dict):
        if not isinstance(headers_dict, dict):
            raise TypeError("Headers must be initialized with a dictionary")
        self.fields = headers_dict
     
    def __repr__(self):
        return f"Headers({self.fields})"
     
    @classmethod
    def from_dict(cls, headers_dict: dict):
        return cls(headers_dict)
     
     
class ComData:
    def __init__(self, *, url: str, model: str, headers: Headers):
        if not isinstance(headers, Headers):
            raise TypeError("Headers must be an instance of Headers class")
        self.url = url
        self.headers = headers
        self.model = model
     
     
class ConversationData:
    def __init__(self, *, query: str, system: str, data: pandas.DataFrame):
        self.user = query
        self.system = system
        self.data = data
     
    def __repr__(self) -> str:
        return f"ConversationData(user='{self.user}', system='{self.system}')"
     
    def make_message(self)->list[dict[str,str]]:
        return [
            {
                "role": "system",
                "content": self.system + "\n\nHere's the weather data for analysis:"
            },
            {
                "role": "system",
                "content": "The following message contains weather forecast data." \
                "Each dictionary in the list represents a different weather  " \
                "parameter, with the 'hourly' key containing a list of 24 values ," \
                "one for each hour of the day."
            },
            {
                "role": "user",
                "content": self.user + self.data.to_json()
            }]
         
         
def conversation_to_json(conv_data: ConversationData):
    return json.dumps(conv_data.make_message())

def make_data(com_data, conv_data):
    msg = {
        "model": com_data.model,
        "messages": conv_data.make_message()
    }
    return msg



def ai_send_fn(com_data: ComData):

    def send_fn(con_data):
        data = make_data(com_data,conv_data)
        reqObj = requests.Request('POST', comdata.url, json=data, headers=com_data.headers.fields)
        with requests.Session() as session:
            req=reqObj.prepare()
            response = session.send(req, verify=False)
            if response.status_code == 200:
                return Just(response)
            else:
                return Maybe(value=response, monoid=False)
        return req
     
    return send_fn

class PositionData:
    def __init__(self, latitude, longitude):
        self.lat = latitude
        self.lon = longitude
     
    def __eq__(self, other):
        return isinstance(other, PositionData) and self.lat == other.lat and self.lon == other.lon
     
    def __repr__(self):
        return f"PositionData(lat={self.lat}, lon={self.lon})"
     
     
class WindSpeed(Enum):
    MS = 'ms'
    KMH = 'kmh'
    MPH = 'mph'
    KNOTS = 'knots'

class Temperature(Enum):
    FAHRENHEIT = 'fahrenheit'
    CELSIUS = 'celsius'

class TimeFormat(Enum):
    UNIX = 'unixtime'
    ISO8601 = 'ISO8601'

class PrecipitationType(Enum):
    MM = 'mm'
    INCH = 'inch'

class UnitTypes:
    def __init__(self,
                 wind_speed: WindSpeed = WindSpeed.MS,
                 temperature: Temperature = Temperature.CELSIUS,
                 time_format: TimeFormat = TimeFormat.UNIX,
                 precipitation: PrecipitationType = PrecipitationType.MM):
     
        self.wind_speed = wind_speed
        self.temperature = temperature
        self.time_format = time_format
        self.precipitation = precipitation
     
    def __str__(self):
        return (f'Wind Speed: {self.wind_speed.value}, '
                f'Temperature: {self.temperature.value}, '
                f'Time Format: {self.time_format.value}, '
                f'Precipitation: {self.precipitation.value}')
         
         
def create_unit_params(unit_types: UnitTypes):
    return {
        "wind_speed_unit": unit_types.wind_speed.value,
        #"timeformat": unit_types.time_format.value,
        "precipitation_unit": unit_types.precipitation.value,
        "temperature_unit": unit_types.temperature.value}
     
     
class WeatherData:
    def __init__(self, position: PositionData,
                 parameters: list[str],
                 types: UnitTypes,
                 forcast_days: int = 1):
        self.variables = parameters
        self.types = types
        self.position = position
        self.forcast_days = forcast_days
     
     
    def __repr__(self):
        return (f"WeatherData(variables={self.variables}, "
                f"types={self.types})")
         
    def __str__(self):
        return (f"Weather Data:\n"
                f"Position {self.position}\n"
                f"Variables: {', '.join(self.variables)}\n"
                f"Types: {self.types}"
                f"Forcast days: {self.forcast_days}")
         
         
         
         
         
def create_weather_params(weather: WeatherData):
    return {
        "latitude": weather.position.lat,
        "longitude": weather.position.lon,
        "hourly": weather.variables,
        "forecast_days": weather.forcast_days,
    }

def create_request_params(weather: WeatherData):
    weather_params = create_weather_params(weather)
    unit_params = create_unit_params(weather.types)
    return {**weather_params, **unit_params}





def send_request(url: str) -> callable:
    def send_fn(weather: WeatherData):
        params = create_request_params(weather)
        response = requests.get(url, params=params,verify=False, timeout=10)
        if response.status_code == 200:
            return Just(response.json())
        else:
            return Nothing
         
    return send_fn

def transform_to_df(json_str:str) -> pandas.DataFrame:
    return Just(pandas.DataFrame(json_str))

###############################################################################
#                       Here we set the values we want.                       #
###############################################################################
headers = Headers({
    "Authorization": f"Bearer {API_KEY}",
    # "Content-Type": "application/json"
})

comdata = ComData(
    url="https://openrouter.ai/api/v1/chat/completions",
    headers=headers,
    model="google/gemini-flash-1.5"
)

weather_data = WeatherData(PositionData(57.707,11.95),
                           ["temperature_2m",
                            "apparent_temperature",
                            "rain",
                            "showers",
                            "wind_speed_10m",
                            "wind_direction_180m"
                            ],
                           UnitTypes(),
                           forcast_days=3
                           )
api_ret_json = Just(weather_data).bind(send_request("https://api.open-meteo.com/v1/forecast")) \
                                 .bind(transform_to_df)
                                 
df = api_ret_json.value



context = """
This weather data contains the following information:
1. Time: Hourly timestamps
2. Temperature (2m above ground): in °C
3. Apparent temperature: in °C
4. Rain: precipitation in mm
5. Showers: precipitation from showers in mm
6. Wind speed (10m above ground): in m/s
7. Wind direction (180m above ground): in degrees

The 'hourly' key in each dictionary contains a list of values corresponding to these measurements for each hour of the day.
The role weather_data will contain a json with 24h weather data. Analyse the data and answere the user question.
"""

conv_data = ConversationData(
    query="My name is Carl, i will take my bike every morning and home every evening" \
    " between 08:00-09:00 and going home at 17:00-18:00, Give me a summary of the weather forecast," \
    "Also i had west on the morings, and east on the evnings, I want to know if im heading into the wind or tailwind" \
    "also give me suggestions for clothing during my ride and if there are any significant changes during the period",
    system=context,
    data=df
)


send_fn = ai_send_fn(comdata)
maybe_response = send_fn(conv_data)
if maybe_response.is_just():
    data = maybe_response.value.json()
    content = data['choices'][0]['message']['content']
    print(content)