def run(event, context):
load_dependency('pydot')
channel = event.get('channel')
data = event.get('dot')
#slack_message("in dot to svg: {0}".format(event), [], channel)
log_to_elk("in dot to svg: {0}".format(event))
import dot_parser
try:
(fd, tmp_file) = tempfile.mkstemp('dot)')
dot_static = '/tmp/lambdas-dependencies/pydot/dot_static'
Process.run("chmod", ['+x', dot_static])
data = data.replace('<', '<').replace(
'>', '>'
) # this solved a really nasty bug caused by the fact that Slack will html encode the < and >
# graph = pydot.graph_from_dot_data(data).pop()
# <from pydot> use code below (instead of above) to get a better error message from dot parser
graphparser = dot_parser.graph_definition()
graphparser.parseWithTabs()
tokens = graphparser.parseString(data)
graph = list(tokens).pop()
# </from pydot>
graph.write_svg(tmp_file, prog=dot_static)
svg_raw = Files.contents(tmp_file)
return base64.b64encode(svg_raw.encode()).decode()
except Exception as error:
slack_message("[dot_to_svg] Error: {0} ".format(error), [], channel)
return None
def elk(team_id=None, channel=None, params=None):
load_dependency('syncer')
from osbot_browser.browser.sites.Site_ELK import ELK_Commands
from osbot_browser.browser.sites.Site_ELK import Site_ELK
if len(params) == 0:
Slack_Commands_Helper(ELK_Commands).invoke(team_id, channel,
params)
return None
browser_helper = Browser_Lamdba_Helper().setup()
elk = Site_ELK(browser_helper.api_browser, team_id, channel)
elk.sync__connect_and_login()
params.append(browser_helper)
params.append(elk)
result = Slack_Commands_Helper(ELK_Commands).invoke(
team_id, channel, params)
if team_id:
return None
else:
return result
def run(event, context):
load_dependency('plantuml')
dot_static = '/tmp/lambdas-dependencies/plantuml/dot_static'
plantuml_jar = '/tmp/lambdas-dependencies/plantuml/plantuml.jar'
Process.run("chmod", ['+x', dot_static])
Process.run("chmod", ['+x', plantuml_jar])
os.environ['PLANTUML_LIMIT_SIZE'] = str(
4096 * 4) # set max with to 4 times the default (16,384)
os.environ['GRAPHVIZ_DOT'] = dot_static
(fd, puml_file) = tempfile.mkstemp('.puml')
png_file = puml_file.replace(".puml", ".png")
code = event.get('puml')
Files.write(puml_file, code)
subprocess.run([
'java', '-jar', plantuml_jar, '-Xmx2512m', '-tpng', '-o', '/tmp',
puml_file
],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
if os.path.exists(png_file):
with open(png_file, "rb") as image_file:
png = base64.b64encode(image_file.read()).decode()
else:
png = None
return {"png_base64": png}
def run(event, context):
load_dependency('jira')
data = event.get('data')
channel = event.get('channel')
team_id = event.get('team_id')
from osbot_jira.api.slack.Slack_Dialog_Submissions import Slack_Dialog_Submissions
return Slack_Dialog_Submissions(data, channel, team_id).handle()
def run(event, context):
load_dependency("slack") # this will download the dependencies the first time the lambda function is executed
from pbx_gs_python_utils.utils.slack.API_Slack import API_Slack
API_Slack(channel='...').send_message("this was sent from an lambda function")
#load_dependency("requests") # the Slack dependency already includes this dependency
import requests
return len(requests.get("https://www.google.com").text)
def run(event, context):
load_dependency('requests')
issue_id = event.get('issue_id')
from osbot_jira.api.jira_server.API_Jira_Rest import API_Jira_Rest
api_jira_rest = API_Jira_Rest()
return api_jira_rest.issue(issue_id)
def run(event, context):
load_dependency('jupyter')
#result = Process.run('jupyter')
from runipy.notebook_runner import NotebookRunner
from IPython.nbformat.current import read
notebook = read(open("MyNotebook.ipynb"), 'json')
return notebook
def run(event, context):
load_dependency(
"pyppeteer"
) # (on first run downloads a zip file from S3 to /tmp/lambdas-dependencies/pyppeteer/ which contains
# the contents of `pip3 install pyppeteer - t pyppeteer` and the headless_shell file created by
# https://github.com/sambaiz/puppeteer-lambda-starter-kit
# This command also sets the add the /tmp/lambdas-dependencies/pyppeteer/ to sys.path
path_headless_shell = '/tmp/lambdas-dependencies/pyppeteer/headless_shell' # path to headless_shell AWS Linux executable
path_page_screenshot = '/tmp/screenshot.png' # path to store screenshot of url loaded
os.environ[
'PYPPETEER_HOME'] = '/tmp' # tell pyppeteer to use this read-write path in Lambda aws
target_url = event.get('url') # get url to load from lambda params
doc_type = event.get('doc_type')
async def get_screenshot(): # async method to run request
from pyppeteer import launch # import pyppeteer dependency
Process.run("chmod",
['+x', path_headless_shell
]) # set the privs of path_headless_shell to execute
browser = await launch(
executablePath=
path_headless_shell, # lauch chrome (i.e. headless_shell)
args=['--no-sandbox', '--single-process'
]) # two key settings or the requests will not work
page = await browser.newPage(
) # typical pyppeteer code, where we create a new Page object
await page.goto(target_url) # - open an url
await page.waitFor(2 * 1000)
# To Remove
#await page.waitForNavigation(); not working
if doc_type and doc_type == 'pdf':
await page.pdf({'path': path_page_screenshot})
else:
await page.screenshot({
'path': path_page_screenshot
}) # - take a screenshot of the page loaded and save it
await browser.close() # - close the browser
asyncio.get_event_loop().run_until_complete(get_screenshot(
)) # event loop to start the run async method which will open the
# url provided in the lambda params and save it as an png
with open(path_page_screenshot,
"rb") as image_file: # open path_page_screenshot file
encoded_png = base64.b64encode(image_file.read()).decode(
) # save it as a png string (base64 encoded to make it easier to return)
return {"base64_data": encoded_png} # return value to Lambda caller
def run(event, context):
load_dependency('requests')
from osbot_jupyter.api.Live_Notebook import Live_Notebook
short_id = event.get('short_id')
code = event.get('code')
target = event.get('target')
keep_contents = event.get('keep_contents')
notebook = Live_Notebook(short_id)
notebook.login()
return notebook.execute_python(python_code=code,
target=target,
keep_contents=keep_contents)
return notebook.jupyter_web().screenshot_base64()
def cmd_create(self, params, team_id=None, channel=None):
try:
if len(params) < 3:
text = ":exclamation: To create an issue you need to provide the `issue type` and `summary`. For example `jira create task abc"
return {"text": text, "attachments": []}
else:
params.pop(0) # the create command
issue_type = params.pop(
0) #.title() # todo: find a better solution for this
project = issue_type.upper(
) # todo: and to address the mapping of issue types to projects
summary = ' '.join(params)
slack_message(
':point_right: Going to create an `{0}` issue, in project `{1}` with summary `{2}`'
.format(issue_type, project,
summary), [], channel, team_id)
#to do, move this feature to a separate lambda (which can be called to create issues
from osbot_aws.Dependencies import load_dependency
load_dependency('jira')
from osbot_jira.api.jira_server.API_Jira import API_Jira
# create issue
result = API_Jira().issue_create(project, summary, '',
issue_type)
issue_id = "{0}".format(result)
# show issue screenshot
# payload = {'issue_id': issue_id,'channel': channel,'team_id': team_id, }
# Lambda('osbot_browser.lambdas.jira_web').invoke_async(payload)
# show issue UI
payload = {'params': ['issue', issue_id], "channel": channel}
Lambda('osbot_jira.lambdas.jira').invoke_async(payload)
# show link of new issue to user
jira_link = "https://glasswall.atlassian.net/browse/{0}".format(
issue_id)
text = ':point_right: New issue created with id <{0}|{1}>'.format(
jira_link, issue_id)
return {"text": text, "attachments": []}
except Exception as error:
log_to_elk('jira create error', f'{error}')
return {
'text':
f':red_circle: Issue could not be created, please make sure that: \n - issue type exists\n - issue type = project type\n - Issue type CamelCase is correctly entered (you want `Task` and not `task`)',
"attachments": []
}
def maps(team_id=None, channel=None, params=None):
load_dependency('syncer')
load_dependency('requests')
load_dependency('pyppeteer')
load_dependency('websocket-client')
from osbot_browser.view_helpers.Maps_Views import Maps_Views
(text, attachments) = Slack_Commands_Helper(Maps_Views).invoke(
'not-used', channel, params)
if team_id is None:
return text
def sow(team_id=None, channel=None, params=None):
load_dependency('syncer')
load_dependency('requests')
load_dependency('pyppeteer')
load_dependency('websocket-client')
try:
from osbot_browser.view_helpers.Sow_Views import Sow_Views
(text, attachments) = Slack_Commands_Helper(Sow_Views).invoke(
'not-used', channel, params)
if channel is None:
return text
except Exception as error:
return f'[sow error] {error}'
def handle_request(self, event, response_handler=None):
load_dependency('requests')
import requests
path = event.get('path', '')
method = event.get('httpMethod', '')
headers = event.get('headers', {})
domain_prefix = event.get('requestContext', {}).get('domainPrefix')
try:
self.log_request(path, method, headers, domain_prefix, self.url)
request_headers = {
'accept': headers.get('headers'),
'User-Agent': headers.get('User-Agent'),
'accept-encoding': headers.get('accept-encoding'),
}
response = requests.get(self.url, headers=request_headers)
# The original value of result.headers is not serializable:
response_headers = {}
for key, value in response.headers.items():
if key != 'Content-Encoding':
response_headers[key] = str(value)
response_body = self.get_response_body(response)
if response_handler:
response_body = response_handler.process(response_body)
return self.response(
self.is_binary_content_type(response), HTTPStatus.OK.value,
response_headers, response_body
)
except Exception as error:
message = f'Proxy error: {error}'
log_to_elk('proxy message', message, level='error')
return self.response(
False, HTTPStatus.INTERNAL_SERVER_ERROR.value, headers, message
)
def run(event, context):
load_dependency('gmail')
from _from_pydot.gmail.API_GMail import API_GMail
gmail = API_GMail().setup()
return gmail.labels()
def test_nbconvert(self):
payload = { }
from osbot_aws.Dependencies import load_dependency
load_dependency('jupyter')
#self.png_data = self.aws_lambda.invoke(payload)
self.result = self.aws_lambda.invoke(payload)