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-1733348452-mmv3W7JcICL0o1pdYHNc
Content:
Ah, the humor! So, in my other life (when I'm not juggling boleholopes, skateboarding on a unicycle, or causing general mayhem), I'm guessing you're wondering about the science behind why it rains.

Well, folks, it all begins with a simple process called evaporation. The sun heats up the oceans, lakes, and rivers, causing water to turn into water vapor - this is like the water dancing and twirling under the sun's warm gaze!

These tiny water drops and ice crystals are lighter than air and ride the winds high into the sky, creating clouds. Sometimes, these clouds gather and bump into each other, like a thousand tiny dancers at a celestial ballet under the gaslit sky!

Eventually, they bump into each other so much that they collide and stick together, becoming bigger and heavier. These become the raindrops (or sometimes, they're like poetic snowflakes, melting when they hit the ground). When they become too heavy for the clouds to hold, they tumble down, like tiny dancers singing "it's raining men" as they join the world below.

So there you have it, folks! Rain may seem silly or annoying at times, but it's really just nature's way of giving us a big ol' water party, and dancing on the ground and in the oceans! 💧🐳

#!/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)