prompt large_stringlengths 72 9.34k | completion large_stringlengths 0 7.61k |
|---|---|
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def __init__(self,header=''):
self._header = header
def send(self... | self._at = ''
return [] |
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def __init__(self,header=''):
self._header = header
def send(self... | self._at = msg.split()[0]+' ' |
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def __init__(self,header=''):
self._header = header
def send(self... | msg = self._at+msg |
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def __init__(self,header=''):
self._header = header
def send(self... | if uid[0] is '@': assert uid[1:] in get_attr(Uid)
else: assert uid in get_attr(Uid) |
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def __init__(self,header=''):
self._header = header
def send(self... | assert uid[1:] in get_attr(Uid) |
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def __init__(self,header=''):
self._header = header
def send(self... | assert uid in get_attr(Uid) |
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def __init__(self,header=''):
self._header = header
def send(self... | Printer('A simple printer: ').send('Just printing a msg to current_thread')
script = [
'@other_uid topic data',
'@other_uid topic',
'uid topic data',
'uid topic'
]
async = ['async topic '+str(n) for n in [1,2,3,4,5,6,7,8,9,0]]
async2 = ['async2 topic '+str(n) for n in [1,2,3,4,5,6,7,8,9,0]]
Script(scri... |
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def <|fim_middle|>(self,header=''):
self._header = header
def sen... | __init__ |
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def __init__(self,header=''):
self._header = header
def <|fim_mid... | send |
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def __init__(self,header=''):
self._header = header
def send(self... | __init__ |
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def __init__(self,header=''):
self._header = header
def send(self... | poll |
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def __init__(self,header=''):
self._header = header
def send(self... | subscribe |
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def __init__(self,header=''):
self._header = header
def send(self... | __init__ |
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def __init__(self,header=''):
self._header = header
def send(self... | poll |
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def __init__(self,header=''):
self._header = header
def send(self... | subscribe |
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def __init__(self,header=''):
self._header = header
def send(self... | load |
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def __init__(self,header=''):
self._header = header
def send(self... | set_period |
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def __init__(self,header=''):
self._header = header
def send(self... | run |
<|file_name|>connectors_local.py<|end_file_name|><｜fim▁begin｜>import time
from threading import Thread
import threading
from wtfj_ids import *
from wtfj_utils import *
class Printer:
''' Opens a new output window and prints messages sent to it '''
def __init__(self,header=''):
self._header = header
def send(self... | run_async |
<|file_name|>__init__.py<|end_file_name|><｜fim▁begin｜>#! /usr/bin/env python
# encoding: UTF-8
<｜fim▁hole｜><｜fim▁end｜> | '''give access permission for files in this folder''' |
<|file_name|>admin.py<|end_file_name|><｜fim▁begin｜>from django.contrib import admin
from .models import Question
# Register your models here.<｜fim▁hole｜><｜fim▁end｜> | admin.site.register(Question) |
<|file_name|>train.py<|end_file_name|><｜fim▁begin｜># Example implementing 5 layer encoder
# Original code taken from
# https://github.com/aymericdamien/TensorFlow-Examples/blob/master/examples/3_NeuralNetworks/autoencoder.py
# The model trained here is restored in load.py
from __future__ import division, print_functio... | y_pred = model.predict(x)
# Cost function
cost = tf.reduce_mean(tf.pow(y_true - y_pred, 2)) |
<|file_name|>blinds.py<|end_file_name|><｜fim▁begin｜># OpenShot Video Editor is a program that creates, modifies, and edits video files.
# Copyright (C) 2009 Jonathan Thomas
#
# This file is part of OpenShot Video Editor (http://launchpad.net/openshot/).
#
# OpenShot Video Editor is free software: you can redistribut... | if params["start_frame"] == params["end_frame"]:
bpy.context.scene.frame_start = params["end_frame"]
bpy.context.scene.frame_end = params["end_frame"]
|
<|file_name|>blinds.py<|end_file_name|><｜fim▁begin｜># OpenShot Video Editor is a program that creates, modifies, and edits video files.
# Copyright (C) 2009 Jonathan Thomas
#
# This file is part of OpenShot Video Editor (http://launchpad.net/openshot/).
#
# OpenShot Video Editor is free software: you can redistribut... | """ Load a new TTF font into Blender, and return the font object """
# get the original list of fonts (before we add a new one)
original_fonts = bpy.data.fonts.keys()
# load new font
bpy.ops.font.open(filepath=font_path)
# get the new list of fonts (after we added a new one)
for font_name in bpy.data.fonts.k... |
<|file_name|>blinds.py<|end_file_name|><｜fim▁begin｜># OpenShot Video Editor is a program that creates, modifies, and edits video files.
# Copyright (C) 2009 Jonathan Thomas
#
# This file is part of OpenShot Video Editor (http://launchpad.net/openshot/).
#
# OpenShot Video Editor is free software: you can redistribut... | return bpy.data.fonts[font_name] |
<|file_name|>blinds.py<|end_file_name|><｜fim▁begin｜># OpenShot Video Editor is a program that creates, modifies, and edits video files.
# Copyright (C) 2009 Jonathan Thomas
#
# This file is part of OpenShot Video Editor (http://launchpad.net/openshot/).
#
# OpenShot Video Editor is free software: you can redistribut... | font = load_font(params["fontname"]) |
<|file_name|>blinds.py<|end_file_name|><｜fim▁begin｜># OpenShot Video Editor is a program that creates, modifies, and edits video files.
# Copyright (C) 2009 Jonathan Thomas
#
# This file is part of OpenShot Video Editor (http://launchpad.net/openshot/).
#
# OpenShot Video Editor is free software: you can redistribut... | font = bpy.data.fonts["Bfont"] |
<|file_name|>blinds.py<|end_file_name|><｜fim▁begin｜># OpenShot Video Editor is a program that creates, modifies, and edits video files.
# Copyright (C) 2009 Jonathan Thomas
#
# This file is part of OpenShot Video Editor (http://launchpad.net/openshot/).
#
# OpenShot Video Editor is free software: you can redistribut... | bpy.context.scene.frame_start = params["end_frame"]
bpy.context.scene.frame_end = params["end_frame"] |
<|file_name|>blinds.py<|end_file_name|><｜fim▁begin｜># OpenShot Video Editor is a program that creates, modifies, and edits video files.
# Copyright (C) 2009 Jonathan Thomas
#
# This file is part of OpenShot Video Editor (http://launchpad.net/openshot/).
#
# OpenShot Video Editor is free software: you can redistribut... | load_font |
<|file_name|>map_remove_entry_listener_codec.py<|end_file_name|><｜fim▁begin｜>from hazelcast.serialization.bits import *
from hazelcast.protocol.client_message import ClientMessage
from hazelcast.protocol.custom_codec import *
from hazelcast.util import ImmutableLazyDataList
from hazelcast.protocol.codec.map_message_typ... | def encode_request(name, registration_id):
""" Encode request into client_message"""
client_message = ClientMessage(payload_size=calculate_size(name, registration_id)) |
<|file_name|>map_remove_entry_listener_codec.py<|end_file_name|><｜fim▁begin｜>from hazelcast.serialization.bits import *
from hazelcast.protocol.client_message import ClientMessage
from hazelcast.protocol.custom_codec import *
from hazelcast.util import ImmutableLazyDataList
from hazelcast.protocol.codec.map_message_typ... | """ Calculates the request payload size"""
data_size = 0
data_size += calculate_size_str(name)
data_size += calculate_size_str(registration_id)
return data_size |
<|file_name|>map_remove_entry_listener_codec.py<|end_file_name|><｜fim▁begin｜>from hazelcast.serialization.bits import *
from hazelcast.protocol.client_message import ClientMessage
from hazelcast.protocol.custom_codec import *
from hazelcast.util import ImmutableLazyDataList
from hazelcast.protocol.codec.map_message_typ... | """ Encode request into client_message"""
client_message = ClientMessage(payload_size=calculate_size(name, registration_id))
client_message.set_message_type(REQUEST_TYPE)
client_message.set_retryable(RETRYABLE)
client_message.append_str(name)
client_message.append_str(registration_id)
client... |
<|file_name|>map_remove_entry_listener_codec.py<|end_file_name|><｜fim▁begin｜>from hazelcast.serialization.bits import *
from hazelcast.protocol.client_message import ClientMessage
from hazelcast.protocol.custom_codec import *
from hazelcast.util import ImmutableLazyDataList
from hazelcast.protocol.codec.map_message_typ... | """ Decode response from client message"""
parameters = dict(response=None)
parameters['response'] = client_message.read_bool()
return parameters |
<|file_name|>map_remove_entry_listener_codec.py<|end_file_name|><｜fim▁begin｜>from hazelcast.serialization.bits import *
from hazelcast.protocol.client_message import ClientMessage
from hazelcast.protocol.custom_codec import *
from hazelcast.util import ImmutableLazyDataList
from hazelcast.protocol.codec.map_message_typ... | calculate_size |
<|file_name|>map_remove_entry_listener_codec.py<|end_file_name|><｜fim▁begin｜>from hazelcast.serialization.bits import *
from hazelcast.protocol.client_message import ClientMessage
from hazelcast.protocol.custom_codec import *
from hazelcast.util import ImmutableLazyDataList
from hazelcast.protocol.codec.map_message_typ... | encode_request |
<|file_name|>map_remove_entry_listener_codec.py<|end_file_name|><｜fim▁begin｜>from hazelcast.serialization.bits import *
from hazelcast.protocol.client_message import ClientMessage
from hazelcast.protocol.custom_codec import *
from hazelcast.util import ImmutableLazyDataList
from hazelcast.protocol.codec.map_message_typ... | decode_response |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
import mock
from sentry.plugins.helpers import get_option, set_option
from sentry.testutils import TestCase
from sentry.models import set_sentry_version, Option
from sentry.tasks.check_update import check_update, PYPI_URL
class CheckUpdateTest(TestCase)... |
def test_run_check_update_task_with_bad_response(self):
with mock.patch('sentry.tasks.check_update.fetch_url_content') as fetch:
fetch.return_value = (None, None, '') |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
import mock
from sentry.plugins.helpers import get_option, set_option
from sentry.testutils import TestCase
from sentry.models import set_sentry_version, Option
from sentry.tasks.check_update import check_update, PYPI_URL
class CheckUpdateTest(TestCase)... | OLD = '5.0.0'
CURRENT = '5.5.0-DEV'
NEW = '1000000000.5.1'
KEY = 'sentry:latest_version'
def test_run_check_update_task(self):
with mock.patch('sentry.tasks.check_update.fetch_url_content') as fetch:
fetch.return_value = (
None, None, json.dumps({'info': {'versi... |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
import mock
from sentry.plugins.helpers import get_option, set_option
from sentry.testutils import TestCase
from sentry.models import set_sentry_version, Option
from sentry.tasks.check_update import check_update, PYPI_URL
class CheckUpdateTest(TestCase)... | with mock.patch('sentry.tasks.check_update.fetch_url_content') as fetch:
fetch.return_value = (
None, None, json.dumps({'info': {'version': self.NEW}})
)
check_update() # latest_version > current_version
fetch.assert_called_once_with(PYPI_URL)
... |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
import mock
from sentry.plugins.helpers import get_option, set_option
from sentry.testutils import TestCase
from sentry.models import set_sentry_version, Option
from sentry.tasks.check_update import check_update, PYPI_URL
class CheckUpdateTest(TestCase)... | with mock.patch('sentry.tasks.check_update.fetch_url_content') as fetch:
fetch.return_value = (None, None, '')
check_update() # latest_version == current_version
fetch.assert_called_once_with(PYPI_URL)
self.assertEqual(get_option(key=self.KEY), None) |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
import mock
from sentry.plugins.helpers import get_option, set_option
from sentry.testutils import TestCase
from sentry.models import set_sentry_version, Option
from sentry.tasks.check_update import check_update, PYPI_URL
class CheckUpdateTest(TestCase)... | set_sentry_version(latest=self.NEW)
self.assertEqual(get_option(key=self.KEY), self.NEW) |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
import mock
from sentry.plugins.helpers import get_option, set_option
from sentry.testutils import TestCase
from sentry.models import set_sentry_version, Option
from sentry.tasks.check_update import check_update, PYPI_URL
class CheckUpdateTest(TestCase)... | set_option(self.KEY, self.OLD)
with mock.patch('sentry.get_version') as get_version:
get_version.return_value = self.CURRENT
set_sentry_version(latest=self.NEW)
self.assertEqual(Option.objects.get_value(key=self.KEY), self.NEW) |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
import mock
from sentry.plugins.helpers import get_option, set_option
from sentry.testutils import TestCase
from sentry.models import set_sentry_version, Option
from sentry.tasks.check_update import check_update, PYPI_URL
class CheckUpdateTest(TestCase)... | set_option(self.KEY, self.NEW)
with mock.patch('sentry.get_version') as get_version:
get_version.return_value = self.CURRENT
set_sentry_version(latest=self.OLD)
self.assertEqual(Option.objects.get_value(key=self.KEY), self.NEW) |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
import mock
from sentry.plugins.helpers import get_option, set_option
from sentry.testutils import TestCase
from sentry.models import set_sentry_version, Option
from sentry.tasks.check_update import check_update, PYPI_URL
class CheckUpdateTest(TestCase)... | test_run_check_update_task |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
import mock
from sentry.plugins.helpers import get_option, set_option
from sentry.testutils import TestCase
from sentry.models import set_sentry_version, Option
from sentry.tasks.check_update import check_update, PYPI_URL
class CheckUpdateTest(TestCase)... | test_run_check_update_task_with_bad_response |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
import mock
from sentry.plugins.helpers import get_option, set_option
from sentry.testutils import TestCase
from sentry.models import set_sentry_version, Option
from sentry.tasks.check_update import check_update, PYPI_URL
class CheckUpdateTest(TestCase)... | test_set_sentry_version_empty_latest |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
import mock
from sentry.plugins.helpers import get_option, set_option
from sentry.testutils import TestCase
from sentry.models import set_sentry_version, Option
from sentry.tasks.check_update import check_update, PYPI_URL
class CheckUpdateTest(TestCase)... | test_set_sentry_version_new |
<|file_name|>tests.py<|end_file_name|><｜fim▁begin｜>import json
import mock
from sentry.plugins.helpers import get_option, set_option
from sentry.testutils import TestCase
from sentry.models import set_sentry_version, Option
from sentry.tasks.check_update import check_update, PYPI_URL
class CheckUpdateTest(TestCase)... | test_set_sentry_version_old |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
<|fim_middle|>
<｜fim▁end｜> | def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f = open(self.file, 'r')
lines = f.readlines()
f.close()
for line in lines:
self.readline(line)
except IOError as e:
print 'File not found:... |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
<|fim_middle|>
def read(self):
try:
f = open(self.file, 'r')
lines = f.readlines()
f.close()
for line in lines:
s... | self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch() |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
<|fim_middl... | try:
f = open(self.file, 'r')
lines = f.readlines()
f.close()
for line in lines:
self.readline(line)
except IOError as e:
print 'File not found: %s (%s)'%(self.file, e)
sys.exit(1) |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | try:
d = os.path.dirname(self.file)
if not os.path.exists(d):
os.makedirs(d)
f = open(self.file, 'w')
f.write('version=%d.%d.%d\n'%(self.major, self.minor, self.revision))
f.write('build=%d\n'%(self.build))
f.write('date=%s\n'%(self.date))
f.close()
except IOError as e:
print 'Failed... |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | line = line.strip('\r\n\t ')
if len(line) == 0:
return
try:
m = re.search('(.*)=(.*)$', line)
if not m:
print 'Failed to parse line: %s'%(line.strip('\n\t '))
return
self.set(m.group(1), m.group(2))
except IndexError as e:
print 'Failed to parse line: %s (%s)'%(line.strip('\n\t '),e) |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | if k == 'version':
m = re.search('.*(\d).(\d).(\d).*', v)
(self.major, self.minor, self.revision) = [int(e) for e in m.groups()]
elif k == 'build':
self.build = int(v)
elif k == 'date':
self.date = v |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | today = date.today()
self.date = today.isoformat() |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | return '%d.%d.%d.%d'%(self.major, self.minor, self.revision, self.build) |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | return '%s'%self.date |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | return 'version: %s, date %s'%(self.version(), self.date) |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | return 'version: %s, date %s'%(self.version(), self.date) |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | if key == 'build':
self.build += 1
elif key == 'revision':
self.revision += 1
self.build = 0
elif key == 'minor':
self.minor += 1
self.revision = 0
self.build = 0
elif key == 'major':
self.major += 1
self.minor = 0
self.revision = 0
self.build = 0 |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | print '%d.%d.%d.%d'%(self.major, self.minor, self.revision, self.build) |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | d = os.path.dirname(file)
if not os.path.exists(d):
os.makedirs(d)
f = open(file, 'w')
(ignored, filename) = os.path.split(file)
name = filename.upper().replace('.', '_')
f.write('#ifndef %s\n'%name)
f.write('#define %s\n'%name)
f.write('#define PRODUCTVER %d,%d,%d,%d\n'%(self.major, self.min... |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | os.makedirs(d) |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | return |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | print 'Failed to parse line: %s'%(line.strip('\n\t '))
return |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | m = re.search('.*(\d).(\d).(\d).*', v)
(self.major, self.minor, self.revision) = [int(e) for e in m.groups()] |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | self.build = int(v) |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | self.date = v |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | self.build += 1 |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | self.revision += 1
self.build = 0 |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | self.minor += 1
self.revision = 0
self.build = 0 |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | self.major += 1
self.minor = 0
self.revision = 0
self.build = 0 |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | os.makedirs(d) |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def <|fim_middle|>(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
... | __init__ |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def <|fim_middle|>(self):
t... | read |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | write |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | readline |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | set |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | touch |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | version |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | datestr |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | __str__ |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | __repr__ |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | increment |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | print_version |
<|file_name|>VersionHandler.py<|end_file_name|><｜fim▁begin｜>#!/bin/python
import re
import sys
import os
from datetime import date
class VersionHandler:
def __init__(self, file):
self.file = file
self.major = 0
self.minor = 0
self.revision = 0
self.build = 1
self.touch()
def read(self):
try:
f =... | write_hpp |
<|file_name|>test_DataSeriesLoader.py<|end_file_name|><｜fim▁begin｜>import unittest
from datetime import datetime
import numpy as np
import pandas as pd
from excel_helper.helper import DataSeriesLoader
class TestDataFrameWithCAGRCalculation(unittest.TestCase):
def test_simple_CAGR(self):
"""
Basi... |
:return:
"""
# the time axis of our dataset |
<|file_name|>test_DataSeriesLoader.py<|end_file_name|><｜fim▁begin｜>import unittest
from datetime import datetime
import numpy as np
import pandas as pd
from excel_helper.helper import DataSeriesLoader
class TestDataFrameWithCAGRCalculation(unittest.TestCase):
<|fim_middle|>
if __name__ == '__main__':
uni... | def test_simple_CAGR(self):
"""
Basic test case, applying CAGR to a Pandas Dataframe.
:return:
"""
# the time axis of our dataset
times = pd.date_range('2009-01-01', '2009-04-01', freq='MS')
# the sample axis our dataset
samples = 2
dfl = Dat... |
<|file_name|>test_DataSeriesLoader.py<|end_file_name|><｜fim▁begin｜>import unittest
from datetime import datetime
import numpy as np
import pandas as pd
from excel_helper.helper import DataSeriesLoader
class TestDataFrameWithCAGRCalculation(unittest.TestCase):
def test_simple_CAGR(self):
<|fim_middle|>
... | """
Basic test case, applying CAGR to a Pandas Dataframe.
:return:
"""
# the time axis of our dataset
times = pd.date_range('2009-01-01', '2009-04-01', freq='MS')
# the sample axis our dataset
samples = 2
dfl = DataSeriesLoader.from_excel('test.x... |
<|file_name|>test_DataSeriesLoader.py<|end_file_name|><｜fim▁begin｜>import unittest
from datetime import datetime
import numpy as np
import pandas as pd
from excel_helper.helper import DataSeriesLoader
class TestDataFrameWithCAGRCalculation(unittest.TestCase):
def test_simple_CAGR(self):
"""
Basi... | """
Basic test case, applying CAGR to a Pandas Dataframe.
:return:
"""
# the time axis of our dataset
times = pd.date_range('2009-01-01', '2009-04-01', freq='MS')
# the sample axis our dataset
samples = 2
dfl = DataSeriesLoader.from_excel('test.x... |
<|file_name|>test_DataSeriesLoader.py<|end_file_name|><｜fim▁begin｜>import unittest
from datetime import datetime
import numpy as np
import pandas as pd
from excel_helper.helper import DataSeriesLoader
class TestDataFrameWithCAGRCalculation(unittest.TestCase):
def test_simple_CAGR(self):
"""
Basi... | """
Basic test case, applying CAGR to a Pandas Dataframe.
:return:
"""
# the time axis of our dataset
times = pd.date_range('2009-01-01', '2009-04-01', freq='MS')
# the sample axis our dataset
samples = 2
dfl = DataSeriesLoader.from_excel('test.x... |
<|file_name|>test_DataSeriesLoader.py<|end_file_name|><｜fim▁begin｜>import unittest
from datetime import datetime
import numpy as np
import pandas as pd
from excel_helper.helper import DataSeriesLoader
class TestDataFrameWithCAGRCalculation(unittest.TestCase):
def test_simple_CAGR(self):
"""
Basi... | """
Basic test case, applying CAGR to a Pandas Dataframe.
:return:
"""
# the time axis of our dataset
times = pd.date_range('2009-01-01', '2009-04-01', freq='MS')
# the sample axis our dataset
samples = 2
dfl = DataSeriesLoader.from_excel('test.x... |
<|file_name|>test_DataSeriesLoader.py<|end_file_name|><｜fim▁begin｜>import unittest
from datetime import datetime
import numpy as np
import pandas as pd
from excel_helper.helper import DataSeriesLoader
class TestDataFrameWithCAGRCalculation(unittest.TestCase):
def test_simple_CAGR(self):
"""
Basi... | times = pd.date_range('2009-01-01', '2009-04-01', freq='MS')
xls = pd.ExcelFile('test.xlsx')
df = xls.parse('Sheet1')
ldr = DataSeriesLoader.from_dataframe(df, times, size=2)
res = ldr['static_one']
assert res.loc[[datetime(2009, 1, 1)]][0] == 1
assert np.abs(re... |
<|file_name|>test_DataSeriesLoader.py<|end_file_name|><｜fim▁begin｜>import unittest
from datetime import datetime
import numpy as np
import pandas as pd
from excel_helper.helper import DataSeriesLoader
class TestDataFrameWithCAGRCalculation(unittest.TestCase):
def test_simple_CAGR(self):
"""
Basi... | """
Basic test case, applying CAGR to a Pandas Dataframe.
:return:
"""
# the time axis of our dataset
times = pd.date_range('2015-01-01', '2016-01-01', freq='MS')
# the sample axis our dataset
samples = 2
dfl = DataSeriesLoader.from_excel('test.x... |
<|file_name|>test_DataSeriesLoader.py<|end_file_name|><｜fim▁begin｜>import unittest
from datetime import datetime
import numpy as np
import pandas as pd
from excel_helper.helper import DataSeriesLoader
class TestDataFrameWithCAGRCalculation(unittest.TestCase):
def test_simple_CAGR(self):
"""
Basi... | unittest.main() |
<|file_name|>test_DataSeriesLoader.py<|end_file_name|><｜fim▁begin｜>import unittest
from datetime import datetime
import numpy as np
import pandas as pd
from excel_helper.helper import DataSeriesLoader
class TestDataFrameWithCAGRCalculation(unittest.TestCase):
def <|fim_middle|>(self):
"""
Basic ... | test_simple_CAGR |
<|file_name|>test_DataSeriesLoader.py<|end_file_name|><｜fim▁begin｜>import unittest
from datetime import datetime
import numpy as np
import pandas as pd
from excel_helper.helper import DataSeriesLoader
class TestDataFrameWithCAGRCalculation(unittest.TestCase):
def test_simple_CAGR(self):
"""
Basi... | test_CAGR_ref_date_within_bounds |
<|file_name|>test_DataSeriesLoader.py<|end_file_name|><｜fim▁begin｜>import unittest
from datetime import datetime
import numpy as np
import pandas as pd
from excel_helper.helper import DataSeriesLoader
class TestDataFrameWithCAGRCalculation(unittest.TestCase):
def test_simple_CAGR(self):
"""
Basi... | test_CAGR_ref_date_before_start |
<|file_name|>test_DataSeriesLoader.py<|end_file_name|><｜fim▁begin｜>import unittest
from datetime import datetime
import numpy as np
import pandas as pd
from excel_helper.helper import DataSeriesLoader
class TestDataFrameWithCAGRCalculation(unittest.TestCase):
def test_simple_CAGR(self):
"""
Basi... | test_CAGR_ref_date_after_end |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.