def test_includeSoftware(self):
software = Software(1,"name","text","downloadUrl","applicationSubCategory")
software.imageList = [Image("teste")]
software.LinkList = [Link("teste")]
software.screenshotList = [Screenshot("teste")]
software.review = Review("teste",1)
self.sDao.includeSoftware(software)
def init_software(self):
self._software = Software()
self._software.setup()
self._software.print_header()
self._user = User()
self._user.setup()
def start_software(self, software, open_file=''):
from software import Software
self._software = Software()
self._software.setup()
self.user.setup()
self._software.start(software, open_file)
self._software.print_header()
class Tank(Singleton):
def init_os(self):
self._user = User()
self._user.setup()
def init_software(self):
self._software = Software()
self._software.setup()
self._software.print_header()
self._user = User()
self._user.setup()
@property
def software(self):
return Software()
@property
def user(self):
return self._user
@property
def context(self):
return self._software.context
@property
def data(self):
return libData.get_data()
class Tank(Singleton):
def init_os(self):
# self._notificator = Notificator()
# self._notificator.setup()
pass
def init_software(self):
self._software = Software()
self._software.setup()
self._software.print_header()
self._user = User()
self._user.setup()
self._context = Context()
self._context.setup()
@property
def software(self):
return self._software
@property
def user(self):
return self._user
@property
def context(self):
return self._context
def citeas_product_get(id):
if id.endswith('.pdf'):
return jsonify({'error_message': 'PDF documents are not supported.'})
elif id.endswith(('.doc', 'docx')):
return jsonify({'error_message': 'Word documents are not supported.'})
else:
my_software = Software(id)
my_software.find_metadata()
return jsonify(my_software.to_dict())
def test_version_add(self):
package_name = "sample package"
package = Software(package_name)
version = Version("1.0", datetime.now().isoformat())
package.add_versions(version)
software_item = [package.__dict__]
software = {"software": software_item, "mounts": []}
empty = {"software": [], "mounts": []}
result = compare_and_update_dicts(empty, software)
self.assertTrue(result['software'][0]['package_name'] == package_name)
self.assertTrue(result['software'][0]['versions'][0]['name'] == "1.0")
def readSoftware(self, id):
'''
retorna o software pelo id
carrega todos os relacionamento do software
software_screenshot
software_link
software_image
software_review
'''
software=None
try:
self.cur = self.conn.cursor()
stmt = 'SELECT *'
stmt += "\nFROM software_software"
stmt += "\nWHERE id=?"
stmt += ';'
self.cur.execute(stmt,[id])
data = self.cur.fetchone()
if data:
software= Software(data["id"],data["name"],data["text"],data["downloadUrl"],data["applicationSubCategory"])
stmt = 'select * from software_screenshot where software_id=?'
self.cur.execute(stmt,[id])
rows = self.cur.fetchall()
for row in rows:
software.screenshotList.append(Screenshot(row["url_screenshot"]))
stmt = 'select * from software_link where software_id=?'
self.cur.execute(stmt,[id])
rows = self.cur.fetchall()
for row in rows:
software.linkList.append(Link(row["url_link"]))
stmt = 'select * from software_image where software_id=?'
self.cur.execute(stmt,[id])
rows = self.cur.fetchall()
for row in rows:
software.imageList.append(Image(row["url_image"]))
stmt = 'select * from software_review where software_id=?'
self.cur.execute(stmt,[id])
data = self.cur.fetchone()
if data:
software.review = Review(data["reviewBody"],data["ratingValue"])
return software
finally:
self.cur.close()
def init():
"""
Initialisiert die Datenbank, sofern das noch nicht geschehen ist und
muss im Idealfall sofort aufgerufen werden.
"""
if Database.database is not None: return
if not os.path.exists(Database.file):
with open(Database.file, 'w'):
pass
Database.load()
# Melde die Datenbank für Statusänderungen der enthaltenen Software bei
# der Klasse an. So können Installations-, Deinstallations- und Update-
# Events abgegriffen werden.
Software.registerStateListener(Database.softwareUpdated)
def getLinkDescriptions(self, linksWithContent, year):
for i in range(0, len(linksWithContent), 1):
description = ""
wikiWithContentSource = requests.get(linksWithContent[i]).text
wikiWithContentSoup = BeautifulSoup(wikiWithContentSource, 'lxml')
wikiWithContentContent = wikiWithContentSoup.find('div',
id='bodyContent')
paragraphs = []
for paragraph in wikiWithContentContent.findAll('p'):
temp = "".join(line.strip()
for line in paragraph.text.split("\n"))
if "<style" in str(paragraph) or "</style>" in str(paragraph) or "<script" in str(paragraph) or \
"</script>" in str(paragraph) or len(temp) == 0:
pass
else:
paragraphs.append("".join(
line.strip() for line in paragraph.text.split("\n")))
j = 0
while len(description) < 500 and j < len(paragraphs):
k = 0
while len(description) < 500 and k < len(paragraphs[j]):
description += paragraphs[j][k]
k += 1
j += 1
description += " "
description += "..."
software = Software(
linksWithContent[i].split("/")[3].split(":")[1], description,
year)
self.result.emit(software)
self.progress.emit(33 / len(linksWithContent))
def readSoftware(repository):
"""
Liest die Software in einer Repository ein und speichert das übergebene
Verzeichnis für spätere Verwendung zwischen.
Parameters
----------
repository : str
Pfad zum Verzeichnis mit allen Softwaredeskriptoren.
"""
Database.repository = repository
dirs = [f.path for f in os.scandir(repository) if f.is_dir()]
for d in dirs:
s = Software(d)
s.setState(Software.INSTALLED if Database.
hasSoftware(s) else Software.UNINSTALLED)
Database.software[s.slug] = s
def showResults(self, year):
self.view.progressBar.setValue(100)
softwareList = self.model.getAllFromYear(year)
for i in softwareList:
software = Software(i[0], i[1], str(i[2]))
self.view.addToList(self.view.scrapeResultsList, software)
finishMessage = QtWidgets.QMessageBox()
finishMessage.question(self.view.window, "Sara",
"Sara is finished searching.", finishMessage.Ok)
def open_software(software: Software):
"""打开软件"""
bin_path = os.path.join(software.home_path, 'bin',
software.get_execute_file_name())
if not os.path.exists(bin_path):
print(f'不在在 {bin_path}')
return
cmd = f'start {bin_path}'
print(cmd)
subprocess.call(cmd, shell=True)
def parseHtmlToObject(item):
software = Software(1,str(item.name), item.text, str(item.downloadUrl), str(item.applicationSubCategory))
images = []
for image in item.get_all('image') :
images.append(Image(str(image)))
software.imageList = images
screenshots = []
for screenshot in item.get_all('screenshot') :
screenshots.append(Screenshot(str(screenshot)))
software.screenshotList=screenshots
urls = []
for url in item.get_all('url') :
urls.append(Link(str(url)))
software.linkList=urls
software.review = Review(item.review.reviewBody,item.review.ratingValue)
return software
def startSearching(self):
self.view.libraryResultsList.clear()
if len(self.view.librarySearchLine.text()
) == 0 or self.view.librarySearchLine.text() == "Enter a year":
self.listAll()
else:
year = int(self.view.librarySearchLine.text())
softwareList = self.model.getAllFromYear(year)
for i in softwareList:
software = Software(i[0], i[1], str(i[2]))
self.view.addToList(self.view.libraryResultsList, software)
def test_software_class(self):
package_name = "test"
package_names = ["foo", "test"]
software = Software(package_name)
package = check_sofware_if_exists(package_name, package_names,
[software])
self.assertTrue(package == software)
package_names = ["Foo", "bar"]
package = check_sofware_if_exists(package_name, package_names,
[software])
self.assertTrue(package == None)
def test_source_preview():
my_software = Software('https://cran.r-project.org/web/packages/stringr')
my_software.find_metadata()
resp = my_software.to_dict()
provenance = resp['provenance'][8]['source_preview']
assert provenance['title'] == '<i>Snapshot of title data found at https://cran.r-project.org/web/packages/stringr/DESCRIPTION.</i><br>Package: stringr<br />Title: <span class="highlight">' \
'Simple, Consistent Wrappers for Common String Operations</span><br />Version: 1.4.0<br />Authors@R: <br /> c(person(given = "Hadley",<br />' \
' family = "Wickham",<br /> role = c("aut", "cre", "cph"),<br /> ' \
'email = "[email protected]"),<br /> person(given = "RStudio",<br /> role = c("cph", "fnd")))<br />' \
'Description: A consistent, simple and easy to use set of<br /> wrappers around the fantastic 'stringi'
assert provenance['author'] == '<i>Snapshot of author data found at https://cran.r-project.org/web/packages/stringr/DESCRIPTION.</i><br>Package: ' \
'stringr<br />Title: Simple, Consistent Wrappers for Common String Operations<br />Version: 1.4.0<br />Authors@R: <br /> ' \
'c(person(given = "<span class="highlight">Hadley</span>",<br /> family = "<span class="highlight">Wickham</span>",<br /> ' \
'role = c("aut", "cre", "cph"),<br /> email = "*****@*****.**"),<br /> person(given = "RStudio",<br /> ' \
'role = c("cph", "fnd")))<br />Description: A consistent, simple and easy to use set of<br /> wrappers around the fantastic stringi package. All function and<br /> ' \
'argument names (and positions) are consistent, all functions deal with<br /> "NA"s and zero length vectors in the same way, and the output from<br /> one function is easy t'
assert provenance['year'] == '<i>Snapshot of year data found at https://cran.r-project.org/web/packages/stringr/DESCRIPTION.</i><br>tringr<br />BugReports: ' \
'https://github.com/tidyverse/stringr/issues<br />Depends: R (>= 3.1)<br />Imports: glue (>= 1.2.0), magrittr, stringi (>= 1.1.7)<br />Suggests: covr, htmltools, ' \
'htmlwidgets, knitr, rmarkdown, testthat<br />VignetteBuilder: knitr<br />Encoding: UTF-8<br />LazyData: true<br />RoxygenNote: 6.1.1<br />' \
'NeedsCompilation: no<br />Packaged: 2019-02-09 16:03:19 UTC; hadley<br />Author: Hadley Wickham [aut, cre, cph],<br /> RStudio [cph, fnd]<br />' \
'Maintainer: Hadley Wickham <[email protected]><br />Repository: CRAN<br />Date/Publication: <span class="highlight">2019-02-10 03:40:03 UTC</span><br />'
def test_version_upgrade(self):
package_name = "sample package"
package = Software(package_name)
version = Version("1.0", datetime.now().isoformat())
package.add_versions(version)
software_item = [package.__dict__]
software = {"software": software_item, "mounts": []}
package2 = Software(package_name)
version = Version("2.0", datetime.now().isoformat())
package2.add_versions(version)
software_item2 = [package2.__dict__]
second_software = {"software": software_item2, "mounts": []}
result = compare_and_update_dicts(software, second_software)
self.assertTrue(result['software'][0]['package_name'] == package_name)
self.assertTrue(result['software'][0]['versions'][0].get(
'removal_date', None) != None)
self.assertTrue(result['software'][0]['versions'][1]['name'] == '2.0')
def get_software_list(config_file='') -> List[Software]:
"""根据配置获取软件列表"""
config = TranslatorXConfig(config_file)
software_home_path = config.get_software_home_path()
omegat_workspace = config.get_omegat_workspace()
software_name_list = config.get_software_name_list()
software_version_list = config.get_software_version_list()
translation_locale = config.get_translation_locale()
if not translation_locale:
translation_locale = Software.DEFAULT_LOCALE
print('读取配置为')
print(f'软件安装目录 {software_home_path}')
print(f'OmegaT 工作目录 {omegat_workspace}')
if not os.path.exists(omegat_workspace):
print('OmegaT 工作目录不在在')
print(f'翻译区域 {translation_locale}')
print()
software_list = []
for i, name in enumerate(software_name_list):
if i >= len(software_version_list):
# 取最后一个
version = software_version_list[-1]
else:
# 取对应版本
version = software_version_list[i]
if '-' in version:
version, release_version = version.split('-')
else:
release_version = 1
software = Software(
name=name,
version=version,
release_version=release_version,
software_home_path=software_home_path,
omegat_workspace=omegat_workspace,
translation_locale=translation_locale,
)
software_list.append(software)
return software_list
def init_software(self, software=''):
if not software: software = os.getenv('SOFTWARE')
if not self._software:
if software == 'maya':
from maya_dcc import Maya
self._software = Maya()
elif software == 'max':
from max_dcc import Max
self._software = Max()
elif software == 'nuke':
from nuke_dcc import Nuke
self._software = Nuke()
elif software == 'houdini':
from houdini_dcc import Houdini
self._software = Houdini()
else:
from software import Software
self._software = Software()
return self._software
nuke.pluginAddPath(paths)
#*******************
# TOOLBAR
add_plugin_paths()
project_data = libData.get_data()
menu_data = project_data['software']['NUKE']['MENU']
menuNode = nuke.menu('Nodes').addMenu(project_data['project']['name'],
icon='nuke.ico')
# nuke.addOnScriptSave(add_write_node)
for menu_item in menu_data:
Software().add_menu(menuNode, menu_item)
menuNode.addSeparator()
add_gizmo_menu(menuNode)
#*******************
# FUNC
def save():
from utils import arSave
reload(arSave)
arSave.main()
LOG.info('SAVE')
def press_btnOpenNuke(self):
LOG.debug('Nuke')
Software('nuke').start_software()
def press_btnOpenHoudini(self):
Software().start('houdini')
def press_btnOpenMax(self):
Software().start('max')
def test_provenance():
my_software = Software('http://yt-project.org')
my_software.find_metadata()
resp = my_software.to_dict()
provenance = resp['provenance']
steps_with_content = [
{
'step_name': 'UserInputStep',
'parent_step_name': 'NoneType'
},
{
'step_name': 'WebpageStep',
'parent_step_name': 'UserInputStep'
},
{
'step_name': 'GithubRepoStep',
'parent_step_name': 'WebpageStep'
},
{
'step_name': 'GithubCitationFileStep',
'parent_step_name': 'GithubRepoStep'
},
{
'step_name': 'CrossrefResponseStep',
'parent_step_name': 'GithubCitationFileStep'
},
{
'step_name': 'CrossrefResponseMetadataStep',
'parent_step_name': 'CrossrefResponseStep'
},
]
steps_without_content = [{
'step_name': 'CrossrefResponseStep',
'parent_step_name': 'UserInputStep'
}, {
'step_name': 'ArxivResponseStep',
'parent_step_name': 'UserInputStep'
}, {
'step_name': 'GithubRepoStep',
'parent_step_name': 'UserInputStep'
}, {
'step_name': 'BitbucketRepoStep',
'parent_step_name': 'UserInputStep'
}, {
'step_name': 'CranLibraryStep',
'parent_step_name': 'UserInputStep'
}, {
'step_name': 'PypiLibraryStep',
'parent_step_name': 'UserInputStep'
}, {
'step_name': 'RelationHeaderStep',
'parent_step_name': 'WebpageStep'
}, {
'step_name': 'CrossrefResponseStep',
'parent_step_name': 'WebpageStep'
}, {
'step_name': 'GithubCodemetaFileStep',
'parent_step_name': 'GithubRepoStep'
}]
for step in steps_with_content:
for p in provenance:
if p['name'] == step['step_name'] and p[
'parent_step_name'] == step['parent_step_name']:
assert p['has_content'] is True
for step in steps_without_content:
for p in provenance:
if p['name'] == step['step_name'] and p[
'parent_step_name'] == step['parent_step_name']:
assert p['has_content'] is False
def test_citations(url, expected):
my_software = Software(url)
my_software.find_metadata()
assert my_software.citation_plain == expected
def gen_conf(self):
Software.gen_conf(self)
pass
def press_btnOpenHoudini(self):
LOG.debug('Houdini')
Software().start_software()
def confirmEdit(self):
self.view.disableAddEdit()
software = Software(self.view.addEditTeam.text(),
self.view.addEditDescription.toPlainText(),
str(self.view.addEditYear.text()))
self.model.replace(software)
def software(self):
return Software()
def listAll(self):
self.view.libraryResultsList.clear()
softwareList = self.model.getAll()
for i in softwareList:
software = Software(i[0], i[1], str(i[2]))
self.view.addToList(self.view.libraryResultsList, software)
def press_btnOpenNuke(self):
Software().start('nuke')
self[key].append(value)
else:
self[key] = [value]
def __missing__(self, key):
LOG.debug('MISSING Key: {}'.format(key))
return key
#************************
# START
import argparse
parser = argparse.ArgumentParser(
description='Setup your pipeline and start scripts.')
parser.add_argument('-s', '--script', help='add script: software')
parser.add_argument('-so', '--software', help='add software: nuke')
parser.add_argument('-p', '--proxy', action='store_true')
args = parser.parse_args()
if args.script:
Setup()
if args.script == 'software':
from software import Software
soft = Software()
soft.setup(args.software)
soft.start()
elif args.script == 'desktop':
import arDesktop
arDesktop.main()
def press_btnOpenMaya(self):
LOG.debug('Maya')
Software('maya').start_software()
