index
int64 | repo_name
string | branch_name
string | path
string | content
string | import_graph
string |
|---|---|---|---|---|---|
36,150
|
sevberg/prefect_playground
|
refs/heads/main
|
/setup.py
|
import pathlib
from setuptools import setup
# The directory containing this file
HERE = pathlib.Path(__file__).parent
with open(HERE / "requirements.txt") as f:
required_packages = f.read().splitlines()
README = (HERE / "README.md").read_text()
VERSION = (HERE / ".version").read_text()
setup(
name="prefectplayground",
version=VERSION,
description="Prefect Playground",
author="D. Severin Ryberg",
author_email="severin-ryberg@sevberg.dev",
packages=["prefectplayground"],
install_requires=required_packages,
)
|
{"/workflow/flow_generator.py": ["/prefectplayground/tasks.py"]}
|
36,151
|
sevberg/prefect_playground
|
refs/heads/main
|
/prefectplayground/tasks.py
|
from prefect import task
import numpy as np
from typing import List, Sized
@task(log_stdout=True)
def generate_list(
n_members: int = 100,
min_value: int = 1000,
max_value: int = 2000,
cycles: int = 1,
seed: int = None,
) -> List[int]:
"""Generate a list of length `n_members` between `min_value` and `max_value`.
`cycles` can be used to increase runtime"""
if seed is not None:
np.random.seed(seed)
for _ in range(cycles):
output = np.random.choice(np.arange(min_value, max_value + 1), size=n_members)
return output.tolist()
@task(log_stdout=True)
def add_matrix(size: int = 1e5, cycles: int = 1000, seed: int = None) -> float:
"""Adds a randomly generated matrix of size `size` by `size` to itself `cycles` times. Then returns the mean of the matrix"""
if seed is not None:
np.random.seed(seed)
matrix = np.random.random(size=(size, size))
for _ in range(cycles):
matrix += matrix
return float(matrix.mean())
|
{"/workflow/flow_generator.py": ["/prefectplayground/tasks.py"]}
|
36,167
|
DoktaPola/Maven_Helper
|
refs/heads/master
|
/maven_helper.py
|
import os
import sys
import zipfile
def traverse_dir(file_path_in, file_path_out):
my_array = []
snapshot_file = open(file_path_out, 'w')
for subdir, dirs, files in os.walk(file_path_in):
for file in files:
if file.endswith('.pom'):
new_subdir = subdir.replace(file_path_in + os.sep, "")
snapshot_file.write(new_subdir + '\n')
my_array.append(os.path.join(subdir, file))
snapshot_file.close()
return my_array
def find_pom(root, file_path):
pom_file = None
for subdir, dirs, files in os.walk(root + os.sep + file_path):
for file in files:
if file.endswith('.pom'):
if is_valid_pom(file, file_path):
pom_file = os.path.join(subdir, file)
return pom_file
def is_valid_pom(found_artifact, missing_lab):
parts = found_artifact.replace('.pom', '')
parts2 = missing_lab.split(os.sep)
str1 = ''
str1 += parts2[len(parts2) - 2] + "-" + parts2[len(parts2) - 1]
if str1 == parts:
return True
return False
def extract_pom_dependency_lines(art):
all_depend = []
f = open(art, 'r')
lines = f.readlines()
f.close()
start, end = '<dependencies>', '</dependencies>'
Flag = False
for line in lines:
line = line.strip()
if Flag:
if line == end:
Flag = False
else:
all_depend.append(line)
elif line == start:
Flag = True
return all_depend
def get_dependent_artifacts(dependency_blocks_lines):
all_versions = []
group_id_splits = None
artifact_id_splits = None
version_splits = None
for a in dependency_blocks_lines:
all = ''
if a.startswith('<groupId>'):
group_id_splits = a.replace('<groupId>', '')
group_id_splits = group_id_splits.replace('</groupId>', '')
if a.startswith('<artifactId>'):
artifact_id_splits = a.replace('<artifactId>', '')
artifact_id_splits = artifact_id_splits.replace('</artifactId>', '')
if a.startswith('<version>'):
version_splits = a.replace('<version>', '')
version_splits = version_splits.replace('</version>', '')
if group_id_splits and artifact_id_splits and version_splits:
all += str(group_id_splits) + ":" + str(artifact_id_splits) + ":" + str(version_splits)
all_versions.append(all)
group_id_splits = artifact_id_splits = version_splits = None
return all_versions
def dependent_artifacts_to_poms(deps):
pom_paths = []
for d in deps:
parts = d.split(':')
for i in range(0, len(parts) - 2):
parts[i] = parts[i].replace('.', os.sep)
parts.append(parts[len(parts) - 2] + os.sep + parts[len(parts) - 1])
parts.remove(parts[1])
parts.remove(parts[1])
s = os.sep.join(parts)
pom_paths.append(s)
return set(pom_paths)
def collect_dependent_poms(artifact, set_of_poms, path_to_maven_folder):
new_artifact = find_pom(path_to_maven_folder, artifact)
if new_artifact:
all_file = extract_pom_dependency_lines(new_artifact)
version = get_dependent_artifacts(all_file)
poms = dependent_artifacts_to_poms(version)
for pom in poms:
set_of_poms.add(pom)
collect_dependent_poms(pom, set_of_poms, path_to_maven_folder)
def read_snap_file(snapshot):
snapshot_file = open(snapshot, 'r')
set_pom = set()
for line in snapshot_file:
set_pom.add(line.strip())
snapshot_file.close()
return set_pom
def find_difference(local, deps):
remote = deps
missed_in_local = remote.difference(local)
if missed_in_local == 0:
print('NO DEPENDENCIES')
return missed_in_local
def zipdir(path, zip_file_name):
for root, dirs, files in os.walk(path):
newzip = zipfile.ZipFile(zip_file_name, 'a')
for file in files:
newzip.write(root + os.sep + file)
newzip.close()
def main():
help_message = '''Please, enter a valid request!'
If you want to use A LOCAL MODE, you should enter:
(--snapshot-maven-local-repo, full path to your snapshot file, full path to Maven folder.)
Example: --snapshot-maven-local-repo .\\SNAPSHOT .\\local
If you want to use A REMOTE MODE, you should enter:
(--pack-missing-artifact-deps, missing library, full path to snapshot file, full path to Maven folder,
full path where you want to your save finale archive.)'
Example: --pack-missing-artifact-deps .\\remote\\org\\apache\\jena\\jena-tdb2\\3.8.0 .\\SNAPSHOT .\\remote .\\MY_AR.zip'''
if len(sys.argv) < 2:
print(help_message)
else:
if sys.argv[1] == '--snapshot-maven-local-repo':
path_to_file = sys.argv[2]
path_to_maven_folder = sys.argv[3]
traverse_dir(path_to_maven_folder, path_to_file)
elif sys.argv[1] == '--pack-missing-artifact-deps':
artifact = sys.argv[2]
path_to_maven_folder = sys.argv[4]
snapshot_file = sys.argv[3]
zip_file_name = sys.argv[5]
zipdir(path_to_maven_folder + os.sep + artifact, zip_file_name)
set_of_poms = set()
collect_dependent_poms(artifact, set_of_poms, path_to_maven_folder)
local_set = read_snap_file(snapshot_file)
difference = find_difference(local_set, set_of_poms)
for d in difference:
zipdir(path_to_maven_folder + os.sep + d, zip_file_name)
else:
print(help_message)
if __name__ == "__main__":
main()
|
{"/unit_test_open_file.py": ["/maven_helper.py"]}
|
36,168
|
DoktaPola/Maven_Helper
|
refs/heads/master
|
/unit_test_open_file.py
|
import os
import unittest
from unittest.mock import patch
from maven_helper import open_each_file
class TestMaven_Helper(unittest.TestCase):
"""Unit test for Maven helper"""
@patch('os.walk')
def test_open_each_file(self, walk):
"""unit test when .pom is in path"""
path = 'path'
pom_file = 'my_pom.pom'
walk.return_value = [
(path, (), ('test.txt', pom_file, 'abc.doc')),
]
actual_res = find_pom(path)
expected_res = os.path.join(path, pom_file)
self.assertEqual(actual_res, expected_res)
@patch('os.walk')
def test_find_pom_several(self, walk):
"""unit test when several .pom are in path"""
path = 'path'
pom_files = ('my_pom.pom', 'second_pom.pom')
walk.return_value = [
(path, (), pom_files)
]
self.assertRaises(ValueError, find_pom, path)
@patch('os.walk')
def test_no_pom(self, walk):
"""unit test when .pom is not in the path"""
path = 'path'
pom_file = ()
walk.return_value = [
(path, (), pom_file)
]
self.assertRaises(ValueError, find_pom, path)
|
{"/unit_test_open_file.py": ["/maven_helper.py"]}
|
36,188
|
zykron1/Line-Track-Designer
|
refs/heads/master
|
/tests/test_cli.py
|
import os
from click.testing import CliRunner
from line_track_designer.cli import linetrack
path = os.path.dirname(os.path.abspath(__file__))
def test_show():
runner = CliRunner()
result = runner.invoke(
linetrack, ['show', os.path.join(path, 'track.txt')])
assert result.exit_code == 0
def test_write():
runner = CliRunner()
result = runner.invoke(
linetrack, ['write', os.path.join(path, 'track.txt')])
assert result.exit_code == 0
def test_savepng():
runner = CliRunner()
result = runner.invoke(
linetrack, ['savepng', os.path.join(path, 'track.txt')])
assert result.exit_code == 0
def test_savemd():
runner = CliRunner()
result = runner.invoke(
linetrack, ['savemd', os.path.join(path, 'track.txt')])
assert result.exit_code == 0
def test_rotate():
runner = CliRunner()
result = runner.invoke(
linetrack, ['rotate', os.path.join(path, 'track.txt'), '-n', 4])
assert result.exit_code == 0
|
{"/tests/test_cli.py": ["/line_track_designer/cli.py"], "/examples/example2.py": ["/line_track_designer/track.py"], "/tests/test_track.py": ["/line_track_designer/track.py"], "/line_track_designer/track.py": ["/line_track_designer/printer.py", "/line_track_designer/tile.py", "/line_track_designer/error.py", "/line_track_designer/markdown.py"], "/line_track_designer/printer.py": ["/line_track_designer/error.py"], "/examples/example4.py": ["/line_track_designer/track.py"], "/examples/example3.py": ["/line_track_designer/track.py"], "/line_track_designer/cli.py": ["/line_track_designer/track.py", "/line_track_designer/tile.py"], "/line_track_designer/tile.py": ["/line_track_designer/error.py"], "/examples/example5.py": ["/line_track_designer/track.py"], "/examples/example1.py": ["/line_track_designer/track.py"]}
|
36,189
|
zykron1/Line-Track-Designer
|
refs/heads/master
|
/examples/example2.py
|
"""
Example 2: Importation of a track and exportation to PNG and MD
"""
from line_track_designer.track import Track
if __name__ == "__main__":
# Import the track saved in a text file
track = Track.read('track_colors/track_colors.txt', 'Colors track')
# Export the track as png and markdown files
track.save_md('track_colors/track_colors.md', 'A track with colors')
|
{"/tests/test_cli.py": ["/line_track_designer/cli.py"], "/examples/example2.py": ["/line_track_designer/track.py"], "/tests/test_track.py": ["/line_track_designer/track.py"], "/line_track_designer/track.py": ["/line_track_designer/printer.py", "/line_track_designer/tile.py", "/line_track_designer/error.py", "/line_track_designer/markdown.py"], "/line_track_designer/printer.py": ["/line_track_designer/error.py"], "/examples/example4.py": ["/line_track_designer/track.py"], "/examples/example3.py": ["/line_track_designer/track.py"], "/line_track_designer/cli.py": ["/line_track_designer/track.py", "/line_track_designer/tile.py"], "/line_track_designer/tile.py": ["/line_track_designer/error.py"], "/examples/example5.py": ["/line_track_designer/track.py"], "/examples/example1.py": ["/line_track_designer/track.py"]}
|
36,190
|
zykron1/Line-Track-Designer
|
refs/heads/master
|
/tests/test_track.py
|
import os
import numpy as np
from line_track_designer.track import Track
import pytest
path = os.path.dirname(os.path.abspath(__file__))
@pytest.fixture
def track():
return Track.read(os.path.join(path, 'track.txt'))
@pytest.fixture
def track_hard():
return Track.read(os.path.join(path, 'track_hard.txt'))
def test_track():
# Arrays for the track
tiles = np.array([
[3, 2, 3],
[2, 11, 2],
[3, 2, 3]
])
orient = np.array([
[1, 1, 0],
[0, 0, 0],
[2, 1, 3]
])
name = 'Test track'
# Creation of the track
track = Track(tiles, orient, name)
assert (track.tiles == tiles).all()
assert (track.orient == orient).all()
assert track.name == name
# Test string format
with open(os.path.join(path, 'track.txt')) as f:
assert f.read() == str(track)
def test_max_shape():
assert Track.max_shape(2000, 1500) == (10, 7)
assert Track.max_shape(200, 150) == (1, 0)
def test_add(track):
# Test add col & row
track.add_col()
track.add_row()
tiles = np.array([
[3, 2, 3, 0],
[2, 11, 2, 0],
[3, 2, 3, 0],
[0, 0, 0, 0]
])
orient = np.array([
[1, 1, 0, 0],
[0, 0, 0, 0],
[2, 1, 3, 0],
[0, 0, 0, 0]
])
assert (track.tiles == tiles).all()
assert (track.orient == orient).all()
def test_del(track):
# Test del col & row
track.del_col(1)
track.del_row(1)
tiles = np.array([
[3, 3],
[3, 3]
])
orient = np.array([
[1, 0],
[2, 3]
])
assert (track.tiles == tiles).all()
assert (track.orient == orient).all()
def test_set_tile(track):
# Test set tile
track.set_tile(1, 2, 26, 2)
track.set_tile(3, 3, 12, 1)
tiles = np.array([
[3, 2, 3, 0],
[2, 11, 26, 0],
[3, 2, 3, 0],
[0, 0, 0, 12]
])
orient = np.array([
[1, 1, 0, 0],
[0, 0, 2, 0],
[2, 1, 3, 0],
[0, 0, 0, 1]
])
assert (track.tiles == tiles).all()
assert (track.orient == orient).all()
def test_rotate(track):
# Test rotate
track.rotate()
with open(os.path.join(path, 'track_rotate_1.txt')) as f:
assert f.read() == str(track)
track.rotate(2)
with open(os.path.join(path, 'track_rotate_2.txt')) as f:
assert f.read() == str(track)
def test_dimensions(track, track_hard):
# Test dimensions
assert track.dimensions() == (600, 600)
assert track_hard.dimensions() == (600, 1000)
|
{"/tests/test_cli.py": ["/line_track_designer/cli.py"], "/examples/example2.py": ["/line_track_designer/track.py"], "/tests/test_track.py": ["/line_track_designer/track.py"], "/line_track_designer/track.py": ["/line_track_designer/printer.py", "/line_track_designer/tile.py", "/line_track_designer/error.py", "/line_track_designer/markdown.py"], "/line_track_designer/printer.py": ["/line_track_designer/error.py"], "/examples/example4.py": ["/line_track_designer/track.py"], "/examples/example3.py": ["/line_track_designer/track.py"], "/line_track_designer/cli.py": ["/line_track_designer/track.py", "/line_track_designer/tile.py"], "/line_track_designer/tile.py": ["/line_track_designer/error.py"], "/examples/example5.py": ["/line_track_designer/track.py"], "/examples/example1.py": ["/line_track_designer/track.py"]}
|
36,191
|
zykron1/Line-Track-Designer
|
refs/heads/master
|
/line_track_designer/track.py
|
"""
With the **track** module, you can create, import, edit, save, and
export tracks.
"""
from pathlib import Path
import numpy as np
from PIL import Image
import logging
from line_track_designer.printer import Printer
from line_track_designer.tile import Tile, Tiles
from line_track_designer.error import LineTrackDesignerError
from line_track_designer.markdown import Markdown
class Track:
"""
Representation of a track.
An instance of the **Track** class is composed of three fields:
* **tiles**: array which contains the number of each tile of the track
* **orient**: array which indicates the orientation of each tile
* **name**: name of the track
"""
@staticmethod
def read(file, name='track'):
"""
Read a text file representing a track
and return the track associated.
Args:
file (str): filename
name (str): name of the track
Returns:
Track: the track associated to the file
Raises:
LineTrackDesignerError: file not found
LineTrackDesignerError: bad filename extension: requires .txt
"""
try:
f = open(file, 'r')
except IOError:
raise LineTrackDesignerError('file {} not found'.format(file))
p = Path(file)
if p.suffix != '.txt':
raise LineTrackDesignerError(
'bad filename extension: requires .txt')
lines = f.readlines()
f.close()
tiles, orient = [], []
for line in lines:
line = line.strip('\n').split(' ')
lt, lo = [], []
for i in line:
t, o = i.split(';')
lt.append(int(t))
lo.append(int(o))
tiles.append(lt)
orient.append(lo)
logging.info('Reading track: {}'.format(file))
return Track(
np.array(tiles, dtype=int),
np.array(orient, dtype=int), name)
@staticmethod
def zeros(nrow, ncol, name='track'):
"""
Create an empty track.
Args:
nrow (int): number of rows
ncol (int): number of columns
name (str): name of the track
Returns:
Track: empty track (only zeros)
"""
tiles = np.zeros((nrow, ncol), dtype=int)
orient = np.zeros((nrow, ncol), dtype=int)
return Track(tiles, orient, name)
@staticmethod
def max_shape(width, height):
"""
Return the maximum number of rows and columns
of a track limited by a width and a height in mm.
Args:
width (int): width in mm
height (int): height in mm
Returns:
tuple of int: number of rows and columns
"""
return width // Tile.SIDE, height // Tile.SIDE
def __init__(self, tiles, orient, name='track'):
"""
Init a track. The arguments tiles and orient must be numpy arrays.
For example:
.. code-block:: python
import numpy as np
from line_track_designer.track import Track
tiles = np.array([
[3, 2, 3],
[2, 11, 2],
[3, 2, 3]
])
orient = np.array([
[1, 1, 0],
[0, 0, 0],
[2, 1, 3]
])
track = Track(tiles, orient, 'my track')
Args:
tiles (numpy.array): array of tiles
orient (numpy.array): array of orientations
name (str): name of the track
Raises:
LineTrackDesignerError: tiles and orient must have the same shape
LineTrackDesignerError: invalid values
"""
if (tiles.shape != orient.shape):
raise LineTrackDesignerError(
'tiles and orient must have the same shape')
nrow, ncol = tiles.shape
for i in range(nrow):
for j in range(ncol):
t, o = tiles[i][j], orient[i][j]
if t != 0 and not Tile.is_valid(t):
raise LineTrackDesignerError(
'{} is not a valid tile value'.format(t))
if not 0 <= o <= 3:
raise LineTrackDesignerError(
'{} is not a valid orient value'.format(o))
self._name = name
self._tiles = tiles.copy()
self._orient = orient.copy()
logging.info('Track created')
@property
def tiles(self):
"""Get the array of tiles."""
return self._tiles
@property
def orient(self):
"""Get the array of orientations."""
return self._orient
@property
def name(self):
"""Get the name of the track."""
return self._name
def __str__(self):
"""
Make the string format of the track.
The tiles and orient matrix are superposed in one matrix.
Each couple of values is separated by a semicolon.
With the last example, we obtain:
.. code-block:: text
3;1 2;1 3;0
2;0 11;0 2;0
3;2 2;1 3;3
"""
lines = []
for line_t, line_o in zip(self.tiles, self.orient):
line = ' '.join(
['{};{}'.format(t, o) for t, o in zip(line_t, line_o)])
lines.append(line)
return '\n'.join(lines)
def __repr__(self):
"""
Make the repr format of the track.
It's the same than the string format.
"""
return str(self)
def add_col(self):
"""
Add a column to the track. This column is filled with 0.
"""
new_col = np.zeros(self.tiles.shape[0], dtype=int)
new_col = np.atleast_2d(new_col).T
self._tiles = np.hstack([self.tiles, new_col])
self._orient = np.hstack([self.orient, new_col])
logging.info('Column added to track')
def add_row(self):
"""
Add a row to the track. This row is filled with 0.
"""
new_row = np.zeros(self.tiles.shape[1], dtype=int)
self._tiles = np.vstack([self.tiles, new_row])
self._orient = np.vstack([self.orient, new_row])
logging.info('Row added to track')
def del_col(self, col):
"""
Delete a column from the track.
Args:
col (int): index of the column to delete
"""
self._tiles = np.delete(self.tiles, col, axis=1)
self._orient = np.delete(self.orient, col, axis=1)
logging.info('Column deleted from track')
def del_row(self, row):
"""
Delete a row from the track.
Args:
row (int): index of the row to delete
"""
self._tiles = np.delete(self.tiles, row, axis=0)
self._orient = np.delete(self.orient, row, axis=0)
logging.info('Row deleted from track')
def set_tile(self, row, col, tile, orient):
"""
Set a tile of the track.
Args:
row (int): index of the row of the tile
col (int): index of the column of the tile
tile (int): number of the tile
orient (int): orientation of the tile
Raises:
LineTrackDesignerError: invalid tile/orient value
"""
if tile != 0 and not Tile.is_valid(tile):
raise LineTrackDesignerError(
'{} is not a valid tile value'.format(tile))
if not 0 <= orient <= 3:
raise LineTrackDesignerError(
'{} is not a valid orient value'.format(orient))
nrow, ncol = self.tiles.shape
if row >= nrow:
for _ in range(nrow - 1, row):
self.add_row()
if col >= ncol:
for _ in range(ncol - 1, col):
self.add_col()
self._tiles[row][col] = tile
self._orient[row][col] = orient
logging.info('Tile ({}, {}) set to track'.format(row, col))
def rotate(self, k=1):
"""
Rotate the track.
The argument k is the number of times the array
is rotated by 90 degrees.
Args:
k (int): number of rotations (default: 1)
"""
nrow, ncol = self.orient.shape
shape = (nrow, ncol) if k % 2 == 0 else (ncol, nrow)
self._tiles = np.rot90(self.tiles, k)
self._orient = np.mod(
(np.rot90(self.orient, k) + np.ones(shape, dtype=int) * k), 4)
logging.info('Track rotated {} times'.format(k))
def dimensions(self):
"""
Return the dimensions in mm of the track.
Returns:
tuple of int: width and height in mm
"""
nrow, ncol = self.tiles.shape
return ncol*Tile.SIDE, nrow*Tile.SIDE
def occurences(self):
"""
Return the occurences of each tile used by the track.
It returns a dictionary. The keys corresponds to the number
of a tile and the values are the number of occurences.
Returns:
dict: occurences
"""
occur = {}
for i in range(2, 34):
count = np.count_nonzero(self.tiles == i)
if count != 0:
occur[i] = count
return occur
def print_track(self):
"""
Ask the printer to print the tiles to build the track.
"""
try:
occur = self.occurences()
printer = Printer()
logging.info('Printing track')
for i in occur:
printer.print_page(occur[i], i, self.name)
except Exception:
raise LineTrackDesignerError('unable to print the track')
def export_img(self):
"""
Export the track to image. It uses the PIL library.
Returns:
Image: image of the track
"""
SIDE = 1575
t = Tiles()
nrow, ncol = self.tiles.shape
track_img = Image.new('RGB', (ncol*SIDE, nrow*SIDE))
for i in range(nrow):
for j in range(ncol):
num_t = self.tiles[i][j]
current_tile = t.get_tile(num_t if num_t != 0 else 11)
current_orient = self.orient[i][j]
track_img.paste(
current_tile.image.rotate(90*current_orient),
(j*SIDE, i*SIDE))
track_img.thumbnail((SIDE, SIDE), Image.ANTIALIAS)
logging.info('Track exported to image')
return track_img
def show(self):
"""
Displays the track with the PIL library.
The image is in PNG format.
"""
track_img = self.export_img()
track_img.show(title=self.name)
logging.info('Showing track')
def save_img(self, file):
"""
Save the track as an image.
Args:
file (str): filename
Raises:
LineTrackDesignerError: bad filename extension: use .png
"""
p = Path(file)
if p.suffix != '.png':
raise LineTrackDesignerError('bad filename extension: use .png')
track_img = self.export_img()
track_img.save(file)
logging.info('Track saved as PNG file: {}'.format(file))
def save_txt(self, file):
"""
Save the track as a text file. The content of the text
file corresponds to the string format of the track.
Args:
file (str): filename
Raises:
LineTrackDesignerError: bad filename extension: use .txt
"""
p = Path(file)
if p.suffix != '.txt':
raise LineTrackDesignerError('bad filename extension: use .txt')
f = open(file, 'w')
f.write(str(self))
f.close()
logging.info('Track saved: {}'.format(file))
def save_md(self, file, description=''):
"""
Save the track as a markdown file. It also creates the PNG image
associated to the track. The md file contains the following
informtions:
* name of the track
* PNG image of the track
* description of the track (optionnal)
* dimensions (in mm)
* tiles required to build the track
Args:
file (str): filename (markdown file)
description (str): description of the track
Raises:
LineTrackDesignerError: bad extension file: use .md
"""
p = Path(file)
if p.suffix != '.md':
raise LineTrackDesignerError('bad extension file: use .md')
with Markdown(file) as m:
m.add_title(self.name, 1)
img = p.with_suffix('.png')
self.save_img(img)
m.add_image(img.name, self.name)
if description != '':
m.add_title('description', 2)
m.write(description)
m.add_title('dimensions', 2)
w, h = self.dimensions()
m.add_table([
['Width', 'Height'],
['{} mm'.format(w), '{} mm'.format(h)]])
m.add_title('tiles', 2)
occ = self.occurences()
occ_array = [[i, occ[i]] for i in occ]
occ_array.insert(0, ['Tile number', 'Number of copies required'])
m.add_table(occ_array)
m.write(('Built with [Line Track Designer]'
'(https://github.com/Quentin18/Line-Track-Designer)'))
logging.info('Track saved as markdown file: {}'.format(file))
|
{"/tests/test_cli.py": ["/line_track_designer/cli.py"], "/examples/example2.py": ["/line_track_designer/track.py"], "/tests/test_track.py": ["/line_track_designer/track.py"], "/line_track_designer/track.py": ["/line_track_designer/printer.py", "/line_track_designer/tile.py", "/line_track_designer/error.py", "/line_track_designer/markdown.py"], "/line_track_designer/printer.py": ["/line_track_designer/error.py"], "/examples/example4.py": ["/line_track_designer/track.py"], "/examples/example3.py": ["/line_track_designer/track.py"], "/line_track_designer/cli.py": ["/line_track_designer/track.py", "/line_track_designer/tile.py"], "/line_track_designer/tile.py": ["/line_track_designer/error.py"], "/examples/example5.py": ["/line_track_designer/track.py"], "/examples/example1.py": ["/line_track_designer/track.py"]}
|
36,192
|
zykron1/Line-Track-Designer
|
refs/heads/master
|
/line_track_designer/printer.py
|
"""
With the **printer** module, you can print the tracks built with the
library. It uses *CUPS*.
Warnings:
This module can be used only on Linux and macOS.
"""
import os
import logging
try:
import cups
except ImportError:
pass
from line_track_designer.error import LineTrackDesignerError
class Printer:
"""
Manage the printer to print a track. It is composed of three fields:
* **conn**: connection to the *CUPS* server
* **printer_name**: the name of the default printer
* **file_tiles**: the path to the PDF document with the tiles to print
Raises:
LineTrackDesignerError: no printers found
Note:
If no printer is found, you need to add one in your devices.
"""
def __init__(self):
"""Init a Printer object."""
try:
self._conn = cups.Connection()
printers = self._conn.getPrinters()
if printers:
self._printer_name = list(printers.keys())[0]
cwd = os.path.dirname(os.path.abspath(__file__))
self._file_tiles = os.path.join(
cwd, 'pdf', 'linefollowtiles.pdf')
else:
raise LineTrackDesignerError('no printers found')
logging.info('Printer {} found'.format(self.printer_name))
except ImportError:
pass
@property
def conn(self):
"""Get the connection."""
return self._conn
@property
def printer_name(self):
"""Get the name of the printer."""
return self._printer_name
@property
def file_tiles(self):
"""Get the path of the PDF file."""
return self._file_tiles
def __str__(self):
"""
Make the string format of the Printer object.
It returns the name of the printer.
"""
return self.printer_name
def __repr__(self):
"""
Make the repr format of the Printer object.
It's the same than the string format.
"""
return str(self)
def print_page(self, copies, pages, title, media='a4'):
"""
Ask to the printer to print pages of the PDF file.
Args:
copies (int): number of copies to print
pages (int): pages to print
title (str): name of the printing
media (str): format (default: 'a4')
Raises:
LineTrackDesignerError: printing failed
"""
try:
self.conn.printFile(
self.printer_name,
self.file_tiles,
title,
{
'copies': str(copies),
'page-ranges': str(pages),
'media': media,
'sides': 'one-sided'})
except Exception:
raise LineTrackDesignerError('printing failed')
logging.info('Pages {} printed'.format(pages))
|
{"/tests/test_cli.py": ["/line_track_designer/cli.py"], "/examples/example2.py": ["/line_track_designer/track.py"], "/tests/test_track.py": ["/line_track_designer/track.py"], "/line_track_designer/track.py": ["/line_track_designer/printer.py", "/line_track_designer/tile.py", "/line_track_designer/error.py", "/line_track_designer/markdown.py"], "/line_track_designer/printer.py": ["/line_track_designer/error.py"], "/examples/example4.py": ["/line_track_designer/track.py"], "/examples/example3.py": ["/line_track_designer/track.py"], "/line_track_designer/cli.py": ["/line_track_designer/track.py", "/line_track_designer/tile.py"], "/line_track_designer/tile.py": ["/line_track_designer/error.py"], "/examples/example5.py": ["/line_track_designer/track.py"], "/examples/example1.py": ["/line_track_designer/track.py"]}
|
36,193
|
zykron1/Line-Track-Designer
|
refs/heads/master
|
/setup.py
|
"""
* Install with pip (recommended):
pip3 install .
* Install with setuptools:
python3 setup.py install
* Run tests:
python3 setup.py pytest
"""
import setuptools
with open('README.md', 'r') as fh:
long_description = fh.read()
setuptools.setup(
name='line-track-designer',
version='0.0.2',
description='A library to design line following tracks for robots',
long_description=long_description,
long_description_content_type='text/markdown',
author='Quentin Deschamps',
author_email='quentindeschamps18@gmail.com',
url='https://github.com/Quentin18/Line-Track-Designer/',
packages=['line_track_designer'],
classifiers=[
'License :: OSI Approved :: MIT License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3.8',
'Topic :: Education',
'Topic :: Scientific/Engineering'
],
license='MIT',
keywords='robotics line follow robot track',
project_urls={
'Documentation':
'https://line-track-designer.readthedocs.io/en/latest/',
'Travis':
'https://travis-ci.org/github/Quentin18/Line-Track-Designer/',
'Source Code': 'https://github.com/Quentin18/Line-Track-Designer/',
},
platforms=['any'],
include_package_data=True,
zip_safe=True,
install_requires=[
'numpy',
'Click',
'Pillow',
"pycups;platform_system!='Windows'"
],
entry_points='''
[console_scripts]
linetrack=line_track_designer.cli:linetrack
''',
python_requires='>=3.6',
setup_requires=['pytest-runner'],
tests_require='pytest'
)
|
{"/tests/test_cli.py": ["/line_track_designer/cli.py"], "/examples/example2.py": ["/line_track_designer/track.py"], "/tests/test_track.py": ["/line_track_designer/track.py"], "/line_track_designer/track.py": ["/line_track_designer/printer.py", "/line_track_designer/tile.py", "/line_track_designer/error.py", "/line_track_designer/markdown.py"], "/line_track_designer/printer.py": ["/line_track_designer/error.py"], "/examples/example4.py": ["/line_track_designer/track.py"], "/examples/example3.py": ["/line_track_designer/track.py"], "/line_track_designer/cli.py": ["/line_track_designer/track.py", "/line_track_designer/tile.py"], "/line_track_designer/tile.py": ["/line_track_designer/error.py"], "/examples/example5.py": ["/line_track_designer/track.py"], "/examples/example1.py": ["/line_track_designer/track.py"]}
|
36,194
|
zykron1/Line-Track-Designer
|
refs/heads/master
|
/examples/example4.py
|
"""
Example 4: Edition functions
"""
from line_track_designer.track import Track
if __name__ == "__main__":
# Import the track saved in a text file
track = Track.read('track_hard/track_hard.txt', 'Hard track')
# Export the track as png and markdown files
track.save_md('track_hard/track_hard.md', 'A very hard track')
# Delete a row
track.del_row(1)
# Rotate the track
track.rotate()
# Show the track
track.show()
|
{"/tests/test_cli.py": ["/line_track_designer/cli.py"], "/examples/example2.py": ["/line_track_designer/track.py"], "/tests/test_track.py": ["/line_track_designer/track.py"], "/line_track_designer/track.py": ["/line_track_designer/printer.py", "/line_track_designer/tile.py", "/line_track_designer/error.py", "/line_track_designer/markdown.py"], "/line_track_designer/printer.py": ["/line_track_designer/error.py"], "/examples/example4.py": ["/line_track_designer/track.py"], "/examples/example3.py": ["/line_track_designer/track.py"], "/line_track_designer/cli.py": ["/line_track_designer/track.py", "/line_track_designer/tile.py"], "/line_track_designer/tile.py": ["/line_track_designer/error.py"], "/examples/example5.py": ["/line_track_designer/track.py"], "/examples/example1.py": ["/line_track_designer/track.py"]}
|
36,195
|
zykron1/Line-Track-Designer
|
refs/heads/master
|
/line_track_designer/error.py
|
"""
The **error** module manages the errors of the library.
"""
class LineTrackDesignerError(Exception):
"""Manage exception errors."""
pass
|
{"/tests/test_cli.py": ["/line_track_designer/cli.py"], "/examples/example2.py": ["/line_track_designer/track.py"], "/tests/test_track.py": ["/line_track_designer/track.py"], "/line_track_designer/track.py": ["/line_track_designer/printer.py", "/line_track_designer/tile.py", "/line_track_designer/error.py", "/line_track_designer/markdown.py"], "/line_track_designer/printer.py": ["/line_track_designer/error.py"], "/examples/example4.py": ["/line_track_designer/track.py"], "/examples/example3.py": ["/line_track_designer/track.py"], "/line_track_designer/cli.py": ["/line_track_designer/track.py", "/line_track_designer/tile.py"], "/line_track_designer/tile.py": ["/line_track_designer/error.py"], "/examples/example5.py": ["/line_track_designer/track.py"], "/examples/example1.py": ["/line_track_designer/track.py"]}
|
36,196
|
zykron1/Line-Track-Designer
|
refs/heads/master
|
/examples/example3.py
|
"""
Example 3: Importation, exportation and show a track
"""
from line_track_designer.track import Track
if __name__ == "__main__":
# Import the track saved in a text file
track = Track.read('track_cool_guy/track_cool_guy.txt', 'Cool guy track')
# Export the track as png and markdown files
track.save_md('track_cool_guy/track_cool_guy.md',
'It looks like a face...')
# Show the track
track.show()
|
{"/tests/test_cli.py": ["/line_track_designer/cli.py"], "/examples/example2.py": ["/line_track_designer/track.py"], "/tests/test_track.py": ["/line_track_designer/track.py"], "/line_track_designer/track.py": ["/line_track_designer/printer.py", "/line_track_designer/tile.py", "/line_track_designer/error.py", "/line_track_designer/markdown.py"], "/line_track_designer/printer.py": ["/line_track_designer/error.py"], "/examples/example4.py": ["/line_track_designer/track.py"], "/examples/example3.py": ["/line_track_designer/track.py"], "/line_track_designer/cli.py": ["/line_track_designer/track.py", "/line_track_designer/tile.py"], "/line_track_designer/tile.py": ["/line_track_designer/error.py"], "/examples/example5.py": ["/line_track_designer/track.py"], "/examples/example1.py": ["/line_track_designer/track.py"]}
|
36,197
|
zykron1/Line-Track-Designer
|
refs/heads/master
|
/line_track_designer/cli.py
|
"""
Command line interface from Line Track Designer
"""
import click
from pathlib import Path
import logging
import webbrowser
from line_track_designer.track import Track
from line_track_designer.tile import Tile, Tiles
@click.group()
@click.option('-v', '--verbosity', is_flag=True, help='Set the verbosity')
def linetrack(verbosity):
"""Generate line following tracks for robots."""
if verbosity:
logging.basicConfig(format='%(levelname)s:%(message)s',
level=logging.INFO)
@linetrack.command()
@click.argument('filename', type=click.Path(exists=True))
def show(filename):
"""Show track FILENAME as PNG file.
FILENAME is a text file following the track file's conventions.
"""
track = Track.read(filename)
track.show()
@linetrack.command()
@click.argument('filename', type=click.Path(exists=True))
def write(filename):
"""Write track FILENAME in the command prompt."""
track = Track.read(filename)
click.echo(track)
logging.info('Track writed')
@linetrack.command()
@click.argument('filename', type=click.Path())
@click.argument('nrow', type=int)
@click.argument('ncol', type=int)
def create(filename, nrow, ncol):
"""Create empty track FILENAME.
NROW is the number of rows.
NCOL is the number of columns.
"""
track = Track.zeros(nrow, ncol)
track.save_txt(filename)
click.edit(filename=filename)
@linetrack.command()
@click.argument('filename', type=click.Path(exists=True))
def edit(filename):
"""Edit track FILENAME."""
logging.info('Editing track: {}'.format(filename))
click.edit(filename=filename)
@linetrack.command()
@click.argument('filename', type=click.Path(exists=True))
def addcol(filename):
"""Add a column to track FILENAME."""
track = Track.read(filename)
track.add_col()
track.save_txt(filename)
@linetrack.command()
@click.argument('filename', type=click.Path(exists=True))
def addrow(filename):
"""Add a row to track FILENAME."""
track = Track.read(filename)
track.add_row()
track.save_txt(filename)
@linetrack.command()
@click.argument('filename', type=click.Path(exists=True))
@click.argument('col', type=int)
def delcol(filename, col):
"""Delete column COL from track FILENAME.
COL is the number of the column to delete.
"""
track = Track.read(filename)
track.del_col(col)
track.save_txt(filename)
@linetrack.command()
@click.argument('filename', type=click.Path(exists=True))
@click.argument('row', type=int)
def delrow(filename, row):
"""Delete row ROW from track FILENAME.
ROW is the number of the row to delete.
"""
track = Track.read(filename)
track.del_row(row)
track.save_txt(filename)
@linetrack.command()
@click.argument('filename', type=click.Path(exists=True))
@click.option('-n', default=1, help='Number of rotations')
def rotate(filename, n):
"""Rotate track FILENAME."""
track = Track.read(filename)
track.rotate(n)
track.save_txt(filename)
@linetrack.command()
@click.argument('filename', type=click.Path(exists=True))
@click.option('-o', '--output', 'filename_png', default='',
help='Name of the PNG file')
@click.option('-s', '--show', is_flag=True, help='Show the file created')
def savepng(filename, filename_png, show):
"""Save track FILENAME as PNG file."""
track = Track.read(filename)
p = Path(filename)
if filename_png == '':
filename_png = p.with_suffix('.png')
track.save_img(filename_png)
if show:
track.show()
@linetrack.command()
@click.argument('filename', type=click.Path(exists=True))
@click.option('-o', '--output', 'filename_md', default='',
help='Name of the MD file')
@click.option('-n', '--name', 'name', default='Track',
prompt='Name', help='Name of the track')
@click.option('-d', '--description', 'description', default='',
prompt='Description', help='Description of the track')
def savemd(filename, filename_md, name, description):
"""Save track FILENAME as MD file."""
track = Track.read(filename, name)
p = Path(filename)
if filename_md == '':
filename_md = p.with_suffix('.md')
track.save_md(filename_md, description)
@linetrack.command()
@click.argument('filename', type=click.Path(exists=True))
def printing(filename):
"""Print track FILENAME."""
if click.confirm('Do you want to print the track?'):
track = Track.read(filename)
track.print_track()
@linetrack.command()
@click.argument('number', type=int)
@click.option('-o', '--orient', default=0, help='Orientation')
def showtile(number, orient):
"""Show tile NUMBER."""
t = Tile(number)
t.show(orient)
@linetrack.command()
def pdf():
"""Open the PDF file containing the tiles."""
Tiles.show()
@linetrack.command()
def doc():
"""Open the documentation."""
webbrowser.open('https://line-track-designer.readthedocs.io/en/latest/')
logging.info('Doc opened')
|
{"/tests/test_cli.py": ["/line_track_designer/cli.py"], "/examples/example2.py": ["/line_track_designer/track.py"], "/tests/test_track.py": ["/line_track_designer/track.py"], "/line_track_designer/track.py": ["/line_track_designer/printer.py", "/line_track_designer/tile.py", "/line_track_designer/error.py", "/line_track_designer/markdown.py"], "/line_track_designer/printer.py": ["/line_track_designer/error.py"], "/examples/example4.py": ["/line_track_designer/track.py"], "/examples/example3.py": ["/line_track_designer/track.py"], "/line_track_designer/cli.py": ["/line_track_designer/track.py", "/line_track_designer/tile.py"], "/line_track_designer/tile.py": ["/line_track_designer/error.py"], "/examples/example5.py": ["/line_track_designer/track.py"], "/examples/example1.py": ["/line_track_designer/track.py"]}
|
36,198
|
zykron1/Line-Track-Designer
|
refs/heads/master
|
/line_track_designer/tile.py
|
"""
The **tile** module manages the tiles that are used to build a track.
Note:
You can see all the tiles here:
:download:`linefollowtiles.pdf <pdf/linefollowtiles.pdf>`
Warnings:
The tiles 10 and 32 can not be used by *Line Track Designer*.
"""
import os
import logging
from PIL import Image
import webbrowser
from line_track_designer.error import LineTrackDesignerError
class Tile:
"""
Representation of a tile.
An instance of the **Tile** class is composed of four fields:
* **number**: number of the tile
* **name**: name of the tile
* **path**: path to the PNG image corresponding to the tile
* **image**: PIL.Image format associated to the tile
"""
SIDE = 200 # side of a tile in mm
@staticmethod
def is_valid(number):
"""
Return True if the number corresponds to a valid tile.
It is valid if the number is between 2 and 33, and the tiles
10 and 32 are invalid.
Args:
number (int): number of a tile
Returns:
bool: Is a valid number
"""
return number >= 2 and number < 34 and number not in [10, 32]
def __init__(self, number):
"""
Init a tile.
Args:
number (int): number of the tile
Raises:
LineTrackDesignerError: invalid tile number
"""
if Tile.is_valid(number):
self._number = number
self._name = 'linefollowtiles-{}.png'.format(str(number).zfill(2))
cwd = os.path.dirname(os.path.abspath(__file__))
self._path = os.path.join(cwd, 'png', self._name)
self._image = Image.open(self._path)
else:
raise LineTrackDesignerError('Tile {} is not valid'.format(number))
logging.info('Tile {} created'.format(number))
@property
def number(self):
"""Get the number of the tile."""
return self._number
@property
def name(self):
"""Get the name of the tile."""
return self._name
@property
def path(self):
"""Get the path of the PNG image associated to the tile."""
return self._path
@property
def image(self):
"""Get the image associated to the tile."""
return self._image
def __str__(self):
"""Make the sting format of the tile. It returns its name."""
return self.name
def __repr__(self):
"""
Make the repr format of the tile.
It's the same than the string format.
"""
return str(self)
def show(self, orient=0):
"""
Show the tile in your picture viewer.
Args:
orient (int): orientation of the tile (default: 0)
Raises:
LineTrackDesignerError: invalid orient value
"""
if orient not in [0, 1, 2, 3]:
raise LineTrackDesignerError(
'{} is not a valid orient value'.format(orient))
img = self.image.rotate(90*orient)
img.show(title=self.name)
logging.info('Showing tile')
class Tiles:
"""
Manage all the tiles.
The tiles are stocked in the dictionary **dict_tiles**.
The keys correspond to the number of the tile and the values are
the Tile objects corresponding to this number.
"""
def __init__(self):
"""
Init the tiles. It creates the dictionary **dict_tiles**.
"""
self._dict_tiles = {}
for i in range(2, 34):
if i not in [10, 32]:
self._dict_tiles[i] = Tile(i)
logging.info('Tiles created')
@property
def dict_tiles(self):
"""
Get the dictionary of tiles.
"""
return self._dict_tiles
def __str__(self):
"""
Make the sting format of the tiles.
It returns the names of the tiles.
"""
return '\n'.join([str(self.dict_tiles[t]) for t in self.dict_tiles])
def __repr__(self):
"""
Make the repr format of the tiles.
It's the same than the string format.
"""
return str(self)
def get_tile(self, number):
"""
Get a tile from its number.
Args:
number (int): number of the tile
Returns:
Tile: tile associated to the number
Raises:
LineTrackDesignerError: tile not found
"""
if number in self.dict_tiles:
return self.dict_tiles[number]
raise LineTrackDesignerError('tile {} not found'.format(number))
@staticmethod
def show():
"""
Open the PDF file containing the tiles.
Raises:
LineTrackDesignerError: unable to open the PDF file
"""
try:
cwd = os.path.dirname(os.path.abspath(__file__))
pdf = os.path.join(cwd, 'pdf', 'linefollowtiles.pdf')
webbrowser.open_new(pdf)
logging.info('Showing the tiles')
except FileNotFoundError:
raise LineTrackDesignerError('unable to open the PDF file')
|
{"/tests/test_cli.py": ["/line_track_designer/cli.py"], "/examples/example2.py": ["/line_track_designer/track.py"], "/tests/test_track.py": ["/line_track_designer/track.py"], "/line_track_designer/track.py": ["/line_track_designer/printer.py", "/line_track_designer/tile.py", "/line_track_designer/error.py", "/line_track_designer/markdown.py"], "/line_track_designer/printer.py": ["/line_track_designer/error.py"], "/examples/example4.py": ["/line_track_designer/track.py"], "/examples/example3.py": ["/line_track_designer/track.py"], "/line_track_designer/cli.py": ["/line_track_designer/track.py", "/line_track_designer/tile.py"], "/line_track_designer/tile.py": ["/line_track_designer/error.py"], "/examples/example5.py": ["/line_track_designer/track.py"], "/examples/example1.py": ["/line_track_designer/track.py"]}
|
36,199
|
zykron1/Line-Track-Designer
|
refs/heads/master
|
/examples/example5.py
|
"""
Example 5: Create a track with zeros
"""
from line_track_designer.track import Track
if __name__ == "__main__":
# Create an empty track
track = Track.zeros(2, 3)
# Set the tiles of the track manually
track.set_tile(1, 0, 17, 1)
track.set_tile(1, 1, 3, 3)
track.set_tile(0, 1, 3, 1)
track.set_tile(0, 2, 17, 3)
# Show the track
track.show()
|
{"/tests/test_cli.py": ["/line_track_designer/cli.py"], "/examples/example2.py": ["/line_track_designer/track.py"], "/tests/test_track.py": ["/line_track_designer/track.py"], "/line_track_designer/track.py": ["/line_track_designer/printer.py", "/line_track_designer/tile.py", "/line_track_designer/error.py", "/line_track_designer/markdown.py"], "/line_track_designer/printer.py": ["/line_track_designer/error.py"], "/examples/example4.py": ["/line_track_designer/track.py"], "/examples/example3.py": ["/line_track_designer/track.py"], "/line_track_designer/cli.py": ["/line_track_designer/track.py", "/line_track_designer/tile.py"], "/line_track_designer/tile.py": ["/line_track_designer/error.py"], "/examples/example5.py": ["/line_track_designer/track.py"], "/examples/example1.py": ["/line_track_designer/track.py"]}
|
36,200
|
zykron1/Line-Track-Designer
|
refs/heads/master
|
/line_track_designer/markdown.py
|
"""
The **markdown** module is usefull to export tracks to markdown files.
The **Markdown** class creates a markdown file and can add elements such
as titles, images, and tables.
A markdown file can be edited using the *with* statement.
Note:
You can read markdown files using *Zettlr*.
"""
class Markdown:
"""
Create a markdown file. A Markdown object is composed of two fields:
* **filename** (str)
* **f** (file object)
"""
def __init__(self, filename):
"""
Init a markdown file. It creates and opens the file.
Args:
filename (str): filename (markdown file)
"""
self._filename = filename
self._f = open(filename, 'w')
@property
def filename(self):
"""Get the filename."""
return self._filename
@property
def f(self):
"""Get the file object."""
return self._f
def __enter__(self):
"""Enter in a with statement."""
return self
def write(self, text, break_before=True, break_after=True):
"""
Write text in the file. You can precise if you want a break line
before and/or after the text.
Args:
text (str): text to add
breack_before (bool): add a break line before the text if True
breack_after (bool): add a break line after the text if True
"""
text = '\n' + text if break_before else text
text = text + '\n' if break_after else text
self.f.write(text)
def close(self):
"""Close the file."""
self.f.close()
def add_title(self, title, level):
"""
Add a title to the file. You can choose the level of the title.
Args:
title (str): title to add
level (int): level of the title (must be between 1 and 6)
Raises:
Exception: invalid level for a title in md
"""
if not 1 <= level <= 6:
raise Exception('invalid level for a title in md')
self.write(''.join([level*'#', ' ', title.capitalize()]), level != 1)
def add_image(self, file, name='Track'):
"""
Add an image to the file.
Args:
file (str): filename of the image to add
name (str): label of the image
"""
self.write(''.format(name, file))
def add_separator(self):
"""Add a separator to the file."""
self.write('---')
def add_table(self, array, head=True):
"""
Add a table to the file. You can precise if you want a header or not.
Args:
array(numpy.array): table to add
head(bool): make a header if True
"""
add_hline = False
for line in array:
str_line = [str(i) for i in line]
self.write(' | '.join(str_line), False)
if not add_hline and head:
self.write(' | '.join([':---:']*len(line)), False)
add_hline = True
def __exit__(self, exc_type, exc_value, traceback):
"""Exit and close the file."""
self.close()
|
{"/tests/test_cli.py": ["/line_track_designer/cli.py"], "/examples/example2.py": ["/line_track_designer/track.py"], "/tests/test_track.py": ["/line_track_designer/track.py"], "/line_track_designer/track.py": ["/line_track_designer/printer.py", "/line_track_designer/tile.py", "/line_track_designer/error.py", "/line_track_designer/markdown.py"], "/line_track_designer/printer.py": ["/line_track_designer/error.py"], "/examples/example4.py": ["/line_track_designer/track.py"], "/examples/example3.py": ["/line_track_designer/track.py"], "/line_track_designer/cli.py": ["/line_track_designer/track.py", "/line_track_designer/tile.py"], "/line_track_designer/tile.py": ["/line_track_designer/error.py"], "/examples/example5.py": ["/line_track_designer/track.py"], "/examples/example1.py": ["/line_track_designer/track.py"]}
|
36,201
|
zykron1/Line-Track-Designer
|
refs/heads/master
|
/examples/example1.py
|
"""
Example 1: Creation of a track with arrays and exportation to PNG an MD
"""
import os
import numpy as np
from line_track_designer.track import Track
if __name__ == "__main__":
# Creation of a folder
if not os.path.exists('track_test'):
os.makedirs('track_test')
# Arrays for the track
tiles = np.array([
[3, 2, 3],
[2, 11, 2],
[3, 2, 3]
])
orient = np.array([
[1, 1, 0],
[0, 0, 0],
[2, 1, 3]
])
# Creation of the track
track = Track(tiles, orient, 'Test track')
# Save the track
track.save_txt('track_test/track.txt')
track.save_img('track_test/track.png')
track.save_md('track_test/track.md', 'Easy track')
|
{"/tests/test_cli.py": ["/line_track_designer/cli.py"], "/examples/example2.py": ["/line_track_designer/track.py"], "/tests/test_track.py": ["/line_track_designer/track.py"], "/line_track_designer/track.py": ["/line_track_designer/printer.py", "/line_track_designer/tile.py", "/line_track_designer/error.py", "/line_track_designer/markdown.py"], "/line_track_designer/printer.py": ["/line_track_designer/error.py"], "/examples/example4.py": ["/line_track_designer/track.py"], "/examples/example3.py": ["/line_track_designer/track.py"], "/line_track_designer/cli.py": ["/line_track_designer/track.py", "/line_track_designer/tile.py"], "/line_track_designer/tile.py": ["/line_track_designer/error.py"], "/examples/example5.py": ["/line_track_designer/track.py"], "/examples/example1.py": ["/line_track_designer/track.py"]}
|
36,202
|
zakizhou/deep-anpr-cn
|
refs/heads/master
|
/utils.py
|
# -*- coding: utf-8 -*-
"""
Created on Wed Oct 05 22:21:42 2016
@author: Windo
"""
import string
# abbrevation of Chinese provinces,the first char of a plate
provinces = u"京津冀晋蒙辽吉黑沪苏浙皖闽赣鲁豫鄂湘粤桂琼川贵云渝藏陕甘青宁新"
digits = string.digits
chars = string.uppercase
elements = digits+chars
|
{"/gen_training_set.py": ["/utils.py"]}
|
36,203
|
zakizhou/deep-anpr-cn
|
refs/heads/master
|
/gen_training_set.py
|
# -*- coding: utf-8 -*-
"""
Created on Wed Oct 05 22:19:47 2016
@author: Windo
"""
import random
import utils
def make_pure_plate_code(show_code=False):
"""
The first placeholder of any Chinese plate is the abbreviation of a province.
The second placeholder is a upper char representing a city in this province.
Three to six is any combination of upper chars and digits
"""
code = u"{}{}·{}{}{}{}".format(random.choice(utils.provinces),
random.choice(utils.chars),
random.choice(utils.elements),
random.choice(utils.elements),
random.choice(utils.elements),
random.choice(utils.elements))
if(show_code==True):
print(code)
return code
|
{"/gen_training_set.py": ["/utils.py"]}
|
36,206
|
Pneha1234/flask_restful_sqlalchemy
|
refs/heads/master
|
/app.py
|
import uuid
from datetime import datetime
from flask import Flask, request, g, jsonify
from flask_restful import Api, Resource, abort
from flask_sqlalchemy import SQLAlchemy
from migration import Base
from validator_methods import set_attributes
app = Flask(__name__)
api = Api(app)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///moru_blog.db'
db = SQLAlchemy(app)
# class BaseModel(db.Model, Base):
# __tablename__ = 'base_model'
# __abstract__ = True
#
# id = db.Column(db.String, primary_key=True)
# created_at = db.Column(db.DateTime)
# created_by = db.Column(db.String())
# updated_at = db.Column(db.DateTime)
# updated_by = db.Column(db.String())
#
# def __init__(self, **kwargs):
# super(BaseModel, self).__init__(**kwargs)
# self.id = str(uuid.uuid4())
# self.created_at = datetime.utcnow()
# user = g.get('user', None)
# if user is not None:
# self.created_by = user.get('user_id', None)
class BlogModel(Base):
__tablename__ = 'blog_model'
id = db.Column(db.String, primary_key=True)
text = db.Column(db.String(100))
views = db.Column(db.Integer)
likes = db.Column(db.Integer)
allowed_keys = {'text', 'views', 'likes'}
def __init__(self, **kwargs):
super().__init__()
self.id = str(uuid.uuid4())
set_attributes(self, **kwargs)
def blog_json(self):
return {
"id": self.id,
"text": self.text,
"views": self.views,
"likes": self.likes
}
class Blog(Resource):
def get(self, blog_id):
result = BlogModel.query.filter_by(id=blog_id).first()
if not result:
abort(404, message="Could not find blog with that id")
return result.blog_json()
def put(self, blog_id):
data = request.get_json()
blog = BlogModel.query.filter_by(id=blog_id).first()
if blog is None:
abort(404, message="Could not find blog with that id")
blog.text = data.get('text', None)
blog.views = data.get('views', None)
blog.likes = data.get('likes', None)
db.session.add(blog)
db.session.commit()
return blog.blog_json(), 201
def delete(self, blog_id):
result = BlogModel.query.filter_by(id=blog_id).first()
if not result:
abort(404, message="Blog doesn't exist, cannot delete")
db.session.delete(result)
db.session.commit()
return '', 204
class Blogs(Resource):
def post(self):
data = request.get_json()
blog = BlogModel(**data)
db.session.add(blog)
db.session.commit()
return blog.blog_json()
def get(self):
blogs = BlogModel.query.all()
return jsonify([blog.blog_json() for blog in blogs])
api.add_resource(Blog, '/blogs/<blog_id>')
api.add_resource(Blogs, '/blogs')
if __name__ == "__main__":
app.run(debug=True)
|
{"/app.py": ["/migration.py", "/validator_methods.py"]}
|
36,207
|
Pneha1234/flask_restful_sqlalchemy
|
refs/heads/master
|
/validator_methods.py
|
def set_attributes(obj, **kwargs):
for key, value in kwargs.items():
if key in obj.allowed_keys:
setattr(obj, key, value)
|
{"/app.py": ["/migration.py", "/validator_methods.py"]}
|
36,208
|
Pneha1234/flask_restful_sqlalchemy
|
refs/heads/master
|
/migration.py
|
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
engine = create_engine('sqlite:///moru_blog.db', echo=True)
Base = declarative_base()
def main():
Base.metadata.create_all(engine)
moru_blog_connection = engine.connect()
moru_blog_trans = moru_blog_connection.begin()
moru_blog_connection.execute("alter table blog_model add column active boolean default True;")
moru_blog_connection.execute("update blog_model set views=5 where views is null;")
moru_blog_trans.commit()
print('tables created')
if __name__ == "__main__":
main()
|
{"/app.py": ["/migration.py", "/validator_methods.py"]}
|
36,251
|
Yujiao001/test0001
|
refs/heads/master
|
/page/send_mms_page.py
|
import allure
from selenium.webdriver.common.by import By
from base.base_action import BaseAction
class SendMmsPage(BaseAction):
receive_tel = By.XPATH,"//*[@text='接收者']"
input_tel = By.XPATH, "//*[@text='键入信息']"
send_msg = By.XPATH, "//*[@content-desc='发送']"
@allure.step(title="输入接收人")
def receive_msg(self,text):
allure.attach("接收人", text)
self.input(self.receive_tel,text)
@allure.step(title="输入信息")
def input_msg(self,text):
# 附件，一个提示信息 内容 类型（如果是文字默认可以省略）
allure.attach("信息", text)
self.input(self.input_tel,text)
# 本地会保留图片
# self.driver.get_screenshot_as_file("./xx.png")
# with open("./xx.png",'rb') as f:
# allure.attach('截图',f.read(), allure.attach_type.PNG)
# 本地不会保留图片
allure.attach('截图', self.driver.get_screenshot_as_png(), allure.attach_type.PNG)
@allure.step(title="点击发送")
def send_button(self):
self.click(self.send_msg)
|
{"/scripts/test_mms.py": ["/page/page.py"], "/page/page.py": ["/page/send_mms_page.py", "/page/show_mms_page.py", "/page/success_mms_page.py"]}
|
36,252
|
Yujiao001/test0001
|
refs/heads/master
|
/page/success_mms_page.py
|
import allure
from selenium.webdriver.common.by import By
from base.base_action import BaseAction
class SuccessMmsPage(BaseAction):
succ_msg = By.ID,"com.android.mms:id/text_view"
@allure.step(title="确认发送成功")
def find_msg(self):
return self.last_element_text(self.succ_msg)
|
{"/scripts/test_mms.py": ["/page/page.py"], "/page/page.py": ["/page/send_mms_page.py", "/page/show_mms_page.py", "/page/success_mms_page.py"]}
|
36,253
|
Yujiao001/test0001
|
refs/heads/master
|
/scripts/test_mms.py
|
import pytest
import allure
from base.base_driver import init_driver
from page.page import Page
from base.base_analyze import analyze_with_file
class TestMms:
def setup(self):
self.driver = init_driver()
self.page = Page(self.driver)
def teardown(self):
self.driver.quit()
@pytest.mark.parametrize("args", analyze_with_file("mms_data", "test_mms1"))
@allure.severity('critical')
def test_mms1(self, args):
# receive = "13718701752"
# input = "hello"
receive = args["receive"]
msg = args["msg"]
self.page.show_mms.new_mms_button()
self.page.send_mms.receive_msg(receive)
self.page.send_mms.input_msg(msg)
self.page.send_mms.send_button()
assert self.page.success_mms.find_msg() == msg
@pytest.mark.parametrize("args", analyze_with_file("mms_data", "test_mms2"))
@allure.severity('blocker')
def test_mms2(self, args):
# receive = "13718701752"
# input = "hello"
receive = args["receive"]
msg = args["msg"]
self.page.show_mms.new_mms_button()
self.page.send_mms.receive_msg(receive)
self.page.send_mms.input_msg(msg)
self.page.send_mms.send_button()
assert self.page.success_mms.find_msg() == msg
|
{"/scripts/test_mms.py": ["/page/page.py"], "/page/page.py": ["/page/send_mms_page.py", "/page/show_mms_page.py", "/page/success_mms_page.py"]}
|
36,254
|
Yujiao001/test0001
|
refs/heads/master
|
/page/show_mms_page.py
|
import allure
from selenium.webdriver.common.by import By
from base.base_action import BaseAction
class ShowMmsPage(BaseAction):
new_mms = By.ID,"com.android.mms:id/action_compose_new"
@allure.step(title="点击新建信息")
def new_mms_button(self):
self.click(self.new_mms)
|
{"/scripts/test_mms.py": ["/page/page.py"], "/page/page.py": ["/page/send_mms_page.py", "/page/show_mms_page.py", "/page/success_mms_page.py"]}
|
36,255
|
Yujiao001/test0001
|
refs/heads/master
|
/page/page.py
|
from page.send_mms_page import SendMmsPage
from page.show_mms_page import ShowMmsPage
from page.success_mms_page import SuccessMmsPage
class Page:
def __init__(self,driver):
self.driver = driver
self.page = Page
@property
def show_mms(self):
return ShowMmsPage(self.driver)
@property
def send_mms(self):
return SendMmsPage(self.driver)
@property
def success_mms(self):
return SuccessMmsPage(self.driver)
|
{"/scripts/test_mms.py": ["/page/page.py"], "/page/page.py": ["/page/send_mms_page.py", "/page/show_mms_page.py", "/page/success_mms_page.py"]}
|
36,272
|
Grace-Amondi/Django-rest-framework-geospatial-tutorial
|
refs/heads/master
|
/geaopienv/bin/django-admin.py
|
#!/root/geoapi/geaopienv/bin/python3
from django.core import management
if __name__ == "__main__":
management.execute_from_command_line()
|
{"/geoapi/mygeoapi/views.py": ["/geoapi/mygeoapi/serializers.py", "/geoapi/mygeoapi/models.py"], "/geoapi/mygeoapi/urls.py": ["/geoapi/mygeoapi/views.py"]}
|
36,273
|
Grace-Amondi/Django-rest-framework-geospatial-tutorial
|
refs/heads/master
|
/geoapi/mygeoapi/apps.py
|
from django.apps import AppConfig
class MygeoapiConfig(AppConfig):
name = 'mygeoapi'
|
{"/geoapi/mygeoapi/views.py": ["/geoapi/mygeoapi/serializers.py", "/geoapi/mygeoapi/models.py"], "/geoapi/mygeoapi/urls.py": ["/geoapi/mygeoapi/views.py"]}
|
36,274
|
Grace-Amondi/Django-rest-framework-geospatial-tutorial
|
refs/heads/master
|
/geoapi/mygeoapi/views.py
|
from django.contrib.auth.models import User, Group
from rest_framework import viewsets
from .serializers import UserSerializer, GroupSerializer, SchoolSerializer
from .models import School
from rest_framework_gis.filters import DistanceToPointFilter
from rest_framework.decorators import api_view
from rest_framework.response import Response
@api_view(['GET'])
def api_root(request, format=None):
return Response({
'users': reverse('user-list', request=request, format=format),
'groups': reverse('group-list', request=request, format=format),
'schools': reverse('schools-list', request=request, format=format),
})
class UserViewSet(viewsets.ModelViewSet):
"""
API endpoint that allows users to be viewed or edited.
"""
queryset = User.objects.all().order_by('date_joined')
serializer_class = UserSerializer
class GroupViewSet(viewsets.ModelViewSet):
"""
API endpoint that allows group to be viewed or edited.
"""
queryset=Group.objects.all()
serializer_class=GroupSerializer
class SchoolViewSet(viewsets.ModelViewSet):
queryset = School.objects.all()
serializer_class = SchoolSerializer
distance_filter_field = 'geometry'
filter_backends = (DistanceToPointFilter,)
bbox_filter_include_overlapping = True
|
{"/geoapi/mygeoapi/views.py": ["/geoapi/mygeoapi/serializers.py", "/geoapi/mygeoapi/models.py"], "/geoapi/mygeoapi/urls.py": ["/geoapi/mygeoapi/views.py"]}
|
36,275
|
Grace-Amondi/Django-rest-framework-geospatial-tutorial
|
refs/heads/master
|
/geoapi/mygeoapi/serializers.py
|
from rest_framework import serializers
from django.contrib.auth.models import User, Group
from mygeoapi.models import School
from rest_framework_gis.serializers import GeoFeatureModelSerializer
class UserSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = User
fields = ('username', 'id', 'email', 'groups')
class GroupSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = Group
fields = ('id', 'name')
class SchoolSerializer(GeoFeatureModelSerializer):
""" A class to serialize locations as GeoJSON compatible data """
class Meta:
model = School
geo_field = 'location'
auto_bbox = True
# you can also explicitly declare which fields you want to include
# as with a ModelSerializer.
fields = ('id', 'name', 'county', 'enrollment', 'location', 'electricity_availability', 'emmis_code')
|
{"/geoapi/mygeoapi/views.py": ["/geoapi/mygeoapi/serializers.py", "/geoapi/mygeoapi/models.py"], "/geoapi/mygeoapi/urls.py": ["/geoapi/mygeoapi/views.py"]}
|
36,276
|
Grace-Amondi/Django-rest-framework-geospatial-tutorial
|
refs/heads/master
|
/geoapi/mygeoapi/urls.py
|
from django.conf.urls import url, include
from .views import UserViewSet, GroupViewSet, SchoolViewSet, api_root
from rest_framework.urlpatterns import format_suffix_patterns
user_list = UserViewSet.as_view({
'get': 'list'
})
user_detail = UserViewSet.as_view({
'get': 'retrieve',
'post': 'create',
'put': 'update',
'delete': 'destroy'
})
group_list = GroupViewSet.as_view({
'get': 'list'
})
group_detail = GroupViewSet.as_view({
'get': 'retrieve',
'post': 'create',
'put': 'update',
'delete': 'destroy'
})
school_list = SchoolViewSet.as_view({
'get': 'list'
})
school_detail = SchoolViewSet.as_view({
'get': 'retrieve',
'post': 'create',
'put': 'update',
'delete': 'destroy'
})
urlpatterns = [
url(r'^$', api_root),
url(r'^users', user_list, name=user_list),
url(r'^user/(?P<pk>[0-9]+)/$', user_detail, name=user_detail),
url(r'^groups', user_list, name=group_list),
url(r'^groups/(?P<pk>[0-9]+)/$', user_detail, name=group_detail),
url(r'^schools', school_list, name=school_list),
url(r'^schools/(?P<pk>[0-9]+)/$', school_detail, name=school_detail),
] # Login and logout views for the browsable API
urlpatterns += [
url(r'^api-auth/', include('rest_framework.urls',
namespace='rest_framework')),
]
|
{"/geoapi/mygeoapi/views.py": ["/geoapi/mygeoapi/serializers.py", "/geoapi/mygeoapi/models.py"], "/geoapi/mygeoapi/urls.py": ["/geoapi/mygeoapi/views.py"]}
|
36,277
|
Grace-Amondi/Django-rest-framework-geospatial-tutorial
|
refs/heads/master
|
/geoapi/mygeoapi/models.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models
from django.contrib.gis.db import models
from django.contrib.postgres.fields import HStoreField
class School(models.Model):
name = models.CharField(max_length=100)
county = models.CharField(max_length=100, null=True)
enrollment = models.IntegerField()
location = models.PointField(srid=4326)
electricity_availability = models.BooleanField(default=False)
emmis_code = models.IntegerField(null=False,default=0)
def __unicode__(self):
return self.name
class Link(models.Model):
"""
Metadata is stored in a PostgreSQL HStore field, which allows us to
store arbitrary key-value pairs with a link record.
"""
metadata = HStoreField(blank=True, null=True, default=dict)
geo = models.LineStringField()
objects = models.GeoManager()
|
{"/geoapi/mygeoapi/views.py": ["/geoapi/mygeoapi/serializers.py", "/geoapi/mygeoapi/models.py"], "/geoapi/mygeoapi/urls.py": ["/geoapi/mygeoapi/views.py"]}
|
36,294
|
ktarrant/kevtools
|
refs/heads/master
|
/calscripts.py
|
import urllib.request
from calendar import Calendar
import locale
months = ["January", "February", "March", "April", "May", "June", "July",
"August", "September", "October", "November", "December"]
def grabEnclosedString(content, cur, tag):
size = cur
cur = content.find("<" + tag, cur)
if cur == -1: return cur
cur = content.find(">", cur) + 1
end = content.find("</" + tag + ">", cur)
size = end + len("</" + tag + ">") - size
return (content[cur:end], size)
def parseAndAdd(label, date, year, cal):
date_sp = date.split(" ")
multi_month = False
ranged = False
st_month = months.index(date_sp.pop(0)) + 1
st_date = ""
en_month = ""
en_date = ""
dt = date_sp.pop(0)
while dt == "":
dt = date_sp.pop(0)
dt_sp = dt.split("-")
if len(dt_sp) > 1:
ranged = True
st_date = dt_sp[0]
if months.count(dt_sp[1]) > 0:
en_month = months.index(dt_sp[1]) + 1
multi_month = True
else:
en_month = st_month
en_date = int(dt_sp[1])
else:
st_date = int(dt_sp[0])
if (multi_month):
dt = date_sp.pop(0)
while dt == "":
dt = date_sp.pop(0)
en_date = int(dt)
st_str = str(st_month) + "/" + str(st_date) + "/" + str(year)
if ranged:
en_str = str(en_month) + "/" + str(en_date) + "/" + str(year)
else:
en_str = ""
edit = cal.edit()
edit.addEvent({"Subject": label, \
"Start Date": st_str, "End Date": en_str, \
"All Day Event": "True"}).commit()
def createAcademicCalendar(year, filename=""):
#cal = Calendar(filename)
year = int(year)
yearSuffix = year % 100
url = "http://www.provost.umd.edu/calendar/%d.html" % yearSuffix
content = urllib.request.urlopen(url).read()
encoding = locale.getdefaultlocale()[1]
content = content.decode(encoding)
cal = Calendar(filename)
cur = 0
state = "SEEK"
year = 0
while (cur >= 0 and cur < len(content)):
if (state == "SEEK"):
hcur = content.find("<h2>", cur)
cur = content.find("<tr>", cur)
if hcur > 0 and hcur < cur:
hcur = content.find("20", hcur)
year = int(content[hcur+2:hcur+4])
state = "READ"
elif (state == "READ"):
(block, sz) = grabEnclosedString(content, cur, "tr")
(label, lsz) = grabEnclosedString(block, 0, "td")
(date, dsz) = grabEnclosedString(block, lsz, "td")
cur = cur + sz
parseAndAdd(label, date, year, cal)
state = "SEEK"
#createAcademicCalendar("13", "UMD_2013_Calendar.csv")
|
{"/calscripts.py": ["/calendar.py"], "/kevtools.py": ["/cmdline.py", "/it_ebooks.py", "/download.py", "/calscripts.py", "/server.py"], "/it_ebooks.py": ["/cmdline.py", "/download.py"]}
|
36,295
|
ktarrant/kevtools
|
refs/heads/master
|
/kevtools.py
|
#!/usr/bin/env python
import sys
from cmdline import CommandLineCaller
import it_ebooks
import download
import calscripts
import server
mycaller = CommandLineCaller(sys.argv[0])
mycaller.createCommandFunction("download-ebook", it_ebooks.downloadEbook)
mycaller.createCommandFunction("download-ebook-all", \
it_ebooks.downloadAllEbooks)
mycaller.createCommandFunction("download download-direct", \
download.downloadDirect)
mycaller.createCommandFunction("download-indirect", download.downloadIndirect)
mycaller.createCommandFunction("calendar-academic", \
calscripts.createAcademicCalendar)
mycaller.createCommandFunction("run-server", server.run_server)
mycaller.callFromArgument(sys.argv[1:])
|
{"/calscripts.py": ["/calendar.py"], "/kevtools.py": ["/cmdline.py", "/it_ebooks.py", "/download.py", "/calscripts.py", "/server.py"], "/it_ebooks.py": ["/cmdline.py", "/download.py"]}
|
36,296
|
ktarrant/kevtools
|
refs/heads/master
|
/calendar.py
|
# Creates a calendar based on UMD Calendar information
# The calendar is a CSV file that can be imported to Google Calendar
import os
class Calendar:
fields = ("Subject", \
"Start Date", "Start Time", \
"End Date", "End Time", \
"All Day Event", \
"Description", "Location", \
"Private")
filename = ""
def __init__(self, filename=""):
""" Creates a Calendar object and attempts to open
an output file. If the output filename is not
valid, or if the file is not a valid calendar
file, the Calendar will output to "temp.csv".
If the file is a valid calendar file, the
Calendar will append to the existing calendar. """
if (filename is None or filename == ""):
self.createNewCalendar("temp.csv")
else:
try:
f=open(filename, "r")
if (self.verifyValidCalendar(f) == True):
f.close()
self.filename = filename
else:
self.createNewCalendar(filename)
except (FileNotFoundError):
self.createNewCalendar(filename)
def verifyValidCalendar(self, fileObject):
# TODO: add code to validate existing calendars
return False
def createNewCalendar(self, filename):
self.filename = filename
if os.path.isfile(filename):
os.remove(filename)
f = open(filename, "w")
self.writeCalendarHeaders(f)
f.close()
def writeCalendarHeaders(self, fileObject):
for field in self.fields:
fileObject.write(field + ", ")
fileObject.write("\n")
def edit(self):
return self.CalendarEditor(open(self.filename, "a"))
class CalendarEditor:
fileObject = None
fields = ("Subject", \
"Start Date", "Start Time", \
"End Date", "End Time", \
"All Day Event", \
"Description", "Location", \
"Private")
def __init__(self, fileObject):
self.fileObject = fileObject
def addEvent(self, fields_dict):
for field in self.fields:
if field in fields_dict:
self.fileObject.write(fields_dict[field])
self.fileObject.write(", ")
self.fileObject.write("\n")
return self
def commit(self):
self.fileObject.close()
# Testing
|
{"/calscripts.py": ["/calendar.py"], "/kevtools.py": ["/cmdline.py", "/it_ebooks.py", "/download.py", "/calscripts.py", "/server.py"], "/it_ebooks.py": ["/cmdline.py", "/download.py"]}
|
36,297
|
ktarrant/kevtools
|
refs/heads/master
|
/cmdline.py
|
# Command line tools module
from collections import deque
import inspect
def printUsageHeader():
print("Usage: <arg> means required argument, " + \
"[arg] means optional argument\n")
class CommandLineError(Exception):
def __init__(self, value):
self.value = value
def __str__(self):
return str(self.value)
class CommandLineFunction:
""" A Class that holds function information for a command line function """
def no_func(): print("There is no function assigned to this command.")
flags = []
func = no_func
args = None
varargs = None
keywords = None
defaults = None
description = ""
def __init__(self, flags, function, description=None):
try:
flags = flags.split(" ")
except (AttributeError, TypeError):
try:
flags = list(flags)
except (AttributeError, TypeError):
raise CommandLineError("Cannot create list from argument " + \
"'flags'.")
self.flags = flags
self.func = function;
arglist = inspect.getargspec(self.func)
arglist = list(arglist)
for i in range(len(arglist)):
if arglist[i] is None: arglist[i] = []
elif isinstance(arglist[i], str): arglist[i] = [arglist[i]]
(self.args, self.varargs, self.keywords, self.defaults) = tuple(arglist)
self.description = description
def printUsage(self):
print("Command: " + self.flags[0])
print(" Aliases: ", end="")
for flag in self.flags:
print(flag, end=" ")
print("")
print(" Arguments: ", end="")
if self.description is not None: print(self.description)
offset = len(self.args) - len(self.defaults)
for i in range(len(self.args)):
if i < offset:
print("<" + self.args[i] + ">", end=" ")
else:
deft = self.defaults[i - offset]
print("[" + self.args[i] + "=\"" + str(deft) + "\"]", end=" ")
for vararg in self.varargs: print("[" + vararg + "=*]", end=" ")
for keyword in self.keywords: print("[" + keyword + "=**]", end=" ")
print("")
def callFromArgument(self, args):
if args is None: args = ""
if (isinstance(args, str)):
args = args.split(" ")
if len(args) < len(self.args) - len(self.defaults):
raise CommandLineError( \
"Insufficient number of arguments provided.")
else:
if len(args) == 0: return self.func()
elif len(args) == 1: return self.func(args[0])
else: return self.func(*args)
def hasFlag(self, flag):
return self.flags.count(flag) > 0
class CommandLineCaller:
""" A Class that calls functions based on command line arguments """
moduleName_ = ""
commands_ = deque()
def __init__(self, moduleName):
self.argFuncs_ = deque()
if (moduleName is None):
self.moduleName_ = ""
elif (len(moduleName.split("\\")) > 1):
self.moduleName_ = moduleName.split("\\")[-1]
elif (len(moduleName.split("/")) > 1):
self.moduleName_ = moduleName.split("/")[-1]
else:
self.moduleName_ = moduleName
def printUsage(self):
printUsageHeader()
for command in self.commands_:
command.printUsage()
print("")
def createCommandFunction(self, flags, function):
self.commands_.append(CommandLineFunction(flags, function))
def callFromArgument(self, args):
if args is None: args = ""
if (isinstance(args, str)):
args = args.split(" ")
try:
name = args.pop(0)
for command in self.commands_:
if command.hasFlag(name): return command.callFromArgument(args)
except IndexError:
self.printUsage()
## Unit tests
# for __init__
assert(CommandLineCaller("C:\\Test_Case_0\\program_name").moduleName_ \
== "program_name")
assert(CommandLineCaller("/usr/data/Test_Case_0/program_name").moduleName_ \
== "program_name")
assert(CommandLineCaller("/test_case_1").moduleName_ == "test_case_1")
assert(CommandLineCaller("\\test_case_1").moduleName_ == "test_case_1")
assert(CommandLineCaller("test_case_2").moduleName_ == "test_case_2")
assert(CommandLineCaller("/usr/data/test_case_3/").moduleName_ == "")
assert(CommandLineCaller("").moduleName_ == "")
assert(CommandLineCaller("\\").moduleName_ == "")
assert(CommandLineCaller("/").moduleName_ == "")
assert(CommandLineCaller(None).moduleName_ == "")
# for printUsageInformation and callFromArgument
def testFunction(val1, val2="test", *val3):
pass
mycaller = CommandLineCaller("testProgram")
mycaller.createCommandFunction("testFunction tstFunc", testFunction)
def testFunction2(val1, val2, *val3):
if (val1 != "test1"):
return False
if (val2 != "test2"):
return False
if isinstance(val3, str):
return 1
else:
return len(val3)
mycaller.createCommandFunction(["testFunction2","tstFunc2"], testFunction2)
def testFunction3(val1="test1", val2="test2"):
pass
mycaller.createCommandFunction("testFunction3", testFunction3)
def checkError(str):
try:
mycaller.callFromArgument(str)
return False
except CommandLineError:
return True
assert(mycaller.callFromArgument("tstFunc test") is None)
assert(mycaller.callFromArgument("tstFunc2 test1 test2") == 0)
assert(mycaller.callFromArgument("testFunction2 test0 test2") == False)
assert(mycaller.callFromArgument("tstFunc2 test1 test2 extra1 extra2") == 2)
assert(mycaller.callFromArgument("tstFunc2 test1 test2 extra1") == 1)
assert(checkError("tstFunc2 tst"))
assert(checkError("tstFunc2"))
assert(not checkError("tstFunc2 tst tst"))
mycaller = None
|
{"/calscripts.py": ["/calendar.py"], "/kevtools.py": ["/cmdline.py", "/it_ebooks.py", "/download.py", "/calscripts.py", "/server.py"], "/it_ebooks.py": ["/cmdline.py", "/download.py"]}
|
36,298
|
ktarrant/kevtools
|
refs/heads/master
|
/server.py
|
#import http.server
#import socketserver
import tornado.ioloop
import tornado.web
from os import walk
PORT = 5000
def getItems(path):
f = []
for (dirpath, dirnames, filenames) in walk(path):
f.extend(filenames)
break
return f
class MainHandler(tornado.web.RequestHandler):
def get(self):
items = getItems("./server_data/")
self.render("index.html", title="kevtools", items=items)
application = tornado.web.Application([
(r"/", MainHandler),
])
def run_server():
application.listen(PORT)
print("listening on port %d" % PORT)
tornado.ioloop.IOLoop.instance().start()
if __name__ == "__main__":
run_server()
|
{"/calscripts.py": ["/calendar.py"], "/kevtools.py": ["/cmdline.py", "/it_ebooks.py", "/download.py", "/calscripts.py", "/server.py"], "/it_ebooks.py": ["/cmdline.py", "/download.py"]}
|
36,299
|
ktarrant/kevtools
|
refs/heads/master
|
/download.py
|
#!/usr/bin/env python
import os
import sys
import urllib.request
import time
def getInfoString(bytes):
units = ("B", "K", "M", "G", "T", "P")
unitChoice = 0
bytes_f = float(bytes)
while bytes_f > 1024:
bytes_f = bytes_f / 1024.0
unitChoice = unitChoice + 1
if unitChoice >= len(units):
return "%.2f ?B" % bytes_f
else:
return "%.2f %sB" % (bytes_f, units[unitChoice])
def _downloadData(HTTPObject, saveFile, printStatus=True):
fileObject = open(saveFile, 'wb')
content_header = HTTPObject.getheader("Content-length")
if (content_header is None):
if (printStatus):
print("Unable to retrieve content header.")
return False
file_size = int(HTTPObject.getheader("Content-length"))
if (printStatus):
sys.stdout.write("Downloading \"%s\" ... (%s)\n" \
% (saveFile, getInfoString(file_size)))
file_size_dl = 0
block_sz = 8192
dotThresh = file_size / 100
curDot = 1
if (printStatus):
sys.stdout.write("Status: [")
startTime = time.clock()
while True:
buf = HTTPObject.read(block_sz)
if not buf:
break
file_size_dl += len(buf)
fileObject.write(buf)
if (printStatus):
while (curDot < file_size_dl / dotThresh):
for e in (25, 50, 75):
if (curDot == e):
sys.stdout.write("%s%%" % e)
curDot = curDot + 3
continue
sys.stdout.write("=")
curDot = curDot + 2
sys.stdout.flush()
if (printStatus):
sys.stdout.write("]\n")
elapsedTime = time.clock() - startTime
sys.stdout.write("Finished in %.2f seconds. (%s/second)\n" \
% (elapsedTime, getInfoString(float(file_size) / elapsedTime)))
fileObject.close()
return True
def downloadIndirect(url, referer, saveFile="", \
overWrite=True, printStatus=True):
req = urllib.request.Request(url, data=None, \
headers={"Referer": referer})
opener = urllib.request.build_opener()
u = opener.open(req)
contDisp = u.getheader("Content-Disposition")
if saveFile is None or saveFile == "":
if contDisp is None:
saveFile = url.split('/')[-1]
else:
lowIndex = contDisp.find("\"")
hiIndex = contDisp.find("\"", lowIndex + 1)
if (lowIndex != -1 and hiIndex != -1):
saveFile = contDisp[lowIndex + 1: hiIndex]
else:
saveFile = url.split('/')[-1]
if os.path.isfile(saveFile):
if (overWrite):
os.remove(saveFile)
if (printStatus):
print("Overwriting file: \"%s\"" % saveFile)
else:
if (printStatus):
print("File already exists! Will not download.")
return False
return _downloadData(u, saveFile, printStatus)
def downloadDirect(url, saveFile="", overWrite=True, printStatus=True):
if saveFile is None or saveFile == "":
saveFile = url.split('/')[-1]
if os.path.isfile(saveFile):
if (overWrite):
os.remove(saveFile)
if (printStatus):
print("Overwriting file: %s" % saveFile)
else:
if (printStatus):
print("File already exists! Will not download.")
return False
u = urllib.request.urlopen(url)
return _downloadData(u, saveFile, printStatus)
# Unit Tests
|
{"/calscripts.py": ["/calendar.py"], "/kevtools.py": ["/cmdline.py", "/it_ebooks.py", "/download.py", "/calscripts.py", "/server.py"], "/it_ebooks.py": ["/cmdline.py", "/download.py"]}
|
36,300
|
ktarrant/kevtools
|
refs/heads/master
|
/it_ebooks.py
|
import os
from cmdline import CommandLineCaller
from download import downloadIndirect
import urllib.request
import locale
def downloadAllEbooks(directory="", startIndex=1):
counter = int(startIndex)
rval = True
while (rval is True):
print("%d: " % counter, end = "")
rval = downloadEbook(counter, directory)
counter += 1
return "Downloaded %d books." % (counter - 1)
def downloadEbook(pageNum, directory=""):
if directory is None:
directory = ""
elif directory is not "":
if not directory.endswith("/") and not directory.endswith("\\"):
directory = directory + "/"
if not os.path.exists(directory):
os.makedirs(directory)
url = "http://it-ebooks.info/book/%s/" % pageNum
u = urllib.request.urlopen(url)
encoding = locale.getdefaultlocale()[1]
content = u.read().decode(encoding)
ind = content.find("<title>")
lowerInd = ind + len("<title>")
higherInd = content.find(" - Free Download", ind)
title = content[lowerInd:higherInd] + ".pdf"
if title == "IT eBooks.pdf": # Means we 404'd
return "Page Not Found"
ind = content.find("<tr><td>Download:</td><td>")
ind = content.find("href", ind)
lowerInd = ind + len("href='")
ind = content.find("\"", lowerInd)
higherInd = content.find("'", lowerInd)
if higherInd == -1:
if ind == -1:
return "Parsing error."
else:
higherInd = ind
else:
if ind != -1 and ind < higherInd:
higherInd = ind
content = content[lowerInd:higherInd]
if content.startswith("/"):
content = "http://it-ebooks.info" + content
print("Downloading \"%s\"" % content)
return downloadIndirect(content, url, directory + title)
# Unit Tests
|
{"/calscripts.py": ["/calendar.py"], "/kevtools.py": ["/cmdline.py", "/it_ebooks.py", "/download.py", "/calscripts.py", "/server.py"], "/it_ebooks.py": ["/cmdline.py", "/download.py"]}
|
36,309
|
Varghese-Kuruvilla/Sentiment_Analysis
|
refs/heads/master
|
/conv_nets.py
|
import torch
import os
from nltk import sent_tokenize,word_tokenize
from collections import Counter
import time
from string import punctuation
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from torch.utils.data import DataLoader , TensorDataset
from torch import nn
from define_model import process_model
#Global variables
punctuation = punctuation + "/" + ">" + "<" + "!" + "+"
class sentiment:
def __init__(self):
self.labels = [] #List containing the labels associated with the reviews
self.text = [] #List of lists where each list contains an individual review
self.entire_text = " " #Entire texts
self.no_punct = " " #Entire text with no punctuation
self.vocab_to_int = {} #Vocab to int mapping where the most common word has the least integer mapping
self.reviews_split = []
self.reviews_int = []
self.encoded_labels = []
self.seq_length = 500
self.review_len = []
#self.train_x = []
#self.train_y = []
#self.test_x = []
#self.test_y = []
#self.valid_x = []
#self.valid_y = []
#self.features is a data member with reviews_len as rows and seq_length columns
#self.x
#self.words gives us all the individual words in the training data
def parse_dataset(self):
count = 0
imdb_dir = "/home/varghese/sentiment_analysis/aclImdb/"
train_dir = os.path.join(imdb_dir,'train')
print("train_dir:",train_dir)
self.labels = []
self.text = []
#Parsing through the labels
for label_type in ['neg','pos']:
dir_name = os.path.join(train_dir,label_type)
print("dir_name:",dir_name)
for fname in os.listdir(dir_name):
if(fname[-4:] == ".txt"):
f = open(os.path.join(dir_name,fname))
self.text.append([f.read()])
f.close()
if(label_type == "neg"):
self.labels.append(0)
elif(label_type == "pos"):
self.labels.append(1)
count = count + 1 #Use this for debugging...
# if(count == 3):
# print("text:",text)
# print("labels:",labels)
if(count == 100):
break
break
#Concatenating the list into an entire string of text
for i in range(0,len(self.text)):
self.entire_text = self.entire_text + ' '.join(self.text[i]) + "\n"
#print("self.entire_text:",self.entire_text)
#print("self.text:",self.text)
#print("self.labels:",self.labels)
#print("len(labels):",len(self.labels))
#print("len(text):",len(self.text))
def tokenize(self):
#self.reviews_split = self.entire_text.split('\n')
#print("self.reviews_split:",self.reviews_split)
self.entire_text = self.entire_text.lower()
#print("self.entire_text:",self.entire_text)
#inp = input("Waiting for input...")
for char in self.entire_text:
if char not in punctuation:
self.no_punct = self.no_punct + char
self.reviews_split = self.no_punct.split("\n")
self.reviews_split.pop()
print("Number of reviews:",len(self.reviews_split))
self.words = self.no_punct.split()
#print("words:",words)
#Counting all of the words
count_words = Counter(self.words)
total_words = len(self.words)
sorted_words = count_words.most_common(total_words)
#print("count_words:",count_words)
#print("sorted_words:",sorted_words)
#Creating a vocab to int mapping
self.vocab_to_int = {w:i+1 for i,(w,c) in enumerate(sorted_words)} #Here the most common word gets the lowest value and the least common words get the highest value
#print("vocab_to_int:",self.vocab_to_int)
#Encoding the words
self.reviews_int = []
for review in self.reviews_split:
r = [self.vocab_to_int[w] for w in review.split()]
self.reviews_int.append(r)
#print("self.reviews_int:",self.reviews_int)
#Encoding the labels
self.encoded_labels = [1 if label == "positive" else 0 for label in self.labels]
self.encoded_labels = np.array(self.encoded_labels)
print("Inside tokenize:")
print(type(self.encoded_labels))
#print("self.encoded_labels:",self.encoded_labels)
def analyze_data(self):
#Visualizing the length of each review
self.review_len = [len(review) for review in self.reviews_int]
#print("review_len:",review_len)
#plt.plot(review_len)
#plt.xlabel("Review number")
#plt.ylabel("Review length")
#plt.show()
#print(pd.Series(review_len).describe())
#Removing Outliers
self.reviews_int = [self.reviews_int[i] for i,l in enumerate(self.review_len) if l>0]
self.encoded_labels = [self.encoded_labels[i] for i,l in enumerate(self.review_len) if l>0]
self.encoded_labels = np.array(self.encoded_labels)
print("len(self.reviews_int):",len(self.reviews_int))
print("len(self.encoded_labels):",len(self.encoded_labels))
def prepare_data(self):
#Pruning all reviews to length = seq_length
self.features = np.zeros([len(self.reviews_int) , (self.seq_length)], dtype=int)
print("self.features.shape:",self.features.shape)
for i,review_int in enumerate(self.reviews_int):
if(len(review_int) >= self.seq_length):
temp = review_int[0:self.seq_length]
elif(len(review_int) < self.seq_length):
#zeros = np.zeros(self.seq_length - len(review_int))
zeros = [0] * (self.seq_length - len(review_int))
temp = review_int + zeros
#print(np.array(temp).shape)
self.features[i,:] = np.array(temp) #So each row of our np array would contain the encoding for each particular review
print("self.features.shape:",self.features.shape)
print("self.encoded_labels:",type(self.encoded_labels))
print(int(len(self.review_len) * 0.8))
#Splitting into training,testing and validation sets
self.train_x = self.features[0:int(len(self.review_len) * 0.8),:]
self.train_y = self.encoded_labels[0:int(len(self.review_len) * 0.8)]
remaining_x = self.features[int(len(self.review_len)*0.8):,:]
remaining_y = self.encoded_labels[int(len(self.review_len)*0.8):]
self.test_x = remaining_x[0:int(len(remaining_x)*0.5),:]
self.test_y = remaining_y[0:int(len(remaining_y)*0.5)]
self.valid_x = remaining_x[int(len(remaining_x)*0.5):,:]
self.valid_y = remaining_y[int(len(remaining_y)*0.5):]
def datasets(self):
self.train_data = TensorDataset(torch.from_numpy(self.train_x),torch.from_numpy(self.train_y))
self.valid_data = TensorDataset(torch.from_numpy(self.valid_x),torch.from_numpy(self.valid_y))
self.test_data = TensorDataset(torch.from_numpy(self.test_x),torch.from_numpy(self.test_y))
self.train_loader = DataLoader(self.train_data , shuffle = True , batch_size = 50)
self.test_loader = DataLoader(self.test_data , shuffle = True , batch_size = 50)
self.valid_loader = DataLoader(self.valid_data , shuffle = True , batch_size = 50)
process_model(self.words,self.train_loader,self.test_loader,self.valid_loader)
def visualize(self):
dataiter = iter(self.train_loader)
sample_x , sample_y = dataiter.next()
self.x = sample_x.type(torch.LongTensor)
print("sample_x:",sample_x.size())
print("sample_y:",sample_y.size())
if __name__ == "__main__":
print("punctuation:",punctuation)
s = sentiment()
s.parse_dataset()
s.tokenize()
s.analyze_data()
s.prepare_data()
s.datasets()
s.visualize()
s.model()
|
{"/conv_nets.py": ["/define_model.py"]}
|
36,310
|
Varghese-Kuruvilla/Sentiment_Analysis
|
refs/heads/master
|
/define_model.py
|
#Script to define the model
from torch import nn,optim
import torch
class Model(nn.Module):
def __init__(self,words):
super(Model,self).__init__()
vocab_size = len(words)
embedding_dims = 30
self.embed = nn.Embedding(vocab_size,embedding_dims) #Inputs : vocabulary size and embedding dimensions
#So for each of the tokenized words we add the dimension 30 to it
#LSTM Layer
self.lstm = nn.LSTM(input_size=embedding_dims , hidden_size=512, num_layers=1 , batch_first= True)
#The output of our LSTM layer is a 50,500,512 tensor which we feed into the FC layer
self.fc = nn.Linear(in_features = 512, out_features =1)
#Finally we pass this through a sigmoid layer
self.sigm = nn.Sigmoid()
def forward(self,x):
#print("x.shape:",x.shape)
embed_out = self.embed(x)
#print("embed_out.shape:",embed_out.shape)
batch_size = 50
hidden = None
lstm_out ,h = self.lstm(embed_out,hidden)
#print("lstm_out:",lstm_out.shape)
fc_out = self.fc(lstm_out.contiguous().view(-1,512))
#print("fc_out:",fc_out.shape)
sigm_out = self.sigm(fc_out)
#print("sigm_out.shape:",sigm_out.shape)
out = sigm_out.view(batch_size,-1)
#print("out[:,-1].view(batch_size,-1).shape",out[:,-1].view(batch_size,-1).shape)
return out[:,-1].view(batch_size,-1)
def process_model(words,train_loader,test_loader,valid_loader):
model = Model(words)
print("model:",model)
#loss_function = nn.BCEWithLogitsLoss(reduction='mean')
loss_function = nn.MSELoss()
optimizer = optim.Adam(model.parameters())
for epoch in range(1,11):
train_loss , valid_loss = [] , []
#Training
model.train()
for data,target in train_loader:
print("type(target):",type(target))
target_flag = 0
target = target.float()
print("target.shape[0]:",target.shape[0])
if(target.shape[0] < 50):
target_1 = torch.zeros(50)
target_1[:target.shape[0]] = target
target = target_1
optimizer.zero_grad()
output = model(data)
print("shape of the output:",output.shape)
print("target.view(-1,1).shape:",target.view(-1,1).shape)
loss = loss_function(output, target.view(-1,1))
loss.backward()
optimizer.step()
train_loss.append(loss.item())
print("Inside training loop")
#Validation
model.eval()
for data,target in valid_loader:
print("Inside evaluation loop:")
if(target.shape[0] < 50):
target_1 = torch.zeros(50)
target_1[:target.shape[0]] = target
target = target_1
output = model(data)
loss = loss_function(output, target.view(-1,1))
valid_loss.append(loss.item())
print("Epoch {} , Training_loss{}:".format(epoch , train_loss))
print("Epoch {} , Validation_loss{}:".format(epoch,valid_loss))
#dataiter = iter(valid_loader)
#data , labels = dataiter.next()
#output = model(data)
#_,preds_tensor = torch.max(output,1)
#preds = np.squeeze(preds_tensor.numpy)
|
{"/conv_nets.py": ["/define_model.py"]}
|
36,311
|
simplefractal/kareflow
|
refs/heads/master
|
/apps/provider/models.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models
from util.randz import make_8_key
ROLE_CHOICES = (
(1, "Other"),
(2, "Nurse"),
(3, "PCP"),
(4, "Specialist"),
)
class Provider(models.Model):
user = models.OneToOneField("auth.user", null=True)
uuid = models.CharField(blank=True, unique=True, max_length=50)
first_name = models.CharField(max_length=50, null=True)
last_name = models.CharField(max_length=50, null=True)
email = models.CharField(max_length=250, null=True, blank=True)
phone = models.CharField(max_length=15, null=True, blank=True)
role = models.PositiveSmallIntegerField(choices=ROLE_CHOICES, default=1)
def __unicode__(self):
return "Dr. {}, {}".format(self.last_name, self.first_name)
@property
def name(self):
return u"{} {}".format(self.first_name, self.last_name)
def to_json(self):
return {
"uuid": self.uuid,
"name": self.name,
"email": self.email,
"phone": self.phone,
"role": dict(ROLE_CHOICES).get(self.role),
}
def save(self, *args, **kwargs):
"""
Ensure unique uuid
"""
if not self.uuid:
uuid = make_8_key()
while Provider.objects.filter(uuid=uuid).exists():
uuid = make_8_key()
self.uuid = uuid
super(Provider, self).save(*args, **kwargs)
|
{"/apps/task/views.py": ["/apps/task/models.py"], "/apps/discharge/admin.py": ["/apps/discharge/models.py"], "/apps/task/models.py": ["/apps/task/managers.py"]}
|
36,312
|
simplefractal/kareflow
|
refs/heads/master
|
/apps/discharge/models.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from json_field import JSONField
from django.db import models
from util.randz import make_8_key
class Discharge(models.Model):
uuid = models.CharField(blank=True, unique=True, max_length=50)
# Message
date = models.DateTimeField(null=True, blank=True)
facility = models.CharField(max_length=100, null=True, blank=True)
diagnosis = models.CharField(max_length=50, null=True, blank=True)
# Patient
patient = models.ForeignKey('patient.Patient')
metadata = JSONField(null=True, blank=True)
# Doctors
attending = models.ForeignKey('provider.Provider', related_name="attending", null=True, blank=True)
referring = models.ForeignKey('provider.Provider', related_name="referring", null=True, blank=True)
def __unicode__(self):
return u"{} ({})".format(
self.patient,
self.date.strftime("%m/%d/%y"))
def save(self, *args, **kwargs):
"""
Ensure unique uuid
"""
if not self.uuid:
uuid = make_8_key()
while Discharge.objects.filter(uuid=uuid).exists():
uuid = make_8_key()
self.uuid = uuid
super(Discharge, self).save(*args, **kwargs)
|
{"/apps/task/views.py": ["/apps/task/models.py"], "/apps/discharge/admin.py": ["/apps/discharge/models.py"], "/apps/task/models.py": ["/apps/task/managers.py"]}
|
36,313
|
simplefractal/kareflow
|
refs/heads/master
|
/apps/patient/models.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import datetime
from django.db import models
from util.randz import make_8_key
from util.stringz import format_phone
class Address(models.Model):
street_1 = models.CharField(max_length=100)
street_2 = models.CharField(max_length=100, null=True, blank=True)
city = models.CharField(max_length=50)
state = models.CharField(max_length=50, null=True, blank=True)
zip_code = models.CharField(max_length=10)
country = models.CharField(max_length=50, default="United States")
def __unicode__(self):
return "{}, {}, {} {}, {}".format(
self.street_1, self.city, self.state, self.zip_code, self.country)
def to_json(self):
return {
'street1': self.street_1,
'street2': self.street_2,
'city': self.city,
'state': self.state,
'zip_code': self.zip_code,
'country': self.country,
}
class Patient(models.Model):
uuid = models.CharField(blank=True, unique=True, max_length=50)
first_name = models.CharField(max_length=50, null=True)
last_name = models.CharField(max_length=50, null=True)
# Demographics
ssn = models.CharField(max_length=15, null=True, blank=True)
dob = models.DateTimeField(null=True, blank=True)
sex = models.CharField(max_length=10, null=True, blank=True)
marital_status = models.CharField(max_length=50, null=True, blank=True)
# Contact info
phone_home = models.CharField(max_length=15, null=True, blank=True)
phone_work = models.CharField(max_length=15, null=True, blank=True)
phone_cell = models.CharField(max_length=15, null=True, blank=True)
email = models.CharField(max_length=100, null=True, blank=True)
address = models.ForeignKey('patient.Address', null=True, blank=True)
insurance = models.CharField(max_length=200, null=True, blank=True)
def __unicode__(self):
return "{}, {}".format(self.last_name, self.first_name)
@property
def name(self):
return u"{} {}".format(self.first_name, self.last_name)
@property
def age(self):
if not self.dob:
return
now = datetime.datetime.now()
dob = datetime.datetime(self.dob.year, self.dob.month, self.dob.day)
total_seconds = (now - dob).total_seconds()
# return the integer number of years since DOB to now
return int(total_seconds / (60 * 60 * 24 * 365))
@property
def phone(self):
if self.phone_cell:
return self.phone_cell
elif self.phone_home:
return self.phone_work
else:
return self.phone_home
@property
def status(self):
"""
Smart property displaying the current
status of the patient based on recent
events
"""
# TODO: implement
return "in Jupiter ER"
def to_json(self):
return {
"name": self.name,
"age": self.age,
"status": self.status,
"uuid": self.uuid,
"firstName": self.first_name,
"lastName": self.last_name,
"name": self.name,
"ssn": self.ssn,
"dob": self.dob and self.dob.strftime('%m/%d/%Y'),
"sex": self.sex,
"maritalStatus": self.marital_status,
"phoneHome": format_phone(self.phone_home),
"phoneWork": format_phone(self.phone_work),
"phoneCell": format_phone(self.phone_cell),
"email": self.email,
"address": self.address and self.address.to_json(),
"insurance": self.insurance,
}
def save(self, *args, **kwargs):
"""
Ensure unique uuid
"""
if not self.uuid:
uuid = make_8_key()
while Patient.objects.filter(uuid=uuid).exists():
uuid = make_8_key()
self.uuid = uuid
super(Patient, self).save(*args, **kwargs)
|
{"/apps/task/views.py": ["/apps/task/models.py"], "/apps/discharge/admin.py": ["/apps/discharge/models.py"], "/apps/task/models.py": ["/apps/task/managers.py"]}
|
36,314
|
simplefractal/kareflow
|
refs/heads/master
|
/apps/task/urls.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.conf.urls import patterns, url
urlpatterns = patterns(
'',
url(r'^$', 'task.views.task_list', name='task_list'),
url(r'^complete/(?P<task_uuid>\w+)/$', 'task.views.mark_complete', name='mark_complete'),
url(r'^open/(?P<task_uuid>\w+)/$', 'task.views.mark_open', name='mark_open'),
)
|
{"/apps/task/views.py": ["/apps/task/models.py"], "/apps/discharge/admin.py": ["/apps/discharge/models.py"], "/apps/task/models.py": ["/apps/task/managers.py"]}
|
36,315
|
simplefractal/kareflow
|
refs/heads/master
|
/apps/emailer/__init__.py
|
from django.core.mail import EmailMessage
from django.template.loader import render_to_string
class BaseEmailEngine(object):
"""
Base email engine for rendering a template and sending it.
Example implementation:
class WelcomeEmail(BaseEmailEngine):
'''
A welcome email once a user signs up for our service.
'''
template = 'welcome.html'
def __init__(self, user):
self.user = user
def get_recipients(self):
return [self.user.email]
>>> from emailer import WelcomeEmail
>>> first_user = User.objects.get(id=1)
>>> WelcomeEmail(first_user).send()
"""
from_address = "youremail@address.com"
def render(self):
return render_to_string(self.template, self.get_context())
def send(self):
message = EmailMessage(
self.make_subject_line(),
self.render(),
self.from_address,
self.get_recipients,
headers={'Reply-To': self.from_address}
)
message.content_subtype = "html"
message.send()
def get_recipients(self):
raise NotImplementedError
|
{"/apps/task/views.py": ["/apps/task/models.py"], "/apps/discharge/admin.py": ["/apps/discharge/models.py"], "/apps/task/models.py": ["/apps/task/managers.py"]}
|
36,316
|
simplefractal/kareflow
|
refs/heads/master
|
/apps/task/views.py
|
from django.views.generic import TemplateView, View
from django.shortcuts import get_object_or_404
from django.http import HttpResponseRedirect
from django.core.urlresolvers import reverse
from .models import Task
class TaskList(TemplateView):
template_name = "task_list.html"
def get_context_data(self, *args, **kwargs):
tasks = Task.objects.all()
if self.request.GET.get("completed"):
active_filter = "completed"
tasks = tasks.completed()
else:
tasks = tasks.open()
active_filter = "open"
return {
"active_filter": active_filter,
"tasks": sorted(
list(tasks),
key=lambda task: task.action_deadline)
}
class MarkComplete(View):
def get(self, request, task_uuid):
task = get_object_or_404(Task, uuid=task_uuid)
task.mark_complete()
return HttpResponseRedirect(reverse('task_list'))
class MarkOpen(View):
def get(self, request, task_uuid):
task = get_object_or_404(Task, uuid=task_uuid)
task.mark_open()
return HttpResponseRedirect(reverse('task_list'))
task_list = TaskList.as_view()
mark_complete = MarkComplete.as_view()
mark_open = MarkOpen.as_view()
|
{"/apps/task/views.py": ["/apps/task/models.py"], "/apps/discharge/admin.py": ["/apps/discharge/models.py"], "/apps/task/models.py": ["/apps/task/managers.py"]}
|
36,317
|
simplefractal/kareflow
|
refs/heads/master
|
/settings/common.py
|
# List of callables that know how to import templates from various sources.
import os
ADMINS = ()
DATABASES = {'default': {'ENGINE': 'django.db.backends.mysql', 'NAME': 'my_db', 'HOST': '', 'USER': 'root', 'PASSWORD': '', 'PORT': ''}}
DEBUG = True
EMAIL_HOST = 'smtp.sendgrid.net'
EMAIL_HOST_PASSWORD = os.environ.get('SENDGRID_PASSWORD')
EMAIL_HOST_USER = os.environ.get('SENDGRID_USERNAME')
EMAIL_PORT = 587
EMAIL_USE_TLS = True
INSTALLED_APPS = (
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.humanize',
'django.contrib.sessions',
'django.contrib.sites',
'django.contrib.messages',
'django.contrib.staticfiles',
'django.contrib.admin',
'gunicorn',
'south',
'django_extensions',
'kareflow',
'emailer',
'provider',
'account',
'task',
'patient',
'discharge')
LANGUAGE_CODE = 'en-us'
LOGGING = {'loggers': {'django.request': {'level': 'ERROR', 'propagate': True, 'handlers': ['mail_admins']}}, 'version': 1, 'filters': {'require_debug_false': {'()': 'django.utils.log.RequireDebugFalse'}}, 'disable_existing_loggers': False, 'handlers': {'mail_admins': {'class': 'django.utils.log.AdminEmailHandler', 'filters': ['require_debug_false'], 'level': 'ERROR'}}}
MANAGERS = ()
MEDIA_ROOT = 'media'
MEDIA_URL = '/media/'
MIDDLEWARE_CLASSES = ('django.middleware.common.CommonMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware')
ROOT_URLCONF = 'urls'
SECRET_KEY = '24^+j9002sz=^%$%3l#u3-@&u+1xg2zh5_()x^(h7-@2tdp%cb'
SITE_ID = 1
STATICFILES_DIRS = ()
STATICFILES_FINDERS = ('django.contrib.staticfiles.finders.FileSystemFinder', 'django.contrib.staticfiles.finders.AppDirectoriesFinder')
STATIC_ROOT = ''
STATIC_URL = '/static/'
TEMPLATE_DEBUG = True
TEMPLATE_DIRS = ('templates',)
TEMPLATE_LOADERS = ('django.template.loaders.filesystem.Loader', 'django.template.loaders.app_directories.Loader')
TIME_ZONE = 'America/Chicago'
USE_I18N = True
USE_L10N = True
USE_TZ = False
|
{"/apps/task/views.py": ["/apps/task/models.py"], "/apps/discharge/admin.py": ["/apps/discharge/models.py"], "/apps/task/models.py": ["/apps/task/managers.py"]}
|
36,318
|
simplefractal/kareflow
|
refs/heads/master
|
/apps/discharge/admin.py
|
from django.contrib import admin
from .models import Discharge
admin.site.register(Discharge)
|
{"/apps/task/views.py": ["/apps/task/models.py"], "/apps/discharge/admin.py": ["/apps/discharge/models.py"], "/apps/task/models.py": ["/apps/task/managers.py"]}
|
36,319
|
simplefractal/kareflow
|
refs/heads/master
|
/apps/task/managers.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db.models.query import QuerySet
from django.db.models import Manager
class TaskQuerySet(QuerySet):
def open(self):
return self.filter(status=1)
def completed(self):
return self.filter(status=10)
class TaskManager(Manager):
def get_query_set(self):
return TaskQuerySet(self.model)
|
{"/apps/task/views.py": ["/apps/task/models.py"], "/apps/discharge/admin.py": ["/apps/discharge/models.py"], "/apps/task/models.py": ["/apps/task/managers.py"]}
|
36,320
|
simplefractal/kareflow
|
refs/heads/master
|
/apps/task/models.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import datetime
from django.contrib.humanize.templatetags.humanize import naturaltime
from django.db import models
from util.randz import make_8_key
from .managers import TaskManager
ACTION_CHOICES = (
(1, "Call patient"),
(2, "Schedule visit for patient"),
(3, "See patient in office"),
)
TASK_STATUSES = (
(1, "Incomplete"),
(10, "Complete"),
)
class Task(models.Model):
uuid = models.CharField(blank=True, unique=True, max_length=50)
patient = models.ForeignKey("patient.Patient")
action = models.PositiveSmallIntegerField(choices=ACTION_CHOICES, default=1)
deadline = models.DateTimeField()
date_completed = models.DateTimeField(null=True, blank=True)
date_added = models.DateTimeField(auto_now_add=True)
providers = models.ManyToManyField("provider.Provider")
status = models.PositiveSmallIntegerField(choices=TASK_STATUSES, default=1)
marked_complete_by = models.ForeignKey("account.Account", blank=True, null=True)
last_modified = models.DateTimeField(auto_now=True)
objects = TaskManager()
def __unicode__(self):
return "{}: {}".format(self.patient.name, self.action)
@property
def is_open(self):
return self.status == 1
@property
def is_complete(self):
return self.status == 10
@property
def is_call(self):
return self.action == 1
@property
def is_schedule(self):
return self.action == 2
@property
def is_visit(self):
return self.action == 3
@property
def display_text(self):
if self.is_call:
return "Call {} at {}".format(
self.patient.name,
self.patient.phone_cell)
else:
return "Schedule {} a visit before {}".format(
self.patient.name,
self.deadline.strftime("%m/%d"))
@property
def action_deadline(self):
"""
This is the deadline for the staff member to complete the task.
For scheduling a visit, the deadline is 2 days after the task was added,
even though the visit must take place within 7 or 14 days. The 7 or 14 day
endpoint is the deadline, while 2 days is the action_deadline.
"""
if self.is_schedule:
return datetime.datetime(
self.date_added.year,
self.date_added.month,
self.date_added.day,
self.date_added.hour,
self.date_added.minute) + datetime.timedelta(days=2)
else:
return self.deadline
@property
def action_deadline_text(self):
text = naturaltime(self.action_deadline)
text = text.replace("ago", "late")
text = text.replace("from now", "left")
return text
@property
def is_urgent(self):
"""
Less than a day to complete.
"""
# TODO fix hack to avoid tz awareness
action_deadline = datetime.datetime(
self.action_deadline.year,
self.action_deadline.month,
self.action_deadline.day,
self.action_deadline.hour,
self.action_deadline.minute)
return ((action_deadline - datetime.datetime.now())
.total_seconds() < 60 * 60 * 24)
def mark_complete(self):
self.status = 10
self.save()
def mark_open(self):
self.status = 1
self.save()
def save(self, *args, **kwargs):
"""
Ensure unique uuid
"""
if not self.uuid:
uuid = make_8_key()
while Task.objects.filter(uuid=uuid).exists():
uuid = make_8_key()
self.uuid = uuid
super(Task, self).save(*args, **kwargs)
|
{"/apps/task/views.py": ["/apps/task/models.py"], "/apps/discharge/admin.py": ["/apps/discharge/models.py"], "/apps/task/models.py": ["/apps/task/managers.py"]}
|
36,321
|
simplefractal/kareflow
|
refs/heads/master
|
/apps/account/models.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models
from util.randz import make_8_key
class Account(models.Model):
user = models.OneToOneField("auth.user", null=True)
uuid = models.CharField(blank=True, unique=True, max_length=50)
first_name = models.CharField(max_length=50, null=True)
last_name = models.CharField(max_length=50, null=True)
email = models.CharField(max_length=250, null=True, blank=True)
phone = models.CharField(max_length=15, null=True, blank=True)
providers = models.ManyToManyField("provider.Provider")
def save(self, *args, **kwargs):
"""
Ensure unique uuid
"""
if not self.uuid:
uuid = make_8_key()
while Account.objects.filter(uuid=uuid).exists():
uuid = make_8_key()
self.uuid = uuid
super(Account, self).save(*args, **kwargs)
|
{"/apps/task/views.py": ["/apps/task/models.py"], "/apps/discharge/admin.py": ["/apps/discharge/models.py"], "/apps/task/models.py": ["/apps/task/managers.py"]}
|
36,322
|
simplefractal/kareflow
|
refs/heads/master
|
/apps/util/stringz.py
|
import phonenumbers
def format_phone(phone_number):
"""
Takes an unformatted phone number, e.g. 8572079431
and turns it into 857-207-9431
"""
if not phone_number:
return ""
parsed = phonenumbers.parse(phone_number, "US")
formatted = phonenumbers.format_number(
parsed,
phonenumbers.PhoneNumber()
)
return formatted
|
{"/apps/task/views.py": ["/apps/task/models.py"], "/apps/discharge/admin.py": ["/apps/discharge/models.py"], "/apps/task/models.py": ["/apps/task/managers.py"]}
|
36,323
|
simplefractal/kareflow
|
refs/heads/master
|
/apps/util/randz.py
|
from django.contrib.auth.models import User
def make_8_key():
return User.objects.make_random_password(length=8)
|
{"/apps/task/views.py": ["/apps/task/models.py"], "/apps/discharge/admin.py": ["/apps/discharge/models.py"], "/apps/task/models.py": ["/apps/task/managers.py"]}
|
36,325
|
pixelkfr/django-ecommerce
|
refs/heads/master
|
/ecommerce/ecommerce/urls.py
|
from django.conf.urls import include, url
from django.contrib import admin
urlpatterns = [
url(r'^orders/', include('orders.urls', namespace="orders")),
url(r'^admin/', include(admin.site.urls)),
]
|
{"/ecommerce/orders/forms.py": ["/ecommerce/orders/models.py"]}
|
36,326
|
pixelkfr/django-ecommerce
|
refs/heads/master
|
/ecommerce/orders/models.py
|
from django.db import models
class Order(models.Model):
marketplace = models.CharField(max_length=100)
order_purchase_date = models.DateField('purchase date')
order_amount = models.FloatField()
order_currency = models.CharField(max_length=3)
order_id = models.CharField(max_length=19, primary_key=True)
def __unicode__(self): # __str__ on Python 3
return self.order_id
|
{"/ecommerce/orders/forms.py": ["/ecommerce/orders/models.py"]}
|
36,327
|
pixelkfr/django-ecommerce
|
refs/heads/master
|
/ecommerce/orders/urls.py
|
from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^$', views.IndexView.as_view(), name='index'),
url(r'^(?P<pk>([0-9]+|[A-Z]+|\-)+)/$', views.DetailView.as_view(),
name='detail'),
url(r'^new/$', views.order_new, name='order_new'),
url(r'^(?P<pk>([0-9]+|[A-Z]+|\-)+)/remove/$', views.order_remove,
name='order_remove'),
url(r'^(?P<pk>([0-9]+|[A-Z]+|\-)+)/edit/$', views.order_edit,
name='order_edit'),
]
|
{"/ecommerce/orders/forms.py": ["/ecommerce/orders/models.py"]}
|
36,328
|
pixelkfr/django-ecommerce
|
refs/heads/master
|
/ecommerce/orders/management/commands/getdata.py
|
import urllib2
import logging
import xml.etree.ElementTree as ET
from django.core.management.base import BaseCommand, CommandError
from django.core import serializers
from orders.models import Order
class Command(BaseCommand):
"""
Simple command to extract data from xml file and save them in the Order model.
Data are available at the following adress: http://test.ecommerce.io/orders-test.xml
"""
help = 'Load data from xml file, and save them in the Order model'
def handle(self, *args, **options):
logger = logging.getLogger()
steam_handler = logging.StreamHandler()
steam_handler.setLevel(logging.DEBUG)
logger.addHandler(steam_handler)
try:
request = urllib2.urlopen("http://test.ecommerce.io/orders-test.xml")
tree = ET.parse(request)
except:
raise CommandError('Xml file is not valid')
orders = tree.find("orders")
for item in orders.getiterator('order'):
if ((item.find('marketplace').text) is not None)\
and(item.find('order_purchase_date').text is not None)\
and(item.find('order_amount').text is not None)\
and(item.find('order_currency').text is not None)\
and(item.find('order_id').text is not None):
marketplace = item.find('marketplace')
order_purchase_date = item.find('order_purchase_date')
order_amount = item.find('order_amount')
order_currency = item.find('order_currency')
order_id = item.find('order_id')
# add and save a new order
new_order = Order(marketplace=marketplace.text,
order_purchase_date=order_purchase_date.text,
order_amount=order_amount.text,
order_currency=order_currency.text,
order_id=order_id.text)
new_order.save()
else:
logger.warning("A required argument is missing"
" for one order, please look at your xml file.")
|
{"/ecommerce/orders/forms.py": ["/ecommerce/orders/models.py"]}
|
36,329
|
pixelkfr/django-ecommerce
|
refs/heads/master
|
/ecommerce/orders/migrations/0001_initial.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
class Migration(migrations.Migration):
dependencies = [
]
operations = [
migrations.CreateModel(
name='Order',
fields=[
('marketplace', models.CharField(max_length=100)),
('order_purchase_date', models.DateField(verbose_name=b'purchase date')),
('order_amount', models.FloatField()),
('order_id', models.CharField(max_length=19, serialize=False, primary_key=True)),
],
),
]
|
{"/ecommerce/orders/forms.py": ["/ecommerce/orders/models.py"]}
|
36,330
|
pixelkfr/django-ecommerce
|
refs/heads/master
|
/ecommerce/orders/admin.py
|
from django.contrib import admin
# Not implemented yet, not usefull in our case.
|
{"/ecommerce/orders/forms.py": ["/ecommerce/orders/models.py"]}
|
36,331
|
pixelkfr/django-ecommerce
|
refs/heads/master
|
/ecommerce/orders/forms.py
|
from django import forms
from .models import Order
class OrderForm(forms.ModelForm):
class Meta:
model = Order
fields = ('marketplace', 'order_purchase_date',
'order_amount', 'order_currency', 'order_id',)
|
{"/ecommerce/orders/forms.py": ["/ecommerce/orders/models.py"]}
|
36,332
|
julienmendes/crous_scraping
|
refs/heads/master
|
/scrapper.py
|
import pandas as pd
import numpy as np
import re
import requests
import bs4
import smtplib
import time
def crous_scrapper(URL : str, MAIL : str, MAIL_mdp: str):
'''
URL: lien de la page de recherche
MAIL: addresse mail ou l'on souhaite recevoir les informations mais aussi celle qui va envoyer les mails
MAIL_mdp: mot de passe de la boite mail
'''
msg = ''
while True:
token = URL
def get_pages(token, nb):
pages = []
for i in range(1,nb+1):
j = token + str(i)
pages.append(j)
return pages
pages = get_pages(token,1)
for i in pages:
response = requests.get(i)
soup = bs4.BeautifulSoup(response.text, 'html.parser')
em_box = soup.find_all("li", {"class":"SearchResults-item"})
l = []
for link in soup.find_all('a',{"aria-hidden":"true"}):
l.append(link.get('title'))
df = pd.DataFrame(l)
df = df.dropna().reset_index(drop=True)
liste = []
for i in range(len(df)):
text = df.iloc[i].tolist()[0][22:]
liste.append(re.sub(r'.*([0-9]{5}).*',r'\1',text))
df = pd.DataFrame(liste,columns=['post code'])
df["post code"] = pd.to_numeric(df["post code"])
df = df.where(df['post code']!=2160).dropna()
new_msg = str(df['post code'].tolist())
if len(df) > 0 and new_msg != msg:
# Specifying the from and to addresses
fromaddr = MAIL
toaddrs = MAIL
# Writing the message (this message will appear in the email)
msg = str(df['post code'].tolist())
# Gmail Login
username = MAIL
password = MAIL_mdp
# Sending the mail
server = smtplib.SMTP('smtp.gmail.com:587')
server.starttls()
server.login(username,password)
server.sendmail(fromaddr, toaddrs, msg)
server.quit()
else:
msg = str(df['post code'].tolist())
|
{"/main.py": ["/scrapper.py"]}
|
36,333
|
julienmendes/crous_scraping
|
refs/heads/master
|
/main.py
|
from scrapper import crous_scrapper
if __name__ == "__main__":
crous_scrapper()
|
{"/main.py": ["/scrapper.py"]}
|
36,334
|
CollinsMuiruri/Recycle
|
refs/heads/master
|
/recycle/urls.py
|
from django.conf.urls import url
from django.urls import path
from . import views
from django.conf import settings
from django.conf.urls.static import static
urlpatterns = [
path(r'', views.index, name = 'index'),
#path(r'register/', views.register, name = 'register'),
path(r'profile/',views.profile, name = 'profile')
]
|
{"/recycler/admin.py": ["/recycler/models.py"], "/recycler/forms.py": ["/recycler/models.py"], "/recycler/views.py": ["/recycler/models.py", "/recycler/forms.py"], "/recycler/models.py": ["/recycle/models.py"], "/recycle/views.py": ["/recycle/models.py"]}
|
36,335
|
CollinsMuiruri/Recycle
|
refs/heads/master
|
/recycler/admin.py
|
from django.contrib import admin
from .models import CompanyProfile,Category,Product,Blog
# Register your models here.
admin.site.register(CompanyProfile)
admin.site.register(Product)
admin.site.register(Blog)
admin.site.register(Category)
|
{"/recycler/admin.py": ["/recycler/models.py"], "/recycler/forms.py": ["/recycler/models.py"], "/recycler/views.py": ["/recycler/models.py", "/recycler/forms.py"], "/recycler/models.py": ["/recycle/models.py"], "/recycle/views.py": ["/recycle/models.py"]}
|
36,336
|
CollinsMuiruri/Recycle
|
refs/heads/master
|
/recycler/forms.py
|
from django import forms
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth.models import User
from .models import CompanyProfile,Product
from django.contrib.auth import get_user_model
User = get_user_model()
class CompanySignUpForm(UserCreationForm):
"""
Model Form to create a sign up form for businesses
"""
class Meta:
model = User
fields = ('username',)
class CreateProductForm(forms.ModelForm):
"""
Form to facilitate creation of a Product
"""
class Meta:
model = Product
fields = ['name','description','mode_of_recycling']
exclude = ['User']
|
{"/recycler/admin.py": ["/recycler/models.py"], "/recycler/forms.py": ["/recycler/models.py"], "/recycler/views.py": ["/recycler/models.py", "/recycler/forms.py"], "/recycler/models.py": ["/recycle/models.py"], "/recycle/views.py": ["/recycle/models.py"]}
|
36,337
|
CollinsMuiruri/Recycle
|
refs/heads/master
|
/recycle/models.py
|
from django.db import models
from django.contrib.auth.models import AbstractUser
# Create your models here.
# The models that differentiate users start here
class User(AbstractUser):
is_consumer = models.BooleanField(default = False)
is_company = models.BooleanField(default = False)
# The models that differentiate users start here
class Profile(models.Model):
user = models.ForeignKey(User, on_delete=models.CASCADE)
image = models.ImageField(default = 'default.jpg', upload_to = 'profile_pics')
def __str__(self):
return f'{self.user.username} Profile'
class Photo(models.Model):
photo = models.ImageField(upload_to='photos/', blank=True, null=True)
photo_caption = models.CharField(max_length=140)
pub_date = models.DateTimeField(auto_now_add=True)
class Meta:
ordering = ['-pub_date']
def __str__(self):
return self.photo_caption
def save_photo(self):
self.save()
@classmethod
def get_photos(cls):
photos = Photo.objects.all()
return photos
|
{"/recycler/admin.py": ["/recycler/models.py"], "/recycler/forms.py": ["/recycler/models.py"], "/recycler/views.py": ["/recycler/models.py", "/recycler/forms.py"], "/recycler/models.py": ["/recycle/models.py"], "/recycle/views.py": ["/recycle/models.py"]}
|
36,338
|
CollinsMuiruri/Recycle
|
refs/heads/master
|
/recycler/views.py
|
from django.shortcuts import render,redirect
from django.contrib.auth.models import User
from django.contrib.auth.forms import UserCreationForm
from django.http import HttpResponse,Http404,HttpResponseRedirect,JsonResponse
from django.db.models.signals import post_save
from .models import CompanyProfile, Product
from .forms import CreateProductForm,CompanySignUpForm
from django.contrib.auth.decorators import login_required
from django.contrib.auth import authenticate,login
from django.contrib import messages
from .models import Product,Category
from django.views.generic import TemplateView,CreateView
# Create your views here.
from django.contrib.auth import get_user_model
User = get_user_model()
def save_profile(sender, instance, **kwargs):
instance.CompanyProfile.save()
post_save.connect(save_profile, sender=User)
class SignUpView(TemplateView):
template_name = "registration/signit.html"
def recycler_home(request):
return render(request, 'home.html')
def search(request):
"""
This view function will serach for available products
"""
if request.GET['search']:
search_term = request.GET.get("search")
products = CompanyProfile.find_profile(search_term)
message = f"{search_term}"
return render(request, 'search.html',{"message":message, "products":products})
else:
message = "It seems you have not searched for anything ..."
return render(request, 'search.html',{"message":message})
# def register(request):
# if request.method == 'POST':
# form = UserCreationForm(request.POST)
# if form.is_valid():
# form.save()
# username = form.cleaned_data['username']
# password = form.cleaned_data['password1']
# user = authenticate(username = username,password = password)
# login(request, user)
# return redirect('index')
# else:
# form = UserCreationForm()
# context = {'form': form}
# return render(request, 'registration/register.html', context)
@login_required(login_url ="/accounts/login")
def create_product(request):
"""
This view function creates an instance of a product
"""
if request.method == 'POST':
form = CreateProductForm(request.POST)
if form.is_valid():
products = form.save(commit = False)
products.user = request.user
products.save()
messages.success(request, 'Product created successfully !!')
return redirect('profile')
else:
form = CreateProductForm()
return render(request, 'edit.html',{"form":form})
def product(request):
categories = Category.objects.all()
return render(request, 'index.html',{"categories":categories})
class CompanySignUpView(CreateView):
model = User
form_class = CompanySignUpForm
template_name = 'registration/signup_form.html'
def get_context_data(self, **kwargs):
kwargs['user_type'] = 'teacher'
return super().get_context_data(**kwargs)
def form_valid(self, form):
user = form.save()
login(self.request, user)
return redirect('profile')
|
{"/recycler/admin.py": ["/recycler/models.py"], "/recycler/forms.py": ["/recycler/models.py"], "/recycler/views.py": ["/recycler/models.py", "/recycler/forms.py"], "/recycler/models.py": ["/recycle/models.py"], "/recycle/views.py": ["/recycle/models.py"]}
|
36,339
|
CollinsMuiruri/Recycle
|
refs/heads/master
|
/recycler/models.py
|
from django.db import models
# from django.contrib.auth.models import AbstractUser
from recycle.models import User
# Create your models here.
class CompanyProfile(models.Model):
user = models.OneToOneField(User, on_delete = models.CASCADE)
bio = models.CharField(max_length = 30, blank = True)
def __str__(self):
return f'{user.username}\'s Profile'
def save_profile(self):
self.save()
def delete_profile(self):
self.delete()
@classmethod
def get_profile(cls):
profile = CompanyProfile.objects.all()
return profile
@classmethod
def find_profile(cls, search_term):
profile = cls.objects.filter(user__username__icontains=search_term)
return profile
@classmethod
def update_profile(cls, id, bio):
updated = CompanyProfile.objects.filter(id=id).update(bio=bio)
return updated
class Category(models.Model):
name = models.TextField(max_length = 20)
def __str__(self):
return self.name
def delete_category(self):
self.delete()
class Product(models.Model):
name = models.TextField(max_length = 20)
user = models.ForeignKey(User, on_delete = models.CASCADE)
category = models.ForeignKey(Category, on_delete = models.CASCADE)
description = models.TextField(max_length = 500, default = 'No description provided')
mode_of_recycling = models.TextField(max_length = 50, default = 'Send to our drop off points')
def __str__(self):
return self.name
def delete_product(self):
self.delete()
@classmethod
def search_product(cls, search_term):
products = cls.objects.filter(name__icontains = search_term)
return products
class Blog(models.Model):
name = models.TextField(max_length = 20)
body = models.TextField(max_length= 400)
user = models.ForeignKey(User, on_delete = models.CASCADE)
|
{"/recycler/admin.py": ["/recycler/models.py"], "/recycler/forms.py": ["/recycler/models.py"], "/recycler/views.py": ["/recycler/models.py", "/recycler/forms.py"], "/recycler/models.py": ["/recycle/models.py"], "/recycle/views.py": ["/recycle/models.py"]}
|
36,340
|
CollinsMuiruri/Recycle
|
refs/heads/master
|
/recycler/apps.py
|
from django.apps import AppConfig
class RecyclerConfig(AppConfig):
name = 'recycler'
|
{"/recycler/admin.py": ["/recycler/models.py"], "/recycler/forms.py": ["/recycler/models.py"], "/recycler/views.py": ["/recycler/models.py", "/recycler/forms.py"], "/recycler/models.py": ["/recycle/models.py"], "/recycle/views.py": ["/recycle/models.py"]}
|
36,341
|
CollinsMuiruri/Recycle
|
refs/heads/master
|
/recycle/views.py
|
from django.shortcuts import render,redirect
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth.decorators import login_required
from django.contrib.auth import authenticate,login
from .models import User
from .forms import ConsumerSignUpForm
from django.views.generic import TemplateView,CreateView
from django.contrib.auth import get_user_model
User = get_user_model()
# Create your views here.
def index(request):
return render(request, 'index.html')
class SignUpView(TemplateView):
template_name = "registration/signit.html"
class ConsumerSignUpView(CreateView):
model = User
form_class = ConsumerSignUpForm
template_name = 'registration/register.html'
def get_context_data(self, **kwargs):
kwargs['user_type'] = 'consumer'
return super().get_context_data(**kwargs)
def form_valid(self, form):
user = form.save()
login(self.request, user)
return redirect('index')
# def register(request):
# if request.method == 'POST':
# form = UserCreationForm(request.POST)
# if form.is_valid():
# form.save()
# username = form.cleaned_data['username']
# password = form.cleaned_data['password1']
# user = authenticate(username = username,password = password)
# login(request, user)
# return redirect('index')
# else:
# form = UserCreationForm()
# context = {'form': form}
# return render(request, 'registration/register.html', context)
@login_required(login_url ="/accounts/login")
def profile(request):
return render(request, 'profile.html')
|
{"/recycler/admin.py": ["/recycler/models.py"], "/recycler/forms.py": ["/recycler/models.py"], "/recycler/views.py": ["/recycler/models.py", "/recycler/forms.py"], "/recycler/models.py": ["/recycle/models.py"], "/recycle/views.py": ["/recycle/models.py"]}
|
36,343
|
KSSSenapati/nitriders_myntra
|
refs/heads/main
|
/main.py
|
import os
from flask import Flask, render_template, request, url_for, send_from_directory
from PIL import Image
import numpy as np
import time
import platform
from Model import Model
import random
import cv2
from io import StringIO, BytesIO
import base64
from datetime import datetime
import json
def readb64(base64_string):
sbuf = BytesIO()
sbuf.write(base64.b64decode(base64_string))
res = Image.open(sbuf)
return np.array(res)
def writeb64(img):
img_str = cv2.imencode('.bmp', img)[1]
imagebase64 = base64.b64encode(img_str)
imagebase64 = bytes.decode(imagebase64)
return imagebase64
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
model = Model("checkpoints/jpp.pb",
"checkpoints/gmm.pth",
"checkpoints/tom.pth",
use_cuda=True)
app = Flask(__name__)
BASE_DIR = os.path.abspath(os.path.dirname(__file__))
cloth_list_raw = os.listdir(os.path.join(BASE_DIR, "static", "img"))
cloth_list = []
counter = 0
for cloth in cloth_list_raw:
if 'jpg' in cloth:
cloth_list.append([os.path.join("static", "img", cloth), counter])
counter += 1
@app.route('/web')
def hello_world():
return render_template('login.html', img_list=cloth_list)
@app.route('/upload', methods=['GET', 'POST'])
def upload_image():
print(request.form)
print(request.files)
if (not len(request.files) == 2 or (len(request.form) == 1 and len(request.files) == 1)):
return render_template('login.html', info="selection error", img_list=cloth_list)
else:
index = 0
cloth_image = None
if len(request.form) == 1:
index = int(request.form['optionsRadios'][6:])
person_image = request.files['person_image']
if len(request.files) == 2:
cloth_image = request.files['cloth_image']
start_time = time.time()
o_name, h_name = run_model_web(
person_image, cloth_list[index][0].split("\\")[-1], cloth_image)
end_time = time.time()
if o_name is None:
return 'I told you only clothes image with shape 256*192*3'
else:
return render_template('login.html', img_list=cloth_list, result1=h_name, result2=o_name, info="time: %.3f" % (end_time-start_time))
def run_model_web(f, cloth_name, cloth_f=None):
if cloth_f is None:
print(f, cloth_name)
c_img = np.array(Image.open(cloth_name))
else:
print(f, cloth_f)
try:
c_img = np.array(Image.open(cloth_f))
except:
c_img = np.array(Image.open(cloth_name))
temp_o_name = os.path.join("static", "result", "%d_%s" % (
int(time.time()), cloth_name.split("/")[-1]))
temp_h_name = os.path.join("static", "human", "%d_%s" % (
int(time.time()), cloth_name.split("/")[-1]))
if c_img.shape[0] != 256 or c_img.shape[1] != 192 or c_img.shape[2] != 3:
return None, None
img = Image.open(f)
human_img = np.array(img)
out, v = model.predict(human_img, c_img, need_bright=False, keep_back=True)
print("v:"+str(v))
out = np.array(out, dtype='uint8')
img.save(temp_h_name)
Image.fromarray(out).save(temp_o_name, quality=95)
return temp_o_name, temp_h_name
def getimg():
data_str = request.data
data_str = bytes.decode(data_str)
data_str = data_str.replace('\n', '')
data_json = json.loads(data_str)
base64img_p = data_json['image_person']
img_person = readb64(base64img_p)
img_person = cv2.rotate(img_person, 2)
img_person = cv2.flip(img_person, 1)
base64img_c = data_json['image_cloth']
img_cloth = readb64(base64img_c)
return [img_person, img_cloth]
@app.route('/cloth', methods=['GET', 'POST'])
def Hello_cloth():
output_str = ""
output_json = {}
status = 'ok'
if request.method == 'POST':
input_person, input_cloth = getimg()
cv2.imwrite('in.jpg', input_person)
input_person = input_person[60:580, 45:435]
cv2.imwrite('in_2.jpg', input_person)
output_img, v = model.predict(input_person, input_cloth, need_bright=True, keep_back=True, need_dilate=True)
output_img = cv2.cvtColor(output_img, cv2.COLOR_RGB2BGR)
cv2.imwrite('out.jpg', output_img)
print("v:"+str(v))
output_base64 = writeb64(output_img)
if v < 0.1:
status = 'failure'
else:
status = 'ok'
output_json["status"] = status
output_json["output_image"] = output_base64
output_str = json.dumps(output_json)
return output_str
return "please use http client to request!"
if __name__ == '__main__':
app.jinja_env.auto_reload = True
app.config['TEMPLATES_AUTO_RELOAD'] = True
app.run()
|
{"/main.py": ["/Model.py"], "/trial.py": ["/Model.py"], "/Model.py": ["/CPVTON.py", "/JPPNet.py"]}
|
36,344
|
KSSSenapati/nitriders_myntra
|
refs/heads/main
|
/CPVTON.py
|
# coding=utf-8
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np
from PIL import Image, ImageDraw
import argparse
import os
import time
import sys
from networks import GMM, UnetGenerator, load_checkpoint
import json
# normalize inputs
transformer = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
class CPVTON(object):
def __init__(self, gmm_path, tom_path, use_cuda=True):
opt = self.get_opt()
self.use_cuda = use_cuda
self.gmm = GMM(opt, use_cuda=use_cuda)
load_checkpoint(self.gmm, gmm_path, use_cuda=use_cuda)
self.gmm.eval()
self.tom = UnetGenerator(26, 4, 6, ngf=64, norm_layer=nn.InstanceNorm2d)
load_checkpoint(self.tom, tom_path, use_cuda=use_cuda)
self.tom.eval()
if use_cuda:
self.gmm.cuda()
self.tom.cuda()
print("use_cuda = "+str(self.use_cuda))
def predict(self, parse_array, pose_map, human, c):
im = transformer(human)
c = transformer(c) # [-1,1]
# parse -> shape
parse_shape = (parse_array > 0).astype(np.float32)
# blur, downsample + upsample
parse_shape = Image.fromarray((parse_shape*255).astype(np.uint8))
parse_shape = parse_shape.resize((192//16, 256//16), Image.BILINEAR)
parse_shape = parse_shape.resize((192, 256), Image.BILINEAR)
shape = transformer(parse_shape)
parse_head = (parse_array == 1).astype(np.float32) + \
(parse_array == 2).astype(np.float32) + \
(parse_array == 4).astype(np.float32) + \
(parse_array == 13).astype(np.float32) + \
(parse_array == 9).astype(np.float32)
phead = torch.from_numpy(parse_head) # [0,1]
im_h = im * phead - (1 - phead)
agnostic = torch.cat([shape, im_h, pose_map], 0)
if self.use_cuda:
# batch==1
agnostic = agnostic.unsqueeze(0).cuda()
c = c.unsqueeze(0).cuda()
# warp result
grid, theta = self.gmm(agnostic.cuda(), c.cuda())
c_warp = F.grid_sample(c.cuda(), grid, padding_mode='border')
else:
agnostic = agnostic.unsqueeze(0)
c = c.unsqueeze(0)
grid, theta = self.gmm(agnostic, c)
c_warp = F.grid_sample(c, grid, padding_mode='border')
tensor = (c_warp.detach().clone()+1)*0.5 * 255
tensor = tensor.cpu().clamp(0, 255)
array = tensor.numpy().astype('uint8')
c_warp = transformer(np.transpose(array[0], axes=(1, 2, 0)))
c_warp = c_warp.unsqueeze(0)
if self.use_cuda:
outputs = self.tom(torch.cat([agnostic.cuda(), c_warp.cuda()], 1))
else:
outputs = self.tom(torch.cat([agnostic, c_warp], 1))
p_rendered, m_composite = torch.split(outputs, 3, 1)
p_rendered = torch.tanh(p_rendered)
m_composite = torch.sigmoid(m_composite)
if self.use_cuda:
p_tryon = c_warp.cuda() * m_composite + p_rendered * (1 - m_composite)
else:
p_tryon = c_warp * m_composite + p_rendered * (1 - m_composite)
return (p_tryon, c_warp)
def get_opt(self):
parser = argparse.ArgumentParser()
parser.add_argument("--fine_width", type=int, default=192)
parser.add_argument("--fine_height", type=int, default=256)
parser.add_argument("--grid_size", type=int, default=5)
opt = parser.parse_args()
return opt
|
{"/main.py": ["/Model.py"], "/trial.py": ["/Model.py"], "/Model.py": ["/CPVTON.py", "/JPPNet.py"]}
|
36,345
|
KSSSenapati/nitriders_myntra
|
refs/heads/main
|
/trial.py
|
from PIL import Image
import numpy as np
import matplotlib.pyplot as plt
import time
import cv2 as cv
from Model import Model
import argparse
def get_opt():
parser = argparse.ArgumentParser()
parser.add_argument('--jpp', type=str, default='checkpoints/jpp.pb', help='model checkpoint for JPPNet')
parser.add_argument('--gmm', type=str, default='checkpoints/gmm.pth', help='model checkpoint for GMM')
parser.add_argument('--tom', type=str, default='checkpoints/tom.pth', help='model checkpoint for TOM')
parser.add_argument('--image', type=str, default='image.jpeg', help='input image')
parser.add_argument('--cloth', type=str, default='cloth.jpeg', help='cloth image')
opt = parser.parse_args()
return opt
opt = get_opt()
model = Model(opt.jpp, opt.gmm, opt.tom, use_cuda=False)
cloth = np.array(Image.open(opt.cloth))
plt.imshow(cloth)
plt.show()
image = np.array(Image.open(opt.image))
plt.imshow(image)
plt.show()
start = time.time()
result,trusts = model.predict(image, cloth, need_pre=False, check_dirty=True)
if result is not None:
end = time.time()
print("time:"+str(end-start))
print("Confidence"+str(trusts))
plt.imshow(result)
plt.show()
cv.imwrite('result.jpeg', result)
|
{"/main.py": ["/Model.py"], "/trial.py": ["/Model.py"], "/Model.py": ["/CPVTON.py", "/JPPNet.py"]}
|
36,346
|
KSSSenapati/nitriders_myntra
|
refs/heads/main
|
/get.py
|
import requests
import optparse
import cv2
import numpy as np
import sys
import threading
import os
from os.path import basename
import json
import base64
parser = optparse.OptionParser()
parser.add_option(
'-u', '--url', default='http://localhost:5000/cloth', dest='url')
def test():
# Use base64 to encode & decode image to transfer on the Internet
options, args = parser.parse_args()
img = cv2.imread('./example/cloth.jpg')
img_str = cv2.imencode('.jpg', img)[1]
imagebase64_c = base64.b64encode(img_str)
img = cv2.imread('./example/human.jpg')
img_str = cv2.imencode('.jpg', img)[1]
imagebase64_h = base64.b64encode(img_str)
data_str = {
"uuid": "1.jpg",
"image_person": imagebase64_h,
"image_cloth": imagebase64_c,
"format": "jpg",
}
num = 0
res = requests.post(options.url, data=json.dumps(data_str))
print(res.status_code)
num += 1
print(res.content)
if __name__ == '__main__':
threads = []
for x in range(1):
t = threading.Thread(target=test)
threads.append(t)
t.start()
for t in threads:
t.join()
|
{"/main.py": ["/Model.py"], "/trial.py": ["/Model.py"], "/Model.py": ["/CPVTON.py", "/JPPNet.py"]}
|
36,347
|
KSSSenapati/nitriders_myntra
|
refs/heads/main
|
/JPPNet.py
|
import tensorflow as tf
import os
from tensorflow.python.framework import graph_util
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
from tensorflow.python.platform import gfile
import time
class JPP(object):
IMG_MEAN = np.array((104.00698793,116.66876762,122.67891434), dtype=np.float32)
def __init__(self, pb_path):
options = tf.GPUOptions(allow_growth=True)
sess = tf.Session(config=tf.ConfigProto(gpu_options=options))
self.sess = tf.Session()
with gfile.FastGFile(pb_path, 'rb') as f:
graph_def = tf.GraphDef()
graph_def.ParseFromString(f.read())
self.sess.graph.as_default()
tf.import_graph_def(graph_def, name='')
self.sess.run(tf.global_variables_initializer())
self.img_tensor = sess.graph.get_tensor_by_name('img_1:0')
self.pose_tensor = sess.graph.get_tensor_by_name('pose:0')
self.parse_tensor = sess.graph.get_tensor_by_name('parse:0')
def predict(self, img):
ret = self.sess.run([self.pose_tensor,self.parse_tensor], feed_dict={self.img_tensor: img-JPP.IMG_MEAN})
return ret
|
{"/main.py": ["/Model.py"], "/trial.py": ["/Model.py"], "/Model.py": ["/CPVTON.py", "/JPPNet.py"]}
|
36,348
|
KSSSenapati/nitriders_myntra
|
refs/heads/main
|
/Model.py
|
import tensorflow as tf
import os
from tensorflow.python.framework import graph_util
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
from tensorflow.python.platform import gfile
from CPVTON import CPVTON
from JPPNet import JPP
import torch
import time
from PIL import ImageDraw, ImageEnhance
import torchvision.transforms as transforms
import cv2
class Model(object):
transformer = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))])
# transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
def __init__(self, pb_path, gmm_path, tom_path, use_cuda=True):
self.jpp = JPP(pb_path)
self.cpvton = CPVTON(gmm_path, tom_path, use_cuda=use_cuda)
def predict(self, human_img, c_img, need_pre=True, need_bright=False, keep_back=False, need_dilate=False, check_dirty=False):
if need_bright:
enh_bri = ImageEnhance.Brightness(Image.fromarray(human_img))
human_img = np.array(enh_bri.enhance(1.3))
result = self.jpp.predict(human_img)
pose = result[0][0]
parse = result[1][0]
pose_data, trusts = self.__getPoseData__(pose)
if need_pre:
human_img, pose_data, parse = self.__cropByPoseData__(
human_img, pose_data, parse)
if pose_data is None:
return human_img, 0.0
if check_dirty and self.__is_dirty__(pose_data[10], pose_data[15], pose_data[12], pose_data[2], pose_data[3], pose_data[13]):
return human_img, 0.0
pose_map = self.__getPoseMap__(pose_data)
parse = parse + np.array(parse == 16, dtype='uint8') * \
(-(16-9))+np.array(parse == 17, dtype='uint8')*(-(17-9))
parse = np.array(parse[:, :, 0], dtype="uint8")
(out, warp) = self.cpvton.predict(parse, pose_map, human_img, c_img)
out_img = np.array((np.transpose(out.detach().cpu().numpy()[
0], axes=(1, 2, 0))+1)/2*255, dtype='uint8')
if keep_back:
if len(parse.shape) == 2:
parse = parse.reshape((256, 192, 1))
cloth_mask = np.array(parse == 5, dtype='float32')
if need_dilate:
cloth = cloth_mask[:, :, 0]
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (18, 18))
dilated = cv2.dilate(cloth, kernel)
dilated = cv2.blur(dilated, (14, 14))
new_cloth = Image.fromarray((dilated*255))
new_cloth = new_cloth.resize(
(192//10, 256//10), Image.BILINEAR)
new_cloth = new_cloth.resize((192, 256), Image.BILINEAR)
new_cm = np.array(new_cloth)
new_cm = np.array(new_cm/255, dtype='float32')
cloth_mask = np.resize(new_cm, (256, 192, 1))
out_img = human_img*(1-cloth_mask)+out_img*cloth_mask
return np.array(out_img, dtype='uint8'), trusts
def __getPoseData__(self, pose):
contents = []
trusts = []
for i in range(16):
tmp = np.argmax(pose[:, :, i])
y = tmp % pose.shape[1]
x = tmp//pose.shape[1]
contents.append([y, x, 1])
if i not in [0, 1, 4, 5]:
trusts.append(sum([pose[x, y, i],
pose[x+1, y, i],
pose[x, y+1, i],
pose[x-1, y, i],
pose[x, y-1, i],
pose[x+1, y-1, i],
pose[x-1, y+1, i],
pose[x+1, y+1, i],
pose[x-1, y+1, i],
])/8)
return np.array(contents), min(trusts)
def __getPoseMap__(self, pose_data):
im_pose = Image.new('L', (192, 256))
pose_draw = ImageDraw.Draw(im_pose)
point_num = pose_data.shape[0]
pose_map = torch.zeros(point_num, 256, 192)
for i in range(point_num):
one_map = Image.new('L', (192, 256))
draw = ImageDraw.Draw(one_map)
pointx = pose_data[i, 0]
pointy = pose_data[i, 1]
r = 3
if pointx > 1 and pointy > 1:
draw.rectangle((pointx-r, pointy-r, pointx +
r, pointy+r), 'white', 'white')
pose_draw.rectangle(
(pointx-r, pointy-r, pointx+r, pointy+r), 'white', 'white')
one_map = Model.transformer(one_map)
pose_map[i] = one_map[0]
return pose_map
def __cropByPoseData__(self, img, pose_data, parse):
h, w = img.shape[0], img.shape[1]
height = max([pose_data[2][1], pose_data[3][1],
pose_data[10][1], pose_data[15][1]]) - pose_data[9][1]
pre_height = max([pose_data[2][1], pose_data[3][1],
pose_data[10][1], pose_data[15][1]])-pose_data[9][1]
upper = max(pose_data[9][1]-int(pre_height*0.2), 0)
bounder = min(max([pose_data[2][1], pose_data[3][1],
pose_data[10][1], pose_data[15][1]])+int(pre_height*0.2), h)
height = bounder - upper
width = int(height/4*3)
left = min([pose_data[12][0], pose_data[11][0], pose_data[10][0]])
right = max([pose_data[13][0], pose_data[14][0], pose_data[15][0]])
change = (width - (right-left))/2
if left >= 0+change and right <= w-change:
left -= change
right += change
elif left < 0+change:
left = 0
right = min(right+change+change-left, w)
elif right > w-change:
right = w-1
left = max(left-change-(change-(w-right)), 0)
else:
return None
left = int(left)
right = int(right)
print("upper:%d,bounder:%d,left:%d,right:%d" %
(upper, bounder, left, right))
if left >= right or upper >= bounder:
print("no person")
return img, None, None
factor_h = h/height
factor_w = w/width
for i in range(16):
pose_data[i][0] = int((left+pose_data[i][0])*factor_w)
pose_data[i][1] = int((upper+pose_data[i][1])*factor_h)
new_img = np.array(img[upper:bounder, left:right, :])
parse = parse[upper:bounder, left:right, :]
parse = np.array(Image.fromarray(np.array(np.concatenate(
[parse, parse, parse], axis=2)/17*255, dtype='uint8')).resize((192, 256)))
parse = np.array(parse[:, :, :1]/(255/17), dtype='uint8')
print("after crop shape:"+str(new_img.shape))
return np.array(Image.fromarray(new_img).resize((192, 256))), pose_data, parse
def __get_K_b__(self, b, c):
if b[0] == c[0]:
K = 99999999
else:
K = (b[1]-c[1])/(b[0]-c[0])
B = b[1]-K*b[0]
return (K, B)
def __upon_line__(self, a, KB):
K, B = KB
if K*a[0]+B > a[1]:
return True
else:
return False
# reverse
def __right_line__(self, a, KB, x):
K, B = KB
if K == 99999999:
if a[0] > x+5:
return True
else:
return False
result = K*a[0]+B >= a[1]
if (result > a[1] and K > 0) or (result < a[1] and K < 0):
return True
else:
return False
def __is_dirty__(self, wrist_a, wrist_b, a, b, c, d):
margin = 250
KB_list = [self.__get_K_b__(a, b), self.__get_K_b__(
b, c), self.__get_K_b__(c, d), self.__get_K_b__(a, d)]
if np.sum((np.sum(np.array(wrist_a)-np.array(b)))**2) <= margin or np.sum((np.sum(np.array(wrist_b)-np.array(c)))**2) <= margin:
return False # too close to standard points
if self.__right_line__(wrist_a, KB_list[0], wrist_a[0]) and self.__upon_line__(wrist_a, KB_list[1]):
print("wrist_a dirty")
return True
if not self.__right_line__(wrist_b, KB_list[2], wrist_b[0]) and self.__upon_line__(wrist_b, KB_list[1]):
print("wrist_b dirty")
return True
else:
return False
|
{"/main.py": ["/Model.py"], "/trial.py": ["/Model.py"], "/Model.py": ["/CPVTON.py", "/JPPNet.py"]}
|
36,353
|
Gdaimon/flask-vue-medidor
|
refs/heads/master
|
/main.py
|
import json
import os
import uuid
from datetime import datetime, timezone
from flask import Flask
from flask_mongoengine import MongoEngine
from flask_restful import Api
from resources import MeasurementDetail, MeasurementList
# Obtenemos la variable de entorno
API_HOST = os.environ.get('API_HOST', 'localhost')
DB_HOST = os.environ.get('DB_HOST', '')
DB_NAME = os.environ.get('DB_NAME', '')
DB_USER = os.environ.get('DB_USER', '')
DB_PASSWORD = os.environ.get('DB_PASSWORD', '')
# Configuracion app
app = Flask(__name__)
api = Api(app)
# Configuracion db
db = MongoEngine()
app.config['MONGODB_SETTINGS'] = {
'host': DB_HOST,
'db': DB_NAME,
'connect': False,
'username': DB_USER,
'password': DB_PASSWORD,
'authentication_source': 'admin'
}
db.init_app(app)
# Creacion Modelos db
# Simulacion base de datos
def generate_uuid():
identifier = uuid.uuid4()
return json.dumps(identifier, default=str)
def get_utc_now():
now = datetime.utcnow().replace(tzinfo=timezone.utc)
return json.dumps(now, default=str)
api.add_resource(MeasurementDetail, '/v1/measurements/<string:id>')
api.add_resource(MeasurementList, '/v1/measurements/')
if __name__ == "__main__":
# app.run(debug=True, port=5000)
# ya no se necesita porque se toman los del archivo .env
app.run(host=API_HOST)
|
{"/main.py": ["/resources.py"], "/resources.py": ["/models.py", "/utils.py"]}
|
36,354
|
Gdaimon/flask-vue-medidor
|
refs/heads/master
|
/models.py
|
from datetime import date
from mongoengine import Document, EmailField, IntField, StringField, DateTimeField, ReferenceField
class User(Document):
email = EmailField(required=True)
name = StringField(max_length=255, required=True)
surname = StringField(max_length=255, required=True)
class Measurement(Document):
sys = IntField(min_value=0, max_value=200, required=True)
dia = IntField(min_value=0, max_value=200, required=True)
pul = IntField(min_value=0, max_value=200, required=True)
created = DateTimeField(default=date.today, unique=True)
user = ReferenceField(User, required=True)
def to_dic(self):
return {
'id': str(self.id),
'sys': self.sys,
'dia': self.dia,
'pul': self.pul,
'created': self.created.strftime("%Y-%m-%d"),
'user': str(self.user.id)
}
|
{"/main.py": ["/resources.py"], "/resources.py": ["/models.py", "/utils.py"]}
|
36,355
|
Gdaimon/flask-vue-medidor
|
refs/heads/master
|
/resources.py
|
from flask_restful import Resource, abort, reqparse
from mongoengine import NotUniqueError, \
ValidationError
# Obtenemos la variable de entorno
from werkzeug.exceptions import NotFound, BadRequest
from models import Measurement, User
# class measurement(Resource):
#
# def get(self, id):
#
# # import pdb #Debugger
# # pdb.set_trace() # debugger
#
# for measurement in MEASUREMENTS:
# print('id: ', id)
# print('var: ', measurement.get('id'))
# if id == measurement.get('id'):
# return measurement, 200
# abort(
# 404,
# message={
# 'message': 'Measurement ID={id} was not found'
# }
# )
from utils import normalize_data, get_formatted_date, get_today_date
class MeasurementDetail(Resource):
def __init__(self):
self.reqparse = reqparse.RequestParser()
self.reqparse.add_argument('sys', type=int, required=False, location='json')
self.reqparse.add_argument('dia', type=int, required=False, location='json')
self.reqparse.add_argument('pul', type=int, required=False, location='json')
super(MeasurementDetail, self).__init__()
def get(self, id):
try:
measurement = Measurement.objects(id=id).first()
if measurement is not None:
return measurement.to_dic(), 200
abort(404, message=f'Measurement ID={id} was not found')
except NotFound as e:
raise e
except Exception as e:
abort(500, message=str(e))
def patch(self, id):
try:
import pdb
pdb.set_trace()
measurement = Measurement.objects(id=id).first()
if measurement is not None:
if get_formatted_date(measurement.created) != get_formatted_date(get_today_date()):
raise BadRequest(f'Cannot update a measurement for {measurement.created}')
data = self.reqparse.parse_args()
data = normalize_data(data) # eliminamos los valores None
measurement.update(**data)
measurement.reload()
return measurement.to_dic(), 200
abort(404, message=f'Measurement ID={id} was not found')
except BadRequest as e:
raise e
except NotFound as e:
raise e
except Exception as e:
abort(500, message=str(e))
class MeasurementList(Resource):
def __init__(self):
self.reqparse = reqparse.RequestParser()
self.reqparse.add_argument('sys', type=int, required=True, location='json')
self.reqparse.add_argument('dia', type=int, required=True, location='json')
self.reqparse.add_argument('pul', type=int, required=True, location='json')
super(MeasurementList, self).__init__()
def get(self):
import pdb
pdb.set_trace()
try:
data = [measurement.to_dic() for measurement in Measurement.objects]
return data, 200
except Exception as e:
abort(500, message=str(e))
def post(self):
try:
data = self.reqparse.parse_args()
measurement = Measurement(**data)
user = User.objects(email='darkklitos@gmail.com').first()
measurement.user = user
measurement.save()
return measurement.to_dic(), 201
except BadRequest as e:
abort(400, message=e.data.get('message'))
except(NotUniqueError, ValidationError)as e:
abort(400, message=str(e))
except Exception as e:
abort(500, message=str(e))
# def get(self):
# return MEASUREMENTS, 200
#
# def post(self):
# data = json.loads(request.data)
# measurement = {
# 'id': ge nerate_uuid(),
# 'sys': data.get('sys'),
# 'dia': data.get('dia'),
# 'pul': data.get('pul'),
# 'created': get_utc_now(),
# 'user_id': '8f9bfe9d1345237cb3b2b205864da075'
# }
# MEASUREMENTS.append(measurement)
# return measurement, 201
|
{"/main.py": ["/resources.py"], "/resources.py": ["/models.py", "/utils.py"]}
|
36,356
|
Gdaimon/flask-vue-medidor
|
refs/heads/master
|
/utils.py
|
from datetime import datetime, timedelta
def normalize_data(data):
return {key: value for key, value in data.items() if value is not None} # eliminamos los valores None
def get_yesterday_date():
return datetime.utcnow() - timedelta(1)
def get_today_date():
return datetime.utcnow()
def get_formatted_date(date):
return datetime.strftime(date, '%Y-%m-%d')
|
{"/main.py": ["/resources.py"], "/resources.py": ["/models.py", "/utils.py"]}
|
36,358
|
rcarmo/android-signage-server
|
refs/heads/master
|
/signage/migrations/0007_auto_20160910_2031.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.1 on 2016-09-10 19:31
from __future__ import unicode_literals
import datetime
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('signage', '0006_auto_20160910_2011'),
]
operations = [
migrations.AddField(
model_name='alert',
name='shown_on',
field=models.ManyToManyField(editable=False, related_name='shown_on', to='signage.Device'),
),
migrations.AlterField(
model_name='alert',
name='when',
field=models.DateTimeField(default=datetime.datetime.now, verbose_name='Start At'),
),
]
|
{"/backoffice/urls.py": ["/signage/__init__.py"], "/signage/admin.py": ["/signage/models.py", "/signage/fields.py"], "/signage/views.py": ["/signage/models.py"]}
|
36,359
|
rcarmo/android-signage-server
|
refs/heads/master
|
/signage/migrations/0009_auto_20160911_1141.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.1 on 2016-09-11 10:41
from __future__ import unicode_literals
import django.core.validators
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('signage', '0008_asset_parameters'),
]
operations = [
migrations.AlterField(
model_name='asset',
name='parameters',
field=models.CharField(blank=True, max_length=512, null=True),
),
migrations.AlterField(
model_name='asset',
name='url',
field=models.CharField(max_length=512, validators=[django.core.validators.URLValidator()], verbose_name='URL'),
),
]
|
{"/backoffice/urls.py": ["/signage/__init__.py"], "/signage/admin.py": ["/signage/models.py", "/signage/fields.py"], "/signage/views.py": ["/signage/models.py"]}
|
36,360
|
rcarmo/android-signage-server
|
refs/heads/master
|
/signage/migrations/0012_auto_20160911_1616.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.1 on 2016-09-11 15:16
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('signage', '0011_auto_20160911_1331'),
]
operations = [
migrations.AlterField(
model_name='alert',
name='when',
field=models.DateTimeField(verbose_name='Start At'),
),
]
|
{"/backoffice/urls.py": ["/signage/__init__.py"], "/signage/admin.py": ["/signage/models.py", "/signage/fields.py"], "/signage/views.py": ["/signage/models.py"]}
|
36,361
|
rcarmo/android-signage-server
|
refs/heads/master
|
/signage/migrations/0004_auto_20160910_1823.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.1 on 2016-09-10 17:23
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('signage', '0003_device_last_seen'),
]
operations = [
migrations.AddField(
model_name='asset',
name='kind',
field=models.CharField(choices=[('web', 'Web Page'), ('video', 'Video (MP4)')], default='web', max_length=8, verbose_name='Asset Type'),
),
migrations.AlterField(
model_name='device',
name='ip_address',
field=models.CharField(default='127.0.0.1', editable=False, max_length=45, verbose_name='IP Address'),
),
migrations.AlterField(
model_name='device',
name='last_seen',
field=models.DateTimeField(auto_now=True, verbose_name='Last Seen'),
),
migrations.AlterField(
model_name='device',
name='mac_address',
field=models.CharField(default='00:de:ad:be:ef:42', editable=False, max_length=17, unique=True, verbose_name='MAC Address'),
),
migrations.AlterField(
model_name='device',
name='name',
field=models.CharField(default='Unnamed Device', max_length=128, verbose_name='Device Name'),
),
]
|
{"/backoffice/urls.py": ["/signage/__init__.py"], "/signage/admin.py": ["/signage/models.py", "/signage/fields.py"], "/signage/views.py": ["/signage/models.py"]}
|
36,362
|
rcarmo/android-signage-server
|
refs/heads/master
|
/backoffice/urls.py
|
"""backoffice URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/1.10/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: url(r'^$', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.conf.urls import url, include
2. Add a URL to urlpatterns: url(r'^blog/', include('blog.urls'))
"""
from django.conf.urls import url
from django.contrib import admin
from django.views.generic import RedirectView
from signage import views
from os import environ
admin.site.site_header = environ.get('SITE_NAME', 'Signage Administration')
urlpatterns = [
url(r'^$', RedirectView.as_view(url='https://pixels.camp')),
url(r'^admin/', admin.site.urls),
url(r'^api/v1/assetlist/(?P<device_id>(.+))/(?P<mac_address>([0-9A-F]{2}[:-]){5}([0-9A-F]{2}))/(?P<ip_address>((2[0-5]|1[0-9]|[0-9])?[0-9]\.){3}((2[0-5]|1[0-9]|[0-9])?[0-9]))$', views.PlaylistView.as_view(), name="Get playlist"),
]
|
{"/backoffice/urls.py": ["/signage/__init__.py"], "/signage/admin.py": ["/signage/models.py", "/signage/fields.py"], "/signage/views.py": ["/signage/models.py"]}
|
36,363
|
rcarmo/android-signage-server
|
refs/heads/master
|
/signage/migrations/0005_auto_20160910_2007.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.1 on 2016-09-10 19:07
from __future__ import unicode_literals
import django.core.validators
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('signage', '0004_auto_20160910_1823'),
]
operations = [
migrations.CreateModel(
name='Alert',
fields=[
('playlist_ptr', models.OneToOneField(auto_created=True, on_delete=django.db.models.deletion.CASCADE, parent_link=True, primary_key=True, serialize=False, to='signage.Playlist')),
('active', models.BooleanField(default=False)),
('devices', models.ManyToManyField(to='signage.Device')),
],
options={
'verbose_name_plural': 'Alerts',
},
bases=('signage.playlist',),
),
migrations.AlterField(
model_name='asset',
name='duration',
field=models.PositiveIntegerField(default=30, validators=[django.core.validators.MaxValueValidator(1800), django.core.validators.MinValueValidator(5)], verbose_name='Duration (s)'),
),
]
|
{"/backoffice/urls.py": ["/signage/__init__.py"], "/signage/admin.py": ["/signage/models.py", "/signage/fields.py"], "/signage/views.py": ["/signage/models.py"]}
|
36,364
|
rcarmo/android-signage-server
|
refs/heads/master
|
/signage/migrations/0001_initial.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.1 on 2016-09-06 21:03
from __future__ import unicode_literals
import adminsortable.fields
import django.core.validators
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Asset',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(default='Untitled Asset', max_length=140)),
('url', models.URLField(max_length=512, verbose_name='URL')),
('duration', models.PositiveIntegerField(default=10, validators=[django.core.validators.MaxValueValidator(1800), django.core.validators.MinValueValidator(5)], verbose_name='Duration (s)')),
('active', models.BooleanField(default=True)),
('asset_order', models.PositiveIntegerField(db_index=True, default=0, editable=False)),
],
options={
'ordering': ['asset_order'],
},
),
migrations.CreateModel(
name='Device',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('identifier', models.CharField(max_length=128)),
('name', models.CharField(default='Unnamed Device', max_length=128)),
('active', models.BooleanField(default=False)),
],
),
migrations.CreateModel(
name='Playlist',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(default='Untitled Playlist', max_length=140, unique=True)),
('playlist_order', models.PositiveIntegerField(db_index=True, default=0, editable=False)),
],
options={
'ordering': ['playlist_order'],
'verbose_name_plural': 'Playlists',
},
),
migrations.AddField(
model_name='device',
name='playlist',
field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to='signage.Playlist'),
),
migrations.AddField(
model_name='asset',
name='playlist',
field=adminsortable.fields.SortableForeignKey(on_delete=django.db.models.deletion.CASCADE, to='signage.Playlist'),
),
]
|
{"/backoffice/urls.py": ["/signage/__init__.py"], "/signage/admin.py": ["/signage/models.py", "/signage/fields.py"], "/signage/views.py": ["/signage/models.py"]}
|
36,365
|
rcarmo/android-signage-server
|
refs/heads/master
|
/signage/migrations/0010_template.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.1 on 2016-09-11 12:08
from __future__ import unicode_literals
import django.core.validators
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('signage', '0009_auto_20160911_1141'),
]
operations = [
migrations.CreateModel(
name='Template',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(default='Untitled Template', max_length=140)),
('url', models.CharField(max_length=512, validators=[django.core.validators.URLValidator()], verbose_name='URL')),
],
),
]
|
{"/backoffice/urls.py": ["/signage/__init__.py"], "/signage/admin.py": ["/signage/models.py", "/signage/fields.py"], "/signage/views.py": ["/signage/models.py"]}
|
36,366
|
rcarmo/android-signage-server
|
refs/heads/master
|
/signage/migrations/0011_auto_20160911_1331.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.1 on 2016-09-11 12:31
from __future__ import unicode_literals
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('signage', '0010_template'),
]
operations = [
migrations.RenameModel(
old_name='Template',
new_name='PredefinedAsset',
),
migrations.AlterModelOptions(
name='predefinedasset',
options={'verbose_name': 'Predefined Asset', 'verbose_name_plural': 'Predefined Assets'},
),
]
|
{"/backoffice/urls.py": ["/signage/__init__.py"], "/signage/admin.py": ["/signage/models.py", "/signage/fields.py"], "/signage/views.py": ["/signage/models.py"]}
|
36,367
|
rcarmo/android-signage-server
|
refs/heads/master
|
/signage/admin.py
|
from django.contrib.admin import site, ModelAdmin, SimpleListFilter
from django.utils import timezone
from datetime import datetime, timedelta
from django.forms import CharField, TextInput, ModelForm
from django.core import urlresolvers
from .models import Playlist, Asset, Device, Alert, PredefinedAsset
from .fields import OptionalChoiceField
from adminsortable.admin import NonSortableParentAdmin, SortableStackedInline, SortableTabularInline
class AssetForm(ModelForm):
def __init__(self, *args, **kwargs):
super(AssetForm,self).__init__(*args, **kwargs)
self.auto_id=False
self.fields['active'].widget.attrs['title']="Active"
self.fields['active'].widget.attrs['style']="margin-right: 4px !important;"
self.fields['kind'].label=''
self.fields['name'].label=''
self.fields['url'].label=''
choices = [('','Input URL:')]
for t in PredefinedAsset.objects.all():
choices.append((t.url, t.name))
self.fields['url'] = OptionalChoiceField(label='',choices=choices)
class AssetInline(SortableStackedInline):
fields = (('name', 'kind', 'duration','active'),('url', 'parameters'))
search_fields = ('name', 'url', 'parameters')
model = Asset
form = AssetForm
extra = 0
verbose_name = 'Item'
verbose_name_plural = 'Items'
class ActiveFilter(SimpleListFilter):
title = 'State'
parameter_name = 'active'
def lookups(self, request, obj):
return [(True,"Active"),(False,"Inactive")]
def queryset(self, request, qs):
if not self.value():
return qs
return qs.filter(active=self.value())
class PlaylistFilter(SimpleListFilter):
title = 'Playlist'
parameter_name = 'playlist'
def lookups(self, request, obj):
playlists = set(list(Device.objects.values_list("playlist", flat=True)))
return sorted(map(lambda x: (0 if x == None else x, Playlist.objects.get(pk=x) if x else '(No playlist)'), playlists))
def queryset(self, request, qs):
if self.value() == None:
return qs
elif int(self.value()) == 0:
return qs.filter(playlist__isnull=True)
return qs.filter(playlist__pk=self.value())
class SeenFilter(SimpleListFilter):
title = 'Last Seen'
parameter_name = 'last_seen'
def lookups(self, request, obj):
return [
(60, 'Last Minute'),
(3600, 'Last Hour'),
(86400, 'Last 24h'),
(-86400, 'Yesterday'),
(-86400*7, 'Last Week')
]
def queryset(self, request, qs):
if not self.value():
return qs
limit = int(self.value())
if limit < 0:
return qs.filter(last_seen__lte=(timezone.now() + timedelta(seconds=limit)))
else:
return qs.filter(last_seen__gte=(timezone.now() - timedelta(seconds=limit)))
class DeviceAdmin(ModelAdmin):
readonly_fields=('device_id','ip_address','mac_address','last_seen')
list_display = ('name', 'active', 'related_playlist', 'device_id', 'mac_address', 'ip_address', 'last_seen')
list_filter = (ActiveFilter,PlaylistFilter,SeenFilter)
search_fields = ('name', 'ip_address', 'mac_address', 'device_id')
# These cannot be added, only modified or deleted
def has_add_permission(self, request):
return False
def related_playlist(self, obj):
if obj.playlist:
link = urlresolvers.reverse("admin:signage_playlist_change", args=[obj.playlist.id])
return u'<a href="%s">%s</a>' % (link, obj.playlist.name)
return '(No playlist)'
related_playlist.short_description = "Playlist"
related_playlist.allow_tags = True
class PlaylistAdmin(NonSortableParentAdmin):
inlines = [AssetInline]
list_display = ('name', 'active_assets', 'asset_count', 'active_duration', 'total_duration')
search_fields = ('name',)
def get_queryset(self, request):
qs = super(PlaylistAdmin, self).get_queryset(request)
return qs.filter(alert__isnull=True)
def asset_count(self, obj):
return obj.asset_set.count()
def active_assets(self, obj):
return reduce(lambda x, y: x + 1 if y.active else x, obj.asset_set.all(), 0)
def total_duration(self, obj):
return reduce(lambda x, y: x + y.duration, obj.asset_set.all(), 0)
def active_duration(self, obj):
return reduce(lambda x, y: x + y.duration if y.active else x, obj.asset_set.all(), 0)
asset_count.short_description = "Total Assets"
class Media:
js = ['optionalchoice.js']
class DeviceFilter(SimpleListFilter):
title = 'Device'
parameter_name = 'device'
def lookups(self, request, obj):
devices = set(list(Alert.objects.values_list("devices", flat=True)))
if len(devices):
return sorted(map(lambda x: (x, Device.objects.get(pk=x) if x else 'None'), devices))
def queryset(self, request, qs):
if not self.value():
return qs
return qs.filter(devices__pk__exact=self.value())
class DeliveryFilter(SimpleListFilter):
title = 'Delivered To'
parameter_name = 'shown'
def lookups(self, request, obj):
devices = set(list(Alert.objects.values_list("shown_on", flat=True)))
if len(devices):
return sorted(map(lambda x: (x, Device.objects.get(pk=x) if x else 'None'), devices))
def queryset(self, request, qs):
if not self.value():
return qs
return qs.filter(devices__pk__exact=self.value())
class AlertAdmin(NonSortableParentAdmin):
fields = ('name','active','when','devices')
inlines = [AssetInline]
list_display = ('name', 'active', 'asset_count', 'total_duration', 'device_names', 'delivered_to', 'when')
search_fields = ('name',)
list_filter = (ActiveFilter,DeviceFilter,DeliveryFilter)
def save_model(self, request, obj, form, change):
super(AlertAdmin,self).save_model(request, obj, form, change)
obj.shown_on.clear()
obj.save()
def asset_count(self, obj):
return obj.asset_set.count()
def total_duration(self, obj):
return reduce(lambda x, y: x + y.duration, obj.asset_set.all(), 0)
def device_names(self, obj):
return map(lambda x: x.name, obj.devices.all())
def delivered_to(self, obj):
return map(lambda x: x.name, obj.shown_on.all())
device_names.short_description = "Devices"
asset_count.short_description = "Assets"
class Media:
js = ['optionalchoice.js']
class PredefinedAssetAdmin(ModelAdmin):
list_display = ('name', 'url')
search_fields = ('name', 'url')
site.register(Alert, AlertAdmin)
site.register(Playlist, PlaylistAdmin)
site.register(Device, DeviceAdmin)
site.register(PredefinedAsset, PredefinedAssetAdmin)
|
{"/backoffice/urls.py": ["/signage/__init__.py"], "/signage/admin.py": ["/signage/models.py", "/signage/fields.py"], "/signage/views.py": ["/signage/models.py"]}
|
36,368
|
rcarmo/android-signage-server
|
refs/heads/master
|
/signage/models.py
|
from __future__ import unicode_literals
from django.db.models import Model, BooleanField, DateTimeField, CharField, URLField, TextField, ForeignKey, PositiveIntegerField, ManyToManyField
from django.core.validators import MaxValueValidator, MinValueValidator, URLValidator
from adminsortable.models import SortableMixin, SortableForeignKey
from datetime import datetime
# Create your models here.
class Playlist(SortableMixin):
name = CharField(max_length=140, default='Untitled', unique=True)
# ordering field
playlist_order = PositiveIntegerField(default=0, editable=False, db_index=True)
class Meta:
ordering = ['playlist_order']
verbose_name_plural = 'Playlists'
def __unicode__(self):
return self.name
class Asset(SortableMixin):
name = CharField(max_length=140, default='Untitled Asset')
kind = CharField(max_length=8, default='web', choices=(
('web', 'Web Page'),
('video', 'Video (MP4)'),
), verbose_name='Asset Type')
url = CharField(max_length=512, verbose_name='URL',validators=[URLValidator()])
parameters = CharField(max_length=512,blank=True,null=True)
duration = PositiveIntegerField(default=30, validators=[MaxValueValidator(1800),MinValueValidator(5),], verbose_name='Duration (s)')
active = BooleanField(default=True)
playlist = SortableForeignKey(Playlist)
# ordering field
asset_order = PositiveIntegerField(default=0, editable=False, db_index=True)
class Meta:
ordering = ['asset_order']
def __unicode__(self):
return self.name
class Device(Model):
device_id = CharField(max_length=128, default='00deadbeef42', unique=True, editable=False)
mac_address = CharField(max_length=17, default='00:de:ad:be:ef:42', unique=True,editable=False, verbose_name='MAC Address')
ip_address = CharField(max_length=45, default='127.0.0.1', editable=False, verbose_name='IP Address') # IPv6
name = CharField(max_length=128,default='Unnamed Device', verbose_name='Device Name')
active = BooleanField(default=False)
playlist = ForeignKey(Playlist, blank=True, null=True)
last_seen = DateTimeField(auto_now=True, editable=False, verbose_name='Last Seen')
def __unicode__(self):
return self.name
class Alert(Playlist):
when = DateTimeField(verbose_name='Start At')
active = BooleanField(default=True)
devices = ManyToManyField(Device)
shown_on = ManyToManyField(Device, editable=False, related_name="shown_on")
class Meta:
verbose_name_plural = 'Alerts'
def __unicode__(self):
return self.name
class PredefinedAsset(Model):
name = CharField(max_length=140, default='Untitled Template')
url = CharField(max_length=512, verbose_name='URL',validators=[URLValidator()])
class Meta:
verbose_name = 'Predefined Asset'
verbose_name_plural = 'Predefined Assets'
def __unicode__(self):
return self.name
|
{"/backoffice/urls.py": ["/signage/__init__.py"], "/signage/admin.py": ["/signage/models.py", "/signage/fields.py"], "/signage/views.py": ["/signage/models.py"]}
|
36,369
|
rcarmo/android-signage-server
|
refs/heads/master
|
/signage/migrations/0003_device_last_seen.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.1 on 2016-09-10 12:35
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('signage', '0002_auto_20160910_1109'),
]
operations = [
migrations.AddField(
model_name='device',
name='last_seen',
field=models.DateTimeField(auto_now=True),
),
]
|
{"/backoffice/urls.py": ["/signage/__init__.py"], "/signage/admin.py": ["/signage/models.py", "/signage/fields.py"], "/signage/views.py": ["/signage/models.py"]}
|
36,370
|
rcarmo/android-signage-server
|
refs/heads/master
|
/signage/views.py
|
from django.shortcuts import render
from django.http import HttpResponseRedirect
from django.urls import reverse
from django.views.generic import TemplateView, DetailView
from django.utils import timezone
from uuid import uuid5, NAMESPACE_URL
from .models import Playlist, Device, Alert
from datetime import datetime
# Create your views here.
# TODO: handle alerts
class PlaylistView(TemplateView):
template_name = 'playlist.json'
playlist = None
def update_device(self, kwargs):
try:
device = Device.objects.get(device_id=kwargs['device_id'])
dirty = False
if device.ip_address != kwargs['ip_address']:
device.ip_address = kwargs['ip_address']
dirty = True
if device.mac_address != kwargs['mac_address']:
device.mac_address = kwargs['mac_address']
except:
device = Device(device_id = kwargs['device_id'],
mac_address = kwargs['mac_address'],
ip_address = kwargs['ip_address'])
device.save()
return device
def get_context_data(self, **kwargs):
context = super(PlaylistView, self).get_context_data(**kwargs)
device = self.update_device(kwargs)
alert = False
if device.active:
# do we have pending alerts for this device?
alerts = list(Alert.objects.filter(
active=True,
when__lte=timezone.now(),
devices__pk__exact=device.pk
).exclude(
shown_on__pk__exact=device.pk
).order_by('when').distinct()[:1])
if alerts:
alert = alerts[0]
self.alert = True
alert.shown_on.add(device)
if set(list(alert.shown_on.all())) == set(list(alert.devices.all())):
alert.active = False
alert.save()
playlist = alert
context['alert'] = True
elif device.playlist:
playlist = device.playlist
else:
try:
playlist = Playlist.objects.get(name='Default')
except:
playlist = Playlist.objects.get(pk=1)
else:
playlist = Playlist()
context['playlist'] = playlist
context['uuid'] = self.uuid(playlist)
context['assets'] = playlist.asset_set.order_by('asset_order')
return context
def uuid(self, playlist):
acc = []
for a in playlist.asset_set.order_by('asset_order'):
acc.append((a.url, a.duration, a.active, a.kind))
return uuid5(NAMESPACE_URL, str(acc))
class DetailView(DetailView):
model = Playlist
template_name = 'detail.json'
|
{"/backoffice/urls.py": ["/signage/__init__.py"], "/signage/admin.py": ["/signage/models.py", "/signage/fields.py"], "/signage/views.py": ["/signage/models.py"]}
|
36,371
|
rcarmo/android-signage-server
|
refs/heads/master
|
/signage/__init__.py
|
from django.db.backends.signals import connection_created
def activate_wal(sender, connection, **kwargs):
"""Enable WAL mode."""
if 'sqlite' in connection.vendor:
cursor = connection.cursor()
cursor.execute('PRAGMA journal_mode=WAL;')
cursor.execute('PRAGMA synchronous=OFF;')
connection_created.connect(activate_wal)
|
{"/backoffice/urls.py": ["/signage/__init__.py"], "/signage/admin.py": ["/signage/models.py", "/signage/fields.py"], "/signage/views.py": ["/signage/models.py"]}
|
36,372
|
rcarmo/android-signage-server
|
refs/heads/master
|
/signage/fields.py
|
from django.core.exceptions import ValidationError
from django.forms import MultiWidget, ChoiceField, CharField, MultiValueField
class OptionalChoiceWidget(MultiWidget):
def decompress(self,value):
if value: #indicates we have a updating object versus new one
if value in [x[0] for x in self.widgets[0].choices]:
return [value,""] # make it set the pulldown to choice
else:
return ["",value] # keep pulldown to blank, set freetext
return ["",""] # default for new object
class OptionalChoiceField(MultiValueField):
def __init__(self, choices, max_length=80, *args, **kwargs):
""" sets the two fields as not required but will enforce that (at least) one is set in compress """
fields = (ChoiceField(choices=choices,required=False),
CharField(required=False))
self.widget = OptionalChoiceWidget(widgets=[f.widget for f in fields])
super(OptionalChoiceField,self).__init__(required=False,fields=fields,*args,**kwargs)
def compress(self,data_list):
""" return the choicefield value if selected or charfield value (if both empty, will throw exception """
if not data_list:
raise ValidationError('Need to select choice or enter text for this field')
return data_list[0] or data_list[1]
|
{"/backoffice/urls.py": ["/signage/__init__.py"], "/signage/admin.py": ["/signage/models.py", "/signage/fields.py"], "/signage/views.py": ["/signage/models.py"]}
|
36,373
|
rcarmo/android-signage-server
|
refs/heads/master
|
/signage/migrations/0002_auto_20160910_1109.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.1 on 2016-09-10 11:09
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('signage', '0001_initial'),
]
operations = [
migrations.RemoveField(
model_name='device',
name='identifier',
),
migrations.AddField(
model_name='device',
name='device_id',
field=models.CharField(default='00deadbeef42', editable=False, max_length=128, unique=True),
),
migrations.AddField(
model_name='device',
name='ip_address',
field=models.CharField(default='127.0.0.1', editable=False, max_length=45),
),
migrations.AddField(
model_name='device',
name='mac_address',
field=models.CharField(default='00:de:ad:be:ef:42', editable=False, max_length=17, unique=True),
),
]
|
{"/backoffice/urls.py": ["/signage/__init__.py"], "/signage/admin.py": ["/signage/models.py", "/signage/fields.py"], "/signage/views.py": ["/signage/models.py"]}
|
36,374
|
rcarmo/android-signage-server
|
refs/heads/master
|
/signage/migrations/0006_auto_20160910_2011.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.1 on 2016-09-10 19:11
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('signage', '0005_auto_20160910_2007'),
]
operations = [
migrations.AddField(
model_name='alert',
name='when',
field=models.DateTimeField(auto_now=True, verbose_name='At'),
),
migrations.AlterField(
model_name='alert',
name='active',
field=models.BooleanField(default=True),
),
migrations.AlterField(
model_name='playlist',
name='name',
field=models.CharField(default='Untitled', max_length=140, unique=True),
),
]
|
{"/backoffice/urls.py": ["/signage/__init__.py"], "/signage/admin.py": ["/signage/models.py", "/signage/fields.py"], "/signage/views.py": ["/signage/models.py"]}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.