semvec/pypi-packages huggingface dataset:
justogres 3.0.11
This library is used to read or write data in Postgres, MongoDB (Only read) or Google Sheets
Requires Python: >=3.6

# Overview

Justogres is a connector to comunicate pandas.DataFrame objects with postgres database

# Quick start

for more details review [documentation](./docs/)

## Install or upgrade package

install:

```bash
pip install justogres
```

upgrade:

```bash
pip install justogres --upgrade
```

## Init module

```python
from justogres import clientPsql

psql = clientPsql(
        host = "<your host>",
        user = "<your user>",
        password = "<your password>",
        db_name = "<your database name>",
    )
```

## Insert data into postgres

```python
import pandas as pd
example_df = pd.DataFrame(data=example_data)

psql.insert(
    example_df,
    table_name=<your table name>, #if doesn't exist table, will be created
    schema=<your schema name>, #should be created previously
  
    #optional
    chunksize=<your chunksize to load (default: 1000)>,
    column_types={<name_column_df>:<data_type postgres>})# if not declare column types, will be assigned automatically
```

## Read table of postgres

we have 2 ways to read DB, both return pandas.DataFrame object but its main difference is the type of data that is assigned to the columns of the dataframe

### 1. use exec_query() -> all columns are defines as object (string datatype in pandas)

```python
query_example_to_read="""SELECT * 
    FROM schema_name.table_name;"""

df = psql.exec_query(
    query_example_to_read,

    #optional
    chunksize=<your chunksize to load (default: 1000)>
    )
```

### 2. use read_with_pandas() -> columns are defined with datatype declare for each column into DB

```python
query_example_to_read="""SELECT * 
    FROM schema_name.table_name;"""

df = psql.read_with_pandas(
    query_example_to_read,

    #optional
    **kwargs=<all attributes we can use with pandas.read_sql()>
    )
```

