auxiliary_functions.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importar libs necessárias\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import random\n",
    "import requests\n",
    "import json\n",
    "from itertools import cycle\n",
    "from random import randint\n",
    "from random import choice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Função de gerar fake dataframes\n",
    "Reference: https://towardsdatascience.com/generating-fake-data-with-pandas-very-quickly-b99467d4c618"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_fake_dataframe(size, cols, col_names = None, intervals = None, seed = None):\n",
    "    \n",
    "    categories_dict = {'animals': ['cow', 'rabbit', 'duck', 'shrimp', 'pig', 'goat', 'crab', 'deer', 'bee', 'sheep', 'fish', 'turkey', 'dove', 'chicken', 'horse'],\n",
    "                       'names'  : ['James', 'Mary', 'Robert', 'Patricia', 'John', 'Jennifer', 'Michael', 'Linda', 'William', 'Elizabeth', 'Ahmed', 'Barbara', 'Richard', 'Susan', 'Salomon', 'Juan Luis'],\n",
    "                       'cities' : ['São Paulo', 'Belo Horizonte', 'Recife', 'Fortaleza', 'Salvador', 'Curitiba', 'Porto Alegre', 'Manaus', 'Palmas', 'Río de Janeiro', 'Macapá', 'Teresina', 'Goiânia', 'Brasília', 'Vitória', 'Florianópolis', 'Curitiba', 'João Pessoa', 'São Luís', 'Natal', 'Cuiabá', 'Campo Grande'],\n",
    "                       'colors' : ['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'purple', 'pink', 'silver', 'gold', 'beige', 'brown', 'grey', 'black', 'white']\n",
    "                      }\n",
    "    default_intervals = {\"i\" : (0,10), \"f\" : (0,100), \"c\" : (\"names\", 5), \"d\" : (\"2020-01-01\",\"2020-12-31\")}\n",
    "    rng = np.random.default_rng(seed)\n",
    "\n",
    "    first_c = default_intervals[\"c\"][0]\n",
    "    categories_names = cycle([first_c] + [c for c in categories_dict.keys() if c != first_c])\n",
    "    default_intervals[\"c\"] = (categories_names, default_intervals[\"c\"][1])\n",
    "    \n",
    "    if isinstance(col_names,list):\n",
    "        assert len(col_names) == len(cols), f\"The fake DataFrame should have {len(cols)} columns but col_names is a list with {len(col_names)} elements\"\n",
    "    elif col_names is None:\n",
    "        suffix = {\"c\" : \"cat\", \"i\" : \"int\", \"f\" : \"float\", \"d\" : \"date\"}\n",
    "        col_names = [f\"column_{str(i)}_{suffix.get(col)}\" for i, col in enumerate(cols)]\n",
    "\n",
    "    if isinstance(intervals,list):\n",
    "        assert len(intervals) == len(cols), f\"The fake DataFrame should have {len(cols)} columns but intervals is a list with {len(intervals)} elements\"\n",
    "    else:\n",
    "        if isinstance(intervals,dict):\n",
    "            assert len(set(intervals.keys()) - set(default_intervals.keys())) == 0, f\"The intervals parameter has invalid keys\"\n",
    "            default_intervals.update(intervals)\n",
    "        intervals = [default_intervals[col] for col in cols]\n",
    "    df = pd.DataFrame()\n",
    "    for col, col_name, interval in zip(cols, col_names, intervals):\n",
    "        if interval is None:\n",
    "            interval = default_intervals[col]\n",
    "        assert (len(interval) == 2 and isinstance(interval, tuple)) or isinstance(interval, list), f\"This interval {interval} is neither a tuple of two elements nor a list of strings.\"\n",
    "        if col in (\"i\",\"f\",\"d\"):\n",
    "            start, end = interval\n",
    "        if col == \"i\":\n",
    "            df[col_name] = rng.integers(start, end, size)\n",
    "        elif col == \"f\":\n",
    "            df[col_name] = np.round(rng.uniform(start, end, size), 2)\n",
    "        elif col == \"c\":\n",
    "            if isinstance(interval, list):\n",
    "                categories = np.array(interval)\n",
    "            else:\n",
    "                cat_family, length = interval\n",
    "                if isinstance(cat_family, cycle):\n",
    "                    cat_family = next(cat_family)\n",
    "                assert cat_family in categories_dict.keys(), f\"There are no samples for category '{cat_family}'. Consider passing a list of samples or use one of the available categories: {categories_dict.keys()}\"\n",
    "                categories = rng.choice(categories_dict[cat_family], length, shuffle = True)\n",
    "            df[col_name] = rng.choice(categories, size, shuffle = True)\n",
    "        elif col == \"d\":\n",
    "            df[col_name] = rng.choice(pd.date_range(start, end), size)\n",
    "    return df  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Função para gerar colunas de quantidade preterida e tipo de consumidos (física ou jurídica)\n",
    "Pensando na coluna de quantidade preterida foi levado em conta se o consumidor é uma pessoa jurídica ou física. Isso foi levado em conta, pois uma pessoa jurídica normalmente é um estabelecimento, ou seja, busca uma maior quantidade de cafés para compra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_person_type_and_desired_quantity(size):\n",
    "    aux_array = []\n",
    "    for _ in range(size):\n",
    "        person_type = choice([1, 2])\n",
    "        if person_type == 2:\n",
    "            desired_quantity = 60\n",
    "        else: \n",
    "            available_quantity = [0.5, 1]\n",
    "            desired_quantity = choice(available_quantity)\n",
    "        aux_array.append([person_type, desired_quantity])\n",
    "    return aux_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Função para gerar colunas de condição financeira do consumidor e se procura café especial\n",
    "Possivelmente quem tem interesse em café especial, esta disposto a gastar um pouco mais"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_search_special_coffee_and_financial_condition(size):\n",
    "    percentage = 0.65\n",
    "    size_not_special = round(size*percentage)\n",
    "    size_special = size - size_not_special\n",
    "    aux_array = []\n",
    "    for _ in range(size_not_special):\n",
    "        financial_condition = round(random.gauss(100, 20))\n",
    "        aux_array.append([False, financial_condition])\n",
    "    for _ in range(size_special):\n",
    "        financial_condition = round(random.gauss(300, 50))\n",
    "        aux_array.append([True, financial_condition])\n",
    "    \n",
    "    np.random.shuffle(aux_array)\n",
    "    return aux_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Função para gerar colunas de pontuação do café e residências\n",
    "Pontuação do café gerada com base na altitude e qualidade médias dos cafés nos estados pesquisados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_coffee_score_and_residences(size):\n",
    "    aux_array = []\n",
    "    for _ in range(size):\n",
    "        state_id = choice([1, 2, 3, 4, 5, 6])\n",
    "        if state_id == 1:\n",
    "            # Bahia\n",
    "            coffee_score = round(random.gauss(62, 7))\n",
    "        elif state_id == 2:\n",
    "            # Minas Gerais\n",
    "            coffee_score = round(random.gauss(79, 3))\n",
    "        elif state_id == 3:\n",
    "            # Espírito Santo\n",
    "            coffee_score = round(random.gauss(62, 8))\n",
    "        elif state_id == 4:\n",
    "            # Rio de Janeiro\n",
    "            coffee_score = round(random.gauss(68, 7))\n",
    "        elif state_id == 5:\n",
    "            # São Paulo\n",
    "            coffee_score = round(random.gauss(76, 5))\n",
    "        else:\n",
    "            # Paraná\n",
    "            coffee_score = round(random.gauss(72, 7))\n",
    "        aux_array.append([state_id, coffee_score])\n",
    "    return aux_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Função para gerar colunas de quantidade produzida do café e se produz café especial\n",
    "Normalmente produtores que produzem café especial, produzem em uma quantidade menor de que quem não produz café especial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_produces_special_coffee_and_quantity_produced(size):\n",
    "    percentage = 0.5\n",
    "    size_not_special = round(size*percentage)\n",
    "    size_special = size - size_not_special\n",
    "    aux_array = []\n",
    "    for _ in range(size_not_special):\n",
    "        quantity_produced = round(random.gauss(900, 200))\n",
    "        aux_array.append([False, quantity_produced])\n",
    "    for _ in range(size_special):\n",
    "        quantity_produced = round(random.gauss(700, 200))\n",
    "        aux_array.append([True, quantity_produced])\n",
    "    \n",
    "    np.random.shuffle(aux_array)\n",
    "    return aux_array"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}