for more info of [pandas.read_sql()](https://pandas.pydata.org/docs/reference/api/pandas.read_sql.html)

## Execute sql queries

this method doesn't return anything

```python
query_example="""DELETE 
    FROM schema_name.table_name 
    WHERE column_name='value';"""

psql.exec_query(
    query_example,
    #optional
    chunksize=<your chunksize to load (default: 1000)>
    )
```

# SpreadSheets Module

## Write DataFrame in Worksheet

```python
from justogres import SpreadSheets

spread_sheet_client = SpreadSheets("credentials.json")
spreadsheet_id = '1SVZDYBw17S1XeRNBW08YA7i29mOfFlGmmF6EWKH84bk'
worksheet_name = 'Result'

spread_sheet_client.append_dataframe(data_frame ,spreadsheet_id, worksheet_name)
```

## Read DataFrame in Worksheet

```python
from justogres import SpreadSheets

spread_sheet_client = SpreadSheets("credentials.json")
spreadsheet_id = '1SVZDYBw17S1XeRNBW08YA7i29mOfFlGmmF6EWKH84bk'
worksheet_name = 'Result'

spread_sheet_client.worksheet_to_dataframe(spreadsheet_id, worksheet_name)
```
telegram-notifier-prakhar 0.2
A simple library to send Telegram notifition when your code is completed .
Keywords: telegram bot message notify

# Telegram Notifier - Prakhar

`telegram-notifier-prakhar` is a Python package designed to send notifications via Telegram. This is particularly useful for notifying users about the completion of long-running processes in their code.

## Features

- Easy to integrate with any Python script.
- Customizable message content.
- Uses Telegram Bot to send notifications.

## Prerequisites

Before you can use this package, you need to set up a Telegram Bot. Follow these steps to get started:

### Step 1: Create a Telegram Bot

1. Open Telegram app and search for "BotFather".
2. Start a chat with BotFather and send `/newbot`.
3. Follow the instructions to create your bot. You will receive a token for accessing your bot via HTTP API.

### Step 2: Get Your Chat ID

1. Start a chat with your newly created bot or add it to a group.
2. Send a message to the bot or in the group.
3. Visit `https://api.telegram.org/bot<YourBOTToken>/getUpdates` in your web browser.
4. Look for `"chat":{"id":<number>}` in the response. This number is your chat ID.

## Installation

Install the package via pip:

```bash
pip install telegram-notifier-prakhar
```

## Usage
Here is a simple example of how to use the telegram-notifier-prakhar in your Python script:

```bash
from telegram_notifier import send_telegram_message

bot_token = 'your_bot_token'  # Replace with your bot token
chat_id = 'your_chat_id'  # Replace with your chat id

# Send a custom message
send_telegram_message(bot_token, chat_id, "Your script has finished running.")
```
blossom 2.0.0
A simple evolution simulator

# blossom [![PyPI version](https://badge.fury.io/py/blossom.svg)](https://badge.fury.io/py/blossom) [![Build Status](https://travis-ci.org/blossom-evolution/blossom.svg?branch=master)](https://travis-ci.org/blossom-evolution/blossom) [![Documentation Status](https://readthedocs.org/projects/blossom/badge/?version=latest)](https://blossom.readthedocs.io/en/latest/?badge=latest)

Blossom is a Python package for simulating the dynamics of organism populations. Blossom supports both one and two dimensional worlds. 

## Installation 

You can use pip to install the latest version of the package automatically:

```
pip install blossom
```

Alternately, execute:

```
git clone git@github.com:blossom-evolution/blossom.git
python setup.py install
```

## Basic Usage 

To start a simulation project, create a new directory to house all custom 
scripts, including a configuration file `config.yml`. In this config file, you
specify species parameters, including starting population, max age, and action
methods. Some action methods are built-in (for movement, eating, drinking, and
reproduction), but you may use custom methods defined in external Python 
scripts, which are imported at runtime by Blossom via `linked_modules`. 

World parameters are also specified in the config file, including dimensions 
and the distribution of water and food. You may also set limits on the number
of timesteps and organisms, in order to control the simulation in case of
runaway populations. 

With your project directory set up, you may run the simulation using the 
included command-line interface (CLI):

```
blossom run
```

Note that for reproducibility, you can set the random seed either in the config
file or at the CLI. For additional options, run `blossom run -h`. 


## Dashboard 

Blossom provides a dashboard that runs in your local browser, tracking the 
progress of your population runs. 

Initiate the dashboard, run 

```
blossom dashboard TRACK_DIR [-p PORT]
```
where `TRACK_DIR` is the simulation project directory. You can then view the 
dashboard at `localhost:PORT`.

![dashboard screenshot](media/blossom-dashboard.png)


### GIF of basic simulation

![example simulation](media/combined.gif)
pygerm 0.0.4
A powerful, component based, 2D Python game engine
Requires Python: >=3.7

PyGerm is a free, open-source, cross-platform library built for the development of 2D, component based games using Python. It is built on top of the Simple DirectMedia Layer library (SDL2) and other popular libraries to abstract away the most tedious tasks of game development. With PyGerm, you can focus on building your game, your way, without worrying about cross-platform support, physics, and more.
yatracker 2024.4.2
Async client for Yandex Tracker API
Requires Python: >=3.10
Keywords: API, Tracker, Yandex, async

YaTracker
===

Asyncio Yandex Tracker API client

[![Python](https://img.shields.io/badge/python-^3.10-blue)](https://www.python.org/)
[![Code linter: ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v1.json)](https://github.com/charliermarsh/ruff)
[![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
[![Linters](https://github.com/Olegt0rr/YaTracker/actions/workflows/linters.yml/badge.svg)](https://github.com/Olegt0rr/YaTracker/actions/workflows/linters.yml)
---

Documentation: https://olegt0rr.github.io/YaTracker/

API docs: https://cloud.yandex.com/en/docs/tracker/about-api

## Attention!
* All `self` properties renamed to `url` cause it's incompatible with Python.
* All `camelCase` properties renamed to `pythonic_case`.
* All datetime values converted to python's `datetime.datetime` objects.
* Methods named by author, cause Yandex API has no clear method names.


## How to install
```text
pip install yatracker
```


## How to use
```python
from yatracker import YaTracker

tracker = YaTracker(org_id=..., token=...)

async def foo():
    # create issue
    issue = await tracker.create_issue('New Issue', 'KEY')

    # get issue
    issue = await tracker.get_issue('KEY-1')

    # update issue (just pass kwargs)
    issue = await tracker.edit_issue('KEY-1', description='Hello World')

    # get transitions:
    transitions = await issue.get_transitions()

    # execute transition
    transition = transitions[0]
    await transition.execute()

```
```python
# don't forget to close tracker on app shutdown
async def on_shutdown():
    await tracker.close()

```