index int64 | repo_name string | branch_name string | path string | content string | import_graph string |
|---|---|---|---|---|---|
74,042 | leonardo-modules/leonardo-system | refs/heads/master | /leonardo_system/package/views.py |
from __future__ import absolute_import
from django.utils.translation import ugettext_lazy as _
from leonardo.views import *
from .forms import PluginInstallForm
class PluginInstallView(ModalFormView, ContextMixin, ModelFormMixin):
form_class = PluginInstallForm
def get_success_url(self):
return self.request.build_absolute_uri()
def get_context_data(self, **kwargs):
context = super(PluginInstallView, self).get_context_data(**kwargs)
context['url'] = self.request.build_absolute_uri()
context['modal_header'] = _('Install Packages')
context['title'] = _('Install')
context['form_submit'] = _('Install')
context['heading'] = _('Install Packages')
return context
| {"/leonardo_system/pip/__init__.py": ["/leonardo_system/pip/versions.py"], "/leonardo_system/package/views.py": ["/leonardo_system/package/forms.py"], "/leonardo_system/__init__.py": ["/leonardo_system/package/patch_pip.py"], "/leonardo_system/management/commands/system_check.py": ["/leonardo_system/pip/__init__.py"], "/leonardo_system/package/urls.py": ["/leonardo_system/package/views.py"], "/leonardo_system/package/forms.py": ["/leonardo_system/package/utils.py"], "/leonardo_system/maintenance/urls.py": ["/leonardo_system/maintenance/views.py"], "/leonardo_system/maintenance/forms.py": ["/leonardo_system/maintenance/tables.py"], "/leonardo_system/maintenance/views.py": ["/leonardo_system/maintenance/forms.py"]} |
74,043 | leonardo-modules/leonardo-system | refs/heads/master | /leonardo_system/__init__.py |
from __future__ import absolute_import
from django.apps import AppConfig
default_app_config = 'leonardo_system.Config'
LEONARDO_APPS = ['leonardo_system']
LEONARDO_OPTGROUP = 'System'
LEONARDO_URLS_CONF = 'leonardo_system.urls'
LEONARDO_PAGE_ACTIONS = ['system/module_actions.html']
LEONARDO_ORDERING = 150
LEONARDO_DASHBOARD_MENU = ['leonardo_system.menu.system_menu']
class Config(AppConfig):
name = 'leonardo_system'
verbose_name = "Leonardo System Module"
def ready(self):
try:
from leonardo_system.package.patch_pip import indent_log
from pip.req import req_set
req_set.indent_log = indent_log
except:
pass
| {"/leonardo_system/pip/__init__.py": ["/leonardo_system/pip/versions.py"], "/leonardo_system/package/views.py": ["/leonardo_system/package/forms.py"], "/leonardo_system/__init__.py": ["/leonardo_system/package/patch_pip.py"], "/leonardo_system/management/commands/system_check.py": ["/leonardo_system/pip/__init__.py"], "/leonardo_system/package/urls.py": ["/leonardo_system/package/views.py"], "/leonardo_system/package/forms.py": ["/leonardo_system/package/utils.py"], "/leonardo_system/maintenance/urls.py": ["/leonardo_system/maintenance/views.py"], "/leonardo_system/maintenance/forms.py": ["/leonardo_system/maintenance/tables.py"], "/leonardo_system/maintenance/views.py": ["/leonardo_system/maintenance/forms.py"]} |
74,044 | leonardo-modules/leonardo-system | refs/heads/master | /leonardo_system/menu.py | from django.utils.translation import ugettext_lazy as _
from leonardo_admin_dashboard import modules
system_menu = modules.MenuModelList(
_('Settings'),
models=('constance.*', 'auth.*', 'sites.*', 'admin_sso.*',),
order=99
)
| {"/leonardo_system/pip/__init__.py": ["/leonardo_system/pip/versions.py"], "/leonardo_system/package/views.py": ["/leonardo_system/package/forms.py"], "/leonardo_system/__init__.py": ["/leonardo_system/package/patch_pip.py"], "/leonardo_system/management/commands/system_check.py": ["/leonardo_system/pip/__init__.py"], "/leonardo_system/package/urls.py": ["/leonardo_system/package/views.py"], "/leonardo_system/package/forms.py": ["/leonardo_system/package/utils.py"], "/leonardo_system/maintenance/urls.py": ["/leonardo_system/maintenance/views.py"], "/leonardo_system/maintenance/forms.py": ["/leonardo_system/maintenance/tables.py"], "/leonardo_system/maintenance/views.py": ["/leonardo_system/maintenance/forms.py"]} |
74,045 | leonardo-modules/leonardo-system | refs/heads/master | /leonardo_system/settings.py |
from leonardo.utils.settings import dotdict
PIP_CONF = dotdict({
'cache_dir': '/tmp',
'trusted_hosts': ['https://pypi.python.org/pypi'],
'index': 'https://pypi.python.org/pypi',
'extra_index_urls': [],
'no_index': [],
'find_links:': []
})
| {"/leonardo_system/pip/__init__.py": ["/leonardo_system/pip/versions.py"], "/leonardo_system/package/views.py": ["/leonardo_system/package/forms.py"], "/leonardo_system/__init__.py": ["/leonardo_system/package/patch_pip.py"], "/leonardo_system/management/commands/system_check.py": ["/leonardo_system/pip/__init__.py"], "/leonardo_system/package/urls.py": ["/leonardo_system/package/views.py"], "/leonardo_system/package/forms.py": ["/leonardo_system/package/utils.py"], "/leonardo_system/maintenance/urls.py": ["/leonardo_system/maintenance/views.py"], "/leonardo_system/maintenance/forms.py": ["/leonardo_system/maintenance/tables.py"], "/leonardo_system/maintenance/views.py": ["/leonardo_system/maintenance/forms.py"]} |
74,046 | leonardo-modules/leonardo-system | refs/heads/master | /leonardo_system/management/commands/system_check.py | from __future__ import unicode_literals
from optparse import make_option
from ._utils import pp
from django.core.management.base import BaseCommand, NoArgsCommand
from leonardo_system.pip import check_versions
class Command(BaseCommand):
help = "Check version of system packages"
option_list = NoArgsCommand.option_list + (
make_option('--leonardo',
action='store_false', dest='interactive', default=True,
help="Check just leonardo packages"),
make_option('--noinput',
action='store_false', dest='interactive', default=True,
help="Do NOT prompt the user for input of any kind."),
)
def handle(self, **options):
result = check_versions(only_leonardo=True)
output = pp.pprint(result)
self.stdout.write(str(output))
return "Needs System Update"
| {"/leonardo_system/pip/__init__.py": ["/leonardo_system/pip/versions.py"], "/leonardo_system/package/views.py": ["/leonardo_system/package/forms.py"], "/leonardo_system/__init__.py": ["/leonardo_system/package/patch_pip.py"], "/leonardo_system/management/commands/system_check.py": ["/leonardo_system/pip/__init__.py"], "/leonardo_system/package/urls.py": ["/leonardo_system/package/views.py"], "/leonardo_system/package/forms.py": ["/leonardo_system/package/utils.py"], "/leonardo_system/maintenance/urls.py": ["/leonardo_system/maintenance/views.py"], "/leonardo_system/maintenance/forms.py": ["/leonardo_system/maintenance/tables.py"], "/leonardo_system/maintenance/views.py": ["/leonardo_system/maintenance/forms.py"]} |
74,047 | leonardo-modules/leonardo-system | refs/heads/master | /leonardo_system/package/utils.py |
from django.utils.translation import ugettext_lazy as _
from leonardo import messages
from leonardo.utils import dotdict
from django.core import management
try:
import github
GITHUB = True
except Exception:
GITHUB = False
# github specific
ORG = None
try:
import pip # noqa
PIP = True
except Exception:
PIP = False
# for this time
# all items for fast search
# in memory ..
REPOS = None
GITHUB_REPOS = None
AVAIL_WIDGETS = None
# hide from search plugin
_BLACKLIST = [
'django-leonardo',
'raspiface',
]
def pip_install(packages, request=None, reload_server=False):
"""install packages from pip
if request is provided, user messages is pushed out
"""
if PIP:
# install
try:
pip.main(['install', packages])
if request:
messages.success(request, _(
'Packages %s was successfully installed,\
please restart your server.' % packages))
except Exception as e:
if request:
messages.error(request, _(
'Installing packages raised exception %s' % e))
else:
raise e
else:
if reload_server:
# try self kill
try:
import os
os.kill(os.getpid(), 9)
except Exception as e:
if request:
messages.error(request, _(
'Run post install task fails with %s' % e))
else:
raise e
else:
if request:
messages.error(request, _(
'For this functionality please install pip package'))
def filter_repos():
"""filter repos for duplicity
"""
global REPOS
_pkgs = []
_pkgs_names = []
if REPOS:
for item in REPOS:
if item.name not in _BLACKLIST and item.name not in _pkgs_names:
_pkgs_names.append(item.name)
_pkgs.append(item)
REPOS = _pkgs
def update_global_repos(items):
"""update repos safety
"""
global REPOS
if REPOS:
REPOS += items
else:
REPOS = items
def get_widgets(query='leonardo', request=None):
"""returns all widgets
"""
widgets = {}
global GITHUB_REPOS
if GITHUB_REPOS is None:
update_packages_from_github(query, request)
if GITHUB:
for repo in GITHUB_REPOS:
# TODO read setup.py
mod_name = repo.name
raise Exception(mod_name)
try:
descriptor = repo.get_file_contents(
'%s/__init__.py' % mod_name).decoded_content
except Exception:
pass
else:
widgets.update({
mod_name: descriptor.widgets
})
raise Exception(widgets)
def update_packages_from_pip(query, request=None):
"""updates global REPOS from pypi
"""
if PIP:
try:
from pip.commands.search import SearchCommand
search_results = SearchCommand().search(
'leonardo', dotdict({
'cache_dir': '/tmp',
'trusted_hosts': ['https://pypi.python.org/pypi'],
'index': 'https://pypi.python.org/pypi'}))
# serialize to dot access dict
search_results = [dotdict(d) for d in search_results]
except ImportError:
if request:
messages.error(request, _(
'For this functionality please install pip package'))
else:
update_global_repos(search_results)
def update_packages_from_github(query, request=None):
"""updates global REPOS from leonardo github organization
"""
global REPOS
global GITHUB_REPOS
if GITHUB:
global ORG
try:
g = github.Github()
org = g.get_organization('leonardo-modules')
except ImportError:
if request:
messages.error(request, _(
'For this functionality please run pip install PyGithub'))
else:
GITHUB_REPOS = org.get_repos()
update_global_repos(list(org.get_repos()))
ORG = org
def update_all(query='leonardo', request=None):
global REPOS
if not REPOS:
update_packages_from_pip(query, request)
update_packages_from_github(query, request)
filter_repos()
return REPOS
| {"/leonardo_system/pip/__init__.py": ["/leonardo_system/pip/versions.py"], "/leonardo_system/package/views.py": ["/leonardo_system/package/forms.py"], "/leonardo_system/__init__.py": ["/leonardo_system/package/patch_pip.py"], "/leonardo_system/management/commands/system_check.py": ["/leonardo_system/pip/__init__.py"], "/leonardo_system/package/urls.py": ["/leonardo_system/package/views.py"], "/leonardo_system/package/forms.py": ["/leonardo_system/package/utils.py"], "/leonardo_system/maintenance/urls.py": ["/leonardo_system/maintenance/views.py"], "/leonardo_system/maintenance/forms.py": ["/leonardo_system/maintenance/tables.py"], "/leonardo_system/maintenance/views.py": ["/leonardo_system/maintenance/forms.py"]} |
74,048 | leonardo-modules/leonardo-system | refs/heads/master | /leonardo_system/package/urls.py | from django.conf.urls import include, patterns, url
from .views import PluginInstallView
urlpatterns = patterns('',
url(r'^plugin-install/$',
PluginInstallView.as_view(), name='plugin_install'),
)
| {"/leonardo_system/pip/__init__.py": ["/leonardo_system/pip/versions.py"], "/leonardo_system/package/views.py": ["/leonardo_system/package/forms.py"], "/leonardo_system/__init__.py": ["/leonardo_system/package/patch_pip.py"], "/leonardo_system/management/commands/system_check.py": ["/leonardo_system/pip/__init__.py"], "/leonardo_system/package/urls.py": ["/leonardo_system/package/views.py"], "/leonardo_system/package/forms.py": ["/leonardo_system/package/utils.py"], "/leonardo_system/maintenance/urls.py": ["/leonardo_system/maintenance/views.py"], "/leonardo_system/maintenance/forms.py": ["/leonardo_system/maintenance/tables.py"], "/leonardo_system/maintenance/views.py": ["/leonardo_system/maintenance/forms.py"]} |
74,049 | leonardo-modules/leonardo-system | refs/heads/master | /leonardo_system/package/forms.py |
from django.utils.translation import ugettext_lazy as _
from django_select2.forms import Select2Widget
from leonardo import forms, messages
from .utils import pip_install, update_all
class PluginInstallForm(forms.SelfHandlingForm):
"""simple form for installing packages
this support new abilities like an dynamic plugin install etc..
"""
packages = forms.ChoiceField(label=_('Search packages'), widget=Select2Widget())
reload_server = forms.BooleanField(
label=_('Reload Server'), initial=False,
required=False,
help_text=_('Warning: this kill this Leonardo instance !!!\
For successfull reload must be run under Supervisor !\
You may lost your data !'),)
def __init__(self, *args, **kwargs):
kwargs.pop('request', None)
super(PluginInstallForm, self).__init__(*args, **kwargs)
# I think that this is not best solution
self.fields['packages'].choices = [
(repo.name, repo.name, )
for repo in update_all()]
self.helper.layout = forms.Layout(
forms.TabHolder(
forms.Tab('Main',
'packages',
css_id='plugins-install-main'
),
forms.Tab('Advance',
'reload_server'
)
)
)
def handle(self, request, data):
kwargs = data
kwargs['request'] = request
try:
pip_install(**kwargs)
except Exception as e:
messages.error(request, str(e))
else:
return True
return False
| {"/leonardo_system/pip/__init__.py": ["/leonardo_system/pip/versions.py"], "/leonardo_system/package/views.py": ["/leonardo_system/package/forms.py"], "/leonardo_system/__init__.py": ["/leonardo_system/package/patch_pip.py"], "/leonardo_system/management/commands/system_check.py": ["/leonardo_system/pip/__init__.py"], "/leonardo_system/package/urls.py": ["/leonardo_system/package/views.py"], "/leonardo_system/package/forms.py": ["/leonardo_system/package/utils.py"], "/leonardo_system/maintenance/urls.py": ["/leonardo_system/maintenance/views.py"], "/leonardo_system/maintenance/forms.py": ["/leonardo_system/maintenance/tables.py"], "/leonardo_system/maintenance/views.py": ["/leonardo_system/maintenance/forms.py"]} |
74,050 | leonardo-modules/leonardo-system | refs/heads/master | /leonardo_system/maintenance/urls.py | from django.conf.urls import include, patterns, url
from .views import ServerReloadView, ManagementView, InfoView, ConfigUpdate
urlpatterns = patterns('',
url(r'^server-reload/$',
ServerReloadView.as_view(), name='server_reload'),
url(r'^management-commands/$',
ManagementView.as_view(), name='server_management'),
url(r'^system-info/$',
InfoView.as_view(), name='system_info'),
url(r'^settings/$',
ConfigUpdate.as_view(), name='live_config'),
)
| {"/leonardo_system/pip/__init__.py": ["/leonardo_system/pip/versions.py"], "/leonardo_system/package/views.py": ["/leonardo_system/package/forms.py"], "/leonardo_system/__init__.py": ["/leonardo_system/package/patch_pip.py"], "/leonardo_system/management/commands/system_check.py": ["/leonardo_system/pip/__init__.py"], "/leonardo_system/package/urls.py": ["/leonardo_system/package/views.py"], "/leonardo_system/package/forms.py": ["/leonardo_system/package/utils.py"], "/leonardo_system/maintenance/urls.py": ["/leonardo_system/maintenance/views.py"], "/leonardo_system/maintenance/forms.py": ["/leonardo_system/maintenance/tables.py"], "/leonardo_system/maintenance/views.py": ["/leonardo_system/maintenance/forms.py"]} |
74,051 | leonardo-modules/leonardo-system | refs/heads/master | /leonardo_system/maintenance/forms.py | import os
import django.dispatch
from django.conf import settings
from django.core import management
from django.utils import six
from django.utils.translation import ugettext_lazy as _
from django.views.debug import get_safe_settings
from horizon import tables
from horizon_contrib.tables import FilterAction
from leonardo import forms, leonardo, messages
from leonardo.utils import get_conf_from_module
from .tables import LeonardoTable, SettingsTable
RESTORE_FLAG_CHOICES = (
('no_option', '------'),
('create_flag', _('Create restore flag')),
('delete_flag', _('Delete restore flag'))
)
server_restart = django.dispatch.Signal(providing_args=["request", "delay"])
def server_restart_callback(request, delay=0, **kwargs):
# time.sleep(delay)
try:
# from django.utils.autoreload import restart_with_reloader, reloader_thread
# kill self
os.kill(os.getpid(), 9)
messages.success(
request, _('Server was successfuly restarted !'))
except Exception as e:
messages.error(request, str(e))
else:
return True
return False
server_restart.connect(server_restart_callback)
class ServerReloadForm(forms.SelfHandlingForm):
delay = forms.IntegerField(
label=_('delay before restart'), initial=10, help_text=_('Delay before restart'))
def handle(self, request, data):
"""PoC for self restart
this support new abilities like an dynamic plugin install etc..
"""
try:
server_restart.send(sender=self.__class__,
request=request, delay=data['delay'])
messages.warning(
request, _('Server going to down !'))
except Exception as e:
messages.error(request, str(e))
else:
return True
return False
class ManagementForm(forms.SelfHandlingForm):
"""form wich handle managemenet commands
this supports running management commands via admin
"""
makemigrations = forms.BooleanField(
label=_('Make migrations'), initial=False,
required=False,
help_text=_('Run makemigrations after install ?'))
migrate = forms.BooleanField(
label=_('Migrate'), initial=False,
required=False,
help_text=_('Run migrate command after install ?'))
sync_all = forms.BooleanField(
label=_('Sync All'), initial=False,
required=False,
help_text=_('Run Sync All command after install ?'))
sync_force = forms.BooleanField(
label=_('Sync all force'), initial=False,
required=False,
help_text=_('Warning: this may override you database changes !'),)
reload_server = forms.BooleanField(
label=_('Reload Server'), initial=False,
required=False,
help_text=_('Warning: this kill this Leonardo instance !!!\
For successfull reload must be run under Supervisor !\
You may lost your data !'),)
restore_flag = forms.ChoiceField(
label=_('Restore flag'), required=False, choices=RESTORE_FLAG_CHOICES,
help_text=_('Warning: when you delete this flag restart will cause restore of all data!'),)
def __init__(self, *args, **kwargs):
super(ManagementForm, self).__init__(*args, **kwargs)
self.helper.layout = forms.Layout(
forms.TabHolder(
forms.Tab('Main',
'makemigrations',
'migrate',
'sync_all',
css_id='plugins-install-main'
),
forms.Tab('Advance',
'sync_force',
'reload_server',
),
forms.Tab('Backup/Restore',
'restore_flag',
)
)
)
def handle(self, request, data):
restore_flag_path = settings.MEDIA_ROOT + 'DATA_RESTORED'
try:
if data.get('makemigrations', None):
management.call_command(
'makemigrations', verbosity=1, interactive=False)
if data.get('migrate', None):
management.call_command(
'migrate', verbosity=1, interactive=False)
if data.get('sync_all', None):
management.call_command(
'sync_all', force=data.get('sync_force', False))
if data.get('reload_server', None):
import os
os.kill(os.getpid(), 9)
# create/delete DATA_RESTORED file in media root - restart app will cause restore of all data
if data.get('restore_flag') == 'create_flag':
import os
if not os.path.exists(restore_flag_path):
flag = open(restore_flag_path, 'w+')
flag.close()
messages.success(request, 'Restore flag was created.')
else:
messages.info(request, 'Restore flag already exists.')
if data.get('restore_flag') == 'delete_flag':
import os
if os.path.exists(restore_flag_path):
os.remove(restore_flag_path)
messages.success(request, 'Restore flag was removed.')
else:
messages.info(request, 'Restore flag does not exist.')
except Exception as e:
messages.error(request, str(e))
else:
return True
return False
class InfoForm(forms.SelfHandlingForm):
"""wrapper for system info
"""
def __init__(self, *args, **kwargs):
request = kwargs.pop('request', None)
super(InfoForm, self).__init__(*args, **kwargs)
_settings = [{'key': k, 'value': v}
for k, v in six.iteritems(get_safe_settings())]
table = SettingsTable(request, data=_settings)
leonardo_table = LeonardoTable(
request, data=leonardo.get_modules_as_list())
self.helper.layout = forms.Layout(
forms.TabHolder(
forms.Tab('Leonardo modules',
forms.HTML(leonardo_table.render())
),
forms.Tab('Settings',
forms.HTML(table.render())
),
)
)
def handle(self, request, data):
return True
| {"/leonardo_system/pip/__init__.py": ["/leonardo_system/pip/versions.py"], "/leonardo_system/package/views.py": ["/leonardo_system/package/forms.py"], "/leonardo_system/__init__.py": ["/leonardo_system/package/patch_pip.py"], "/leonardo_system/management/commands/system_check.py": ["/leonardo_system/pip/__init__.py"], "/leonardo_system/package/urls.py": ["/leonardo_system/package/views.py"], "/leonardo_system/package/forms.py": ["/leonardo_system/package/utils.py"], "/leonardo_system/maintenance/urls.py": ["/leonardo_system/maintenance/views.py"], "/leonardo_system/maintenance/forms.py": ["/leonardo_system/maintenance/tables.py"], "/leonardo_system/maintenance/views.py": ["/leonardo_system/maintenance/forms.py"]} |
74,052 | leonardo-modules/leonardo-system | refs/heads/master | /leonardo_system/maintenance/views.py |
from __future__ import absolute_import
from constance.admin import ConstanceForm
from django.utils.translation import ugettext_lazy as _
from django.core import urlresolvers
from leonardo.views import *
from leonardo.views import ModalFormView
from constance import settings, LazyConfig
from .forms import InfoForm, ManagementForm, ServerReloadForm
config = LazyConfig()
class ServerReloadView(ModalFormView, ContextMixin, ModelFormMixin):
form_class = ServerReloadForm
def get_success_url(self):
return self.request.build_absolute_uri()
def get_context_data(self, **kwargs):
context = super(ServerReloadView, self).get_context_data(**kwargs)
context['url'] = self.request.build_absolute_uri()
context['modal_header'] = 'Reload Server'
context['title'] = 'Reload Server'
context['form_submit'] = _('Submit Reload')
context['heading'] = 'Reload Server'
context['modal_size'] = 'sm'
return context
class InfoView(ModalFormView, ContextMixin, ModelFormMixin):
form_class = InfoForm
def get_success_url(self):
return self.request.build_absolute_uri()
def get_form(self, form_class):
"""Returns an instance of the form to be used in this view."""
kwargs = self.get_form_kwargs()
kwargs.update({
'request': self.request,
})
return form_class(**kwargs)
def get_context_data(self, **kwargs):
context = super(InfoView, self).get_context_data(**kwargs)
context['url'] = self.request.build_absolute_uri()
context['modal_header'] = _('Leonardo Info')
context['title'] = _('Leonardo Info')
context['form_submit'] = _('Close')
context['heading'] = _('Leonardo Info')
context['modal_size'] = 'fullscreen'
return context
def form_invalid(self, form):
raise Exception(form.errors)
class ManagementView(ModalFormView, ContextMixin, ModelFormMixin):
form_class = ManagementForm
def get_success_url(self):
return self.request.build_absolute_uri()
def get_context_data(self, **kwargs):
context = super(ManagementView, self).get_context_data(**kwargs)
context['url'] = self.request.build_absolute_uri()
context['modal_header'] = _('Management commands')
context['title'] = _('Management commands')
context['form_submit'] = _('Run commands')
context['heading'] = _('Management commands')
context['modal_size'] = 'md'
return context
def form_invalid(self, form):
raise Exception(form.errors)
class ConfigUpdate(ModalFormView):
form_class = ConstanceForm
success_url = "feincms_home"
def get_context_data(self, *args, **kwargs):
context = super(ConfigUpdate, self).get_context_data(*args, **kwargs)
context['modal_size'] = 'lg'
return context
def get_success_url(self):
return urlresolvers.reverse(self.success_url)
def get_initial(self):
from constance import config
initial = {}
for key in dir(config):
initial[key] = getattr(config, key)
return initial
| {"/leonardo_system/pip/__init__.py": ["/leonardo_system/pip/versions.py"], "/leonardo_system/package/views.py": ["/leonardo_system/package/forms.py"], "/leonardo_system/__init__.py": ["/leonardo_system/package/patch_pip.py"], "/leonardo_system/management/commands/system_check.py": ["/leonardo_system/pip/__init__.py"], "/leonardo_system/package/urls.py": ["/leonardo_system/package/views.py"], "/leonardo_system/package/forms.py": ["/leonardo_system/package/utils.py"], "/leonardo_system/maintenance/urls.py": ["/leonardo_system/maintenance/views.py"], "/leonardo_system/maintenance/forms.py": ["/leonardo_system/maintenance/tables.py"], "/leonardo_system/maintenance/views.py": ["/leonardo_system/maintenance/forms.py"]} |
74,053 | leonardo-modules/leonardo-system | refs/heads/master | /leonardo_system/pip/versions.py |
from __future__ import absolute_import
from importlib import import_module
from leonardo.utils import is_leonardo_module
from pip.commands.list import ListCommand
LEONARDO_ENV = None
GLOBAL_ENV = None
def check_versions(only_leonardo=False):
'''returns dictionary of modules with versions to could be updated
return:: {
'name': {
'old': '1.0.1',
'new': '1.0.2',
'type': wheel
}
}
'''
global LEONARDO_ENV
global GLOBAL_ENV
if only_leonardo:
if LEONARDO_ENV:
return LEONARDO_ENV
else:
if GLOBAL_ENV:
return GLOBAL_ENV
listing = ListCommand()
options, args = listing.parse_args([])
update = {}
for dist, version, typ in listing.find_packages_latest_versions(options):
if only_leonardo:
pkg_names = [k for k in dist._get_metadata("top_level.txt")]
for pkg_name in pkg_names:
try:
mod = import_module(pkg_name)
except:
pass
else:
if is_leonardo_module(mod):
if version > dist.parsed_version:
update.update({
dist.project_name: {
'old': dist.version,
'new': version,
'type': typ
}
})
else:
if version > dist.parsed_version:
update.update({
dist.project_name: {
'old': dist.version,
'new': version,
'type': typ
}
})
if only_leonardo:
LEONARDO_ENV = update
else:
GLOBAL_ENV = update
return update
| {"/leonardo_system/pip/__init__.py": ["/leonardo_system/pip/versions.py"], "/leonardo_system/package/views.py": ["/leonardo_system/package/forms.py"], "/leonardo_system/__init__.py": ["/leonardo_system/package/patch_pip.py"], "/leonardo_system/management/commands/system_check.py": ["/leonardo_system/pip/__init__.py"], "/leonardo_system/package/urls.py": ["/leonardo_system/package/views.py"], "/leonardo_system/package/forms.py": ["/leonardo_system/package/utils.py"], "/leonardo_system/maintenance/urls.py": ["/leonardo_system/maintenance/views.py"], "/leonardo_system/maintenance/forms.py": ["/leonardo_system/maintenance/tables.py"], "/leonardo_system/maintenance/views.py": ["/leonardo_system/maintenance/forms.py"]} |
74,054 | leonardo-modules/leonardo-system | refs/heads/master | /leonardo_system/package/patch_pip.py | from __future__ import absolute_import
import contextlib
from pip.utils.logging import get_indentation, _log_state
@contextlib.contextmanager
def indent_log(num=2):
"""
I submited PR to pip because this has raising exception for us
https://github.com/pypa/pip/pull/3161
.. code-block:: python
Exception:
Traceback (most recent call last):
File "/srv/leonardo/sites/majklk/local/lib/python2.7/site-packages/pip/basecommand.py", line 211, in main
status = self.run(options, args)
File "/srv/leonardo/sites/majklk/local/lib/python2.7/site-packages/pip/commands/install.py", line 344, in run
requirement_set.cleanup_files()
File "/srv/leonardo/sites/majklk/local/lib/python2.7/site-packages/pip/req/req_set.py", line 589, in cleanup_files
with indent_log():
File "/usr/lib/python2.7/contextlib.py", line 17, in __enter__
return self.gen.next()
File "/srv/leonardo/sites/majklk/local/lib/python2.7/site-packages/pip/utils/logging.py", line 38, in indent_log
_log_state.indentation -= num
AttributeError: 'thread._local' object has no attribute 'indentation'
"""
_log_state.indentation = get_indentation() + num
try:
yield
finally:
_log_state.indentation = get_indentation() - num
| {"/leonardo_system/pip/__init__.py": ["/leonardo_system/pip/versions.py"], "/leonardo_system/package/views.py": ["/leonardo_system/package/forms.py"], "/leonardo_system/__init__.py": ["/leonardo_system/package/patch_pip.py"], "/leonardo_system/management/commands/system_check.py": ["/leonardo_system/pip/__init__.py"], "/leonardo_system/package/urls.py": ["/leonardo_system/package/views.py"], "/leonardo_system/package/forms.py": ["/leonardo_system/package/utils.py"], "/leonardo_system/maintenance/urls.py": ["/leonardo_system/maintenance/views.py"], "/leonardo_system/maintenance/forms.py": ["/leonardo_system/maintenance/tables.py"], "/leonardo_system/maintenance/views.py": ["/leonardo_system/maintenance/forms.py"]} |
74,055 | leonardo-modules/leonardo-system | refs/heads/master | /leonardo_system/urls.py | from django.conf.urls import include, patterns, url
urlpatterns = patterns('',
url(r'^packages/', include('leonardo_system.package.urls')),
url(r'^maintenance/', include('leonardo_system.maintenance.urls')),
)
| {"/leonardo_system/pip/__init__.py": ["/leonardo_system/pip/versions.py"], "/leonardo_system/package/views.py": ["/leonardo_system/package/forms.py"], "/leonardo_system/__init__.py": ["/leonardo_system/package/patch_pip.py"], "/leonardo_system/management/commands/system_check.py": ["/leonardo_system/pip/__init__.py"], "/leonardo_system/package/urls.py": ["/leonardo_system/package/views.py"], "/leonardo_system/package/forms.py": ["/leonardo_system/package/utils.py"], "/leonardo_system/maintenance/urls.py": ["/leonardo_system/maintenance/views.py"], "/leonardo_system/maintenance/forms.py": ["/leonardo_system/maintenance/tables.py"], "/leonardo_system/maintenance/views.py": ["/leonardo_system/maintenance/forms.py"]} |
74,056 | leonardo-modules/leonardo-system | refs/heads/master | /leonardo_system/maintenance/tables.py | import json
import os
import django.dispatch
from django.conf import settings
from django.core import management
from django.utils import six
from django.utils.translation import ugettext_lazy as _
from django.views.debug import get_safe_settings
from horizon import tables
from horizon_contrib.tables import FilterAction
from leonardo import forms, messages
from leonardo.utils import get_conf_from_module
from leonardo_system.management.commands._utils import get_versions
from django.template.loader import render_to_string
import pprint
pp = pprint.PrettyPrinter(indent=4)
class SettingsTable(tables.DataTable):
key = tables.Column('key')
value = tables.Column('value')
def get_object_id(self, datum):
return datum['key']
class Meta:
name = 'settings'
table_actions = (FilterAction,)
class UninstallAction(tables.DeleteAction):
data_type_singular = 'Module'
data_type_plural = 'Modules'
action_present = _("Uninstall")
action_present_plural = _("Uninstalled")
def allowed(self, request, instance=None):
return True
def action(self, request, obj_id):
raise NotImplementedError
class UpgradeAction(tables.BatchAction):
data_type_singular = 'Module'
data_type_plural = 'Modules'
action_present = _("Upgrade")
action_present_plural = _("Upgraded")
name = 'Upgrade'
def allowed(self, request, instance=None):
return True
def action(self, request, obj_id):
raise NotImplementedError
class LeonardoTable(tables.DataTable):
name = tables.Column('module',
filters=(lambda m: m.__name__,))
widgets = tables.Column(
'widgets', verbose_name=_('Widgets'),
filters=(lambda c: ', '.join([str(w.__name__) for w in c]),))
plugins = tables.Column(
'plugins', verbose_name=_('Plugins'),
filters=(lambda c: ', '.join([p[0] for p in c]),))
version = tables.Column('version',
verbose_name=_('Version'))
needs_migrations = tables.Column('needs_migrations',
verbose_name=_('Needs Migrations'),
filters=(lambda c: _(
'Needs Migrations') if c else '-',)
)
needs_sync = tables.Column('needs_sync',
verbose_name=_('Needs Sync'),
filters=(lambda c: _('Needs Sync') if c else '-',))
def get_object_id(self, datum):
return datum.name
class Meta:
name = 'leonardo-modules'
verbose_name = _('Leonardo Modules')
row_actions = (UpgradeAction, UninstallAction,)
table_actions = (FilterAction,)
| {"/leonardo_system/pip/__init__.py": ["/leonardo_system/pip/versions.py"], "/leonardo_system/package/views.py": ["/leonardo_system/package/forms.py"], "/leonardo_system/__init__.py": ["/leonardo_system/package/patch_pip.py"], "/leonardo_system/management/commands/system_check.py": ["/leonardo_system/pip/__init__.py"], "/leonardo_system/package/urls.py": ["/leonardo_system/package/views.py"], "/leonardo_system/package/forms.py": ["/leonardo_system/package/utils.py"], "/leonardo_system/maintenance/urls.py": ["/leonardo_system/maintenance/views.py"], "/leonardo_system/maintenance/forms.py": ["/leonardo_system/maintenance/tables.py"], "/leonardo_system/maintenance/views.py": ["/leonardo_system/maintenance/forms.py"]} |
74,062 | Teevarapat/Mirror-Man- | refs/heads/master | /checkcollision.py | import pygame
from player import Player
from car import Car
width = 21
height = 43
class CheckCollision (object):
def iamhit(self, player, car, car2, car3, car4):
self.player = player
self.car = car
self.car2 = car2
self.car3 = car3
self.car4 = car4
if self.player.getX() < self.car.getX() + 100 and self.player.getX() + width > self.car.getX():
if self.player.getY() + height > self.car.getY() and self.player.getY() < self.car.getY() + 50:
#print 'i am hit by car 1'
return True
elif self.player.getX() < self.car3.getX() + 100 and self.player.getX() + width > self.car3.getX():
if self.player.getY() + height > self.car3.getY() and self.player.getY() < self.car3.getY() + 50:
#print 'i am hit by car3'
return True
elif self.player.getX() > self.car2.getX() and self.player.getX() + width < self.car2.getX() + 100:
if self.player.getY() + height > self.car2.getY() and self.player.getY() < self.car2.getY() + 50:
#print 'i am hit by car2'
return True
elif self.player.getX() > self.car4.getX() and self.player.getX() + width < self.car4.getX() + 100:
if self.player.getY() + height > self.car4.getY() and self.player.posy < self.car4.getY() + 50:
#print 'i am hit by car4'
return True | {"/checkcollision.py": ["/player.py", "/car.py"], "/main.py": ["/player.py", "/car.py", "/checkcollision.py"]} |
74,063 | Teevarapat/Mirror-Man- | refs/heads/master | /player.py | import pygame
from pygame.locals import *
width = 21
height = 43
class Player(object):
def __init__(self, pos):
(self.posx , self.posy) = pos
def render(self,surface):
self.man = pygame.image.load("man1.png").convert()
surface.blit(self.man,(self.posx, self.posy))
def move_up(self):
self.posy -= 3
if self.posy < 0:
self.posy = 0
def move_down(self):
self.posy += 3
if self.posy > 600 - height:
self.posy = 600 - height
def move_left(self):
self.posx -= 3
if self.posx < 0:
self.posx = 0
def move_right(self):
self.posx += 3
if self.posx > 800 - width:
self.posx = 800 - width
def getX(self):
return self.posx
def getY(self):
return self.posy | {"/checkcollision.py": ["/player.py", "/car.py"], "/main.py": ["/player.py", "/car.py", "/checkcollision.py"]} |
74,064 | Teevarapat/Mirror-Man- | refs/heads/master | /main.py | import pygame
from pygame.locals import *
import gamelib
import random
from player import Player
from car import Car
from checkcollision import CheckCollision
class MirrorMan(gamelib.SimpleGame):
PURPLE = pygame.Color('purple')
def __init__(self):
super(MirrorMan, self).__init__('Mirror Man', MirrorMan.PURPLE)
self.gameover = False
self.win = False
self.player = Player((random.randint(50,750), 10))
self.car = Car(0, 125, 'yellow')
self.car2 = Car(800, 225, 'red')
self.car3 = Car(-100, 325, 'yellow')
self.car4 = Car(900, 425, 'red')
#self.checkcollision = CheckCollision(self.player, self.car, self.car2, self.car3, self.car4)
def init(self):
super(MirrorMan, self).init()
def update(self):
collision = CheckCollision()
if not self.gameover and not self.win:
self.car.move()
self.car2.move()
self.car3.move()
self.car4.move()
if self.is_key_pressed(K_UP):
self.player.move_down()
elif self.is_key_pressed(K_DOWN):
self.player.move_up()
elif self.is_key_pressed(K_LEFT):
self.player.move_right()
elif self.is_key_pressed(K_RIGHT):
self.player.move_left()
if collision.iamhit(self.player, self.car, self.car2, self.car3, self.car4):
self.gameover = True
def render(self, surface):
self.background = pygame.image.load("background.png")
surface.blit(self.background, (0, 0))
self.player.render(surface)
self.car.render(surface)
self.car2.render(surface)
self.car3.render(surface)
self.car4.render(surface)
if self.gameover:
self.bye = pygame.image.load("gameover.jpg")
surface.blit(self.bye, (150, 150))
if self.player.getY() >= 550:
self.win = pygame.image.load("youwin.png")
surface.blit(self.win, (150, 150))
def main():
game = MirrorMan()
game.run()
if __name__ == '__main__':
main() | {"/checkcollision.py": ["/player.py", "/car.py"], "/main.py": ["/player.py", "/car.py", "/checkcollision.py"]} |
74,065 | Teevarapat/Mirror-Man- | refs/heads/master | /car.py | import pygame
import random
from pygame.locals import *
width = 100
height = 50
class Car(object):
def __init__(self, px, py, typecar, speed = 10):
self.px = px
self.py = py
self.type = typecar
self.vx = speed + random.randint(0,12)
def render(self, surface):
if self.type == 'yellow':
self.car = pygame.image.load("car1.png")
surface.blit(self.car, (self.px, self.py))
elif self.type == 'red':
self.car2 = pygame.image.load("car2.png")
surface.blit(self.car2, (self.px, self.py))
def move(self):
if self.type == 'yellow':
self.px += self.vx
if(self.px > 800):
self.px = 0 - random.randint(100,1000)
if self.type == 'red':
self.px -= self.vx
if(self.px < 0 - width):
self.px = 800 + random.randint(100,1000)
def getX(self):
return self.px
def getY(self):
return self.py | {"/checkcollision.py": ["/player.py", "/car.py"], "/main.py": ["/player.py", "/car.py", "/checkcollision.py"]} |
74,073 | cmarinal04/Quejas_Reclamos | refs/heads/master | /email.py | import win32com.client as win32
from datetime import date
from datetime import datetime
from datetime import timedelta
def send_email():
today = date.today()
yesterday = today - timedelta(days=1)
name_csv = f'Quejas_{yesterday}.csv'
file_local = f'''D:/Desarrollo/Quejas_Millicom_Alejandro/reportes/{name_csv}'''
firma =f'''D:/Desarrollo/Quejas_Millicom_Alejandro/img/firma.jpeg'''
olApp = win32.Dispatch('Outlook.Application')
olNS = olApp.GetNameSpace('MAPI')
mailItem = olApp.CreateItem(0)
mailItem.Subject = 'Consulta de Quejas'
mailItem.BodyFormat = 2
attachment = mailItem.Attachments.Add(firma)
attachment.PropertyAccessor.SetProperty("http://schemas.microsoft.com/mapi/proptag/0x3712001F", "MyId1")
mailItem.HTMLBody = "<html><body><p>Hola Edgar,Te comparto el archivo con la información.</p>\
<p>Saludos.</p>\
<img src=""cid:MyId1""></body></html>"
mailItem.GetInspector
attachment1 = file_local
mailItem.Attachments.Add(Source=attachment1)
mailItem.To ='Edgar.Lopez@tigo.com.co'
#mailItem.To ='yerson@veredata.co;Cristian.Marin.Alvarez@tigo.com.co;johnatan.lopez@tigo.com.co'
mailItem._oleobj_.Invoke(*(64209,0,8,0,olNS.Accounts.item('johnatan.lopez@tigo.com.co')))
mailItem.Display()
mailItem.Save()
mailItem.Send()
| {"/quejas_reclamos.py": ["/email.py"]} |
74,074 | cmarinal04/Quejas_Reclamos | refs/heads/master | /quejas_reclamos.py | import pandas as pd
from connection.Oracle_connection import connection_oracle as con_oracle
from datetime import date
from datetime import datetime
from datetime import timedelta
from email import send_email
def extract_claims():
today = date.today()
yesterday = today - timedelta(days=1)
date_1 = date.strftime(yesterday, '%Y')
date_2 = date.strftime(yesterday, '%m')
date_final = f'SIRA.TBL_TIPI_{date_1}_{date_2}@SIRA'
name_csv = f'Quejas_{yesterday}.csv'
file_local = f'./reportes/{name_csv}'
connection = con_oracle()
script_oracle ='''SELECT * FROM (
SELECT * FROM
(
SELECT TO_CHAR(TO_DATE(FECHA),'YYYYMM') PERIODO, CALLID,
ANI AS TELEFONO, DURACIONSEG AS AHT, TESPERA_SEG AS ASA,
PILOTO,FECHA, HORA, NIVEL1, NIVEL2, NIVEL3, NIVEL4,
CODFINALIZACION,
REGEXP_REPLACE(TRIM(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(UPPER(REGEXP_REPLACE(REGEXP_REPLACE(NIVEL1,'[ ]+',' '),'\s+',' ')),'_',' '),'.',''),'?','Ñ'),'Á','A'),'É','E'),'Í','I'),'Ó','O'),'Ú','U'),'Ñ','Ñ'),'',' ')) || ' - ' || TRIM(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(UPPER(REGEXP_REPLACE(REGEXP_REPLACE(CODFINALIZACION,'[ ]+',' '),'\s+',' ')),'_',' '),'.',''),'?','Ñ'),'Á','A'),'É','E'),'Í','I'),'Ó','O'),'Ú','U'),'Ñ','Ñ'),'',' ')),'\s+',' ') AS TRANSACCION
FROM '''+date_final+'''
WHERE PILOTO IN ('Grup_Skill_UNIV','CMV UNIVERSAL',
'UNE_TIGO_PYMES','CMV_UNE_TIGO_EYG',
'CMV_SIEBEL_8.1','CMV_BQ_SER_CLIEN',
'CMV_BQ_ECOMER','CMV_TIGO_ALTOV_MED')
AND ESTADO = 'Atendido'AND DURACIONSEG > 60
) LLAMADA,
(
SELECT SUBSERVICIO, APLICA_BU, CLASIFICACION_MILLICOM,
QUEJA_MILLICOM,TIPO_QUEJA_MILLICOM, CATEGORIA,
SUBCATEGORIA, BU || '-' || CANAL AS KEY
FROM MADAVIL.TBL_TIPI_EQUIVALENCIAS_3
WHERE QUEJA_MILLICOM = 'QUEJA - DATOS' AND
APLICA_BU = 'SI' AND CLASIFICACION_MILLICOM = 'RECLAMOS'
) TABLA_EQUIVALENCIA
WHERE LLAMADA.TRANSACCION = TABLA_EQUIVALENCIA.SUBSERVICIO (+)
AND 'MOVIL-CONTACT CENTER' = TABLA_EQUIVALENCIA.KEY (+)
UNION ALL
SELECT * FROM
(
SELECT TO_CHAR(TO_DATE(FECHA),'YYYYMM') PERIODO, CALLID,
ANI AS TELEFONO, DURACIONSEG AS AHT, TESPERA_SEG AS ASA,
PILOTO,FECHA, HORA, NIVEL1, NIVEL2, NIVEL3, NIVEL4,
CODFINALIZACION,
REGEXP_REPLACE(TRIM(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(UPPER(REGEXP_REPLACE(REGEXP_REPLACE(NIVEL1,'[ ]+',' '),'\s+',' ')),'_',' '),'.',''),'?','Ñ'),'Á','A'),'É','E'),'Í','I'),'Ó','O'),'Ú','U'),'Ñ','Ñ'),'',' ')) || ' - ' || TRIM(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(UPPER(REGEXP_REPLACE(REGEXP_REPLACE(CODFINALIZACION,'[ ]+',' '),'\s+',' ')),'_',' '),'.',''),'?','Ñ'),'Á','A'),'É','E'),'Í','I'),'Ó','O'),'Ú','U'),'Ñ','Ñ'),'',' ')),'\s+',' ') AS TRANSACCION
FROM '''+date_final+'''
WHERE PILOTO IN ('Grup_Skill_UNIV','CMV UNIVERSAL',
'UNE_TIGO_PYMES','CMV_UNE_TIGO_EYG',
'CMV_SIEBEL_8.1','CMV_BQ_SER_CLIEN',
'CMV_BQ_ECOMER','CMV_TIGO_ALTOV_MED')
AND ESTADO = 'Atendido'
) LLAMADA,
(
SELECT SUBSERVICIO, APLICA_BU, CLASIFICACION_MILLICOM,
QUEJA_MILLICOM,TIPO_QUEJA_MILLICOM, CATEGORIA,
SUBCATEGORIA, BU || '-' || CANAL AS KEY
FROM MADAVIL.TBL_TIPI_EQUIVALENCIAS_3
WHERE QUEJA_MILLICOM <> 'QUEJA - DATOS' AND APLICA_BU = 'SI'
AND CLASIFICACION_MILLICOM = 'RECLAMOS'
) TABLA_EQUIVALENCIA
WHERE LLAMADA.TRANSACCION = TABLA_EQUIVALENCIA.SUBSERVICIO (+)
AND 'MOVIL-CONTACT CENTER' = TABLA_EQUIVALENCIA.KEY (+)
) WHERE QUEJA_MILLICOM is not null'''
df=pd.read_sql (script_oracle,connection)
df.to_csv(file_local,encoding='utf-8-sig', sep=';' , index=False)
send_email_out = send_email()
def main():
extract_claims()
if __name__ == "__main__":
main() | {"/quejas_reclamos.py": ["/email.py"]} |
74,094 | em1tao/fullfinder | refs/heads/master | /input.py | import loader
while True:
print("Choose image file")
screenshot_link = input(":")
if screenshot_link[-3::] in ("png","jpg"):
print(f"You choose '{screenshot_link}'")
break
tags = []
print("Enter some tags (for example hair color) \nType '.' to stop")
while True:
tag = input(":")
if tag == "." and 1 <= len(tags) or len(tags) > 5:
break
tags.append(tag.strip())
links,titles = loader.main(screenshot_path=screenshot_link,tags=tags)
for i in range(len(links)):
print(titles[i])
print(links[i])
print()
| {"/input.py": ["/loader.py"]} |
74,095 | em1tao/fullfinder | refs/heads/master | /loader.py | import requests
import httplib2
from io import BytesIO
from threading import Thread
from bs4 import BeautifulSoup
from imagehash import average_hash
from PIL import Image
class Page(Thread):
pageCount = 1
fulls: list = []
titles: list = []
def __init__(self):
super().__init__()
self.link = f"https://pornhub.com/video/search?search={Page.tags}&page={Page.pageCount}"
Page.pageCount += 1
def run(self):
"""Parses one of the page."""
main_request = requests.get(self.link)
parsed_html = BeautifulSoup(main_request.content, "lxml")
if search_result:= parsed_html.find("ul", {"id": "videoSearchResult"}):
video_items = search_result.findAll("li")[1::]
for video_item in video_items:
preview_tag = video_item.find("img")
preview_url = preview_tag["data-src"]
image_driver = httplib2.Http('.cache')
_, preview_bytes = image_driver.request(preview_url)
preview_image = Image.open(BytesIO(preview_bytes)).convert("RGB")
if self.are_similar(preview_image):
video_id = video_item['data-video-vkey']
Page.fulls.append(f"https://pornhub.com/view_video.php?viewkey={video_id}")
Page.titles.append(preview_tag["alt"])
def are_similar(self, image) -> bool:
return average_hash(Page.original_image) - average_hash(image) <= 16
def main(screenshot_path: str, tags: list) -> list:
Page.original_image = Image.open(screenshot_path)
Page.tags = "+".join(tags)
pages = [Page() for x in range(1, 4)]
for page in pages:
page.start()
page.join()
return [Page.fulls, Page.titles]
| {"/input.py": ["/loader.py"]} |
74,099 | jgruselius/gruselius | refs/heads/master | /gruselius/session2.py | import untangle
def getFractionOfOutagesBy(url, reason):
doc = untangle.parse(url)
tot = 0
count = 0
for outage in doc.NYCOutages.outage:
tot += 1
if outage.reason.cdata == reason:
count += 1
return float(count)/tot | {"/scripts/check_repo.py": ["/gruselius/session3.py"], "/scripts/getting_data.py": ["/gruselius/session2.py"]} |
74,100 | jgruselius/gruselius | refs/heads/master | /gruselius/session4.py | import requests
from dateutil import parser
from pandas import Series
from pandas import DataFrame
import getpass
def input_credentials():
user = raw_input("GitHub username:")
password = getpass.getpass("Password:")
return (user, password)
def get_commit_history():
user, password = input_credentials()
ORG_URL = "https://api.github.com/orgs/pythonkurs"
repo_data = requests.get(ORG_URL+"/repos", auth=(user, password)).json()
d = {}
for repo in repo_data:
url = repo["url"]+"/commits"
commit_data = requests.get(url, auth=(user, password)).json()
dates = []
messages = []
# Skip repos with no commits:
if len(commit_data) > 1:
for commit in commit_data:
dates.append(parser.parse(commit["commit"]["committer"]["date"]))
messages.append(commit["commit"]["message"])
d[repo["name"]] = Series(messages, index=dates)
return DataFrame(d)
# (Not part of session 4 task)
def get_date_of_most_commits(df):
# Count all non-NA/null commit messages, resample index to per day and
# return the index (day) with highest summed counts of commits:
return df.count(1).resample("D",how="sum").idxmax()
def get_commits_by_weekday(df):
commits_by_date = df.count(1).resample("D",how="sum").dropna()
weekday_count = {}
for i in xrange(len(commits_by_date)):
day = commits_by_date.index[i].strftime("%A")
commits = commits_by_date[i]
if day in weekday_count:
weekday_count[day] += commits
else:
weekday_count[day] = commits
return weekday_count
def get_commits_by_hour(df):
commits_by_hour = df.count(1).resample("H",how="sum").dropna()
hour_count = {}
for i in xrange(len(commits_by_hour)):
hour = commits_by_hour.index[i].hour
commits = commits_by_hour[i]
if hour in hour_count:
hour_count[hour] += commits
else:
hour_count[hour] = commits
return hour_count
# Returns the key in d with highest value and that value:
def get_max(d):
key = max(d, key=d.get)
return(key, d[key])
| {"/scripts/check_repo.py": ["/gruselius/session3.py"], "/scripts/getting_data.py": ["/gruselius/session2.py"]} |
74,101 | jgruselius/gruselius | refs/heads/master | /setup.py | from setuptools import setup, find_packages
setup(
name='gruselius',
version='0.1',
author='Joel G',
author_email='joel.gruselius@scilifelab.se',
url='',
packages=find_packages(),
scripts=['scripts/getting_data.py','scripts/check_repo.py'],
license='GPLv3',
long_description=open('README.md').read(),
install_requires = ['untangle'],
)
| {"/scripts/check_repo.py": ["/gruselius/session3.py"], "/scripts/getting_data.py": ["/gruselius/session2.py"]} |
74,102 | jgruselius/gruselius | refs/heads/master | /gruselius/session3.py |
import os
class CourseRepo:
def __init__(self, name):
self.lastname = name
self.updateRequired()
def updateRequired(self):
self.required = [".git", "setup.py", "README.md",
"scripts/getting_data.py", "scripts/check_repo.py",
self.lastname+"/__init__.py", self.lastname+"/session3.py"]
@property
def surename(self):
return self.lastname
@surename.setter
def surename(self, name):
self.lastname = name
self.updateRequired()
def check(self):
status = [os.path.exists(file) for file in self.required]
return all(status)
class TemporarilyChangeDir:
def __init__(self, path):
self.originalPath = os.getcwd()
self.tempPath = path
def __enter__(self):
os.chdir(self.tempPath)
def __exit__(self, type, value, traceback):
os.chdir(self.originalPath)
| {"/scripts/check_repo.py": ["/gruselius/session3.py"], "/scripts/getting_data.py": ["/gruselius/session2.py"]} |
74,103 | jgruselius/gruselius | refs/heads/master | /scripts/num_factors.py | """Python course session 7 assignment"""
import argparse
import time
import multiprocessing
from IPython.parallel import Client
RANGE = (2,500000)
"""
Build a collection of all unique factors:
Method 1, building a set (8.9 s):
unique_factors = set()
for i in xrange(*RANGE):
unique_factors.update(factorize(i))
Method 2, set from list comprehension (8.7 s):
unique_factors = set([factor for i in xrange(*RANGE) for factor in factorize(i)])
Method 3, set from map (9.33 s):
unique_factors = set([factor for factors in map(factorize, xrange(*RANGE)) for factor in factors])
return len(unique_factors)
"""
def factorize(n):
if n < 2:
return []
factors = []
p = 2
while True:
if n == 1:
return factors
r = n % p
if r == 0:
factors.append(p)
n = n / p
elif p * p >= n:
factors.append(n)
return factors
elif p > 2:
p += 2
else:
p += 1
def number_of_unique_factors(n):
return len(set(factorize(n)))
def count_unique(iterable):
counts = {}
for n in iterable:
if n in counts:
counts[n] += 1
else:
counts[n] = 1
return counts
def function1():
"""Sequential non-parallel function"""
return [number_of_unique_factors(i) for i in xrange(*RANGE)]
def function2():
"""Parallelized using multiprocessing"""
pool = multiprocessing.Pool()
return pool.map(number_of_unique_factors, xrange(*RANGE))
def function3():
"""Parallelized using iPython"""
dview = Client()[:]
#ifunc = dview.parallel(block=True)(lambda iter: [len(set(factorize(i))) for i in iter])
@dview.parallel(block=True)
def ifunc(it):
return [len(set(factorize(i))) for i in it]
return ifunc(xrange(*RANGE))
def main(arg):
modes = {"s": function1, "m": function2, "i": function3}
if not arg in modes:
raise NameError
else:
t0 = time.time()
print(count_unique(modes[arg]()))
print("Timer: {0} s".format(time.time()-t0))
if __name__ == "__main__":
p = argparse.ArgumentParser("Factorize integers from {0} to {1}".format(*RANGE))
p.add_argument("mode", help="The mode to run in: s: sequential, " +
"m: parallel with multiprocessing, i: parallel with iPython",
choices=("s","m","i"))
args = p.parse_args()
main(args.mode)
| {"/scripts/check_repo.py": ["/gruselius/session3.py"], "/scripts/getting_data.py": ["/gruselius/session2.py"]} |
74,104 | jgruselius/gruselius | refs/heads/master | /scripts/check_repo.py |
import argparse
import os
from gruselius.session3 import CourseRepo, TemporarilyChangeDir
# Uncomment when running line_profiler or memory_profiler:
#@profile
def main(path):
if not os.path.exists(path):
print("The path '{0}' does not exist".format(path))
else:
path = os.path.abspath(path)
with TemporarilyChangeDir(path):
cr = CourseRepo(os.path.basename(path))
if cr.check():
print("PASS")
else:
print("FAIL")
if __name__ == "__main__":
# To work with profilers the last argument is used as path
p = argparse.ArgumentParser(description="Checks if the specified path" +
"contains the required files")
p.add_argument("path", help="The path to check", nargs="+")
args = p.parse_args()
main(args.path[-1])
| {"/scripts/check_repo.py": ["/gruselius/session3.py"], "/scripts/getting_data.py": ["/gruselius/session2.py"]} |
74,105 | jgruselius/gruselius | refs/heads/master | /scripts/getting_data.py |
import sys
from gruselius.session2 import getFractionOfOutagesBy
def main(args):
xmlUrl = "http://www.grandcentral.org/developers/data/nyct/nyct_ene.xml"
reason = "REPAIR"
fraction = getFractionOfOutagesBy(xmlUrl, reason)
print("Fraction of outages with reason {0}: {1}".format(reason, fraction))
if __name__ == "__main__":
main(sys.argv[1:])
| {"/scripts/check_repo.py": ["/gruselius/session3.py"], "/scripts/getting_data.py": ["/gruselius/session2.py"]} |
74,107 | MarcosPST/implementacao_a_estrela | refs/heads/main | /Movimenta.py | def Movimenta(lista_fn):
"""
Função que recebe a lista de esforço, faz o movimento para o melhor nó e atualiza self.rota
Input:
- lista de f_n do nó atual
- Lista de nós da borda atual
Output: LatLong do próximo movimento
"""
return proximo_movimento
if __name__ == '__main__': | {"/main.py": ["/IniciaMapa.py", "/Inicio.py", "/TesteObjetivo.py", "/ExpandeNo.py", "/CalculoEsforco.py", "/Movimenta.py"]} |
74,108 | MarcosPST/implementacao_a_estrela | refs/heads/main | /main.py | from IniciaMapa import IniciaMapa
from Inicio import Inicio
from TesteObjetivo import TesteObjetivo
from ExpandeNo import ExpandeNo
from CalculoEsforco import CalculoEsforco
from Movimenta import Movimenta
from PrintaEstados import PrintaEstados
rota=[] # Lista onde serão salvos os passos
nos_filhos=[] # Lista com todos os nós a serem explorados. Em outras palavras: borda.
tabuleiro=[] # Tabuleiro
DIMENSOES=[30,30] # Lista com as dimensões do tabuleiro
loc_inicio=[] # Ponto de partida
loc_fim=[] # Objetivo final
tabuleiro = IniciaMapa(dimensoes=DIMENSOES)
loc_inicio, loc_fim = Inicio()
rota.append(loc_inicio)
while(TesteObjetivo(rota[-1], loc_fim)):
lista_filhos = ExpandeNo(rota[-1])
nos_filhos = nos_filhos + lista_filhos
lista_fn = CalculoEsforco(lista_filhos, loc_fim)
proximo_movimento = Movimenta(lista_fn, lista_filhos)
rota.append(proximo_movimento)
PrintaEstados() | {"/main.py": ["/IniciaMapa.py", "/Inicio.py", "/TesteObjetivo.py", "/ExpandeNo.py", "/CalculoEsforco.py", "/Movimenta.py"]} |
74,109 | MarcosPST/implementacao_a_estrela | refs/heads/main | /ExpandeNo.py | def ExpandeNo(posicao_atual):
"""
Função que lista os possíveis próximos movimentos (em outras palavras, olha ao redor e demarca a borda atual)
e dá append em self.nos_filhos
Entrada: posicao atual
Saída: lista de nós filhos para o nó atual
"""
return lista_filhos
if __name__ == '__main__': | {"/main.py": ["/IniciaMapa.py", "/Inicio.py", "/TesteObjetivo.py", "/ExpandeNo.py", "/CalculoEsforco.py", "/Movimenta.py"]} |
74,110 | MarcosPST/implementacao_a_estrela | refs/heads/main | /TesteObjetivo.py | def TesteObjetivo(ponto_atual, destino):
"""
Função que recebe o ponto atual e o ponto objetivo confere se é o objetivo
Inputs:
- LatLong do ponto atual
- LatLong do objetivo
Output: booleano TRUE caso seja o ponto final e FALSE caso não
"""
return e_destino
if __name__ == '__main__': | {"/main.py": ["/IniciaMapa.py", "/Inicio.py", "/TesteObjetivo.py", "/ExpandeNo.py", "/CalculoEsforco.py", "/Movimenta.py"]} |
74,111 | MarcosPST/implementacao_a_estrela | refs/heads/main | /Inicio.py | def Inicio():
"""
Função que printa instruções do código e recebe o ponto de partida e o ponto final
Inputs: n/a
Outputs:
- LatLong início (lista)
- LatLong fim (lista)
"""
return loc_inicio, loc_fim
if __name__ == '__main__': | {"/main.py": ["/IniciaMapa.py", "/Inicio.py", "/TesteObjetivo.py", "/ExpandeNo.py", "/CalculoEsforco.py", "/Movimenta.py"]} |
74,112 | MarcosPST/implementacao_a_estrela | refs/heads/main | /CalculoEsforco.py | def CalculoEsforco(posicao_atual, loc_fim):
"""
Pega a posicao atual em self.rota[-1] e calcula a heuristica para a borda atual em self.nos_filhos[-1]
Entrada:
- borda atual
- Localização do destino
Saída: lista de f(n), que combina a distancia euclidiana até o objetivo e a variação de altura até o próximo nó
"""
return lista_fn
if __name__ == '__main__': | {"/main.py": ["/IniciaMapa.py", "/Inicio.py", "/TesteObjetivo.py", "/ExpandeNo.py", "/CalculoEsforco.py", "/Movimenta.py"]} |
74,113 | MarcosPST/implementacao_a_estrela | refs/heads/main | /IniciaMapa.py | def IniciaMapa(dimensoes=[30,30]):
"""
Carrega randomicamente um tabuleiro com valores aleatórios (por padrão, [30,30])
Entrada:
- Dimensões desejadas para o tabuleiro (lista)
Saída:
- Matriz x por y com valores aleatórios
"""
return tabuleiro
if __name__ == '__main__':
| {"/main.py": ["/IniciaMapa.py", "/Inicio.py", "/TesteObjetivo.py", "/ExpandeNo.py", "/CalculoEsforco.py", "/Movimenta.py"]} |
74,171 | lwanger/onshapepy | refs/heads/master | /python/setup.py | #!/usr/bin/env python
try:
from setuptools import setup, find_packages
except ImportError:
from distutils.core import setup, find_packages
config = {
'name': 'onshapepy',
'version': '0.0.1',
'description': 'Sample package to demonstrate using Onshape API keys',
'long_description': open('README.md').read(),
'author': 'Len Wanger',
'author_email': 'lwanger@impossible-objects.com',
'url': 'https://github.com/lwanger/onshapepy',
'license': open('LICENSE').read(),
#'packages': [ 'onshapepy' ],
'packages': find_packages(),
'classifiers': [
'Programming Language :: Python',
'Operating System :: MacOS :: MacOS X',
'Operating System :: POSIX :: Linux',
'Intended Audience :: Developers',
'Topic :: Software Development :: Libraries :: Python Modules'
]
}
setup(**config)
| {"/python/onshapepy/__init__.py": ["/python/onshapepy/ext_client.py", "/python/onshapepy/utils.py"]} |
74,172 | lwanger/onshapepy | refs/heads/master | /python/part_number_mismatch_fix_util.py | """
part number mismatch fix utility
Uses the OnshapePy api to check for parts with mismatched part number and name (i.e. check that they weren't updated)
I have seen a number of errors where the engineer updates the part number in only one place. Thus utility checks for
that.
for more information about the API see:
https://dev-portal.onshape.com/
also useful to use the OnShape api-explorer app in OnShape
this code uses onshapepy to do authentication:
https://github.com/lwanger/onshapepy
Text-based progress bars shown if tqdm is installed
Len Wanger
Copyright Impossible Objects, 2019
"""
import datetime
import json
import re
import sys
import tkinter as tk
from onshapepy.ext_client import ClientExtended
from onshapepy.utils import parse_url
import cooked_input as ci
# If TQDM is installed then import it to display progress bars
try:
from tqdm import tqdm
tqdm_installed = True
except (ImportError):
tqdm_installed = False
from part_number_fix_util import DEFAULT_PN_RE, get_bom, get_url_and_pn_re, rewrite_part_numbers
from part_number_fix_util import show_pre_table, rewrite_parts_and_show_post_table
# DID, WVM and EID for Part numbering test example model
# DEFAULT_URL="https://cad.onshape.com/documents/d31dbb77700b695251588ff2/w/2c28968f83a53f9631d066fa/e/24f03732ef009163ad541a90"
# DID, WVM and EID for Part numbering test example model (with no part studio)
DEFAULT_URL="https://cad.onshape.com/documents/380c689c8f030496317ad561/w/00debd62a8452d0523ac7d03/e/0545c3d2e4c8885e9ca603f6"
# 698 re-write test
# DEFAULT_URL="https://cad.onshape.com/documents/fe9493f7f250db296dc27535/w/a224fcfe4bc446366ed2d270/e/115ef5787ce2f4aa63465d9d"
# 698 (production)
# DEFAULT_URL="https://cad.onshape.com/documents/3d51153e276619e952362208/w/542e0a82b6fb6c53aa2d5bb3/e/c541ad347688e4da725f3c4c"
HELP_STR = """
OnShape Part Number mismatch part number fixing utility.
This utility checks for parts where the part number and part name look like valid part numbers but don't match.
To get the DID, WVM and EID, go to the model in Onshape and look at the URL. It should look something like:
https://cad.onshape.com/documents/d31dbb77700b695251588ff2/w/2c28968f83a53f9631d066fa/e/24f03732ef009163ad541a90
The string after 'documents' is the DID (e.g. d31dbb77700b695251588ff2)
The string after 'w' is the WVM (e.g. 2c28968f83a53f9631d066fa)
The string after 'e' is the EID (e.g. 24f03732ef009163ad541a90)
"""
def should_set_part_number(part_pn: str, part_name: str, part_re: str) -> bool:
if part_pn is not None and part_name is not None and part_pn != part_name \
and re.search(part_re, part_pn) and re.search(part_re, part_name):
return True
else:
return False
if __name__ == '__main__':
filtered_parts = []
linked_docs = None
stacks = {'cad': 'https://cad.onshape.com'}
c = ClientExtended(stack=stacks['cad'], logging=False)
print(HELP_STR)
did, wvm, eid, pn_re = get_url_and_pn_re(default=DEFAULT_URL, default_re=DEFAULT_PN_RE, use_gui=True)
bom_json, time_delta = get_bom(c, did, wvm, eid, pn_re)
###
filtered_parts = []
for part in bom_json['bomTable']['items']:
if should_set_part_number(part['partNumber'], part['name'], pn_re):
filtered_parts.append(part)
if len(filtered_parts) == 0:
print(f'\n\nNo parts matching the regular expression with mismatch part numbers found (re={pn_re}).\n\n')
sys.exit(0)
print(f'Onshape call time = {str(time_delta)} seconds')
fields = ['name', 'partNumber', 'revision', 'description', 'partId', 'elementId']
show_pre_table(fields)
# For now only show mismatched parts (don't fix) -- can uncomment to change that
# rewrite_parts_and_show_post_table(fields)
| {"/python/onshapepy/__init__.py": ["/python/onshapepy/ext_client.py", "/python/onshapepy/utils.py"]} |
74,173 | lwanger/onshapepy | refs/heads/master | /python/api_doc_util.py | """
Onshape API Documentation utility
Uses the OnshapePy api to create documentation for the Onshape api
Returns a list of endpoints, each a dictionary with:
for more information about the API see:
https://dev-portal.onshape.com/
also useful to use the OnShape api-explorer app in OnShape
this code uses onshapepy to do authentication:
https://github.com/lwanger/onshapepy
TODO:
- Export as PDF from ReportLab
- use text-align:left and vertical align:top in style tag..., not align="left"
- Add search bar to docs...
- Add toggle to toc to show deprecated
Len Wanger
Copyright Impossible Objects, 2018
"""
import datetime
import json
import os
from pathlib import Path
from onshapepy.ext_client import ClientExtended
from onshapepy.utils import convert_response
import cooked_input as ci
ONSHAPEPY_URL = 'https://github.com/lwanger/onshapepy'
TOC_FILENAME = '_toc.html'
CACHED_ENDPOINT_FILE = 'endpoints_cache.json'
FETCH_BY_DEFAULT = 'no'
TITLE_BLOCK= """
<!DOCTYPE html>
<html lang="en">
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css">
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.3/umd/popper.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.1.3/js/bootstrap.min.js"></script>
<script> function loadUrl(url) {{document.getElementById("content-frame").src = url;}}</script>
<head>
<style>
#p2 {{
margin-left: 5%;
}}
#p3 {{
margin-left: 10%;
}}
#t2 {{
margin-left: 5%;
}}
#t3 {{
margin-left: 10%;
}}
.anyClass {{
height:600px;
overflow-y: scroll;
}}
</style>
<title>{title}</title>
</head>
<body>
"""
END_BLOCK="""
</body>
</html>
"""
def write_html_table(f, row_values, border=1, width=None, css_id=None):
"""
write html for a table
:param f: file to write to
:param row_values: list of tuples, each tuple is the values for a row. each cell value is the html for the
cell (incl. <td> tags)
:param border: an integer for the border size
:param width: an integer of the percentage width of the page for the table
:return: None
"""
f.write('<p>')
args = ''
if css_id is not None:
args += f', id="{css_id}"'
if width is not None:
args += f', width="{width}"'
f.write(f'<table border="{border}"{args}>')
for row in row_values:
f.write('<tr>\n')
for cell in row:
f.write(cell + '\n')
f.write('</tr>\n')
f.write('</table></p>\n')
def wrap_in_paragraph(s, css_id=None):
# return the string (s) wrapped in html tags to make it a paragraph
args = ''
if css_id is not None:
args += f'id="{css_id}"'
return f'<p {args}>\n{s}\n</p>\n'
def wrap_in_bold(s):
# return the string (s) wrapped in html tags to make it bold
return f'<b>{s}</b>'
def wrap_in_td(s, align="left"):
# return the string (s) wrapped in html tags for a table data item
return f'<td align="{align}">{s}</td>'
def wrap_in_th(s, align="left"):
# return the string (s) wrapped in html tags for a table data item
return f'<th align="{align}">{s}</th>'
def wrap_in_aref(url, text, target="_top"):
return f'<a href="{url}" target="{target}">{text}</a>'
def bootstrap_radio_button(f, text, active=''):
f.write(f'<label class="btn btn-secondary {active}>\n')
f.write(f'<input type="radio" name="options" id="{text}" autocomplete="off" checked>{text}\n')
f.write('</label>\n')
def bootstrap_button(f, text, url=None, active=''):
f.write('<label class="btn btn btn-sm">\n')
f.write(f'<button target="content-frame" class="btn btn {active}" role="button" onclick="loadUrl(\'{url}\')">{text}</button>\n')
f.write('</label>\n')
def make_html_table_rows(f, vals, fields):
rows = []
rows.append([wrap_in_th(s.capitalize()) for s in fields])
for row in vals:
response_row_vals = [row[v] if v in row else '--' for v in fields]
rows.append([wrap_in_td(s) for s in response_row_vals])
return rows
def is_deprecated(ri):
if 'permission' in ri and 'error' in ri and 'fields' in ri['error']:
for p in ri['permission']:
if p['name'].endswith('deprecated'):
replaced_by = None
for e in ri['error']['fields']['ReplacedBy']:
if e['group'] == 'ReplacedBy':
replaced_by = e['field']
break
return True, replaced_by
return False, None
def export_individual_endpoint_as_html(f, ri):
"""
Export an individual end point as an html page
:param f: file pointer to write the html to
:param ri: the endpoint item
:return: None
"""
deprecated, replaced_by = is_deprecated(ri)
permissions = ', '.join([i['name'] for i in ri['permission']])
title_block = TITLE_BLOCK.format(**ri)
f.write(title_block)
# write top-level infomation
vals = 'name title description url type permission version'.split()
rows = []
if deprecated:
rows.append((wrap_in_bold('deprecated - replaced by:'), replaced_by))
rows.append((wrap_in_td(''), wrap_in_td(''))) # blank row...
for val in vals:
l_cell_val = wrap_in_th( wrap_in_bold(f'{val}:') )
if val == 'permission':
r_cell_val = wrap_in_td(permissions)
else:
r_cell_val = wrap_in_td(f'{ri[val]}')
rows.append((l_cell_val, r_cell_val))
write_html_table(f, rows, border=0, width="75%")
# write response
if 'success' in ri:
f.write(wrap_in_paragraph(wrap_in_bold('Success Entries:'), css_id="p2"))
for field in ri['success']['fields'].items():
f.write(wrap_in_paragraph(wrap_in_bold(field[0]+':'), css_id="p3"))
fields = 'field type optional description'.split()
rows = make_html_table_rows(f, field[1], fields)
write_html_table(f, rows, border=1, width="75%", css_id="t3")
else:
f.write(wrap_in_paragraph('No response block'))
# write header
if 'header' in ri:
vals = ri['header']['fields']['Header']
fields = 'field type optional defaultValue description'.split()
f.write(wrap_in_paragraph(wrap_in_bold('Header:'), css_id="p2"))
rows = make_html_table_rows(f, vals, fields)
write_html_table(f, rows, border=1, width="75%", css_id="t2")
else:
f.write(wrap_in_paragraph('No header block'))
# write parameter block
if 'parameter' in ri:
f.write(wrap_in_paragraph(wrap_in_bold('Parameter:'), css_id="p2"))
if 'Body' in ri['parameter']['fields']:
vals = ri['parameter']['fields']['Body']
fields = 'field type optional description'.split()
title = 'Body:'
f.write(wrap_in_paragraph(wrap_in_bold(title), css_id="p3"))
rows = make_html_table_rows(f, vals, fields)
write_html_table(f, rows, border=1, width="75%", css_id="t3")
if 'PathParam' in ri['parameter']['fields']:
vals = ri['parameter']['fields']['PathParam']
fields = 'field type optional description'.split()
title = 'PathParam:'
f.write(wrap_in_paragraph(wrap_in_bold(title), css_id="p3"))
rows = make_html_table_rows(f, vals, fields)
write_html_table(f, rows, border=1, width="75%", css_id="t3")
if 'QueryParam' in ri['parameter']['fields']:
vals = ri['parameter']['fields']['QueryParam']
fields = 'field type optional defaultValue description'.split()
title = 'QueryParam:'
f.write(wrap_in_paragraph(wrap_in_bold(title), css_id="p3"))
rows = make_html_table_rows(f, vals, fields)
write_html_table(f, rows, border=1, width="75%", css_id="t3")
if 'error' in ri:
f.write(wrap_in_paragraph(wrap_in_bold('Error:'), css_id="p2"))
errors = ri['error']['fields']
fields = 'field optional description'.split()
for error in errors.items():
title = error[0]
f.write(wrap_in_paragraph(wrap_in_bold(title), css_id="p3"))
rows = make_html_table_rows(f, error[1], fields)
write_html_table(f, rows, border=1, width="75%", css_id="t3")
end_block = END_BLOCK.format(ri=ri)
f.write(end_block)
def show_individual_endpoint_action(row, action_dict):
"""
row.item_data['item'] is list of: type, url, title, name, description, group, version, permission (list), success (dict),
groupTitle, header (dict), parameter (dict)
"""
ri = row.item_data["item"]
deprecated, replaced_by = is_deprecated(ri)
print(f'\nname: {ri["name"]}\ttitle: {ri["title"]}')
print(f'description: {ri["description"]}')
print(f'url: {ri["url"]}')
print(f'type: {ri["type"]}\tversion: {ri["version"]}')
if deprecated:
replaced_by_str = 'True' + ' - replaced by: ' + replaced_by
print(f'deprecated: {replaced_by_str}')
permissions = ', '.join([i['name'] for i in ri['permission']])
print(f'permissions: {permissions}')
if 'success' in ri:
# Response is a dict with multiple items. Each looks like Response
print('\nSuccess Entries:\n')
for field in ri['success']['fields'].items():
fields = 'field type optional description'.split()
field_names = [f.capitalize() for f in fields]
tbl = ci.create_table(items=field[1], fields=fields, field_names=field_names, gen_tags=False, add_exit=False, title=f'{field[0]}:')
tbl.show_table()
if 'header' in ri:
header = ri['header']['fields']['Header']
fields = 'field type optional defaultValue description'.split()
field_names = [f.capitalize() for f in fields]
tbl = ci.create_table(items=header, fields=fields, field_names=field_names, gen_tags=False, add_exit=False,
title='\nHeader:')
tbl.show_table()
if 'parameter' in ri:
# add body - list of: type optional field description
if 'Body' in ri['parameter']['fields']:
body = ri['parameter']['fields']['Body']
fields = 'field type optional description'.split()
field_names = [f.capitalize() for f in fields]
tbl = ci.create_table(items=body, fields=fields, field_names=field_names, gen_tags=False, add_exit=False, title='PathParam:')
tbl.show_table()
if 'PathParam' in ri['parameter']['fields']:
path_param = ri['parameter']['fields']['PathParam']
fields = 'field type optional description'.split()
field_names = [f.capitalize() for f in fields]
tbl = ci.create_table(items=path_param, fields=fields, field_names=field_names, gen_tags=False, add_exit=False,
title='PathParam:')
tbl.show_table()
if 'QueryParam' in ri['parameter']['fields']:
query_param = ri['parameter']['fields']['QueryParam']
fields = 'field type optional defaultValue description'.split()
field_names = [f.capitalize() for f in fields]
tbl = ci.create_table(items=query_param, fields=fields, field_names=field_names, gen_tags=False, add_exit=False,
title='QueryParam:')
tbl.show_table()
if 'error' in ri:
# 'error' - dict with 'fields' each with group, optional, field, desciption
errors = ri['error']['fields']
for error in errors.items():
fields = 'field optional description'.split()
field_names = [f.capitalize() for f in fields]
tbl = ci.create_table(items=error[1], fields=fields, field_names=field_names, gen_tags=False, add_exit=False, title=error[0])
tbl.show_table()
print('\n\n\n')
def show_group_endpoints_action(row, action_dict):
print(f'Received row for endpoint: {row.item_data["item"]["groupTitle"]}')
style = ci.TableStyle(rows_per_page=99)
items = row.item_data['item']['endpoints']
fields = 'title name type url'.split()
field_names = [f.capitalize() for f in fields]
tbl = ci.create_table(items=items, fields=fields, field_names=field_names, style=style, gen_tags=True,
default_action=show_individual_endpoint_action,
add_item_to_item_data=True, add_exit=ci.TABLE_ADD_RETURN, prompt='Chooose an endpoint')
tbl.run()
def get_endpoint_groups_action(row, action_dict):
# list endpoints as a table
fields = 'group groupTitle'.split()
field_names = [f.capitalize() for f in fields]
tbl = ci.create_table(items=action_dict['endpoints'], fields=fields, field_names=field_names, style=action_dict['style'],
gen_tags=True, default_action=show_group_endpoints_action, add_item_to_item_data=True, add_exit=True,
prompt='Chooose an endpoint')
tbl.run()
def create_toc(f, endpoints, created):
title_block = TITLE_BLOCK.format(title='Onshape REST API Documentation', name='toc')
f.write(title_block)
# write jumbotron div
f.write('<div class ="jumbotron text-center">\n')
f.write('<h1> Onshape REST API Documentation</h1>\n')
f.write(f'<p> Created on {str(created)} using {wrap_in_aref(ONSHAPEPY_URL, "onshapepy")} </p>\n')
f.write('</div>\n')
# write toc button group
f.write('<div id="top-frame" class="container-fluid" style="margin-top:30px">\n')
f.write('<div class="row">\n')
f.write('<div class="col-sm-4 anyClass">\n')
f.write('<h2>Table of Contents</h2>\n')
f.write('<div class="btn-group-vertical btn-group-toggle" id="toc" name="toc" data-toggle="buttons">\n')
active = 'active'
for group in endpoints:
bootstrap_radio_button(f, group["groupTitle"], active='disabled')
for endpt in group['endpoints']:
deprecated, replaced_by = is_deprecated(endpt)
row_str = ' ' + endpt["name"]
if deprecated:
row_str += f' ({wrap_in_bold("deprecated")})'
url = endpt["name"] + '.html'
bootstrap_button(f, row_str, url=url, active=active)
if len(active) > 0:
first_url = url
else:
active = ''
# end toc button group and add iframe
f.write('</div>\n</div>\n')
f.write('<div class="col-sm-8">\n')
f.write(f'<iframe id="content-frame" name="content-frame" data-target="toc" src="{first_url}" width="100%" style="height:100%; border:none"></iframe>\n')
f.write('</div>\n')
f.write('</div> <! row -->\n')
f.write('</div> <! top-frame -->\n')
# end page
end_block = END_BLOCK.format()
f.write(end_block)
def create_html_action(row, action_dict):
endpoints = action_dict['endpoints']
created = action_dict['created']
export_dir = Path.home().joinpath('export')
dir_validator = ci.SimpleValidator(os.path.isdir)
try:
export_dir = ci.get_string(prompt='directory for html export: ', validators=dir_validator, default=str(export_dir))
except (ci.ValidationError):
if ci.get_yes_no(prompt='Should I create the directory', default='no') == 'yes':
os.mkdir(export_dir)
else:
print('Unable to export html')
return
toc_filename = Path(export_dir, TOC_FILENAME)
with open(toc_filename, mode='w', encoding='utf-8') as f:
create_toc(f, endpoints, created)
for group in endpoints:
for endpt in group['endpoints']:
filename = Path(export_dir, endpt["name"] + '.html')
with open(filename, mode='w', encoding='utf-8') as f:
export_individual_endpoint_as_html(f, endpt)
print('\n\n')
if __name__ == '__main__':
if ci.get_yes_no(prompt='Fetch API endpoint information from Onshape (vs. use cached version)', default='no') == 'yes':
stacks = {'cad': 'https://cad.onshape.com'}
c = ClientExtended(stack=stacks['cad'], logging=False)
print('Getting api endpoints from Onshape...\n')
response = c.get_endpoints()
endpoints = convert_response(response)
created = datetime.datetime.now()
if ci.get_yes_no(prompt='Save API endpoint information to file', default=FETCH_BY_DEFAULT) == 'yes':
cache_content = (created.timestamp(), endpoints)
with open(CACHED_ENDPOINT_FILE, 'w') as f:
f.write( json.dumps(cache_content) )
else:
print('Using saved api endpoints...\n')
with open(CACHED_ENDPOINT_FILE, 'r') as f:
content_str = f.read()
cache_content = json.loads(content_str)
created = datetime.date.fromtimestamp(cache_content[0])
endpoints = cache_content[1]
style = ci.TableStyle(rows_per_page=99, show_cols=False, show_border=False)
item_data = {'endpoints': endpoints, 'style': style }
action_dict = {'endpoints': endpoints, 'created': created, 'style': style }
main_menu_items = [
ci.TableItem(col_values=["Get info for an individual endpoint"], action=get_endpoint_groups_action, item_data=item_data),
ci.TableItem(col_values=["Export api documentation as html"], action=create_html_action, item_data=item_data),
]
main_menu = ci.Table(rows=main_menu_items, prompt='Choose a menu item', style=style, add_exit=True, action_dict=action_dict)
main_menu.run()
| {"/python/onshapepy/__init__.py": ["/python/onshapepy/ext_client.py", "/python/onshapepy/utils.py"]} |
74,174 | lwanger/onshapepy | refs/heads/master | /python/next_page_test.py | """
Test getting next page from OnShape API
Len Wanger
Copyright Impossible Objects, 2018
"""
import datetime
from onshapepy.ext_client import ClientExtended, Pager
IO_COMPANY_ID = '59f3676cac7f7c1075b79b71'
if __name__ == '__main__':
stacks = {'cad': 'https://cad.onshape.com'}
c = ClientExtended(stack=stacks['cad'], logging=False)
doc_query = {'offset': 0, 'q': 'IO', 'filter': 7, 'owner': IO_COMPANY_ID}
docs = c.list_documents(query=doc_query)
print('fetching documents ', end='', flush=True)
start_time = datetime.datetime.now()
fetch_time = start_time
for page in Pager(c, docs):
href = page['href']
offset_idx = href.find("offset")
offset_end_idx = offset_idx + href[offset_idx:].find('&')
elapsed_time = (datetime.datetime.now() - fetch_time).microseconds / 1_000_000
print(f'fetch_time{elapsed_time}\t{href[offset_idx: offset_end_idx]}')
fetch_time = datetime.datetime.now()
end_time = datetime.datetime.now()
print(f'Total time = {end_time-start_time}')
| {"/python/onshapepy/__init__.py": ["/python/onshapepy/ext_client.py", "/python/onshapepy/utils.py"]} |
74,175 | lwanger/onshapepy | refs/heads/master | /python/part_number_fix_util.py | """
part number fix utility
Uses the OnshapePy api to renumber parts imported from Solidworks.
OnShape does not set part numbers when importing files from Solidworks. Instead it sets the part
name to the file name. This utility looks for parts with no part number set and whose part name
matches a regular expression for a part number, and sets those parts part number to the part
name.
for more information about the API see:
https://dev-portal.onshape.com/
also useful to use the OnShape api-explorer app in OnShape
this code uses onshapepy to do authentication:
https://github.com/lwanger/onshapepy
Text-based progress bars shown if tqdm is installed
Len Wanger
Copyright Impossible Objects, 2018
"""
import datetime
import json
import re
import sys
import tkinter as tk
from onshapepy.ext_client import ClientExtended
from onshapepy.utils import parse_url
import cooked_input as ci
# If TQDM is installed then import it to display progress bars
try:
from tqdm import tqdm
tqdm_installed = True
except (ImportError):
tqdm_installed = False
# DID, WVM and EID for Part numbering test example model
# DEFAULT_URL="https://cad.onshape.com/documents/d31dbb77700b695251588ff2/w/2c28968f83a53f9631d066fa/e/24f03732ef009163ad541a90"
# DID, WVM and EID for Part numbering test example model (with no part studio)
# DEFAULT_URL="https://cad.onshape.com/documents/380c689c8f030496317ad561/w/00debd62a8452d0523ac7d03/e/0545c3d2e4c8885e9ca603f6"
# 698 re-write test
# DEFAULT_URL="https://cad.onshape.com/documents/fe9493f7f250db296dc27535/w/a224fcfe4bc446366ed2d270/e/115ef5787ce2f4aa63465d9d"
# 698 (production)
DEFAULT_URL="https://cad.onshape.com/documents/3d51153e276619e952362208/w/542e0a82b6fb6c53aa2d5bb3/e/c541ad347688e4da725f3c4c"
# Bike test
# DEFAULT_URL="https://cad.onshape.com/documents/25f52a92f11ef4c89679f1a6/w/84da6d8f0be0e8ee96911272/e/e3932e91f811a67f399235c5"
# DEFAULT_PN_RE = "^LW-\d{3}$" # LW-123 style part numbers
# Regular expression for default part numbering scheme (IOxxxx, where x is a digit)
DEFAULT_PN_RE = "^IO\d{4}$" # IO style part numbers
HELP_STR = """
OnShape Part Number fixing utility.
When importing from SolidWorks the part number for parts is not set. By default OnShape will use the file
name as the name of the part. This utility will set the part number to be the part name (assuming there is
no part number and the part name matches the part naming scheme for part numbers.)
To get the DID, WVM and EID, go to the model in Onshape and look at the URL. It should look something like:
https://cad.onshape.com/documents/d31dbb77700b695251588ff2/w/2c28968f83a53f9631d066fa/e/24f03732ef009163ad541a90
The string after 'documents' is the DID (e.g. d31dbb77700b695251588ff2)
The string after 'w' is the WVM (e.g. 2c28968f83a53f9631d066fa)
The string after 'e' is the EID (e.g. 24f03732ef009163ad541a90)
"""
def remove_instance_from_name(part_name):
idx = part_name.find('<')
if idx == -1:
return part_name
else:
return part_name[:idx].strip()
# def should_set_part_number(part_pn, part_name, part_re, top_level_parts) -> bool:
def should_set_part_number(part_pn, part_name, part_re) -> bool:
if False:
just_part_name = remove_instance_from_name(part_name)
if just_part_name not in top_level_parts:
if (part_pn is None or len(part_pn) == 0) and re.search(part_re, part_name):
return True
else:
if (part_pn is None or len(part_pn) == 0) and re.search(part_re, part_name):
return True
return False
# def add_if_top_level_assembly(top_level_parts, part, part_re) -> bool:
# if part['type'] == 'Assembly':
# # name is like: "LRW-003 <2>" for mult. instances, so weed out instance #, cut out "<#>"
# part_name = remove_instance_from_name(part['name'])
#
# if part_name is not None and len(part_name) > 0 and part_name not in top_level_parts and re.search(part_re, part_name):
# top_level_parts[part_name] = part
def set_part_info_from_bom(part_from_bom):
return {
'name': part_from_bom['name'],
'partNumber': part_from_bom['partNumber'],
'revision': part_from_bom['revision'],
'description': part_from_bom['description'],
'partId': part_from_bom['itemSource']['partId'],
'elementId': part_from_bom['itemSource']['elementId']
}
def get_url_and_pn_re(default=DEFAULT_URL, default_re=DEFAULT_PN_RE, use_gui=True):
if not use_gui: # use cooked_input
url = ci.get_string(prompt="What Onshape document URL do want to renumber", default=default)
pn_re = ci.get_string(prompt="Regular expression for part names to set as part number", default=DEFAULT_PN_RE)
did, wvm, eid = parse_url(url, w_required=True)
return did, wvm, eid, pn_re
else: # use tkinter
# TODO -- need to clean up -- add instructions, tables, etc.
window = tk.Tk()
window.title("Onshape Part Re-numbering Utility")
window.geometry('950x150')
url_str_var = tk.StringVar()
url_str_var.set(default)
re_str_var = tk.StringVar()
re_str_var.set(default_re)
lbl = tk.Label(window, text="Onshape model document URL:")
lbl.grid(column=0, row=0)
txt = tk.Entry(window, textvariable=url_str_var, width=120)
txt.grid(column=1, row=0)
lbl = tk.Label(window, text="Part number regular expression:")
lbl.grid(column=0, row=1)
txt = tk.Entry(window, textvariable=re_str_var, width=40)
txt.grid(column=1, row=1)
lbl = tk.Label(window, text="")
lbl.grid(column=0, row=2)
btn = tk.Button(window, text="Submit", command=window.quit)
btn.grid(column=1, row=3)
txt.focus()
window.mainloop()
url = url_str_var.get()
pn_re = re_str_var.get()
window.destroy()
did, wvm, eid = parse_url(url, w_required=True)
return did, wvm, eid, pn_re
def rewrite_part(c, part):
part_id = part['itemSource']['partId']
wvm_type = part['itemSource']['wvmType']
part_wvm = part['itemSource']['wvmId']
part_did = part['itemSource']['documentId']
part_eid = part['itemSource']['elementId']
payload = {'partNumber': part['name']}
result = c.set_part_metadata(part_did, part_wvm, part_eid, part_id, payload, wvm_type)
if not result.ok:
print('Error: Could not set part number for parts={} (result code={}, err={})'.format(part["name"],
result.status_code, result.reason))
return False
return True
# def rewrite_top_level_part(c, part):
# part_wvm = part['itemSource']['wvmId']
# part_did = part['itemSource']['documentId']
# payload = {} # TODO
#
# # {
# # "items": "Object[]",
# # "items.0": "Object",
# # "items.0.href": "String",
# # "items.0.properties": "Object[]",
# # "items.0.properties.0": "Object",
# # "items.0.properties.0.propertyId": "String",
# # "items.0.properties.0.value": "Object"
# # }
#
# result = c.set_metadata(part_did, part_wvm, payload)
#
# if not result.ok:
# print('Error: Could not set part number for parts={} (result code={}, err={})'.format(part["name"],
# result.status_code, result.reason))
# return False
#
# return True
def rewrite_parts(c, did, wvm, parts):
items_list = []
payload = { 'items': items_list}
for part in parts:
part_id = part['itemSource']['partId']
wvm_type = part['itemSource']['wvmType']
part_wvm = part['itemSource']['wvmId']
part_did = part['itemSource']['documentId']
part_eid = part['itemSource']['elementId']
properties = [{"value": part['name'], "propertyId": "57f3fb8efa3416c06701d60f"}]
# needed in href configuration: ?configuration=List_EwLwXQKstmDIZM%3Danother%3Bbool%3Dfalse%3Bsize%3D2+in
href = f'https://cad.onshape.com/api/metadata/d/{part_did}/{wvm_type}/{part_wvm}/e/{part_eid}/p/{part_id}'
part_entry = {"properties": properties, "href": href}
items_list.append(part_entry)
result = c.set_parts_metadata(did, wvm, payload)
if not result.ok:
print('Error: Could not set part number for parts={} (result code={}, err={})'.format(part["name"],
result.status_code, result.reason))
return False
return True
def rewrite_part_numbers(c, did, parts):
"""
Sets the part number to the part name for a list of parts
:param did:
:param parts: list of part studio parts from the assembly bom endpoint
:return: True if rewrote parts successfully
assumes part is from the bom table (i.e. has itemSource)
"""
print(f'Re-writing part numbers for did={did}\n')
no_errors = True
if parts is not None:
if True: # old way
if tqdm_installed is True:
with tqdm(total=len(parts)) as pbar:
for i, part in enumerate(parts):
pbar.set_description(f'Rewriting part {part["name"]}')
result = rewrite_part(c, part)
pbar.update(i)
if result is False:
no_errors = False
else:
for part in parts:
print('Rewriting part number for part {}'.format(part["name"]))
result = rewrite_part(c, part)
if result is False:
no_errors = False
else:
# 9/16/2019 -- this does not work!
result= rewrite_parts(c, did, wvm, parts)
return result
return no_errors
# # This has not been debugged. Not sure how to do the payload
# def rewrite_top_level_part_numbers(c, did, top_level_parts):
# """
# Sets the part number to the top level assemblies
#
# :param did:
# :param top_level_parts: list of top level assemblies
# :return: True if rewrote parts successfully
#
# """
# # print('rewrite_top_level_part_numbers: not implemented yet...')
# # return True
#
# print(f'Re-writing top level part numbers for did={did}\n')
#
# if len(top_level_parts) > 0:
# if tqdm_installed is True:
# with tqdm(total=len(top_level_parts)) as pbar:
# for i, part in enumerate(top_level_parts):
# pbar.set_description(f'Rewriting part {part["name"]}')
# result = rewrite_top_level_part(c, part)
# pbar.update(i)
#
# if result is False:
# return False
# else:
# for part in top_level_parts:
# print('Rewriting part number for part {}'.format(part["name"]))
# result = rewrite_top_level_part(c, part)
#
# if result is False:
# return False
#
# return True
def get_bom(c, did, wvm, eid, pn_re):
print('\nFetching bom/part information from Onshape...')
start_time = datetime.datetime.now()
bom = c.get_assembly_bom(did, wvm, eid, multi_level=True)
if bom.ok is False:
print(f'\n\nError: Could not fetch the BOM (status code={bom.status_code}, reason={bom.reason})\n\n')
sys.exit(1)
bom_json = json.loads(bom.text)
end_time = datetime.datetime.now()
time_delta = end_time - start_time
return bom_json, time_delta
# def get_assembly_definition(c, did, wvm, eid, pn_re):
# print('\nFetching assembly information from Onshape...')
# start_time = datetime.datetime.now()
#
# asm = c.get_assembly_definition(did, wvm, eid, include_mate_connectors=False, include_mate_features=False, include_non_solids=False, link_document_id=None)
#
# if asm.ok is False:
# print(f'\n\nError: Could not fetch the assembly information (status code={asm.status_code}, reason={asm.reason})\n\n')
# sys.exit(1)
#
# asm_json = json.loads(asm.text)
# end_time = datetime.datetime.now()
# time_delta = end_time - start_time
#
# return asm_json, time_delta
def show_pre_table(fields, parts_iterable, top_level: bool):
style = ci.TableStyle(show_border=True, hrules=ci.RULE_NONE, rows_per_page=None)
tbl = ci.create_table(parts_iterable, fields=fields, field_names=fields, gen_tags=None, item_data=None,
add_item_to_item_data=True, title=None, prompt=None, default_choice=None, default_str=None,
default_action='table_item', style=style)
if top_level is True:
print('\nTop level parts identified to set:')
else:
print('\nParts identified to set:')
tbl.show_table()
# def rewrite_parts_and_show_post_table(c, did, wvm, eid, fields, filtered_parts, top_level_parts):
def rewrite_parts_and_show_post_table(c, did, wvm, eid, fields, filtered_parts):
if ci.get_yes_no(prompt='Do you want to re-write the part numbers with the part names', default='no') == 'yes':
rewrite_part_numbers(c, did, filtered_parts)
# rewrite_top_level_part_numbers(c, did, top_level_parts)
# show results
print('\nParts after setting part numbers:')
filtered_part_set = {part['name'] for part in filtered_parts}
bom = c.get_assembly_bom(did, wvm, eid)
bom_json = json.loads(bom.text)
changed_parts = [part for part in bom_json['bomTable']['items'] if part['name'] in filtered_part_set]
# for part in top_level_parts:
# changed_parts.append(part)
for part in changed_parts:
part['partId'] = part['itemSource']['partId']
part['elementId'] = part['itemSource']['elementId']
style = ci.TableStyle(show_border=True, hrules=ci.RULE_NONE, rows_per_page=None)
tbl = ci.create_table(changed_parts, fields=fields, field_names=fields, gen_tags=None, item_data=None,
add_item_to_item_data=True, title=None, prompt=None, default_choice=None,
default_str=None, default_action='table_item', style=style)
tbl.show_table()
sys.exit(0)
else:
print('Exiting without re-writing part numbers\n')
sys.exit(0)
if __name__ == '__main__':
print('WARNING: Does not find parts without part names that are assemblies')
stacks = {'cad': 'https://cad.onshape.com'}
c = ClientExtended(stack=stacks['cad'], logging=False)
print(HELP_STR)
did, wvm, eid, pn_re = get_url_and_pn_re(default=DEFAULT_URL)
filtered_parts = None
linked_docs = None
bom_json, time_delta = get_bom(c, did, wvm, eid, pn_re)
# asm_json, time_delta = get_assembly_definition(c, did, wvm, eid, pn_re)
filtered_parts = []
# top_level_parts = {}
# for part in asm_json['rootAssembly']['instances']:
# add_if_top_level_assembly(top_level_parts, part, pn_re)
for part in bom_json['bomTable']['items']:
# if should_set_part_number(part['partNumber'], part['name'], pn_re, top_level_parts):
if should_set_part_number(part['partNumber'], part['name'], pn_re):
filtered_parts.append(part)
# if len(filtered_parts) == 0 and len(top_level_parts)==0:
if len(filtered_parts) == 0:
print(f'\n\nNo parts matching the regular expression without a part number found (re={pn_re}).\n\n')
sys.exit(0)
print(f'Onshape call time = {str(time_delta)} seconds')
fields = ['name', 'partNumber', 'revision', 'description', 'partId', 'elementId']
show_pre_table(fields, filtered_parts, top_level=False)
# print()
# show_pre_table(fields, top_level_parts, top_level=True)
# rewrite_parts_and_show_post_table(c, did, wvm, eid, fields, filtered_parts, top_level_parts)
rewrite_parts_and_show_post_table(c, did, wvm, eid, fields, filtered_parts)
| {"/python/onshapepy/__init__.py": ["/python/onshapepy/ext_client.py", "/python/onshapepy/utils.py"]} |
74,176 | lwanger/onshapepy | refs/heads/master | /python/onshapepy/__init__.py | '''
apikey
======
Demonstrates usage of API keys for the Onshape REST API
'''
__copyright__ = 'Copyright (c) 2016 Onshape, Inc.'
__license__ = 'All rights reserved.'
__title__ = 'apikey'
__all__ = ['onshape', 'client', 'ext_client', 'utils']
from .ext_client import Client, ClientExtended, Pager
from .utils import parse_url
__version__ = "0.0.1"
| {"/python/onshapepy/__init__.py": ["/python/onshapepy/ext_client.py", "/python/onshapepy/utils.py"]} |
74,177 | lwanger/onshapepy | refs/heads/master | /python/onshapepy/utils.py | '''
utils
=====
Handy functions for API key sample app
'''
import logging
from logging.config import dictConfig
import json
__all__ = [
'log'
]
def log(msg, level=0):
'''
Logs a message to the console, with optional level paramater
Args:
- msg (str): message to send to console
- level (int): log level; 0 for info, 1 for error (default = 0)
'''
red = '\033[91m'
endc = '\033[0m'
# configure the logging module
cfg = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'stdout': {
'format': '[%(levelname)s]: %(asctime)s - %(message)s',
'datefmt': '%x %X'
},
'stderr': {
'format': red + '[%(levelname)s]: %(asctime)s - %(message)s' + endc,
'datefmt': '%x %X'
}
},
'handlers': {
'stdout': {
'class': 'logging.StreamHandler',
'level': 'DEBUG',
'formatter': 'stdout'
},
'stderr': {
'class': 'logging.StreamHandler',
'level': 'ERROR',
'formatter': 'stderr'
}
},
'loggers': {
'info': {
'handlers': ['stdout'],
'level': 'INFO',
'propagate': True
},
'error': {
'handlers': ['stderr'],
'level': 'ERROR',
'propagate': False
}
}
}
dictConfig(cfg)
lg = 'info' if level == 0 else 'error'
lvl = 20 if level == 0 else 40
logger = logging.getLogger(lg)
logger.log(lvl, msg)
def parse_url(url, w_required=False):
"""
parse an Onshape document URL into the components: did, wvm and eid.
:param url: URL to parse
:return: tuple of (did, wvm, eid)
URL looks like: https://cad.onshape.com/documents/d31dbb77700b695251588ff2/w/2c28968f83a53f9631d066fa/e/24f03732ef009163ad541a90
returns (d31dbb77700b695251588ff2, 2c28968f83a53f9631d066fa, 24f03732ef009163ad541a90)
"""
split_list = url.split('/')
did = wvm = eid = None
try:
if split_list[3] == 'documents':
did = split_list[4]
else:
raise RuntimeError("Bad URL -- no documents specified")
if (w_required and split_list[5] == 'w'):
wvm = split_list[6]
elif split_list[5] in { 'v', 'm' }:
wvm = split_list[6]
else:
if w_required is true:
raise RuntimeError("Bad URL -- no w specified")
else:
raise RuntimeError("Bad URL -- no wvm specified")
if split_list[7] == 'e':
eid = split_list[8]
else:
raise RuntimeError("Bad URL -- no eid specified")
except (IndexError):
pass # fail on first index error and keep items set to None from there on
return did, wvm, eid
def convert_response(response):
"""
Convert Onshape api response data to a Python data structure (i.e. json conversion usually to a dictionary)
:param response:
:return:
"""
return json.loads(response.text)
| {"/python/onshapepy/__init__.py": ["/python/onshapepy/ext_client.py", "/python/onshapepy/utils.py"]} |
74,178 | lwanger/onshapepy | refs/heads/master | /python/onshapepy/ext_client.py |
"""
Extended onshape api client
TODO:
- The extended client should be integrated into the client class.
- Currently this is just a raw wrapper around the onshape api. For instance, set_part_metadata requires the
caller to put together the payload dictionary by hand. Similarly get (read) functions return a raw payload. It
would be helpful to add some data structures to make reading and writing payloads friendlier. In general some
abstraction layers above the api would be helpful.
Len Wanger, Impossible Objects 2018
"""
import json
from urllib.parse import urlparse, parse_qs
from .client import Client
class Pager():
"""
Iterator to return pages of data for OnShape calls that use a paging mechanism with next/prev page (Teams,
Companies, GetDocuments, etc.). This allow you to call the function like this:
team_names = []
first_response = c.list_teams()
for response_json in onshape_pager(first_response):
team_names += [item['name'] for item in response_json['items']]
:param first_response: The response from running the query the first time (first page of results)
:return: a json version of the result data for the next page of response data
"""
def __init__(self, c, first_response, offset=0, limit=20):
self.client = c
self. first_response = True
self.response = first_response
self.cur_offset = offset
self.limit = limit
def __iter__(self):
return self
def __next__(self):
response_json = json.loads(self.response.text)
if self.first_response is True:
self.first_response = False
return response_json
next_page = response_json['next']
if next_page is None: # Note: never hitting here... limit offsets back to 20
raise StopIteration
self.cur_offset += 20
self.response = self.client.get_next_page(next_page)
return json.loads(self.response.content)
def get_offset(self):
return self.cur_offset
class ClientExtended(Client):
def __init__(self, stack='https://cad.onshape.com', creds='./creds.json', logging=True):
super(ClientExtended, self).__init__(stack, creds, logging)
# def get_next_page(self, next_page_url):
def get_next_page(self, next_page_url, offset=None, limit=20):
'''
Get next page of results for a query. Some api calls (such as get teams) give a 'next' URL.
Returns:
- requests.Response: Onshape response data
'''
parsed_url = urlparse(next_page_url)
path = parsed_url.path
query = parse_qs(parsed_url.query)
use_query = {k: v[0] for k,v in query.items()}
if offset is not None:
use_query['offset'] = offset
if limit is not None:
use_query['limit'] = limit
return self._api.request('get', path, use_query)
def get_endpoints(self):
'''
Get list of Onshape api endpoints
Returns:
- requests.Response: Onshape response data
'''
return self._api.request('get', '/api/endpoints')
def list_teams(self):
'''
Get list of teams for current user.
Returns:
- requests.Response: Onshape response data
'''
return self._api.request('get', '/api/teams')
def get_element_list(self, did, wvm, element_type=None, eid=None, with_thumbnails=False):
'''
Gets workspaces list for specified document
Args:
- did (str): Document ID
- wvm (str): workspace ID or version id or microversion id
- element_type (str, optional): element type - 'PARTSTUDIO', 'ASSEMBLY'
- eid (str, optional): return only elements with element id
- with_thumbnail (bool, optional): include element thumbnail info
Returns:
- requests.Response: Onshape response data
/ documents / d /: did / [wvm] /:wvm / elements
'''
payload = {}
if element_type:
payload['elementType'] = element_type
if eid:
payload['elementType'] = eid
if with_thumbnails:
payload['elementType'] = with_thumbnails
return self._api.request('get', '/api/documents/d/' + did + '/w/' + wvm + '/elements', payload)
def get_workspaces(self, did, no_read_only=False):
'''
Gets workspaces list for specified document
Args:
- did (str): Document ID
- no_read_only (bool): whether to show read only documents
Returns:
- requests.Response: Onshape response data
https://cad.onshape.com/api/documents/d/0f9c85ccbf253b470b931452/workspaces?noreadonly=false
'''
payload = {
'noreadonly': no_read_only
}
return self._api.request('get', '/api/documents/d/' + did + '/workspaces', payload)
def get_assembly_definition(self, did, wvm, eid, include_mate_connectors=False, include_mate_features=False,
include_non_solids=False, link_document_id=None):
'''
Get information about an Assembly. All coordinates and translation matrix components are in meters.
Args:
- did (str): Document ID
- wvm (str): Workspace ID or version id or microversion id
- eid (str): Element ID
- include_mate_connectors (bool, optional): Whether or not to include mate connectors of assembly and parts when includeMateFeatures is also true (adds a "mateConnectors" array in each part and includes mate connectors in assembly "features" array).
- include_mate_features (bool, optional): Whether or not to include mate features in response (adds a "features" array to response)
- include_non_solids (bool, optional): Whether or not to include non-assembly occurrences/instances that are not parts, such as surfaces and sketches. When omitted or set to false, surfaces and sketches are omitted from the output, as though they are not part of the assembly definition.
- link_document_id (string, optional): Id of document that links to the document being accessed. This may provide additional access rights to the document. Allowed only with version (v) path parameter.
bomColumnIDs not implemented yet
Returns:
- requests.Response: Onshape response data
/ assemblies / d / : did / [wvm] / :wvm / e / :eid
'''
payload = {}
payload['includeMateConnectors'] = include_mate_connectors
payload['includeMateFeatures'] = include_mate_features
payload['includeNonSolids'] = include_non_solids
if link_document_id is not None:
payload['linkDocumentId'] = link_document_id
route = '/api/assemblies/d/' + did + '/w/' + wvm + '/e/' + eid
return self._api.request('get', route, payload)
def get_assembly_bom(self, did, wvm, eid, indented=False, multi_level=False, generate_if_absent=True):
'''
Gets bom assoicated with an assembly
Args:
- did (str): Document ID
- wvm (str): Workspace ID or version id or microversion id
- eid (str): Element ID
- indented (bool, optional): if True, returns an indented BOM
- multi_level (bool, optional): if True, returns a multi-level BOM
- generate_if_absent (bool, optional): if True, creates a BOM if not already one with the assembly
bomColumnIDs not implemented yet
Returns:
- requests.Response: Onshape response data
/ assemblies / d / : did / [wvm] / :wvm / e / :eid / bom
'''
payload = {}
payload['generateIfAbsent'] = generate_if_absent
payload['multiLevel'] = multi_level
if multi_level is True:
# multi-level is ignored if indented is False!
payload['indented'] = True
else:
payload['indented'] = indented
route = '/api/assemblies/d/' + did + '/w/' + wvm + '/e/' + eid + '/bom'
return self._api.request('get', route, payload)
def get_parts_list(self, did, wvm, wvm_type='w'):
'''
Get list of parts in a document
Args:
- did (str): Document ID
- wvm (str): Workspace ID or version id or microversion id
- wvm_type (str): type for wvm ("w", "v", or "m")
Returns:
- requests.Response: Onshape response data
/ parts / d / : did / [wvm] / :wvm
'''
payload = {}
route = '/api/parts/d/' + did + '/' + wvm_type + '/' + wvm
return self._api.request('get', route, payload)
def set_part_metadata(self, did, wvm, eid, part_id, payload=None, wvm_type='w'):
"""
set metadata value for an OnShape part
- did (str): Document ID
- wvm (str): Workspace ID or version id or microversion id
- eid (str): element ID or version id or microversion id
- part_id (str): partID
- payload: dictionary containing key/value pairs to set on the entity
Returns:
- requests.Response: Onshape response data
/parts/d/:did/[wvm]/:wvm/e/:eid/partid/:partid/metadata
Example payload:
payload = {"name": "new name", "partNumber": "new part num"}
"""
if payload is None:
payload = {}
payload_json = json.dumps(payload)
if len(part_id):
route = '/api/parts/d/{}/{}/{}/e/{}/partid/{}/metadata'.format(did, wvm_type, wvm, eid, part_id)
else:
route = '/api/parts/d/{}/{}/{}/e/{}/metadata'.format(did, wvm_type, wvm, eid, part_id)
return self._api.request('post', route, body=payload_json)
def batch_update_part_metadata(self, did, wvm, wvm_type, payload=None):
"""
set metadata value for an OnShape part
- did (str): Document ID
- wvm (str): Workspace ID or version id or microversion id
- payload: dictionary containing key/value pairs to set on the entity
Returns:
- requests.Response: Onshape response data
/parts/d/: did/[wvm]/:wvm
"""
if payload is None:
payload = {}
payload_json = json.dumps(payload)
route = '/api/parts/d/{}/{}/{}'.format(did, wvm, wvm_type)
return self._api.request('post', route, body=payload_json)
def get_partstudios_part_metadata(self, did, wvm, eid, wvm_type='w', part_ids=None):
"""
get metadata values for an OnShape list of part
- did (str): Document ID
- wvm (str): Workspace ID or version id or microversion id
- eid (str): Element ID
- wvm_type (str): 'w' for workspace, 'v' for version, 'm' for microversion
- part_ids ([str]): a list (or iterable of part ids to return, None for all parts in the part studio
TODO: query parameters - linkDocumentId
Returns:
- requests.Response: Onshape response data
"""
route = '/api/partstudios/d/{}/{}/{}/e/{}/metadata'.format(did, wvm_type, wvm, eid)
if part_ids is not None:
query = {'partIds': ','.join(part_ids)}
return self._api.request('get', route, query)
def get_element_metadata(self, did, wv, eid, wvm_type='w', linkDocumentId=None):
"""
get metadata values for an OnShape list of part
- did (str): Document ID
- wv (str): Workspace ID or version id
- eid (str): Element ID
- wvm_type (str): 'w' for workspace, 'v' for version
Returns:
- requests.Response: Onshape response data
"""
route = '/api/elements/d/{}/{}/{}/e/{}//metadata'.format(did, wvm_type, wv, eid)
query = {}
if linkDocumentId is not None:
query = {'linkDocumentId': linkDocumentId}
return self._api.request('get', route, query)
def get_part_metadata(self, did, wvm, eid, part_id, wvm_type='w', linkDocumentId=None):
"""
get metadata values for an OnShape list of part
- did (str): Document ID
- wvm (str): Workspace ID or version id or microversion id
- eid (str): Element ID
- part_id ([str]): the id of the part ids to return
- wvm_type (str): 'w' for workspace, 'v' for version, 'm' for microversion
Returns:
- requests.Response: Onshape response data
"""
route = '/api/parts/d/{}/{}/{}/e/{}/partid/{}/metadata'.format(did, wvm_type, wvm, eid, part_id)
query = {}
if linkDocumentId is not None:
query = {'linkDocumentId': linkDocumentId}
return self._api.request('get', route, query)
def set_metadata(self, did, wvm, wvm_type='w', payload=None):
"""
set metadata value for an OnShape document
- did (str): Document ID
- wvm (str): Workspace ID or version id or microversion id
- payload: list of dictionaries, each containing key/value pairs to set on the entity
Returns:
- requests.Response: Onshape response data
Note: payload is required to have elementId and partID for every part. All other metadata values are
optional (e.g. partNumber, material, appearance, etc.).
An example payload to set the partNumber for each part (assuming the part list was retrieved with get_parts_list:
# wrong: payload = [{'elementId': part['elementId'], 'partId': part['partId'], 'partNumber': f'part-{id}' } for idx, part in enumerated(parts)]
/ metadata / d /: did / [wv] /:wv
# payload description is wrong...
payload =
{
"items": [
{
"properties": [
{
"value": "new_description_another",
"propertyId": "57f3fb8efa3416c06701d60e"
}
],
"href": "https://cad.onshape.com/api/metadata/d/624cda69347788edc2259a64/w/c09ce0ce9af4ea6f69323ab7/e/d252e442e4cb6c22e49f4754?configuration=List_EwLwXQKstmDIZM%3Danother%3Bbool%3Dfalse%3Bsize%3D2+in"
},
{
"properties": [
{ "value": "new_description_yet_another", "propertyId": "57f3fb8efa3416c06701d60e" }
],
"href": "https://cad.onshape.com/api/metadata/d/624cda69347788edc2259a64/w/c09ce0ce9af4ea6f69323ab7/e/d252e442e4cb6c22e49f4754?configuration=List_EwLwXQKstmDIZM%3Danother%3Bbool%3Dtrue%3Bsize%3D2+in"
}
]
}
"""
if payload is None:
payload = []
payload_json = json.dumps(payload)
route = '/api/metadata/d/{}/w/{}'.format(did, wvm)
return self._api.request('post', route, body=payload_json)
| {"/python/onshapepy/__init__.py": ["/python/onshapepy/ext_client.py", "/python/onshapepy/utils.py"]} |
74,179 | lwanger/onshapepy | refs/heads/master | /python/onshape_util.py | """
onshape_util
Experiments with the OnShape API.
for more information about the API see:
https://dev-portal.onshape.com/
also useful to use the OnShape api-explorer app in OnShape
this code uses apikey to do authentication:
https://github.com/onshape-public/apikey/tree/master/python
TODO:
- Add: interactively get did, wfm, eid to get BOM, list elements and list parts... instead of hard-coded
- More apis to play with:
- try walking a project - get document for a project - get its parts, for each part of assembly get the part number and tags
then get instances, subassemblies, parts in each assembly and recurse.
get user companies https://cad.onshape.com/api/companies? (no parms)
get teams https://cad.onshape.com/api/teams? (no parms)
Document API - get document - can get tags
Assembly API - assembly definition - gets "instances" (w/ "id", "name", "type" (e.g. "Assembly"), "suppressed" (true/false),
"documentId", "documentMicroversion", "elementId"), "subassemblies" (w/ "documentId", "documentMicroversion",
"elementId", "instances" (w/ "id", "name", "partId", "type", "suppressed", "documentId", "documentMicroversion",
"elementId")
Elements API - get metadata - gets metadata including part number for an element (e.g. a part of assembly). Includes:
"type" (e.g. "ASSEMBLY"), "state" (e.g. "IN_PROGRESS"), "description", "revision", "href", "vendor", "id",
"elementId", "partNumber", "project", "name"
Parts API - get parts
Play with iFrames!
Len Wanger
Copyright Impossible Objects, 2017
---
Notes:
Element types: fields (name, id, element_type, micro_version_id, and various unit information (for parts and assemblies)
- Part Studio (zero or more parts) (element_type="PARTSTUDIO")
- Assembly (zero or more parts or assemblies) (element_type="ASSEMBLY")
- Blob ("Binary Large OBject") This can be data provided by a partner, or by the end user. For example,
the user can upload a PDF file, an image or a text file. Partner applications can store arbitrary data,
but we recommend using the structured storage available in an Application element for better integration. (element_type="BLOB)
- Application. This is an element that presents an IFrame to the user. The user interface in the IFrame is
managed by a server that can be provided by a third-party. Note that Onshape Drawings are a special
case of an application element. (element_type="APPLCIATION")
"""
from collections import Counter
import csv
# import sys
import json
from onshapepy.ext_client import ClientExtended, Pager
from onshapepy.utils import parse_url
import cooked_input as ci
IO_COMPANY_ID = '59f3676cac7f7c1075b79b71'
IO_ENGR_TEAM_ID = '59f396f9ac7f7c1075bf8687'
# Test assembly (bike)
if False:
MAIN_WORKSPACE = '5c9a0477134719bc5b930595'
TEST_ASSEM_DOC_ID = '0f9c85ccbf253b470b931452'
TEST_ASSEM_ELEM_ID = 'fc5140cca987ed4102c2eb3f'
elif False: # IO0571
# https://cad.onshape.com/documents/038582dd6fb5b4e103ae2f91/w/f1c5a07b9a53222043d46954/e/3bc610eb24f2b6686d2f99d5
MAIN_WORKSPACE = 'f1c5a07b9a53222043d46954'
TEST_ASSEM_DOC_ID = '038582dd6fb5b4e103ae2f91' # IO0571
TEST_ASSEM_ELEM_ID = '3bc610eb24f2b6686d2f99d5' # IO0571 assembly
else: # IO0264
# https://cad.onshape.com/documents/3db64a1208d4341aec7b94bb/w/2102c7bd5ea5ab0ed9cf45be/e/d3c27890aa1b23fbc22a55a0
TEST_ASSEM_DOC_ID = '3db64a1208d4341aec7b94bb'
MAIN_WORKSPACE = '2102c7bd5ea5ab0ed9cf45be'
TEST_ASSEM_ELEM_ID = 'd3c27890aa1b23fbc22a55a0'
def help_cmd_action(cmd_str, cmd_vars, cmd_dict):
print('\nCommands:\n')
print('/?, /h\tDisplay this help message')
print('/cancel\tCancel the current operation')
print('/first (/f)\tGo to first page of the table')
print('/last (/l)\tGo to last page of the table')
print('/prev (/p)\tGo to previous page of the table')
print('/next (/n)\tGo to next page of the table')
print()
return (ci.COMMAND_ACTION_NOP, None)
def cancel_cmd_action(cmd_str, cmd_vars, cmd_dict):
print('\nCommand cancelled...')
return (ci.COMMAND_ACTION_CANCEL, None)
std_commands = {
'/?': ci.GetInputCommand(help_cmd_action),
'/h': ci.GetInputCommand(help_cmd_action),
'/help': ci.GetInputCommand(help_cmd_action),
'/cancel': ci.GetInputCommand(cancel_cmd_action),
}
table_commands = {
'/?': ci.GetInputCommand(help_cmd_action),
'/h': ci.GetInputCommand(help_cmd_action),
'/help': ci.GetInputCommand(help_cmd_action),
'/cancel': ci.GetInputCommand(cancel_cmd_action),
'/first': ci.GetInputCommand(ci.first_page_cmd_action),
'/last': ci.GetInputCommand(ci.last_page_cmd_action),
'/prev': ci.GetInputCommand(ci.prev_page_cmd_action),
'/next': ci.GetInputCommand(ci.next_page_cmd_action),
}
class DocRow():
# class to represent an OnShape document
def __init__(self, doc_json):
self.did = doc_json['id']
self.href = doc_json['href']
self.name = doc_json['name']
self.owner_id = doc_json['owner']['id']
self.owner = doc_json['owner']
self.default_workspace_id = doc_json['defaultWorkspace']['id']
self.default_workspace = doc_json['defaultWorkspace']['name']
self.created_at = doc_json['createdAt']
self.created_by_id = doc_json['createdBy']['id']
self.created_by = doc_json['createdBy']['name']
self.modified_at = doc_json['modifiedAt']
self.modified_by_id = doc_json['modifiedBy']['id']
self.modified_by = doc_json['modifiedBy']['name']
def __repr__(self):
return f'{self.name} ({self.did})'
def create_docs_table(c, docs):
"""
Create a table containing documents from OnShape. c is the onShape client and docs
:param c: an onshapepy client
:param docs: a json list of documents from onshapepy
:return: a cooked_input Table containing a list of documents
"""
style = ci.TableStyle(show_cols=True, show_border=True, hrules=ci.RULE_FRAME, vrules=ci.RULE_ALL)
rows = []
print('fetching documents ', end='', flush=True)
for page in Pager(c, docs):
print('.', end='', flush=True)
for item in page['items']:
rows.append(DocRow(item))
print('\n\n')
fields = ["Name", "did", "CreatedAt", "Default Workspace", "ModifiedAt"]
tis = [ci.TableItem([row.name, row.did, row.created_at, row.default_workspace, row.modified_at], tag=None, item_data={'row': row}) for row in rows]
tbl = ci.Table(tis, fields, default_action=ci.TABLE_RETURN_TABLE_ITEM, add_exit=False, style=style)
return tbl
def create_eids_table(c, eids, assemblies_only=True):
"""
Create a table containing elements for an OnShape document
:param c: an onshapepy client
:param eids: a json list of document elements from onshapepy
:param assemblies_only: if true only shows assembly elements
tables are ignoring: type, lengthUnits, angleUnits, massUnits, foreignDataId
:return: a cooked_input Table containing a list of elements
"""
style = ci.TableStyle(show_cols=True, show_border=True, hrules=ci.RULE_FRAME, vrules=ci.RULE_ALL)
tis = []
for item in eids:
element_type = item['elementType']
if assemblies_only and element_type != "ASSEMBLY":
continue
name = item['name']
item_id = item['id']
micro_version_id = item['microversionId']
tis.append(ci.TableItem([name, item_id, element_type, micro_version_id], tag=None, item_data={'item': item}))
fields = "Name Id ElementType MicroversionId".split()
tbl = ci.Table(tis, fields, default_action=ci.TABLE_RETURN_TABLE_ITEM, add_exit=False, tag_str='#', style=style)
print('\n')
return tbl
def list_documents_action(row, action_dict):
# Uses Documents API/Get Documents
# parms - q - search for string in name of document
# filter - 0-9 for filter, 0 - my docs, 6- by owner, 7 by company, 9 by team
# owner - owner id for filter 6 or 7, team if 9
# offset - offset into the page (max 20)
# limit - number of documents returned per page
c = action_dict['client']
doc_query = {'offset': 0, 'limit': 20}
name_filter = ci.get_string(prompt='String to filter document names (hit enter for no filter)', required=False, commands=std_commands)
if name_filter is not None and len(name_filter) > 0:
doc_query['q'] = name_filter
if ci.get_yes_no(prompt='Show only your documents', default='no', commands=std_commands) == 'yes':
filter_val, owner = (0, None) # filter by company
doc_query = {'filter': 0}
elif ci.get_yes_no(prompt='Show documents for your company', default='no', commands=std_commands) == 'yes':
doc_query = {'filter': 7, 'owner': action_dict['company']} # filter by company
# elif ...:
# TODO - implement other filters - team, owner, etc.
#filter_val, owner = (9, action_dict['team']) # filter by team
#doc_query = {'filter': 9, 'owner': action_dict['team']} # filter by team
else:
if ci.get_yes_no(prompt="Are you sure you want to fetch with no filters... this could take a long time!", default='no')=='no':
print('Cancelling action')
raise ci.COMMAND_ACTION_CANCEL
docs = c.list_documents(query=doc_query)
tbl = create_docs_table(c, docs)
tbl.get_table_choice(required=False, commands=table_commands)
print('\n')
def get_document(client, company_id):
# Uses Documents API/Get Documents
# parms - q - search for string in name of document
# filter - 0-9 for filter, 0 - my docs, 6- by owner, 7 by company, 9 by team
# owner - owner id for filter 6 or 7, team if 9
# offset - offset into the page (max 20)
# limit - number of documents returned per page
fname_filter_str = ci.get_string(prompt='Document string to search for', commands=std_commands)
filter_val, owner = (7, company_id) # filter by company
doc_query = {'filter': filter_val, 'owner': owner}
doc_query['q'] = fname_filter_str
docs = c.list_documents(query=doc_query)
tbl = create_docs_table(c, docs)
if tbl.get_num_rows() == 1: # TODO - this doesn't work!
choice = tbl.get_row(tag='1')
else:
choice = tbl.get_table_choice(prompt='choose a document', commands=table_commands)
doc = choice.item_data['row']
return doc
def get_document_action(row, action_dict):
# get a document from OnShape
doc = get_document(action_dict['client'], action_dict['company'])
print(f'chose doc {doc.name} ({doc.did})')
print('\n')
def get_eid_action(row, action_dict):
# Get the element id to work with
client = action_dict['client']
doc = get_document(client, action_dict['company'])
did = doc.did
wvm = doc.default_workspace_id
response = c.get_element_list(did, wvm, element_type=None, eid=None, with_thumbnails=False)
response_json = json.loads(response.text)
tbl = create_eids_table(client, response_json)
if tbl.get_num_rows() == 1: # TODO - this doesn't work!
choice = tbl.get_row(tag='1')
else:
choice = tbl.get_table_choice(prompt='choose a document', commands=table_commands)
eid = choice.item_data['item']['id']
print(f'Chose eid={eid}\n\n')
return eid
def get_dwe_from_url_action(row, action_dict):
# Get the element id to work with
url = ci.get_string(prompt="Get DID,WVM and EID from what Onshape document")
did, wvm, eid = parse_url(url)
action_dict['did'] = did
action_dict['wvm'] = wvm
action_dict['eid'] = eid
print(f'\nSetting did={did}, wvm={wvm} and eid={eid}\n\n')
def list_stats_action(row, action_dict):
client = action_dict['client']
did = action_dict['did']
wvm = action_dict['wvm']
eid = action_dict['eid']
print(f'\nFetching model assembly definition (did={did}, wvm={wvm} and eid={eid})\n\n')
response = client.get_assembly_definition(did, wvm, eid)
response_json = json.loads(response.text)
# parse stats - total parts, type of parts, etc.
# response_json has:
# response_json['rootAssembly']['occurences']
# response_json['rootAssembly']['instances']['type'] # id, name, partId, isStandardContent, elementId, etc.
# response_json['parts']['bodyType'] # partId, configuration, isStandardContent
# response_json['partStudioFeatures']
print(f'Stats for Document (DID={did}):\n')
print(f'Number of Root assembly instances: {len(response_json["rootAssembly"]["instances"])}')
print(f'Number of Root assembly sub-assemblies: {len(response_json["subAssemblies"])}')
ra_types = Counter([part['type'] for part in response_json['rootAssembly']['instances']])
print(f'Root assembly instance types: {", ".join([f"{k}={v}" for k,v in ra_types.items()])}')
print(f'Number of parts: {len(response_json["parts"])}')
part_types = Counter([part['bodyType'] for part in response_json['parts']])
print(f'Part body types: {", ".join([f"{k}={v}" for k,v in part_types.items()])}')
print(f'Number of part studio features: {len(response_json["partStudioFeatures"])}')
print('\n\n')
def list_teams_action(row, action_dict):
c = action_dict['client']
response = c.list_teams()
rows = []
for response_json in Pager(c, response):
for item in response_json['items']:
name = item['name']
item_id = item['id']
description = item['description']
href = item['href']
rows.append(ci.TableItem([name, item_id, description, href]))
col_names = "Name Id Description HREF".split()
ci.Table(rows, col_names=col_names, title='OnShape Teams', tag_str='#').show_table()
print('\n')
def list_workspaces_action(row, action_dict):
print('\n')
c = action_dict['client']
did = action_dict['did']
response = c.get_workspaces(did)
response_json = json.loads(response.text)
rows = []
for i, item in enumerate(response_json):
read_only = item['isReadOnly']
modified_at = item['modifiedAt']
name = item['name']
item_id = item['id']
href = item['href']
rows.append(ci.TableItem([name, item_id, read_only, modified_at, href[:50]]))
col_names = "Name ItemId ReadOnly Modified HREF".split()
ci.Table(rows, col_names=col_names, title='OnShape Workspaces', tag_str='#').show_table()
print('\n')
def list_elements_action(row, action_dict):
print('\n')
c = action_dict['client']
did = action_dict['did']
wvm = action_dict['wvm']
response = c.get_element_list(did, wvm, element_type=None, eid=None, with_thumbnails=False)
response_json = json.loads(response.text)
tbl = create_eids_table(c, response_json, assemblies_only=False)
tbl.show_table()
print('\n')
def list_parts_action(row, action_dict):
print('\n')
c = action_dict['client']
did = action_dict['did']
wvm = action_dict['wvm']
response = c.get_parts_list(did, wvm)
response_json = json.loads(response.text)
rows = []
for i, item in enumerate(response_json):
name = item['name']
desc = item['description']
state = item['state']
element_id = item['elementId']
part_num = item['partNumber']
revision = item['revision']
microversion_id = item['microversionId']
is_hidden = item['isHidden']
# is_mesh = item['isMesh']
# lots more... appearance, bodyType, etc.
# print('item {}: name={}, desc={}, state={}, elementID={}, partNumber={}, revision={}, microversionId={}, isHidden={}'.format(i,
# name, desc, state, element_id, part_num, revision, microversion_id, is_hidden))
rows.append(ci.TableItem([name, desc, state, element_id, part_num, revision, microversion_id, is_hidden]))
col_names = "Name Description State Id PartNum Revision, MicroversionId isHidden".split()
ci.Table(rows, col_names=col_names, title='OnShape Parts', tag_str='#').show_table()
print('\n')
def get_bom_action(row, action_dict):
print('\n')
c = action_dict['client']
did = action_dict['did']
wvm = action_dict['wvm']
eid = action_dict['eid']
types = ["flattened", "top-level", "multi-level"]
type_vals = {"flattened": (False, False), "top-level": (True, False), "multi-level": (True, True)}
prompt_str = f'BOM type ({", ".join(types)})'
type_cleaner = ci.ChoiceCleaner(types)
use_type = ci.get_string(prompt=prompt_str, cleaners=type_cleaner, default="flattened", commands=std_commands)
indented, multi_level = type_vals[use_type]
print(f'Fetching {multi_level} BOM from OnShape (did={did}, wvm={wvm}, eid={eid})')
response = c.get_assembly_bom(did, wvm, eid, indented=indented, multi_level=multi_level, generate_if_absent=True)
response_json = json.loads(response.text)
try:
status = response_json['status']
if status == 404:
msg = response_json['message']
print("\nStatus 404 returned: {}\n".format(msg))
return
except:
pass
bom_table = response_json['bomTable']
format_ver = bom_table['formatVersion']
name = bom_table['name']
bom_type = bom_table['type']
created_at = bom_table['createdAt']
doc_name = bom_table['bomSource']['document']['name']
top_pn = bom_table['bomSource']['element']['partNumber']
try:
top_revision = bom_table['bomSource']['element']['revision'] # column may not be there..
except (KeyError):
top_revision = '--'
state = bom_table['bomSource']['element']['state']
title = (f"\n\n{bom_type} {name} (format version {format_ver}) - {doc_name} ({state} {top_pn}{top_revision}) created_at: {created_at}")
rows = []
for idx,item in enumerate(bom_table['items']):
item_num = item['item']
qty = item['quantity']
part_num = item['partNumber']
desc = item['description']
revision = item['revision']
state = item['state']
rows.append(ci.TableItem([qty, part_num, revision, state, desc], tag=item_num))
col_names = "Qty PartNum Rev State Desc".split()
ci.Table(rows, col_names=col_names, title=title, tag_str='ItemNums').show_table()
print('\n')
# export to csv
if ci.get_yes_no(prompt='Export to CSV file', default='no') == 'yes':
cmds = { '/cancel': ci.GetInputCommand(cancel_cmd_action) }
file_name = ci.get_string(prompt="CSV file_name to export to: ", default=f"{top_pn}_bom_export.csv", commands=cmds)
with open(file_name, "w", encoding='utf-8', newline='') as f:
hdr = 'ITEM_NUM QUANTITY PART_NUM REVISION STATE DESCRIPTION'
csv_writer = csv.writer(f)
csv_writer.writerow([f'{bom_type} BOM for:', top_pn])
csv_writer.writerow([])
csv_writer.writerow(hdr.split())
for item in bom_table['items']:
csv_writer.writerow([item['item'], item['quantity'], item['partNumber'], item['revision'], item['state'], item['description']])
if __name__ == '__main__':
stacks = {'cad': 'https://cad.onshape.com'}
c = ClientExtended(stack=stacks['cad'], logging=False)
ad = {
'client': c, 'did': TEST_ASSEM_DOC_ID,
'team': IO_ENGR_TEAM_ID,
'company': IO_COMPANY_ID,
'did': TEST_ASSEM_DOC_ID,
'wvm': MAIN_WORKSPACE,
'eid': TEST_ASSEM_ELEM_ID,
'name_filter': None,
}
style = ci.TableStyle(show_cols=False, show_border=False)
tis = [
# ci.TableItem('Set document name filter string', action=set_name_filter_action),
ci.TableItem('List Documents', action=list_documents_action),
ci.TableItem('Get did for a document', action=get_document_action),
ci.TableItem('Get eid for a document', action=get_eid_action),
ci.TableItem('Get did, wvm and eid from a url', action=get_dwe_from_url_action),
ci.TableItem('List Teams', action=list_teams_action),
ci.TableItem('List Workspaces', action=list_workspaces_action),
ci.TableItem('List Elements', action=list_elements_action),
ci.TableItem('List Parts', action=list_parts_action),
ci.TableItem('List Stats', action=list_stats_action),
ci.TableItem('Get BOM', action=get_bom_action),
]
print()
menu = ci.Table(tis, add_exit=ci.TABLE_ADD_EXIT, style=style, action_dict=ad)
menu.run()
| {"/python/onshapepy/__init__.py": ["/python/onshapepy/ext_client.py", "/python/onshapepy/utils.py"]} |
74,204 | HelmerNylen/mkbsc | refs/heads/master | /mkbsc/multiplayer_game.py | from .alphabet import Alphabet
from .state import State
from .observation import Observation
from .partitioning import Partitioning
from .transition import Transition
from .helper_functions import _permute, _lookup, _lookup_by_base, _reachable, consistent, powerset
#import threading
#import time
from itertools import chain, combinations, permutations
from collections import deque
import networkx as nx
from networkx.algorithms.isomorphism import is_isomorphic
from networkx.drawing.nx_pydot import to_pydot
class MultiplayerGame:
"""Represents a game of one or more players
The easiest way to create a new game is to call MultiplayerGame.create() with the
appropriate parameters. Among other things, the game has methods to apply the (M)KBSC,
to project the game onto a certain player, to check for isomorphism and to export the
game as a dot string."""
def __init__(self, states, initial_state, alphabet, transitions, partitionings, remove_unreachable=False, validate=False, **attributes):
"""Create a new game and optionally validate and remove unreachable states."""
self.states = states
self.initial_state = initial_state
self.alphabet = alphabet
self.transitions = transitions
self.partitionings = partitionings
self.graph = nx.MultiDiGraph()
self.graph.graph["graph"] = attributes
default_attributes = {
#"rankdir": "LR",
"nodesep": 0.5,
"ranksep": 0.5,
"concentrate": False,
"splines": "True"
}
for key in default_attributes:
if key not in self.graph.graph["graph"]:
self.graph.graph["graph"][key] = default_attributes[key]
self.player_count = len(alphabet)
assert len(partitionings) == self.player_count
if validate:
for partitioning in partitionings:
assert partitioning.valid(states)
for state in states:
self.graph.add_node(state)
for transition in transitions:
if validate:
assert transition.start in states and transition.end in states
for i, action in enumerate(transition.joint_action):
assert action in self.alphabet[i]
self.graph.add_edge(transition.start, transition.end,
label=transition.label(), key=transition.joint_action, action=transition.joint_action)
if remove_unreachable:
to_remove = (set(self.states) - _reachable(self.graph, self.initial_state)) - {self.initial_state}
#print("Removing " + str(to_remove))
self.graph.remove_nodes_from(to_remove)
def create(content, initial, alphabet, transition_edges, state_groupings, **attributes):
"""Create a new game and validate it
content -- the knowledge of the states, ex. [1, 2, 3] or range(5)
initial -- the knowledge in the initial state, ex. 1
alphabet -- the alphabet of actions, ex. (['a', 'b'], ['1', '2']) or ('ab', '12')
transition_edges -- the edges in the game graph, ex. [(1, ('a', '1'), 2), (2, 'b1', 3)]
state_groupings -- the observation partitionings, ex. ([[1, 2], [3]], [[1], [2, 3]])"""
states = tuple(set(map(lambda x: State(x), content)))
initial_state = _lookup(states, initial)
if type(alphabet) is not Alphabet:
alphabet = Alphabet(*alphabet)
transitions = []
expanded_edges = []
for edge_iterable in [transition_edges, expanded_edges]:
for edge in edge_iterable:
if type(edge[2]) is set:
for edge_end in edge[2]:
expanded_edges.append((edge[0], edge[1], edge_end))
continue
start = _lookup(states, edge[0])
end = _lookup(states, edge[2])
if edge[1] == Ellipsis:
for joint_action in alphabet.permute():
transitions.append(Transition(start, joint_action, end))
else:
transitions.append(Transition(start, edge[1], end))
transitions = tuple(transitions)
partitionings = []
for grouping in state_groupings:
observations = []
ellipsis = False
for group in grouping:
if group == Ellipsis:
ellipsis = True
continue
observations.append(Observation(*[_lookup(states, s) for s in group]))
if ellipsis:
covered_states = set()
for observation in observations:
covered_states.update(observation)
for state in states:
if state not in covered_states:
observations.append(Observation(state))
partitionings.append(Partitioning(*observations))
partitionings = tuple(partitionings)
return MultiplayerGame(states, initial_state, alphabet, transitions, partitionings, False, True, **attributes)
def _create_from_serialized(states, initial_state, alphabet, transitions, state_groupings, validate=True, **attributes):
"""Create a new game from serialized data and validate it"""
states = tuple(states)
if type(alphabet) is not Alphabet:
alphabet = Alphabet(*alphabet)
transitions = tuple(map(lambda edge: Transition(*edge), transitions))
partitionings = tuple(map(lambda grouping: Partitioning(*[Observation(*group) for group in grouping]), state_groupings))
return MultiplayerGame(states, initial_state, alphabet, transitions, partitionings, False, validate, **attributes)
def state(self, knowledge):
"""Get the state object with the specified knowledge"""
return _lookup(self.states, knowledge, len(self.states[0].knowledges) == 1)
def states_by_consistent_base(self, base):
"""Get the state objects which represent the specified base states"""
return _lookup_by_base(self.states, base)
def post(self, action, states):
"""Get the states that are possible after taking a certain action in one of the specified states"""
res = set()
if self.player_count == 1:
action = (action,)
if not hasattr(states, '__iter__'):
states = (states,)
for state in states:
neighbors = self.graph.neighbors(state)
for neighbor in neighbors:
edges = self.graph[state][neighbor]
for key in edges:
if edges[key]["action"] == action:
res.add(neighbor)
break
return res
def reachable(self, initial=None):
"""Get the reachable states in a game, optionally given a certain initial state"""
res = set()
if not initial:
initial = self.initial_state
res.add(self.initial_state)
return res.union(_reachable(self.graph, initial))
def to_dot(self, group_observations=None, group_by_base=False, group_edges=True, epistemic=False, \
supress_edges=False, color_scheme="set19", colorfunc=lambda x:x+1, observations_constrain=True, \
target_states=None, **kwargs):
"""Generate a dot representation of the game
group_observations -- if true, places the nodes in an observation within a subgraph cluster. Only works well for some singleplayer games.
group_by_base -- if true, places nodes which represent the same states in separate subgraph clusters. Currently yields rather ugly results.
group_edges -- if true, collects all edges between two nodes into a single edge with all the labels from the original edges. Keeping this true is strongly recommended.
epistemic -- 'verbose', 'nice' or 'isocheck'. Specifies different ways to label the nodes. The default is similar to 'nice' for few iterations of the KBSC. 'nice' is recommended for checking state contents, 'isocheck' for edges and observation groups.
supress_edges -- if true, removes the labels from the edges.
color_scheme -- see https://www.graphviz.org/doc/info/colors.html#brewer for options. defines the coloring for observation equivalence relations for each of the players
colorfunc -- a function which numbers the players from 1 to be used with the color scheme, or provides the color directly
observations_constrain -- if false, ignores the observation equivalence relations when generating the graph layout
target_states -- the states (or singleton knowledge in states) which should be marked in the rendered graph"""
G = self.graph.copy()
all_joint_actions = set(self.alphabet.permute())
if group_edges:
for node in G:
for neighbor in list(G.neighbors(node)):
edges = [edge for edge in G.edges(node, data=True) if edge[1] == neighbor]
if len(edges) == 1:
continue
label = ", ".join(map(lambda edge: edge[2]["label"], edges))
superaction = tuple(edge[2]["action"] for edge in edges)
if len(set(superaction)) == len(all_joint_actions):
label = "(-)"
total_attributes = {}
for edge in edges:
if edge[2]["action"]:
current_attributes = G[edge[0]][edge[1]][edge[2]["action"]]
for key in current_attributes:
if key not in ["label", "action", "key"]:
total_attributes[key] = current_attributes[key]
G.remove_edge(edge[0], edge[1], edge[2]["action"])
G.add_edge(node, neighbor, label=label, key=superaction, action=superaction, **total_attributes)
for edge in G.edges(data="action"):
if edge[0] == edge[1]:
G[edge[0]][edge[1]][edge[2]]["dir"] = "back"
if supress_edges:
for edge in G.edges(data="action"):
G[edge[0]][edge[1]][edge[2]]["label"] = ""
epistemic_functions = {"verbose": State.epistemic_verbose, "nice": State.epistemic_nice, "isocheck": State.epistemic_isocheck}
if epistemic:
func = epistemic_functions[epistemic.lower()]
for state in G.nodes():
G.nodes[state]["label"] = func(state)
G.add_node("hidden", shape="none", label="")
G.add_edge("hidden", self.initial_state)
if target_states:
for i in range(len(target_states)):
if type(target_states[i]) is not State:
target_states[i:i+1] = _lookup_by_base(self.states, target_states[i])
for target_state in target_states:
G.nodes[target_state]["shape"] = "doublecircle"
#if group_observations is None:
# group_observations = (self.player_count == 1)
if group_observations:
State.compact_representation = True
arr = to_pydot(G).to_string().split("\n")
for player, partitioning in enumerate(self.partitionings):
arr[-2:-2] = [observation.to_dot({"style": "dashed", "label": "~" + str(player) if self.player_count > 1 else ""}) for observation in partitioning]
State.compact_representation = False
return "\n".join(arr)
else:
for player, partitioning in enumerate(self.partitionings):
for observation in partitioning:
if len(observation) > 1:
for start, end in combinations(observation, 2):
G.add_edge(start, end, style="dashed", label="~" + str(player) if self.player_count > 1 else "",
arrowhead="none", colorscheme=color_scheme, color=colorfunc(player), constraint=observations_constrain)
State.compact_representation = True
arr = to_pydot(G).to_string().split("\n")
if group_by_base:
groups = {}
for state in self.states:
fs = frozenset(state.consistent_base())
if fs not in groups:
groups[fs] = set()
groups[fs].add(state)
#print(groups.keys())
for i, group in enumerate(groups):
subgraph = nx.Graph()
subgraph.graph["graph"] = { "style": "invis" }
subgraph.add_nodes_from(groups[group])
s = to_pydot(subgraph).to_string()
s = "subgraph cluster" + str(i) + " {" + s[s.index("\n"):]
arr[-2:-2] = [s]
State.compact_representation = False
return "\n".join(arr)
def project(self, player):
"""Project the game onto a player"""
assert player < self.player_count
states = self.states
initial_state = self.initial_state
alphabet = Alphabet(self.alphabet[player])
transitions = [Transition(t.start, (t.joint_action[player],), t.end) for t in self.transitions]
partitionings = (self.partitionings[player],)
attributes = self.graph.graph["graph"]
return MultiplayerGame(states, initial_state, alphabet, transitions, partitionings, **attributes)
def _synchronous_product(self, games):
"""Combine singleplayer knowledge-based games into a single knowledge-based multiplayer game"""
initial_states = tuple(game.initial_state for game in games)
initial_knowledges = tuple(state.knowledges[0] for state in initial_states)
transitions = []
states = {initial_knowledges: State(*initial_knowledges)}
tested = set()
queue = deque([(initial_states, consistent(initial_states))])
while len(queue):
state_tuple, possible = queue.pop()
if state_tuple in tested:
continue
else:
tested.add(state_tuple)
for joint_action in self.alphabet.permute():
possible_post = self.post(joint_action, possible)
players_post = [games[i].post(joint_action[i], state_tuple[i]) for i in range(self.player_count)]
for i in range(self.player_count):
players_post[i] = set(filter(lambda state: not state.knowledges[0].isdisjoint(possible_post), players_post[i]))
for possible_knowledge in _permute(players_post):
knowledge_tuple = tuple(state.knowledges[0] for state in possible_knowledge)
consistent_to = consistent(possible_knowledge)
if not consistent_to:
continue
if knowledge_tuple not in states:
states[knowledge_tuple] = State(*knowledge_tuple)
queue.appendleft((possible_knowledge, consistent_to))
consistent_from = consistent(state_tuple)
for t in self.transitions:
if t.joint_action == joint_action and t.start in consistent_from and t.end in consistent_to:
break
else:
# Prune inconsistent transitions.
continue
k = tuple(state.knowledges[0] for state in state_tuple)
fromstate = states[k]
tostate = states[knowledge_tuple]
transition = Transition(fromstate, joint_action, tostate)
transitions.append(transition)
initial_state = states[initial_knowledges]
states = list(states.values())
attributes = self.graph.graph["graph"]
observation_dicts = [{} for player in range(self.player_count)]
for state in states:
for i in range(self.player_count):
if state[i] in observation_dicts[i]:
observation_dicts[i][state[i]].add(state)
else:
observation_dicts[i][state[i]] = {state}
partitionings = tuple(Partitioning(*[Observation(*observation_dicts[i][knowledge]) for knowledge in observation_dicts[i]]) for i in range(self.player_count))
return MultiplayerGame(states, initial_state, self.alphabet, transitions, partitionings, **attributes)
def KBSC(self):
"""Apply the KBSC to the game (or MKBSC in the multiplayer case)"""
if self.player_count > 1:
games = [self.project(player).KBSC() for player in range(self.player_count)]
game = self._synchronous_product(games)
return game
else:
#print("Singleplayer KBSC")
partitioning = self.partitionings[0]
initial_state = State(frozenset({self.initial_state}))
states = {initial_state[0]: initial_state}
transitions = []
queue = deque([initial_state])
tested = set()
while len(queue):
fromstate = queue.pop()
if fromstate in tested:
continue
else:
tested.add(fromstate)
for action in self.alphabet[0]:
post_states = self.post(action, fromstate.knowledges[0])
for obs in partitioning:
knowledge = post_states.intersection(obs.states)
if knowledge:
knowledge = frozenset(knowledge)
tostate = states.get(knowledge)
if not tostate:
tostate = State(knowledge)
states[knowledge] = tostate
queue.appendleft(tostate)
transitions.append(Transition(fromstate, (action,), tostate))
states = list(states.values())
partitionings = (Partitioning(*[Observation(state) for state in states]),)
attributes = self.graph.graph["graph"]
#print("KBSC game creation")
return MultiplayerGame(states, initial_state, self.alphabet, transitions, partitionings, remove_unreachable=True, **attributes)
def isomorphic(self, other, consider_observations=False):
"""Check if two games have isomorphic graphs with regards to nodes and edges
other -- the other game
consider_observations -- if true, the equivalence relations from the observations must be the same in both graphs as well"""
if len(self.states) != len(other.states):
return False
a = self.graph.copy()
b = other.graph.copy()
for g in ((a, self), (b, other)):
if consider_observations:
for player, partitioning in enumerate(g[1].partitionings):
for observation in partitioning:
if len(observation) > 1:
for start, end in permutations(observation, 2):
g[0].add_edge(start, end, player=str(player))
g[0].add_node("hidden")
g[0].add_edge("hidden", g[1].initial_state)
State.orderable = True
iso = is_isomorphic(a, b, edge_match=lambda x, y: x == y)
State.orderable = False
return iso
def partitioning_profile(self):
"""Return a list of each player's pratitioning of observations larger than a single state
Useful for checking the equivalence relations for large games with complex states"""
s = ""
for player, partitioning in enumerate(self.partitionings):
s += "Spelare " + str(player) + ": " + ", ".join([str(tuple(sorted([s.epistemic_isocheck() for s in o]))) for o in sorted(partitioning.observations, key=lambda o: len(o)) if len(o) > 1])
s += "\n"
return s
| {"/mkbsc/multiplayer_game.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/helper_functions.py"], "/main.py": ["/mkbsc/__init__.py"], "/mkbsc/__init__.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/multiplayer_game.py", "/mkbsc/serialization.py", "/mkbsc/helper_functions.py"], "/mkbsc/alphabet.py": ["/mkbsc/helper_functions.py"], "/mkbsc/serialization.py": ["/mkbsc/state.py", "/mkbsc/multiplayer_game.py"]} |
74,205 | HelmerNylen/mkbsc | refs/heads/master | /main.py | #!/usr/bin/env python3
from mkbsc import MultiplayerGame, iterate_until_isomorphic, \
export, to_string, from_string, to_file, from_file
#states
L = [0, 1, 2]
#initial state
L0 = 0
#action alphabet
Sigma = (("w", "p"), ("w", "p"))
#action labeled transitions
Delta = [
(0, ("p", "p"), 0), (0, ("w", "w"), 0),
(0, ("w", "p"), 1), (0, ("p", "w"), 2),
(1, ("p", "p"), 1), (1, ("w", "w"), 1),
(1, ("w", "p"), 2), (1, ("p", "w"), 0),
(2, ("p", "p"), 2), (2, ("w", "w"), 2),
(2, ("w", "p"), 0), (2, ("p", "w"), 1)
]
#observation partitioning
Obs = [
[[0, 1], [2]],
[[0, 2], [1]]
]
#G is a MultiplayerGame-object, and so are GK and GK0
G = MultiplayerGame.create(L, L0, Sigma, Delta, Obs)
GK = G.KBSC()
GK0 = GK.project(0)
#export the GK game to ./pictures/GK.png
export(GK, "GK")
| {"/mkbsc/multiplayer_game.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/helper_functions.py"], "/main.py": ["/mkbsc/__init__.py"], "/mkbsc/__init__.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/multiplayer_game.py", "/mkbsc/serialization.py", "/mkbsc/helper_functions.py"], "/mkbsc/alphabet.py": ["/mkbsc/helper_functions.py"], "/mkbsc/serialization.py": ["/mkbsc/state.py", "/mkbsc/multiplayer_game.py"]} |
74,206 | HelmerNylen/mkbsc | refs/heads/master | /mkbsc/transition.py | class Transition:
"""Represents a transition between two states"""
def __init__(self, start, joint_action, end):
"""Create a new transition"""
self.start = start
self.joint_action = tuple(joint_action)
self.end = end
def __getitem__(self, index):
"""Get the action of a certain player"""
return self.joint_action[index]
def __repr__(self):
return str(self)
def __str__(self):
return str(self.start) + " --" + str(self.joint_action) + "-> " + str(self.end)
def label(self):
"""Return the string representation of the joint action"""
if len(self.joint_action) > 1:
return "(" + ", ".join(self.joint_action) + ")"
else:
return str(self.joint_action[0])
| {"/mkbsc/multiplayer_game.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/helper_functions.py"], "/main.py": ["/mkbsc/__init__.py"], "/mkbsc/__init__.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/multiplayer_game.py", "/mkbsc/serialization.py", "/mkbsc/helper_functions.py"], "/mkbsc/alphabet.py": ["/mkbsc/helper_functions.py"], "/mkbsc/serialization.py": ["/mkbsc/state.py", "/mkbsc/multiplayer_game.py"]} |
74,207 | HelmerNylen/mkbsc | refs/heads/master | /mkbsc/__init__.py | from .alphabet import Alphabet
from .state import State
from .observation import Observation
from .partitioning import Partitioning
from .transition import Transition
from .multiplayer_game import MultiplayerGame
from .serialization import from_file, to_file, from_string, to_string, export
from .helper_functions import iterate_until_isomorphic
| {"/mkbsc/multiplayer_game.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/helper_functions.py"], "/main.py": ["/mkbsc/__init__.py"], "/mkbsc/__init__.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/multiplayer_game.py", "/mkbsc/serialization.py", "/mkbsc/helper_functions.py"], "/mkbsc/alphabet.py": ["/mkbsc/helper_functions.py"], "/mkbsc/serialization.py": ["/mkbsc/state.py", "/mkbsc/multiplayer_game.py"]} |
74,208 | HelmerNylen/mkbsc | refs/heads/master | /mkbsc/alphabet.py | from .helper_functions import _permute
class Alphabet:
"""Represents the possible joint actions of the player coalition"""
def __init__(self, *actions):
"""Generate a joint alphabet
ex. a = Alphabet(('push', 'wait'), ('break', 'wait'))"""
for playeractions in actions:
s = set()
for action in playeractions:
assert action not in s
s.add(action)
self.actions = tuple(tuple(a for a in playeractions) for playeractions in actions)
def __getitem__(self, index):
"""Get the alphabet (a tuple of the possible actions) for the specified player"""
return self.actions[index]
def __iter__(self):
"""Iterate over the individual alphabets"""
for playeralphabet in self.actions:
yield playeralphabet
def __len__(self):
"""Get the number of individual alphabets"""
return len(self.actions)
def __str__(self):
return str(self.actions)
def permute(self):
"""Generate every possible joint action"""
for joint_action in _permute(self.actions):
yield joint_action
| {"/mkbsc/multiplayer_game.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/helper_functions.py"], "/main.py": ["/mkbsc/__init__.py"], "/mkbsc/__init__.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/multiplayer_game.py", "/mkbsc/serialization.py", "/mkbsc/helper_functions.py"], "/mkbsc/alphabet.py": ["/mkbsc/helper_functions.py"], "/mkbsc/serialization.py": ["/mkbsc/state.py", "/mkbsc/multiplayer_game.py"]} |
74,209 | HelmerNylen/mkbsc | refs/heads/master | /mkbsc/partitioning.py | class Partitioning:
"""Represents a partitioning of observations"""
def __init__(self, *observations):
"""Create a new partitioning
ex. p = Partitioning(o1, o2, o3)"""
self.observations = tuple(observations)
def __iter__(self):
"""Iterate over the observations"""
for observation in self.observations:
yield observation
def valid(self, states):
"""Test if the partitioning contains all states"""
s = set()
for observation in self.observations:
for state in observation:
if state in s:
return False
else:
s.add(state)
return frozenset(s) == frozenset(states)
| {"/mkbsc/multiplayer_game.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/helper_functions.py"], "/main.py": ["/mkbsc/__init__.py"], "/mkbsc/__init__.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/multiplayer_game.py", "/mkbsc/serialization.py", "/mkbsc/helper_functions.py"], "/mkbsc/alphabet.py": ["/mkbsc/helper_functions.py"], "/mkbsc/serialization.py": ["/mkbsc/state.py", "/mkbsc/multiplayer_game.py"]} |
74,210 | HelmerNylen/mkbsc | refs/heads/master | /mkbsc/helper_functions.py | from itertools import combinations, chain
from collections import deque
def _permute(iterables):
"""Generate every permutation taking one item from each iterable
ex. _permute('ab', [1, 2]) -> ('a', 1), ('a', 2), ('b', 1), ('b', 2) in some order"""
iterables = tuple(iterable if hasattr(iterable, '__getitem__') else tuple(iterable) for iterable in iterables)
indexes = [0] * len(iterables)
for iterable in iterables:
if len(iterable) == 0:
return
while indexes[-1] < len(iterables[-1]):
yield tuple(iterables[i][indexes[i]] for i in range(len(iterables)))
i = 0
indexes[i] += 1
while indexes[i] >= len(iterables[i]) and i + 1 < len(iterables):
indexes[i] = 0
i += 1
indexes[i] += 1
def _lookup(states, knowledge, single_knowledge=True):
"""Find the state with the specified knowledge"""
if single_knowledge:
knowledge = (knowledge,)
for state in states:
if state.knowledges == knowledge:
return state
raise KeyError("Could not find a matching state")
def _lookup_by_base(states, base):
"""Find the state with the specified consistent base (see state.py)"""
res = set()
for state in states:
b = state.consistent_base()
if len(b) != len(base):
continue
base_to_check = base.copy()
include = True
for basestate in b:
for valid in base_to_check:
if basestate is valid or basestate.knowledges == (valid,):
base_to_check.remove(valid)
continue
include = False
break
if not include:
break
if include and len(base_to_check) == 0:
res.add(state)
return res
def _reachable(graph, initial):
"""Return all reachable nodes in a networkx graph reachable from a node"""
res = set()
to_check = deque([initial])
while len(to_check):
neighbors = graph.neighbors(to_check.pop())
for neighbor in neighbors:
if neighbor not in res:
to_check.appendleft(neighbor)
res.add(neighbor)
return res
def powerset(iterable):
"""Generate the powerset of an iterable"""
s = list(iterable)
return chain.from_iterable(combinations(s, r) for r in range(1, len(s)+1))
def consistent(states):
"""Return the states in the previous multiplayer game which are consistent, given a set of transformed singleplayer states"""
if not len(states) or len(states[0].knowledges) != 1:
return set()
res = set(states[0][0])
for state in states:
res = res.intersection(state[0])
return res
def iterate_until_isomorphic(G, limit=-1, print_size=False, verbose=True):
"""Iterate the MKBSC until the graph stabilizes or the limit is reached. Returns a log of graph sizes, the final game and whether the final game is stabilized
G -- the game to begin with
limit -- the maximum number of iterations. Use -1 (default) to remove the limit
print_size -- if true, continuously prints the size of the graph
verbose -- if false, logs only the number of nodes in the graph"""
current = G
currentK = None
i = 0
last_iso = 0
log = []
def p(index, size, iso=0):
if verbose:
s = "G" + str(index) + "K:\t" + str(size) + " nodes"
if iso == 1:
s += " (isomorphic)"
elif iso == 2:
s += " (isomorphic with equivalent observations)"
else:
s = size
if print_size:
print(s)
log.append(s)
p(0, len(G.states))
while limit == -1 or i < limit:
currentK = current.KBSC()
i += 1
if len(current.states) == len(currentK.states) and current.isomorphic(currentK):
if current.isomorphic(currentK, consider_observations=True):
last_iso = 2
p(i, len(currentK.states), 2)
break
else:
last_iso = 1
p(i, len(currentK.states), 1)
else:
last_iso = 0
p(i, len(currentK.states))
current = currentK
return log, current, last_iso
| {"/mkbsc/multiplayer_game.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/helper_functions.py"], "/main.py": ["/mkbsc/__init__.py"], "/mkbsc/__init__.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/multiplayer_game.py", "/mkbsc/serialization.py", "/mkbsc/helper_functions.py"], "/mkbsc/alphabet.py": ["/mkbsc/helper_functions.py"], "/mkbsc/serialization.py": ["/mkbsc/state.py", "/mkbsc/multiplayer_game.py"]} |
74,211 | HelmerNylen/mkbsc | refs/heads/master | /mkbsc/serialization.py | from .state import State
from .multiplayer_game import MultiplayerGame
from queue import LifoQueue
from json import dumps, loads
from subprocess import call
import os
def export(game, filename, view=True, folder="pictures", epistemic="nice", supress_edges=False, group_observations=None, target_states=None, **kwargs):
"""Exports the game as a picture
view -- if true, opens the file when done
folder -- the subfolder to save the picture in
epistemic -- how to render the states in the graph. Can be 'verbose', 'nice' or 'isocheck'
supress_edges -- if true, does not draw labels for the transitions
group_observations -- if true, the observations will be arranged in marked subgraphs. Only works for singleplayer games
target_states -- the states (or singleton knowledge in states) which should be marked in the rendered graph"""
with open(folder + "/" + filename + ".dot", "w") as dotfile:
dotfile.write(game.to_dot(epistemic=epistemic, supress_edges=supress_edges, group_observations=group_observations, target_states=target_states, **kwargs))
call(["dot", "-Tpng", folder + "/" + filename + ".dot", "-o", folder + "/" + filename + ".png"])
if view:
call(("start " if os.name == "nt" else "xdg-open ") + folder + "/" + filename + ".png", shell=True)
def from_file(filename, folder="games", fileext=".game", validate=True):
"""Import a game from a file
validate -- if false, skips the computationally expensive validation when creating the game"""
if folder and len(folder) != 0:
folder += "/"
else:
folder = ""
with open(folder + filename + fileext, encoding="utf8", newline="\n") as f:
try:
return _parse(f, validate)
except StopIteration as e:
raise EOFError from e
def from_string(string, validate=True):
"""Import a game from a string
validate -- if false, skips the computationally expensive validation when creating the game"""
try:
return _parse(string.split('\n'), validate)
except StopIteration as e:
raise ValueError from e
def to_file(game, filename, folder="games", fileext=".game"):
"""Export a game to a file"""
if folder and len(folder) != 0:
folder += "/"
else:
folder = ""
with open(folder + filename + fileext, mode="w", encoding="utf8", newline="\n") as f:
for line in _serialize(game):
f.write(line + "\n")
def to_string(game):
"""Export a game to a string"""
return "\n".join(_serialize(game))
def _serialize(game):
#Alphabet
yield "Alphabet:"
action_id = 0
alphabet_dicts = [{} for player in range(game.player_count)]
for i, playeralphabet in enumerate(game.alphabet):
for action in playeralphabet:
alphabet_dicts[i][action] = action_id
action_id += 1
yield ",".join([repr(action) for action in playeralphabet])
yield ""
#States
def _pick(_set):
for x in _set:
return x
raise None
state_id = 0
state_dict = {}
states = game.states
state_stack = LifoQueue()
while type(_pick(states)[0]) is frozenset:
newstates = set()
for state in states:
state_dict[state] = state_id
state_stack.put(state)
for player in range(game.player_count):
newstates.update(state[player])
state_id -= 1
states = newstates
id_add = abs(state_id) + len(states) - 1
yield "Base States:"
state_id -= len(states)
for state in states:
state_id += 1
state_dict[state] = state_id
yield "{0}={1}".format(state_id + id_add, repr(state[0]))
yield ""
yield "Knowledge States:"
while state_stack.qsize() != 0:
state = state_stack.get()
yield "{0}={1}".format(state_dict[state] + id_add, "|".join(map(lambda knowledge: ",".join([str(state_dict[s] + id_add) for s in knowledge]), state.knowledges)))
yield ""
yield "Initial State: " + str(state_dict[game.initial_state] + id_add)
yield ""
#Observations
yield "Observations:"
for partitioning in game.partitionings:
yield "|".join([",".join(str(state_dict[state] + id_add) for state in observation) for observation in partitioning])
yield ""
#Transitions
yield "Transitions:"
for transition in game.transitions:
yield "{0} {1} {2}".format(state_dict[transition.start] + id_add, ",".join([str(alphabet_dicts[player][action]) for player, action in enumerate(transition.joint_action)]), state_dict[transition.end] + id_add)
yield ""
yield "Attributes: " + dumps(game.graph.graph["graph"])
def _parse(iterable, validate=True):
iterator = iter(iterable)
iterator.__next__()
#Alphabet
alphabet_dict = {}
alphabet = []
line = iterator.__next__().strip()
action_id = 0
while line != "" and not line.isspace():
currentalphabet = []
i = 0
while i < len(line):
if line[i] in "\'\"":
nextquote = line.index(line[i], i + 1)
value = line[i + 1:nextquote]
i = nextquote + 2
currentalphabet.append(value)
alphabet_dict[action_id] = value
elif line[i].isdigit():
nextcomma = line.find(',', i)
if nextcomma == -1:
nextcomma = len(line)
value = int(line[i:nextcomma])
i = nextcomma + 1
currentalphabet.append(value)
alphabet_dict[action_id] = value
else:
raise TypeError(line, "Index: " + str(i))
action_id += 1
alphabet.append(currentalphabet)
line = iterator.__next__().strip()
iterator.__next__()
#Base States
state_dict = {}
top_states = set()
line = iterator.__next__()
while line != "" and not line.isspace():
id = int(line[:line.index("=")])
value = line[line.index("=") + 1:]
if value[0] in "\'\"":
value = value[1:-2]
elif value[0].isdigit():
value = int(value)
else:
raise TypeError(line, value)
state = State(value)
state_dict[id] = state
top_states.add(state)
line = iterator.__next__()
iterator.__next__()
#Knowledge States
line = iterator.__next__()
while line != "" and not line.isspace():
id = int(line[:line.index("=")])
knowledge = line[line.index("=") + 1:]
knowledge = [frozenset(state_dict[int(i)] for i in playerknowledge.split(",")) for playerknowledge in knowledge.split("|")]
state = State(*knowledge)
state_dict[id] = state
top_states.add(state)
for playerknowledge in knowledge:
top_states.difference_update(playerknowledge)
line = iterator.__next__()
line = iterator.__next__()
initial_state = state_dict[int(line[line.index(": ") + 2:])]
iterator.__next__()
iterator.__next__()
#Observations
state_groupings = []
line = iterator.__next__()
while line != "" and not line.isspace():
grouping = [[state_dict[int(s)] for s in observation.split(",")] for observation in line.split("|")]
state_groupings.append(grouping)
line = iterator.__next__()
iterator.__next__()
#Transitions
transitions = []
line = iterator.__next__()
while line != "" and not line.isspace():
transition = line.split(" ")
transition[0] = state_dict[int(transition[0])]
transition[2] = state_dict[int(transition[2])]
transition[1] = [alphabet_dict[int(action)] for action in transition[1].split(",")]
transitions.append(transition)
line = iterator.__next__()
line = iterator.__next__()
attributes = loads(line[line.index(": ") + 2:])
return MultiplayerGame._create_from_serialized(top_states, initial_state, alphabet, transitions, state_groupings, validate=validate, **attributes)
| {"/mkbsc/multiplayer_game.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/helper_functions.py"], "/main.py": ["/mkbsc/__init__.py"], "/mkbsc/__init__.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/multiplayer_game.py", "/mkbsc/serialization.py", "/mkbsc/helper_functions.py"], "/mkbsc/alphabet.py": ["/mkbsc/helper_functions.py"], "/mkbsc/serialization.py": ["/mkbsc/state.py", "/mkbsc/multiplayer_game.py"]} |
74,212 | HelmerNylen/mkbsc | refs/heads/master | /mkbsc/state.py | class State:
"""Represents a game state, with separate knowledge for each player
The knowledge is stored as a tuple, and can be accessed by State().knowledges[playerindex]
or simply State()[playerindex]. The players are zero-indexed. In the base game, the states'
knowledge should be an integer or short string, the same for all players. This case is
treated separately and the tuple State().knowledges is a singleton. When applying the KBSC, the new
states' knowledge are sets of states from the previous iteration. For example, after two
iterations the states' knowledge are sets of states, whose knowledge are sets of states,
whose knowledge could be integers."""
def __init__(self, *knowledges):
"""Create a new state
ex. s = State(1)"""
self.knowledges = tuple(knowledges)
def __getitem__(self, index):
"""Get the knowledge of the specified player
Will work as expected even if knowledges is a singleton"""
if len(self.knowledges) == 1:
return self.knowledges[0]
else:
return self.knowledges[index]
def __str__(self):
return repr(self)
compact_representation = False
def __repr__(self):
"""Return a compact string representation of the knowledge"""
#if we are writing to a dot file we only need a unique string, not the full representation
if State.compact_representation:
return str(id(self))
# return "s" + str(self.knowledges)
if len(self.knowledges) == 1:
if type(self.knowledges[0]) is frozenset:
return str(set(self.knowledges[0]))
else:
return str(self.knowledges[0])
else:
return str(tuple(set(self.knowledges[i]) for i in range(len(self.knowledges))))
__indent = "\t"
def epistemic_verbose(self, level=0):
"""Return a verbose representation of the knowledge. Not recommended for overly iterated games."""
if len(self.knowledges) == 1:
return State.__indent * level + "We are in " + str(self.knowledges[0]) + "\n"
s = ""
for player, knowledge in enumerate(self.knowledges):
s += State.__indent * level + "Player " + str(player) + " knows:\n"
s += (State.__indent * (level + 1) + "or\n").join([state.epistemic(level + 1) for state in knowledge])
return s
def epistemic_nice(self, level=0):
"""Return a compact but still quite readable representation of the knowledge"""
def __wrap(state, l):
if len(state.knowledges) > 1:
return "(" + state.epistemic_nice(l + 1) + ")"
else:
return str(state.knowledges[0])
if level == 0:
if len(self.knowledges) > 1:
return "\n".join(["{" + ", ".join([state.epistemic_nice(level + 1) for state in knowledge]) + "}" for knowledge in self.knowledges])
else:
if type(self.knowledges[0]) is frozenset:
return "{" + ", ".join([state.epistemic_nice(level + 1) for state in self.knowledges[0]]) + "}"
else:
return str(self.knowledges[0])
else:
if len(self.knowledges) > 1:
return "-".join(["".join([__wrap(state, level) for state in knowledge]) for knowledge in self.knowledges])
else:
if type(self.knowledges[0]) is frozenset:
return "{" + ", ".join([state.epistemic_nice(level + 1) for state in self.knowledges[0]]) + "}"
else:
return str(self.knowledges[0])
def epistemic_isocheck(self):
"""Return the most compact representation, only containing which states in the base game are possible in this state"""
return ", ".join([str(state.knowledges[0]) for state in self.consistent_base()])
def consistent_base(self):
"""Return the states in the base game that are possible in this state
This assumes that the knowledges in the base game are singletons"""
def _pick(_set):
for x in _set:
return x
raise None
states = [self]
if len(self.knowledges) == 1 and type(self.knowledges[0]) is frozenset:
states = {self.knowledges[0]}
while len(_pick(states).knowledges) > 1:
states = set.intersection(*[set.intersection(*[set(state[player]) for player in range(len(self.knowledges))]) for state in states])
return states
#workaround to make sure the networkx isomorphism check works
orderable = False
def __gt__(self, other):
assert State.orderable
return id(self) > id(other)
def __lt__(self, other):
assert State.orderable
return id(self) < id(other)
| {"/mkbsc/multiplayer_game.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/helper_functions.py"], "/main.py": ["/mkbsc/__init__.py"], "/mkbsc/__init__.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/multiplayer_game.py", "/mkbsc/serialization.py", "/mkbsc/helper_functions.py"], "/mkbsc/alphabet.py": ["/mkbsc/helper_functions.py"], "/mkbsc/serialization.py": ["/mkbsc/state.py", "/mkbsc/multiplayer_game.py"]} |
74,213 | HelmerNylen/mkbsc | refs/heads/master | /mkbsc/observation.py | import networkx as nx
from networkx.drawing.nx_pydot import to_pydot
class Observation:
"""Represents an observation of several states in a game"""
_idcounter = 0
def __init__(self, *states):
"""Create a new observation
ex. o = Observation(s0, s2, s3)"""
self.states = tuple(states)
self.id = Observation._idcounter
Observation._idcounter += 1
def __len__(self):
"""Return the number of states in the observation"""
return len(self.states)
def __iter__(self):
"""Iterate over the states"""
for state in self.states:
yield state
def _subgraph(self, attributes=None):
"""Generates a networkx subgraph of the states"""
subgraph = nx.Graph()
subgraph.add_nodes_from(self.states)
if not attributes:
attributes = { "style": "dashed" }
subgraph.graph["graph"] = attributes
return subgraph
def to_dot(self, attributes=None):
"""Returns the dot representation of the states in the observation"""
s = to_pydot(self._subgraph(attributes)).to_string()
s = "subgraph cluster" + str(self.id) + " {" + s[s.index("\n"):]
return s
| {"/mkbsc/multiplayer_game.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/helper_functions.py"], "/main.py": ["/mkbsc/__init__.py"], "/mkbsc/__init__.py": ["/mkbsc/alphabet.py", "/mkbsc/state.py", "/mkbsc/observation.py", "/mkbsc/partitioning.py", "/mkbsc/transition.py", "/mkbsc/multiplayer_game.py", "/mkbsc/serialization.py", "/mkbsc/helper_functions.py"], "/mkbsc/alphabet.py": ["/mkbsc/helper_functions.py"], "/mkbsc/serialization.py": ["/mkbsc/state.py", "/mkbsc/multiplayer_game.py"]} |
74,289 | nayem1703163/foodappdemo | refs/heads/master | /demo/urls.py | from django.contrib import admin
from django.urls import path
from rest_framework.urlpatterns import format_suffix_patterns
from demoapp import views
urlpatterns = [
path('admin/', admin.site.urls),
path('', views.restaurant_list_which_comes_from_database.as_view()),
]
| {"/demoapp/views.py": ["/demoapp/models.py"]} |
74,290 | nayem1703163/foodappdemo | refs/heads/master | /demoapp/views.py | from django.shortcuts import render
from django.http import HttpResponse
from django.shortcuts import get_object_or_404
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from .models import Restaurants
from .serializers import Resserializer
class restaurant_list_which_comes_from_database(APIView):
def get(self,request):
res = Restaurants.objects.all()
ser = Resserializer(res,many=True)
return Response(ser.data)
def post(self):
pass | {"/demoapp/views.py": ["/demoapp/models.py"]} |
74,291 | nayem1703163/foodappdemo | refs/heads/master | /demoapp/models.py | from django.db import models
class Restaurants (models.Model):
resname = models.CharField(max_length=200)
summary = models.CharField(max_length=200)
def __str__(self):
return self.resname
| {"/demoapp/views.py": ["/demoapp/models.py"]} |
74,293 | hypoxic/sequoia-ptpy | refs/heads/master | /ptpy/transports/ip.py | '''This module implements the IP transport layer for PTP.
It exports the IPTransport class. Both the transport layer and the basic PTP
implementation are Vendor agnostic. Vendor extensions should extend these to
support more operations.
'''
from __future__ import absolute_import
from ..ptp import PTPError
from ..util import _main_thread_alive
from construct import (
Array, Bytes, Container, Debugger, Embedded, Enum, ExprAdapter, Int16ul,
Int32ul, Int64ul, Int8ul, Pass, Range, RepeatUntil, Struct, Switch,
)
from six.moves.queue import Queue
import six
import sys
import socket
import logging
from contextlib import contextmanager
from threading import Thread, Event, Lock
from time import sleep, time
import atexit
# TODO: Deal with timeouts equivalent to those in the USB transport
logger = logging.getLogger(__name__)
__all__ = ('IPTransport')
__author__ = 'Luis Mario Domenzain'
# TODO: Implement discovery mechanisms for PTP/IP like zeroconf.
def actual_socket(sock_object):
"""Get the actual object with sendall and shutdown methods"""
return sock_object._sock if hasattr(sock_object, '_sock') else sock_object
def create_connection(address):
"""Connect to address and return the socket object. """
host, port = address
err = None
for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
af, socktype, proto, canonname, sa = res
sock = None
try:
sock = socket.socket(af, socktype, proto)
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
if 'darwin' not in sys.platform:
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_QUICKACK, 1)
sock.setsockopt(socket.IPPROTO_TCP, socket.SO_KEEPALIVE, 1)
sock.connect(sa)
return sock
except socket.error as _:
logger.error('socket.error: skipping address')
err = _
if sock is not None:
sock.close()
except Exception as e:
logger.error(e)
raise e
else:
raise PTPError('Impossible to connect to device')
if err is not None:
raise err
else:
raise socket.error("getaddrinfo returns an empty list")
class IPTransport(object):
'''Implement IP transport.'''
def __init__(self, device=None):
'''Instantiate the first available PTP device over IP'''
self.__setup_constructors()
logger.debug('Init IP')
self.__dev = device
if device is None:
raise NotImplementedError(
'IP discovery not implemented. Please provide a device.'
)
self.__device = device
# Signal usable implicit session
self.__implicit_session_open = Event()
# Signal implicit session is shutting down
self.__implicit_session_shutdown = Event()
self.__check_session_lock = Lock()
self.__transaction_lock = Lock()
self.__event_queue = Queue()
atexit.register(self._shutdown)
def _shutdown(self):
try:
self.__close_implicit_session()
except Exception as e:
logger.error(e)
@contextmanager
def __implicit_session(self):
'''Manage implicit sessions with responder'''
# There is now an implicit session
self.__check_session_lock.acquire()
if not self.__implicit_session_open.is_set():
try:
self.__open_implicit_session()
self.__check_session_lock.release()
yield
except Exception as e:
logger.error(e)
raise PTPError('Failed to open PTP/IP implicit session')
finally:
if self.__implicit_session_open.is_set():
self.__close_implicit_session()
if self.__check_session_lock.locked():
self.__check_session_lock.release()
else:
self.__check_session_lock.release()
yield
def __open_implicit_session(self):
'''Establish implicit session with responder'''
self.__implicit_session_shutdown.clear()
# Establish Command and Event connections
if type(self.__device) is tuple:
host, port = self.__device
self.__setup_connection(host, port)
else:
self.__setup_connection(self.__device)
self.__implicit_session_open.set()
# Prepare Event and Probe threads
self.__event_proc = Thread(
name='EvtPolling',
target=self.__poll_events
)
self.__event_proc.daemon = False
self.__ping_pong_proc = Thread(
name='PingPong',
target=self.__ping_pong
)
self.__ping_pong_proc.daemon = False
# Launch Event and Probe threads
self.__event_proc.start()
self.__ping_pong_proc.start()
def __close_implicit_session(self):
'''Terminate implicit session with responder'''
self.__implicit_session_shutdown.set()
if not self.__implicit_session_open.is_set():
return
# Only join running threads.
if self.__event_proc.is_alive():
self.__event_proc.join(2)
if self.__ping_pong_proc.is_alive():
self.__ping_pong_proc.join(2)
logger.debug('Close connections for {}'.format(repr(self.__dev)))
try:
self.__evtcon.shutdown(socket.SHUT_RDWR)
except socket.error as e:
if e.errno == 107:
pass
else:
raise e
try:
self.__cmdcon.shutdown(socket.SHUT_RDWR)
except socket.error as e:
if e.errno == 107:
pass
else:
raise e
self.__evtcon.close()
self.__cmdcon.close()
self.__implicit_session_open.clear()
def __setup_connection(self, host=None, port=15740):
'''Establish a PTP/IP session for a given host'''
logger.debug(
'Establishing PTP/IP connection with {}:{}'
.format(host, port)
)
socket.setdefaulttimeout(5)
hdrlen = self.__Header.sizeof()
# Command Connection Establishment
self.__cmdcon = create_connection((host, port))
# Send InitCommand
# TODO: Allow users to identify as an arbitrary initiator.
init_cmd_req_payload = self.__InitCommand.build(
Container(
InitiatorGUID=16*[0xFF],
InitiatorFriendlyName='PTPy',
InitiatorProtocolVersion=Container(
Major=100,
Minor=000,
),
))
init_cmd_req = self.__Packet.build(
Container(
Type='InitCommand',
Payload=init_cmd_req_payload,
)
)
actual_socket(self.__cmdcon).sendall(init_cmd_req)
# Get ACK/NACK
init_cmd_req_rsp = actual_socket(self.__cmdcon).recv(72)
init_cmd_rsp_hdr = self.__Header.parse(
init_cmd_req_rsp[0:hdrlen]
)
if init_cmd_rsp_hdr.Type == 'InitCommandAck':
cmd_ack = self.__InitCommandACK.parse(init_cmd_req_rsp[hdrlen:])
logger.debug(
'Command connection ({}) established'
.format(cmd_ack.ConnectionNumber)
)
elif init_cmd_rsp_hdr.Type == 'InitFail':
cmd_nack = self.__InitFail.parse(init_cmd_req_rsp[hdrlen:])
msg = 'InitCommand failed, Reason: {}'.format(
cmd_nack
)
logger.error(msg)
raise PTPError(msg)
else:
msg = 'Unexpected response Type to InitCommand : {}'.format(
init_cmd_rsp_hdr.Type
)
logger.error(msg)
raise PTPError(msg)
# Event Connection Establishment
self.__evtcon = create_connection((host, port))
self.__evtcon.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
self.__evtcon.setsockopt(socket.IPPROTO_TCP, socket.SO_KEEPALIVE, 1)
# Send InitEvent
payload = self.__InitEvent.build(Container(
ConnectionNumber=cmd_ack.ConnectionNumber,
))
evt_req = self.__Packet.build(
Container(
Type='InitEvent',
Payload=payload,
)
)
actual_socket(self.__evtcon).sendall(evt_req)
# Get ACK/NACK
init_evt_req_rsp = actual_socket(self.__evtcon).recv(
hdrlen + self.__InitFail.sizeof()
)
init_evt_rsp_hdr = self.__Header.parse(
init_evt_req_rsp[0:hdrlen]
)
if init_evt_rsp_hdr.Type == 'InitEventAck':
logger.debug(
'Event connection ({}) established'
.format(cmd_ack.ConnectionNumber)
)
elif init_evt_rsp_hdr.Type == 'InitFail':
evt_nack = self.__InitFail.parse(init_evt_req_rsp[hdrlen:])
msg = 'InitEvent failed, Reason: {}'.format(
evt_nack
)
logger.error(msg)
raise PTPError(msg)
else:
msg = 'Unexpected response Type to InitEvent : {}'.format(
init_evt_rsp_hdr.Type
)
logger.error(msg)
raise PTPError(msg)
# Helper methods.
# ---------------------
def __setup_constructors(self):
'''Set endianness and create transport-specific constructors.'''
# Set endianness of constructors before using them.
self._set_endian('little')
self.__Length = Int32ul
self.__Type = Enum(
Int32ul,
Undefined=0x00000000,
InitCommand=0x00000001,
InitCommandAck=0x00000002,
InitEvent=0x00000003,
InitEventAck=0x00000004,
InitFail=0x00000005,
Command=0x00000006,
Response=0x00000007,
Event=0x00000008,
StartData=0x00000009,
Data=0x0000000A,
Cancel=0x0000000B,
EndData=0x0000000C,
Ping=0x0000000D,
Pong=0x0000000E,
)
self.__Header = Struct(
'Length' / self.__Length,
'Type' / self.__Type,
)
self.__Param = Range(0, 5, self._Parameter)
self.__EventParam = Range(0, 3, self._Parameter)
self.__PacketBase = Struct(
Embedded(self.__Header),
'Payload' / Bytes(
lambda ctx, h=self.__Header: ctx.Length - h.sizeof()),
)
self.__Packet = ExprAdapter(
self.__PacketBase,
encoder=lambda obj, ctx, h=self.__Header: Container(
Length=len(obj.Payload) + h.sizeof(),
**obj
),
decoder=lambda obj, ctx: obj,
)
# Yet another arbitrary string type. Max-length CString utf8-encoded
self.__PTPIPString = ExprAdapter(
RepeatUntil(
lambda obj, ctx, lst:
six.unichr(obj) in '\x00' or len(lst) == 40, Int16ul
),
encoder=lambda obj, ctx:
[] if len(obj) == 0 else[ord(c) for c in six.text_type(obj)]+[0],
decoder=lambda obj, ctx:
u''.join(
[six.unichr(o) for o in obj]
).split('\x00')[0],
)
# PTP/IP packets
# Command
self.__ProtocolVersion = Struct(
'Major' / Int16ul,
'Minor' / Int16ul,
)
self.__InitCommand = Embedded(Struct(
'InitiatorGUID' / Array(16, Int8ul),
'InitiatorFriendlyName' / self.__PTPIPString,
'InitiatorProtocolVersion' / self.__ProtocolVersion,
))
self.__InitCommandACK = Embedded(Struct(
'ConnectionNumber' / Int32ul,
'ResponderGUID' / Array(16, Int8ul),
'ResponderFriendlyName' / self.__PTPIPString,
'ResponderProtocolVersion' / self.__ProtocolVersion,
))
# Event
self.__InitEvent = Embedded(Struct(
'ConnectionNumber' / Int32ul,
))
# Common to Events and Command requests
self.__Reason = Enum(
# TODO: Verify these codes...
Int32ul,
Undefined=0x0000,
RejectedInitiator=0x0001,
Busy=0x0002,
Unspecified=0x0003,
)
self.__InitFail = Embedded(Struct(
'Reason' / self.__Reason,
))
self.__DataphaseInfo = Enum(
Int32ul,
Undefined=0x00000000,
In=0x00000001,
Out=0x00000002,
)
self.__Command = Embedded(Struct(
'DataphaseInfo' / self.__DataphaseInfo,
'OperationCode' / self._OperationCode,
'TransactionID' / self._TransactionID,
'Parameter' / self.__Param,
))
self.__Response = Embedded(Struct(
'ResponseCode' / self._ResponseCode,
'TransactionID' / self._TransactionID,
'Parameter' / self.__Param,
))
self.__Event = Embedded(Struct(
'EventCode' / self._EventCode,
'TransactionID' / self._TransactionID,
'Parameter' / self.__EventParam,
))
self.__StartData = Embedded(Struct(
'TransactionID' / self._TransactionID,
'TotalDataLength' / Int64ul,
))
# TODO: Fix packing and unpacking dataphase data
self.__Data = Embedded(Struct(
'TransactionID' / self._TransactionID,
'Data' / Bytes(
lambda ctx:
ctx._.Length -
self.__Header.sizeof() -
self._TransactionID.sizeof()
),
))
self.__EndData = Embedded(Struct(
'TransactionID' / self._TransactionID,
'Data' / Bytes(
lambda ctx:
ctx._.Length -
self.__Header.sizeof() -
self._TransactionID.sizeof()
),
))
self.__Cancel = Embedded(Struct(
'TransactionID' / self._TransactionID,
))
# Convenience construct for parsing packets
self.__PacketPayload = Debugger(Struct(
'Header' / Embedded(self.__Header),
'Payload' / Embedded(Switch(
lambda ctx: ctx.Type,
{
'InitCommand': self.__InitCommand,
'InitCommandAck': self.__InitCommandACK,
'InitEvent': self.__InitEvent,
'InitFail': self.__InitFail,
'Command': self.__Command,
'Response': self.__Response,
'Event': self.__Event,
'StartData': self.__StartData,
'Data': self.__Data,
'EndData': self.__EndData,
},
default=Pass,
))
))
def __parse_response(self, ipdata):
'''Helper method for parsing data.'''
# Build up container with all PTP info.
response = self.__PacketPayload.parse(ipdata)
# Sneak in an implicit Session ID
response['SessionID'] = self.session_id
return response
def __recv(self, event=False, wait=False, raw=False):
'''Helper method for receiving packets.'''
hdrlen = self.__Header.sizeof()
with self.__implicit_session():
ip = (
actual_socket(self.__evtcon)
if event
else actual_socket(self.__cmdcon)
)
data = bytes()
while True:
try:
ipdata = ip.recv(hdrlen)
except socket.timeout:
if event:
return None
else:
ipdata = ip.recv(hdrlen)
if len(ipdata) == 0 and not event:
raise PTPError('Command connection dropped')
elif event:
return None
# Read a single entire header
while len(ipdata) < hdrlen:
ipdata += ip.recv(hdrlen - len(ipdata))
header = self.__Header.parse(
ipdata[0:hdrlen]
)
# Read a single entire packet
while len(ipdata) < header.Length:
ipdata += ip.recv(header.Length - len(ipdata))
# Run sanity checks.
if header.Type not in [
'Cancel',
'Data',
'Event',
'Response',
'StartData',
'EndData',
]:
raise PTPError(
'Unexpected PTP/IP packet type {}'
.format(header.Type)
)
if header.Type not in ['StartData', 'Data', 'EndData']:
break
else:
response = self.__parse_response(ipdata)
if header.Type == 'StartData':
expected = response.TotalDataLength
current_transaction = response.TransactionID
elif (
header.Type == 'Data' and
response.TransactionID == current_transaction
):
data += response.Data
elif (
header.Type == 'EndData' and
response.TransactionID == current_transaction
):
data += response.Data
datalen = len(data)
if datalen != expected:
logger.warning(
'{} data than expected {}/{}'
.format(
'More' if datalen > expected else 'Less',
datalen,
expected
)
)
response['Data'] = data
response['Type'] = 'Data'
return response
if raw:
# TODO: Deal with raw Data packets??
return ipdata
else:
return self.__parse_response(ipdata)
def __send(self, ptp_container, event=False):
'''Helper method for sending packets.'''
packet = self.__Packet.build(ptp_container)
ip = (
actual_socket(self.__evtcon)
if event
else actual_socket(self.__cmdcon)
)
while ip.sendall(packet) is not None:
logger.debug('Failed to send {} packet'.format(ptp_container.Type))
def __send_request(self, ptp_container):
'''Send PTP request without checking answer.'''
# Don't modify original container to keep abstraction barrier.
ptp = Container(**ptp_container)
# Send unused parameters always
ptp['Parameter'] += [0] * (5 - len(ptp.Parameter))
# Send request
ptp['Type'] = 'Command'
ptp['DataphaseInfo'] = 'In'
ptp['Payload'] = self.__Command.build(ptp)
self.__send(ptp)
def __send_data(self, ptp_container, data):
'''Send data without checking answer.'''
# Don't modify original container to keep abstraction barrier.
ptp = Container(**ptp_container)
# Send data
ptp['Type'] = 'Data'
ptp['DataphaseInfo'] = 'Out'
ptp['Payload'] = data
self.__send(ptp)
# Actual implementation
# ---------------------
def send(self, ptp_container, data):
'''Transfer operation with dataphase from initiator to responder'''
logger.debug('SEND {}{}'.format(
ptp_container.OperationCode,
' ' + str(list(map(hex, ptp_container.Parameter)))
if ptp_container.Parameter else '',
))
with self.__implicit_session():
with self.__transaction_lock:
self.__send_request(ptp_container)
self.__send_data(ptp_container, data)
# Get response and sneak in implicit SessionID and missing
# parameters.
return self.__recv()
def recv(self, ptp_container):
'''Transfer operation with dataphase from responder to initiator.'''
logger.debug('RECV {}{}'.format(
ptp_container.OperationCode,
' ' + str(list(map(hex, ptp_container.Parameter)))
if ptp_container.Parameter else '',
))
with self.__implicit_session():
with self.__transaction_lock:
self.__send_request(ptp_container)
dataphase = self.__recv()
if hasattr(dataphase, 'Data'):
response = self.__recv()
if (
(ptp_container.TransactionID != dataphase.TransactionID) or
(ptp_container.SessionID != dataphase.SessionID) or
(dataphase.TransactionID != response.TransactionID) or
(dataphase.SessionID != response.SessionID)
):
raise PTPError(
'Dataphase does not match with requested operation'
)
response['Data'] = dataphase.Data
return response
else:
return dataphase
def mesg(self, ptp_container):
'''Transfer operation without dataphase.'''
op = ptp_container['OperationCode']
if op == 'OpenSession':
self.__open_implicit_session()
with self.__implicit_session():
with self.__transaction_lock:
self.__send_request(ptp_container)
# Get response and sneak in implicit SessionID and missing
# parameters for FullResponse.
response = self.__recv()
rc = response['ResponseCode']
if op == 'OpenSession':
if rc != 'OK':
self.__close_implicit_session()
elif op == 'CloseSession':
if rc == 'OK':
self.__close_implicit_session()
return response
def event(self, wait=False):
'''Check event.
If `wait` this function is blocking. Otherwise it may return None.
'''
evt = None
ipdata = None
timeout = None if wait else 0.001
if not self.__event_queue.empty():
ipdata = self.__event_queue.get(block=not wait, timeout=timeout)
if ipdata is not None:
evt = self.__parse_response(ipdata)
return evt
def __poll_events(self):
'''Poll events, adding them to a queue.'''
logger.debug('Start')
while (
not self.__implicit_session_shutdown.is_set() and
self.__implicit_session_open.is_set() and
_main_thread_alive()
):
try:
evt = self.__recv(event=True, wait=False, raw=True)
except OSError as e:
if e.errno == 9 and not self.__implicit_session_open.is_set():
break
else:
raise e
if evt is not None:
logger.debug('Event queued')
self.__event_queue.put(evt)
sleep(5e-3)
logger.debug('Stop')
def __ping_pong(self):
'''Poll events, adding them to a queue.'''
logger.debug('Start')
last = time()
while (
not self.__implicit_session_shutdown.is_set() and
self.__implicit_session_open.is_set() and
_main_thread_alive()
):
if time() - last > 10:
logger.debug('PING')
# TODO: implement Ping Pong
last = time()
sleep(0.10)
logger.debug('Stop')
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,294 | hypoxic/sequoia-ptpy | refs/heads/master | /tests/hardware/conftest.py | from ..context import ptpy
import pytest
available_camera = None
try:
available_camera = ptpy.PTPy(knowledge=False)
except Exception as e:
print(e)
pass
# Use the same camera for a testing session. And skip all tests that use it.
@pytest.fixture(scope='session', autouse=True)
def camera():
if available_camera is None:
if not pytest.config.getoption('--expect-camera'):
pytest.skip('No camera available to test')
else:
pytest.fail('Expected a camera but None was found')
return available_camera
# Each test gets the latest operations and properties supported, since these
# may change on different functional modes.
@pytest.fixture(scope='function', autouse=True)
def device_properties(camera):
device_props = (
camera.get_device_info().DevicePropertiesSupported if camera else []
)
return device_props
@pytest.fixture(scope='function', autouse=True)
def device_operations(camera):
device_ops = (
camera.get_device_info().OperationsSupported if camera else []
)
return device_ops
# TODO: This is a hacky solution to the lack of fixtures in parametrize. It
# should be expunged if pytests ends up fixing that.
def pytest_generate_tests(metafunc):
if 'device_property' in metafunc.fixturenames:
device_properties = (
available_camera.get_device_info().DevicePropertiesSupported if
available_camera else []
)
metafunc.parametrize('device_property', device_properties)
if 'device_operation' in metafunc.fixturenames:
device_operations = (
available_camera.get_device_info().OperationsSupported if
available_camera else []
)
metafunc.parametrize('device_property', device_operations)
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,295 | hypoxic/sequoia-ptpy | refs/heads/master | /ptpy/util.py | '''This module holds general utilities'''
from threading import enumerate as threading_enumerate
def _main_thread_alive():
return any(
(i.name == "MainThread") and i.is_alive() for i in
threading_enumerate())
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,296 | hypoxic/sequoia-ptpy | refs/heads/master | /tests/hardware/test_compliance.py | from .test_camera import TestCamera
class TestCompliance(TestCamera):
mandatory_PIMA_15740_2000 = set([
'GetDeviceInfo',
'OpenSession',
'CloseSession',
'GetStorageIDs',
'GetStorageInfo',
])
mandatory_PIMA_15740_2000_pull = set([
'GetNumObjects',
'GetObjectHandles',
'GetObjectInfo',
'GetObject',
'GetThumb',
])
mandatory_PIMA_15740_2000_push = set([
'SendObjectInfo',
'SendObject',
])
# Microsoft Windows needs support for PIMA 15740:2000 Pull mode minus
# 'GetNumObjects'
windows_required = set(
op for op in mandatory_PIMA_15740_2000_pull if op != 'GetNumObjects'
)
# ISO 15740:2013 is fully backwards compatible with PIMA 15740:2000
mandatory_ISO_15740_2013 = mandatory_PIMA_15740_2000
mandatory_ISO_15740_2013_pull = mandatory_PIMA_15740_2000_pull
mandatory_ISO_15740_2013_push = mandatory_PIMA_15740_2000_push
def test_PIMA_15740_2000_mandatory(self, device_operations):
'''
Verify mandatory commands as specified by PIMA15740:2000
'''
supported = set(device_operations)
assert self.mandatory_PIMA_15740_2000.issubset(supported),\
'Not all PIMA 15740:2000 mandatory operations are supported.'
assert self.mandatory_PIMA_15740_2000_pull.issubset(supported) or \
self.mandatory_PIMA_15740_2000_push.issubset(supported),\
'PIMA 15740:2000 requires either pull or push mode.'\
'Neither is supported.'
def test_ISO_15740_2013_mandatory(self, device_operations):
'''
Verify mandatory commands as specified by ISO 15740:2013(E)
'''
supported = set(device_operations)
assert self.mandatory_ISO_15740_2013.issubset(supported)
assert self.mandatory_ISO_15740_2013_pull.issubset(supported) or \
self.mandatory_ISO_15740_2013_push.issubset(supported),\
'ISO 15740:2013(E) requires either pull or push mode.'\
'Neither is supported.'
def test_microsoft_windows_support(self, device_operations):
'''
Verify commands necessary for Microsoft Windows support.
'''
supported = set(device_operations)
assert self.windows_required.issubset(supported),\
'Operations for Microsoft Windows support are missing.'
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,297 | hypoxic/sequoia-ptpy | refs/heads/master | /examples/poll_events.py | #!/usr/bin/env python
import ptpy
camera = ptpy.PTPy()
with camera.session():
while True:
evt = camera.event()
if evt:
print(evt)
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,298 | hypoxic/sequoia-ptpy | refs/heads/master | /ptpy/extensions/nikon.py | '''This module extends PTP for Nikon devices.
Use it in a master module that determines the vendor and automatically uses its
extension. This is why inheritance is not explicit.
'''
from ..util import _main_thread_alive
from construct import (
Container, PrefixedArray, Struct,
)
from contextlib import contextmanager
from six.moves.queue import Queue
from threading import Thread, Event
from time import sleep
import atexit
import logging
logger = logging.getLogger(__name__)
__all__ = ('Nikon',)
class Nikon(object):
'''This class implements Nikon's PTP operations.'''
def __init__(self, *args, **kwargs):
logger.debug('Init Nikon')
super(Nikon, self).__init__(*args, **kwargs)
# TODO: expose the choice to poll or not Nikon events
self.__no_polling = False
self.__nikon_event_shutdown = Event()
self.__nikon_event_proc = None
@contextmanager
def session(self):
'''
Manage Nikon session with context manager.
'''
# When raw device, do not perform
if self.__no_polling:
with super(Nikon, self).session():
yield
return
# Within a normal PTP session
with super(Nikon, self).session():
# launch a polling thread
self.__event_queue = Queue()
self.__nikon_event_proc = Thread(
name='NikonEvtPolling',
target=self.__nikon_poll_events
)
self.__nikon_event_proc.daemon = False
atexit.register(self._nikon_shutdown)
self.__nikon_event_proc.start()
try:
yield
finally:
self._nikon_shutdown()
def _shutdown(self):
self._nikon_shutdown()
super(Nikon, self)._shutdown()
def _nikon_shutdown(self):
logger.debug('Shutdown Nikon events')
self.__nikon_event_shutdown.set()
# Only join a running thread.
if self.__nikon_event_proc and self.__nikon_event_proc.is_alive():
self.__nikon_event_proc.join(2)
def _PropertyCode(self, **product_properties):
props = {
'ShootingBank': 0xD010,
'ShootingBankNameA': 0xD011,
'ShootingBankNameB': 0xD012,
'ShootingBankNameC': 0xD013,
'ShootingBankNameD': 0xD014,
'ResetBank0': 0xD015,
'RawCompression': 0xD016,
'WhiteBalanceAutoBias': 0xD017,
'WhiteBalanceTungstenBias': 0xD018,
'WhiteBalanceFluorescentBias': 0xD019,
'WhiteBalanceDaylightBias': 0xD01A,
'WhiteBalanceFlashBias': 0xD01B,
'WhiteBalanceCloudyBias': 0xD01C,
'WhiteBalanceShadeBias': 0xD01D,
'WhiteBalanceColorTemperature': 0xD01E,
'WhiteBalancePresetNo': 0xD01F,
'WhiteBalancePresetName0': 0xD020,
'WhiteBalancePresetName1': 0xD021,
'WhiteBalancePresetName2': 0xD022,
'WhiteBalancePresetName3': 0xD023,
'WhiteBalancePresetName4': 0xD024,
'WhiteBalancePresetVal0': 0xD025,
'WhiteBalancePresetVal1': 0xD026,
'WhiteBalancePresetVal2': 0xD027,
'WhiteBalancePresetVal3': 0xD028,
'WhiteBalancePresetVal4': 0xD029,
'ImageSharpening': 0xD02A,
'ToneCompensation': 0xD02B,
'ColorModel': 0xD02C,
'HueAdjustment': 0xD02D,
'NonCPULensDataFocalLength': 0xD02E,
'NonCPULensDataMaximumAperture': 0xD02F,
'ShootingMode': 0xD030,
'JPEGCompressionPolicy': 0xD031,
'ColorSpace': 0xD032,
'AutoDXCrop': 0xD033,
'FlickerReduction': 0xD034,
'RemoteMode': 0xD035,
'VideoMode': 0xD036,
'NikonEffectMode': 0xD037,
'Mode': 0xD038,
'CSMMenuBankSelect': 0xD040,
'MenuBankNameA': 0xD041,
'MenuBankNameB': 0xD042,
'MenuBankNameC': 0xD043,
'MenuBankNameD': 0xD044,
'ResetBank': 0xD045,
'A1AFCModePriority': 0xD048,
'A2AFSModePriority': 0xD049,
'A3GroupDynamicAF': 0xD04A,
'A4AFActivation': 0xD04B,
'FocusAreaIllumManualFocus': 0xD04C,
'FocusAreaIllumContinuous': 0xD04D,
'FocusAreaIllumWhenSelected': 0xD04E,
'FocusAreaWrap': 0xD04F,
'VerticalAFON': 0xD050,
'AFLockOn': 0xD051,
'FocusAreaZone': 0xD052,
'EnableCopyright': 0xD053,
'ISOAuto': 0xD054,
'EVISOStep': 0xD055,
'EVStep': 0xD056,
'EVStepExposureComp': 0xD057,
'ExposureCompensation': 0xD058,
'CenterWeightArea': 0xD059,
'ExposureBaseMatrix': 0xD05A,
'ExposureBaseCenter': 0xD05B,
'ExposureBaseSpot': 0xD05C,
'LiveViewAFArea': 0xD05D,
'AELockMode': 0xD05E,
'AELAFLMode': 0xD05F,
'LiveViewAFFocus': 0xD061,
'MeterOff': 0xD062,
'SelfTimer': 0xD063,
'MonitorOff': 0xD064,
'ImgConfTime': 0xD065,
'AutoOffTimers': 0xD066,
'AngleLevel': 0xD067,
'D1ShootingSpeed': 0xD068,
'D2MaximumShots': 0xD069,
'ExposureDelayMode': 0xD06A,
'LongExposureNoiseReduction': 0xD06B,
'FileNumberSequence': 0xD06C,
'ControlPanelFinderRearControl': 0xD06D,
'ControlPanelFinderViewfinder': 0xD06E,
'D7Illumination': 0xD06F,
'NrHighISO': 0xD070,
'SHSetCHGUIDDisp': 0xD071,
'ArtistName': 0xD072,
'NikonCopyrightInfo': 0xD073,
'FlashSyncSpeed': 0xD074,
'FlashShutterSpeed': 0xD075,
'E3AAFlashMode': 0xD076,
'E4ModelingFlash': 0xD077,
'BracketSet': 0xD078,
'E6ManualModeBracketing': 0xD079,
'BracketOrder': 0xD07A,
'E8AutoBracketSelection': 0xD07B,
'BracketingSet': 0xD07C,
'F1CenterButtonShootingMode': 0xD080,
'CenterButtonPlaybackMode': 0xD081,
'F2Multiselector': 0xD082,
'F3PhotoInfoPlayback': 0xD083,
'F4AssignFuncButton': 0xD084,
'F5CustomizeCommDials': 0xD085,
'ReverseCommandDial': 0xD086,
'ApertureSetting': 0xD087,
'MenusAndPlayback': 0xD088,
'F6ButtonsAndDials': 0xD089,
'NoCFCard': 0xD08A,
'CenterButtonZoomRatio': 0xD08B,
'FunctionButton2': 0xD08C,
'AFAreaPoint': 0xD08D,
'NormalAFOn': 0xD08E,
'CleanImageSensor': 0xD08F,
'ImageCommentString': 0xD090,
'ImageCommentEnable': 0xD091,
'ImageRotation': 0xD092,
'ManualSetLensNo': 0xD093,
'MovScreenSize': 0xD0A0,
'MovVoice': 0xD0A1,
'MovMicrophone': 0xD0A2,
'MovFileSlot': 0xD0A3,
'MovRecProhibitCondition': 0xD0A4,
'ManualMovieSetting': 0xD0A6,
'MovQuality': 0xD0A7,
'LiveViewScreenDisplaySetting': 0xD0B2,
'MonitorOffDelay': 0xD0B3,
'Bracketing': 0xD0C0,
'AutoExposureBracketStep': 0xD0C1,
'AutoExposureBracketProgram': 0xD0C2,
'AutoExposureBracketCount': 0xD0C3,
'WhiteBalanceBracketStep': 0xD0C4,
'WhiteBalanceBracketProgram': 0xD0C5,
'LensID': 0xD0E0,
'LensSort': 0xD0E1,
'LensType': 0xD0E2,
'FocalLengthMin': 0xD0E3,
'FocalLengthMax': 0xD0E4,
'MaxApAtMinFocalLength': 0xD0E5,
'MaxApAtMaxFocalLength': 0xD0E6,
'FinderISODisp': 0xD0F0,
'AutoOffPhoto': 0xD0F2,
'AutoOffMenu': 0xD0F3,
'AutoOffInfo': 0xD0F4,
'SelfTimerShootNum': 0xD0F5,
'VignetteCtrl': 0xD0F7,
'AutoDistortionControl': 0xD0F8,
'SceneMode': 0xD0F9,
'SceneMode2': 0xD0FD,
'SelfTimerInterval': 0xD0FE,
'NikonExposureTime': 0xD100,
'ACPower': 0xD101,
'WarningStatus': 0xD102,
'MaximumShots': 0xD103,
'AFLockStatus': 0xD104,
'AELockStatus': 0xD105,
'FVLockStatus': 0xD106,
'AutofocusLCDTopMode2': 0xD107,
'AutofocusArea': 0xD108,
'FlexibleProgram': 0xD109,
'LightMeter': 0xD10A,
'RecordingMedia': 0xD10B,
'USBSpeed': 0xD10C,
'CCDNumber': 0xD10D,
'CameraOrientation': 0xD10E,
'GroupPtnType': 0xD10F,
'FNumberLock': 0xD110,
'ExposureApertureLock': 0xD111,
'TVLockSetting': 0xD112,
'AVLockSetting': 0xD113,
'IllumSetting': 0xD114,
'FocusPointBright': 0xD115,
'ExternalFlashAttached': 0xD120,
'ExternalFlashStatus': 0xD121,
'ExternalFlashSort': 0xD122,
'ExternalFlashMode': 0xD123,
'ExternalFlashCompensation': 0xD124,
'NewExternalFlashMode': 0xD125,
'FlashExposureCompensation': 0xD126,
'HDRMode': 0xD130,
'HDRHighDynamic': 0xD131,
'HDRSmoothing': 0xD132,
'OptimizeImage': 0xD140,
'Saturation': 0xD142,
'BWFillerEffect': 0xD143,
'BWSharpness': 0xD144,
'BWContrast': 0xD145,
'BWSettingType': 0xD146,
'Slot2SaveMode': 0xD148,
'RawBitMode': 0xD149,
'ActiveDLighting': 0xD14E,
'FlourescentType': 0xD14F,
'TuneColourTemperature': 0xD150,
'TunePreset0': 0xD151,
'TunePreset1': 0xD152,
'TunePreset2': 0xD153,
'TunePreset3': 0xD154,
'TunePreset4': 0xD155,
'BeepOff': 0xD160,
'AutofocusMode': 0xD161,
'AFAssist': 0xD163,
'PADVPMode': 0xD164,
'ImageReview': 0xD165,
'AFAreaIllumination': 0xD166,
'NikonFlashMode': 0xD167,
'FlashCommanderMode': 0xD168,
'FlashSign': 0xD169,
'_ISOAuto': 0xD16A,
'RemoteTimeout': 0xD16B,
'GridDisplay': 0xD16C,
'FlashModeManualPower': 0xD16D,
'FlashModeCommanderPower': 0xD16E,
'AutoFP': 0xD16F,
'DateImprintSetting': 0xD170,
'DateCounterSelect': 0xD171,
'DateCountData': 0xD172,
'DateCountDisplaySetting': 0xD173,
'RangeFinderSetting': 0xD174,
'CSMMenu': 0xD180,
'WarningDisplay': 0xD181,
'BatteryCellKind': 0xD182,
'ISOAutoHiLimit': 0xD183,
'DynamicAFArea': 0xD184,
'ContinuousSpeedHigh': 0xD186,
'InfoDispSetting': 0xD187,
'PreviewButton': 0xD189,
'PreviewButton2': 0xD18A,
'AEAFLockButton2': 0xD18B,
'IndicatorDisp': 0xD18D,
'CellKindPriority': 0xD18E,
'BracketingFramesAndSteps': 0xD190,
'LiveViewMode': 0xD1A0,
'LiveViewDriveMode': 0xD1A1,
'LiveViewStatus': 0xD1A2,
'LiveViewImageZoomRatio': 0xD1A3,
'LiveViewProhibitCondition': 0xD1A4,
'MovieShutterSpeed': 0xD1A8,
'MovieFNumber': 0xD1A9,
'MovieISO': 0xD1AA,
'LiveViewMovieMode': 0xD1AC,
'ExposureDisplayStatus': 0xD1B0,
'ExposureIndicateStatus': 0xD1B1,
'InfoDispErrStatus': 0xD1B2,
'ExposureIndicateLightup': 0xD1B3,
'FlashOpen': 0xD1C0,
'FlashCharged': 0xD1C1,
'FlashMRepeatValue': 0xD1D0,
'FlashMRepeatCount': 0xD1D1,
'FlashMRepeatInterval': 0xD1D2,
'FlashCommandChannel': 0xD1D3,
'FlashCommandSelfMode': 0xD1D4,
'FlashCommandSelfCompensation': 0xD1D5,
'FlashCommandSelfValue': 0xD1D6,
'FlashCommandAMode': 0xD1D7,
'FlashCommandACompensation': 0xD1D8,
'FlashCommandAValue': 0xD1D9,
'FlashCommandBMode': 0xD1DA,
'FlashCommandBCompensation': 0xD1DB,
'FlashCommandBValue': 0xD1DC,
'ApplicationMode': 0xD1F0,
'ActiveSlot': 0xD1F2,
'ActivePicCtrlItem': 0xD200,
'ChangePicCtrlItem': 0xD201,
'MovieNrHighISO': 0xD236,
'D241': 0xD241,
'D244': 0xD244,
'D247': 0xD247,
'GUID': 0xD24F,
'D250': 0xD250,
'D251': 0xD251,
'ISO': 0xF002,
'ImageCompression': 0xF009,
'NikonImageSize': 0xF00A,
'NikonWhiteBalance': 0xF00C,
# TODO: Are these redundant? Or product-specific?
'_LongExposureNoiseReduction': 0xF00D,
'HiISONoiseReduction': 0xF00E,
'_ActiveDLighting': 0xF00F,
'_MovQuality': 0xF01C,
}
product_properties.update(props)
return super(Nikon, self)._PropertyCode(
**product_properties
)
def _OperationCode(self, **product_operations):
return super(Nikon, self)._OperationCode(
GetProfileAllData=0x9006,
SendProfileData=0x9007,
DeleteProfile=0x9008,
SetProfileData=0x9009,
AdvancedTransfer=0x9010,
GetFileInfoInBlock=0x9011,
Capture=0x90C0,
AFDrive=0x90C1,
SetControlMode=0x90C2,
DelImageSDRAM=0x90C3,
GetLargeThumb=0x90C4,
CurveDownload=0x90C5,
CurveUpload=0x90C6,
CheckEvents=0x90C7,
DeviceReady=0x90C8,
SetPreWBData=0x90C9,
GetVendorPropCodes=0x90CA,
AFCaptureSDRAM=0x90CB,
GetPictCtrlData=0x90CC,
SetPictCtrlData=0x90CD,
DelCstPicCtrl=0x90CE,
GetPicCtrlCapability=0x90CF,
GetPreviewImg=0x9200,
StartLiveView=0x9201,
EndLiveView=0x9202,
GetLiveViewImg=0x9203,
MfDrive=0x9204,
ChangeAFArea=0x9205,
AFDriveCancel=0x9206,
InitiateCaptureRecInMedia=0x9207,
GetVendorStorageIDs=0x9209,
StartMovieRecInCard=0x920A,
EndMovieRec=0x920B,
TerminateCapture=0x920C,
GetDevicePTPIPInfo=0x90E0,
GetPartialObjectHiSpeed=0x9400,
GetDevicePropEx=0x9504,
**product_operations
)
def _ResponseCode(self, **product_responses):
return super(Nikon, self)._ResponseCode(
HardwareError=0xA001,
OutOfFocus=0xA002,
ChangeCameraModeFailed=0xA003,
InvalidStatus=0xA004,
SetPropertyNotSupported=0xA005,
WbResetError=0xA006,
DustReferenceError=0xA007,
ShutterSpeedBulb=0xA008,
MirrorUpSequence=0xA009,
CameraModeNotAdjustFNumber=0xA00A,
NotLiveView=0xA00B,
MfDriveStepEnd=0xA00C,
MfDriveStepInsufficiency=0xA00E,
AdvancedTransferCancel=0xA022,
**product_responses
)
def _EventCode(self, **product_events):
return super(Nikon, self)._EventCode(
ObjectAddedInSDRAM=0xC101,
CaptureCompleteRecInSdram=0xC102,
AdvancedTransfer=0xC103,
PreviewImageAdded=0xC104,
**product_events
)
def _FilesystemType(self, **product_filesystem_types):
return super(Nikon, self)._FilesystemType(
**product_filesystem_types
)
def _NikonEvent(self):
return PrefixedArray(
self._UInt16,
Struct(
'EventCode' / self._EventCode,
'Parameter' / self._UInt32,
)
)
def _set_endian(self, endian):
logger.debug('Set Nikon endianness')
super(Nikon, self)._set_endian(endian)
self._NikonEvent = self._NikonEvent()
# TODO: Add event queue over all transports and extensions.
def check_events(self):
'''Check Nikon specific event'''
ptp = Container(
OperationCode='CheckEvents',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.recv(ptp)
return self._parse_if_data(response, self._NikonEvent)
# TODO: Provide a single camera agnostic command that will trigger a camera
def capture(self):
'''Nikon specific capture'''
ptp = Container(
OperationCode='Capture',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
return self.mesg(ptp)
def af_capture_sdram(self):
'''Nikon specific autofocus and capture to SDRAM'''
ptp = Container(
OperationCode='AFCaptureSDRAM',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
return self.mesg(ptp)
def event(self, wait=False):
'''Check Nikon or PTP events
If `wait` this function is blocking. Otherwise it may return None.
'''
# TODO: Do something reasonable on wait=True
evt = None
timeout = None if wait else 0.001
# TODO: Join queues to preserve order of Nikon and PTP events.
if not self.__event_queue.empty():
evt = self.__event_queue.get(block=not wait, timeout=timeout)
else:
evt = super(Nikon, self).event(wait=wait)
return evt
def __nikon_poll_events(self):
'''Poll events, adding them to a queue.'''
while (not self.__nikon_event_shutdown.is_set() and
_main_thread_alive()):
try:
evts = self.check_events()
if evts:
for evt in evts:
logger.debug('Event queued')
self.__event_queue.put(evt)
except Exception as e:
logger.error(e)
sleep(3)
self.__nikon_event_shutdown.clear()
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,299 | hypoxic/sequoia-ptpy | refs/heads/master | /ptpy/extensions/microsoft.py | '''This module extends PTP for Microsoft/MTP devices.
Use it in a master module that determines the vendor and automatically uses its
extension. This is why inheritance is not explicit.
'''
import logging
logger = logging.getLogger(__name__)
__all__ = ('Microsoft',)
class Microsoft(object):
'''This class implements Canon's PTP operations.'''
def __init__(self, *args, **kwargs):
logger.debug('Init Microsoft')
super(Microsoft, self).__init__(*args, **kwargs)
def _PropertyCode(self, **product_properties):
return super(Microsoft, self)._PropertyCode(
SynchronizationPartner=0xD401,
DeviceFriendlyName=0xD402,
Volume=0xD403,
SupportedFormatsOrdered=0xD404,
DeviceIcon=0xD405,
SessionInitiatorVendorInfo=0xD406,
PerceivedDeviceType=0xD407,
PlaybackRate=0xD410,
PlaybackObject=0xD411,
PlaybackContainerIndex=0xD412,
**product_properties
)
def _OperationCode(self, **product_operations):
return super(Microsoft, self)._OperationCode(
GetObjectPropsSupported=0x9801,
GetObjectPropDesc=0x9802,
GetObjectPropValue=0x9803,
SetObjectPropValue=0x9804,
GetObjPropList=0x9805,
SetObjPropList=0x9806,
GetInterdependendPropdesc=0x9807,
SendObjectPropList=0x9808,
GetObjectReferences=0x9810,
SetObjectReferences=0x9811,
UpdateDeviceFirmware=0x9812,
Skip=0x9820,
# microsoft.com/WMDRMPD
GetSecureTimeChallenge=0x9101,
GetSecureTimeResponse=0x9102,
SetLicenseResponse=0x9103,
GetSyncList=0x9104,
SendMeterChallengeQuery=0x9105,
GetMeterChallenge=0x9106,
SetMeterResponse=0x9107,
CleanDataStore=0x9108,
GetLicenseState=0x9109,
SendWMDRMPDCommand=0x910A,
SendWMDRMPDRequest=0x910B,
SendWMDRMPDAppRequest=0x9212,
GetWMDRMPDAppResponse=0x9213,
EnableTrustedFilesOperations=0x9214,
DisableTrustedFilesOperations=0x9215,
EndTrustedAppSession=0x9216,
# microsoft.com/AAVT
OpenMediaSession=0x9170,
CloseMediaSession=0x9171,
GetNextDataBlock=0x9172,
SetCurrentTimePosition=0x9173,
# microsoft.com/WMDRMND: 1.0
SendRegistrationRequest=0x9180,
GetRegistrationResponse=0x9181,
GetProximityChallenge=0x9182,
SendProximityResponse=0x9183,
SendWMDRMNDLicenseRequest=0x9184,
GetWMDRMNDLicenseResponse=0x9185,
# microsoft.com/WMPPD: 11.1
ReportAddedDeletedItems=0x9201,
ReportAcquiredItems=0x9202,
PlaylistObjectPref=0x9203,
# microsoft.com/WPDWCN
ProcessWFCObject=0x9122,
**product_operations
)
def _ResponseCode(self, **product_responses):
return super(Microsoft, self)._ResponseCode(
MicrosoftUndefined=0xA800,
Invalid_ObjectPropCode=0xA801,
Invalid_ObjectProp_Format=0xA802,
Invalid_ObjectProp_Value=0xA803,
Invalid_ObjectReference=0xA804,
Invalid_Dataset=0xA806,
Specification_By_Group_Unsupported=0xA807,
Specification_By_Depth_Unsupported=0xA808,
Object_Too_Large=0xA809,
ObjectProp_Not_Supported=0xA80A,
# microsoft.com/AAVT 1.0,
Invalid_Media_Session_ID=0xA170,
Media_Session_Limit_Reached=0xA171,
No_More_Data=0xA172,
# microsoft.com/WPDWCN: 1.0,
Invalid_WFC_Syntax=0xA121,
WFC_Version_Not_Supported=0xA122,
**product_responses
)
def _EventCode(self, **product_events):
return super(Microsoft, self)._EventCode(
ObjectPropChanged=0xC801,
ObjectPropDescChanged=0xC802,
ObjectReferencesChanged=0xC803,
**product_events
)
def _FilesystemType(self, **product_filesystem_types):
return super(Microsoft, self)._FilesystemType(
**product_filesystem_types
)
def _ObjectFormatCode(self, **product_object_formats):
'''Return desired endianness for known ObjectFormatCode'''
return super(Microsoft, self)._ObjectFormatCode(
MediaCard=0xb211,
MediaCardGroup=0xb212,
Encounter=0xb213,
EncounterBox=0xb214,
M4A=0xb215,
Firmware=0xb802,
WindowsImageFormat=0xb881,
UndefinedAudio=0xb900,
WMA=0xb901,
OGG=0xb902,
AAC=0xb903,
AudibleCodec=0xb904,
FLAC=0xb906,
SamsungPlaylist=0xb909,
UndefinedVideo=0xb980,
WMV=0xb981,
MP4=0xb982,
MP2=0xb983,
Mobile3GP=0xb984,
UndefinedCollection=0xba00,
AbstractMultimediaAlbum=0xba01,
AbstractImageAlbum=0xba02,
AbstractAudioAlbum=0xba03,
AbstractVideoAlbum=0xba04,
AbstractAudioVideoPlaylist=0xba05,
AbstractContactGroup=0xba06,
AbstractMessageFolder=0xba07,
AbstractChapteredProduction=0xba08,
AbstractAudioPlaylist=0xba09,
AbstractVideoPlaylist=0xba0a,
AbstractMediacast=0xba0b,
WPLPlaylist=0xba10,
M3UPlaylist=0xba11,
MPLPlaylist=0xba12,
ASXPlaylist=0xba13,
PLSPlaylist=0xba14,
UndefinedDocument=0xba80,
AbstractDocument=0xba81,
XMLDocument=0xba82,
MSWordDocument=0xba83,
MHTCompiledHTMLDocument=0xba84,
MSExcelSpreadsheetXLS=0xba85,
MSPowerpointPresentationPPT=0xba86,
UndefinedMessage=0xbb00,
AbstractMessage=0xbb01,
UndefinedContact=0xbb80,
AbstractContact=0xbb81,
vCard2=0xbb82,
vCard3=0xbb83,
UndefinedCalendarItem=0xbe00,
AbstractCalendarItem=0xbe01,
vCalendar1=0xbe02,
vCalendar2=0xbe03,
UndefinedWindowsExecutable=0xbe80,
MediaCast=0xbe81,
Section=0xbe82,
**product_object_formats
)
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,300 | hypoxic/sequoia-ptpy | refs/heads/master | /tests/conftest.py | from .context import ptpy
def pytest_addoption(parser):
parser.addoption(
"--ideal", action="store_true",
help="Check also for problems that are beyond ISO 15740:2013(EN)"
)
parser.addoption(
"--expect-camera", action="store_true",
help="FAIL on missing camera."
)
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,301 | hypoxic/sequoia-ptpy | refs/heads/master | /ptpy/extensions/sony.py | '''This module extends PTPDevice for Sony devices.
Use it in a master module that determines the vendor and automatically uses its
extension. This is why inheritance is not explicit.
'''
from contextlib import contextmanager
from construct import Container, Struct, Range, Computed, Enum, Array, PrefixedArray, Pass, ExprAdapter
from ..ptp import PTPError
import logging
logger = logging.getLogger(__name__)
__all__ = ('Sony',)
class SonyError(PTPError):
pass
class Sony(object):
'''This class implements Sony's PTP operations.'''
def __init__(self, *args, **kwargs):
logger.debug('Init Sony')
super(Sony, self).__init__(*args, **kwargs)
# TODO: expose the choice to disable automatic Sony extension
self.__raw = False
@contextmanager
def session(self):
'''
Manage Sony session with context manager.
'''
# When raw device, do not perform
if self.__raw:
with super(Sony, self).session():
yield
return
with super(Sony, self).session():
logger.debug('Authentication')
r = []
r.append(self.sdio_connect(1))
r.append(self.sdio_connect(2))
r.append(self.sdio_get_ext_device_info())
r.append(self.sdio_connect(3))
if not all(map(lambda r: r.ResponseCode == 'OK', r)):
raise SonyError('Could not authenticate')
else:
logger.debug('Authentication done')
yield
def _shutdown(self):
logger.debug('Shutdown Sony')
super(Sony, self)._shutdown()
def _PropertyCode(self, **product_properties):
return super(Sony, self)._PropertyCode(
DPCCompensation=0xD200,
DRangeOptimize=0xD201,
SonyImageSize=0xD203,
ShutterSpeed=0xD20D,
ColorTemp=0xD20F,
CCFilter=0xD210,
AspectRatio=0xD211,
FocusFound=0xD213,
ObjectInMemory=0xD215,
ExposeIndex=0xD216,
SonyBatteryLevel=0xD218,
PictureEffect=0xD21B,
ABFilter=0xD21C,
ISO=0xD21E,
AutoFocus=0xD2C1,
Capture=0xD2C2,
Movie=0xD2C8,
StillImage=0xD2C7,
**product_properties
)
def _OperationCode(self, **product_operations):
return super(Sony, self)._OperationCode(
SDIOConnect=0x9201,
SDIOGetExtDeviceInfo=0x9202,
SonyGetDevicePropDesc=0x9203,
SonyGetDevicePropValue=0x9204,
SetControlDeviceA=0x9205,
GetControlDeviceDesc=0x9206,
SetControlDeviceB=0x9207,
GetAllDevicePropData=0x9209,
**product_operations
)
def _ObjectFormatCode(self, **product_object_formats):
return super(Sony, self)._ObjectFormatCode(
RAW=0xb101,
**product_object_formats
)
def _ResponseCode(self, **product_responses):
return super(Sony, self)._ResponseCode(
Sony1=0xa101,
**product_responses
)
def _EventCode(self, **product_events):
return super(Sony, self)._EventCode(
SonyObjectAdded=0xc201,
SonyObjectRemoved=0xc202,
SonyPropertyChanged=0xc203,
**product_events
)
def _FilesystemType(self, **product_filesystem_types):
return super(Sony, self)._FilesystemType(
**product_filesystem_types
)
def _SonyDeviceInfo(self):
return Range(0, 2, self._PTPArray(self._PropertyCode))
def _Visibility(self):
return Enum(
self._UInt8,
Disabled=0x00,
Enabled=0x01,
DisplayOnly=0x02,
)
def _SonyPropDesc(self):
return Struct(
'PropertyCode' / self._PropertyCode,
'DataTypeCode' / self._DataTypeCode,
'SonyGetSet' / self._UInt8,
'GetSet' / Computed(
lambda x: 'GetSet' if x.SonyGetSet & 0x01 else 'Get'
),
'Visibility' / self._Visibility,
'FactoryDefaultValue' / self._DataType,
'CurrentValue' / self._DataType,
'FormFlag' / self._FormFlag,
'Form' / self._Form(self._DataType)
)
def _SonyAllPropDesc(self):
return PrefixedArray(self._UInt64, self._SonyPropDesc)
def _ExposureProgramMode(self):
return Enum(
self._UInt16,
default=Pass,
IntelligentAuto=0x8000,
SuperiorAuto=0x8001,
P=0x2,
A=0x3,
S=0x4,
M=0x1,
MovieP=0x8050,
MovieA=0x8051,
MovieS=0x8052,
MovieM=0x8053,
# Mode=0x8054, # TODO: ??
Panoramic=0x8041,
Portrait=0x7,
SportsAction=0x8011,
Macro=0x8015,
Landscape=0x8014,
Sunset=0x8012,
NightScene=0x8013,
HandheldTwilight=0x8016,
NightPortrait=0x8017,
AntiMotionBlur=0x8018,
)
def _AutoFocus(self):
return Enum(
self._UInt16,
default=Pass,
)
def _PictureEffect(self):
return Enum(
self._UInt16,
default=Pass,
Off=0x8000,
ToyCameraNormal=0x8001,
ToyCameraCool=0x8002,
ToyCameraWarm=0x8003,
ToyCameraGreen=0x8004,
ToyCameraMagenta=0x8005,
Pop=0x8010,
PosterizationBW=0x8020,
PosterizationColor=0x8021,
Retro=0x8030,
SoftHighKey=0x8030,
PartialColorRed=0x8050,
PartialColorGreen=0x8051,
PartialColorBlue=0x8052,
PartialColorYellow=0x8053,
HighContrastMono=0x8060,
SoftFocusLow=0x8070,
SoftFocusMid=0x8071,
SoftFocusHigh=0x8072,
HDRPaintingLow=0x8080,
HDRPaintingMid=0x8081,
HDRPaintingHigh=0x8082,
RichToneMono=0x8090,
MiniatureAuto=0x80a0,
MiniatureTop=0x80a1,
MiniatureMiddleHorizontal=0x80a2,
MiniatureBottom=0x80a3,
MiniatureRight=0x80a4,
MiniatureMiddleVertical=0x80a5,
MiniatureLeft=0x80a6,
Watercolor=0x80b0,
IllustrationLow=0x80c0,
IllustrationMid=0x80c1,
IllustrationHigh=0x80c2,
)
def _StillCaptureMode(self):
'''DriveMode in Sony terminology'''
return Enum(
self._UInt16,
default=Pass,
Single=0x0001,
SelfTimer10s=0x8004,
SelfTimer2s=0x8005,
SelfTimer10sContinuous3Images=0x8008,
SelfTimer10sContinuous5Images=0x8009,
Continuous=0x8013,
ContinuousSpeedPriority=0x8014,
WhiteBalanceBracketLow=0x8018,
WhiteBalanceBracketHigh=0x8028,
DRangeOptimizerBracketLow=0x8019,
DRangoOptimizerBracketHigh=0x8029,
ContinuousBracket1_0EV3Image=0x8311,
ContinuousBracket2_0EV3Image=0x8321,
ContinuousBracket3_0EV3Image=0x8331,
ContinuousBracket0_3EV3Image=0x8337,
ContinuousBracket0_5EV3Image=0x8357,
ContinuousBracket0_7EV3Image=0x8377,
ContinuousBracket0_3EV5Image=0x8537,
ContinuousBracket0_5EV5Image=0x8557,
ContinuousBracket0_7EV5Image=0x8577,
SingleBracket1_0EV3Image=0x8310,
SingleBracket2_0EV3Image=0x8320,
SingleBracket3_0EV3Image=0x8330,
SingleBracket0_3EV3Image=0x8336,
SingleBracket0_5EV3Image=0x8356,
SingleBracket0_7EV3Image=0x8376,
SingleBracket0_3EV5Image=0x8536,
SingleBracket0_5EV5Image=0x8556,
SingleBracket0_7EV5Image=0x8576,
)
def _ExposureBiasCompensation(self):
return ExprAdapter(
self._UInt16,
encode=lambda x: x*1000,
decode=lambda x: x/1000.,
)
def _set_endian(self, endian):
logger.debug('Set Sony endianness')
super(Sony, self)._set_endian(endian)
self._ExposureProgramMode = self._ExposureProgramMode()
self._AutoFocus = self._AutoFocus()
self._PictureEffect = self._PictureEffect()
self._StillCaptureMode = self._StillCaptureMode()
self._Visibility = self._Visibility()
self._SonyPropDesc = self._SonyPropDesc()
self._SonyDeviceInfo = self._SonyDeviceInfo()
self._SonyAllPropDesc = self._SonyAllPropDesc()
def event(self, wait=False):
'''Check Sony or PTP events
If `wait` this function is blocking. Otherwise it may return None.
'''
evt = super(Sony, self).event(wait=wait)
return evt
def sdio_connect(self, step, key1=0, key2=0):
'''Authentication handshake'''
ptp = Container(
OperationCode='SDIOConnect',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[step, key1, key2]
)
return self.recv(ptp)
def sdio_get_ext_device_info(self, version=0xc8):
'''Sony DeviceInfo'''
ptp = Container(
OperationCode='SDIOGetExtDeviceInfo',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[version]
)
return self.recv(ptp)
def get_all_device_prop_data(self):
ptp = Container(
OperationCode='GetAllDevicePropData',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.recv(ptp)
return self._parse_if_data(response, self._SonyAllPropDesc)
def set_control_device_A(self, device_property, value_payload):
code = self._code(device_property, self._PropertyCode)
ptp = Container(
OperationCode='SetControlDeviceA',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[code]
)
response = self.send(ptp, value_payload)
return response
def set_control_device_B(self, device_property, value_payload):
code = self._code(device_property, self._PropertyCode)
ptp = Container(
OperationCode='SetControlDeviceB',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[code]
)
response = self.send(ptp, value_payload)
return response
def get_control_device_desc(self, device_property):
code = self._code(device_property, self._PropertyCode)
ptp = Container(
OperationCode='GetControlDeviceDesc',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[code]
)
response = self.recv(ptp)
return response
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,302 | hypoxic/sequoia-ptpy | refs/heads/master | /examples/timelapse.py | #!/usr/bin/env python
from ptpy import PTPy
from argparse import ArgumentParser
from time import time, sleep
parser = ArgumentParser()
parser.add_argument(
'-t',
type=float,
help='Time between captures in seconds. Default is 0.1 seconds.'
)
parser.add_argument(
'-n',
type=int,
help='Number of captures. Negative numbers mean "forever" (default)'
)
args = parser.parse_args()
camera = PTPy()
with camera.session():
successful = 0
beginning = time()
while True if args.n is None or args.n < 0 else successful < args.n:
capture = camera.initiate_capture()
if capture.ResponseCode == 'OK':
successful += 1
cumulative_rate = (time() - beginning) / (successful)
print('elapsed {:.2f}s cumulative rate {:.2f}s captured {}'.format(
time() - beginning,
cumulative_rate,
successful
))
sleep(.1 if args.t is None else args.t)
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,303 | hypoxic/sequoia-ptpy | refs/heads/master | /ptpy/ptp.py | '''This module implements Picture Transfer Protocol (ISO 15740:2013(E))
It is transport agnostic and requires a transport layer to provide the missing
methods in the class :py:class`PTPDevice`.
Convenience structures are provided to pack messages. These are native-endian
and may need to be adapted to transport-endianness by calling
`_set_endian(endianness)` where `endianness` can be `'big'`, `'little'` or
`'native'`.
'''
from construct import (
Array, BitsInteger, Computed, Container, Enum, ExprAdapter, Int16sb,
Int16sl, Int16sn, Int16ub, Int16ul, Int16un, Int32sb, Int32sl, Int32sn,
Int32ub, Int32ul, Int32un, Int64sb, Int64sl, Int64sn, Int64ub, Int64ul,
Int64un, Int8sb, Int8sl, Int8sn, Int8ub, Int8ul, Int8un, Pass,
PrefixedArray, Struct, Switch,
)
from contextlib import contextmanager
from dateutil.parser import parse as iso8601
from datetime import datetime
import logging
import six
logger = logging.getLogger(__name__)
# Module specific
# _______________
__all__ = ('PTPError', 'PTPUnimplemented', 'PTP',)
__author__ = 'Luis Mario Domenzain'
# Exceptions
# ----------
class PTPError(Exception):
'''PTP implementation exceptions.'''
pass
class PTPUnimplemented(PTPError):
'''Exception to indicate missing implementation.'''
pass
class PTP(object):
'''Implement bare PTP device. Vendor specific devices should extend it.'''
# Base PTP protocol transaction elements
# --------------------------------------
_UInt8 = Int8un
_UInt16 = Int16un
_UInt32 = Int32un
_UInt64 = Int64un
_UInt128 = BitsInteger(128)
_Int8 = Int8sn
_Int16 = Int16sn
_Int32 = Int32sn
_Int64 = Int64sn
_Int128 = BitsInteger(128, signed=True)
def _Parameter(self):
'''Return desired endianness for Parameter'''
return self._UInt32
def _SessionID(self):
'''Return desired endianness for SessionID'''
return self._UInt32
def _TransactionID(self):
'''Return desired endianness for TransactionID'''
return Enum(
self._UInt32,
default=Pass,
NA=0xFFFFFFFF,
)
# TODO: Check if these Enums can be replaced with more general
# associations. Or even with Python Enums. Otherwise there is always a risk
# of a typo creeping in.
def _OperationCode(self, **vendor_operations):
'''Return desired endianness for known OperationCode'''
return Enum(
self._UInt16,
default=Pass,
Undefined=0x1000,
GetDeviceInfo=0x1001,
OpenSession=0x1002,
CloseSession=0x1003,
GetStorageIDs=0x1004,
GetStorageInfo=0x1005,
GetNumObjects=0x1006,
GetObjectHandles=0x1007,
GetObjectInfo=0x1008,
GetObject=0x1009,
GetThumb=0x100A,
DeleteObject=0x100B,
SendObjectInfo=0x100C,
SendObject=0x100D,
InitiateCapture=0x100E,
FormatStore=0x100F,
ResetDevice=0x1010,
SelfTest=0x1011,
SetObjectProtection=0x1012,
PowerDown=0x1013,
GetDevicePropDesc=0x1014,
GetDevicePropValue=0x1015,
SetDevicePropValue=0x1016,
ResetDevicePropValue=0x1017,
TerminateOpenCapture=0x1018,
MoveObject=0x1019,
CopyObject=0x101A,
GetPartialObject=0x101B,
InitiateOpenCapture=0x101C,
StartEnumHandles=0x101D,
EnumHandles=0x101E,
StopEnumHandles=0x101F,
GetVendorExtensionMapss=0x1020,
GetVendorDeviceInfo=0x1021,
GetResizedImageObject=0x1022,
GetFilesystemManifest=0x1023,
GetStreamInfo=0x1024,
GetStream=0x1025,
**vendor_operations
)
def _ResponseCode(self, **vendor_responses):
'''Return desired endianness for known ResponseCode'''
return Enum(
self._UInt16,
default=Pass,
Undefined=0x2000,
OK=0x2001,
GeneralError=0x2002,
SessionNotOpen=0x2003,
InvalidTransactionID=0x2004,
OperationNotSupported=0x2005,
ParameterNotSupported=0x2006,
IncompleteTransfer=0x2007,
InvalidStorageId=0x2008,
InvalidObjectHandle=0x2009,
DevicePropNotSupported=0x200A,
InvalidObjectFormatCode=0x200B,
StoreFull=0x200C,
ObjectWriteProtected=0x200D,
StoreReadOnly=0x200E,
AccessDenied=0x200F,
NoThumbnailPresent=0x2010,
SelfTestFailed=0x2011,
PartialDeletion=0x2012,
StoreNotAvailable=0x2013,
SpecificationByFormatUnsupported=0x2014,
NoValidObjectInfo=0x2015,
InvalidCodeFormat=0x2016,
UnknownVendorCode=0x2017,
CaptureAlreadyTerminated=0x2018,
DeviceBusy=0x2019,
InvalidParentObject=0x201A,
InvalidDevicePropFormat=0x201B,
InvalidDevicePropValue=0x201C,
InvalidParameter=0x201D,
SessionAlreadyOpened=0x201E,
TransactionCanceled=0x201F,
SpecificationOfDestinationUnsupported=0x2020,
InvalidEnumHandle=0x2021,
NoStreamEnabled=0x2022,
InvalidDataset=0x2023,
**vendor_responses
)
def _EventCode(self, **vendor_events):
'''Return desired endianness for known EventCode'''
return Enum(
self._UInt16,
default=Pass,
Undefined=0x4000,
CancelTransaction=0x4001,
ObjectAdded=0x4002,
ObjectRemoved=0x4003,
StoreAdded=0x4004,
StoreRemoved=0x4005,
DevicePropChanged=0x4006,
ObjectInfoChanged=0x4007,
DeviceInfoChanged=0x4008,
RequestObjectTransfer=0x4009,
StoreFull=0x400A,
DeviceReset=0x400B,
StorageInfoChanged=0x400C,
CaptureComplete=0x400D,
UnreportedStatus=0x400E,
**vendor_events
)
def _Event(self):
return Struct(
'EventCode' / self._EventCode,
'SessionID' / self._SessionID,
'TransactionID' / self._TransactionID,
'Parameter' / Array(3, self._Parameter),
)
def _Response(self):
return Struct(
'ResponseCode' / self._ResponseCode,
'SessionID' / self._SessionID,
'TransactionID' / self._TransactionID,
'Parameter' / Array(5, self._Parameter),
)
def _Operation(self):
return Struct(
'OperationCode' / self._OperationCode,
'SessionID' / self._SessionID,
'TransactionID' / self._TransactionID,
'Parameter' / Array(5, self._Parameter),
)
def _PropertyCode(self, **vendor_properties):
'''Return desired endianness for known OperationCode'''
return Enum(
self._UInt16,
default=Pass,
Undefined=0x5000,
BatteryLevel=0x5001,
FunctionalMode=0x5002,
ImageSize=0x5003,
CompressionSetting=0x5004,
WhiteBalance=0x5005,
RGBGain=0x5006,
FNumber=0x5007,
FocalLength=0x5008,
FocusDistance=0x5009,
FocusMode=0x500A,
ExposureMeteringMode=0x500B,
FlashMode=0x500C,
ExposureTime=0x500D,
ExposureProgramMode=0x500E,
ExposureIndex=0x500F,
ExposureBiasCompensation=0x5010,
DateTime=0x5011,
CaptureDelay=0x5012,
StillCaptureMode=0x5013,
Contrast=0x5014,
Sharpness=0x5015,
DigitalZoom=0x5016,
EffectMode=0x5017,
BurstNumber=0x5018,
BurstInterval=0x5019,
TimelapseNumber=0x501A,
TimelapseInterval=0x501B,
FocusMeteringMode=0x501C,
UploadURL=0x501D,
Artist=0x501E,
CopyrightInfo=0x501F,
**vendor_properties
)
# PTP Datasets for specific operations
# ------------------------------------
def _ObjectHandle(self):
'''Return desired endianness for ObjectHandle'''
return self._UInt32
def _ObjectFormatCode(self, **vendor_object_formats):
'''Return desired endianness for known ObjectFormatCode'''
return Enum(
self._UInt16,
default=Pass,
# Ancilliary
UndefinedAncilliary=0x3000,
Association=0x3001,
Script=0x3002,
Executable=0x3003,
Text=0x3004,
HTML=0x3005,
DPOF=0x3006,
AIFF=0x3007,
WAV=0x3008,
MP3=0x3009,
AVI=0x300A,
MPEG=0x300B,
ASF=0x300C,
QT=0x300D,
# Images
UndefinedImage=0x3800,
EXIF_JPEG=0x3801,
TIFF_EP=0x3802,
FlashPix=0x3803,
BMP=0x3804,
CIFF=0x3805,
GIF=0x3807,
JFIF=0x3808,
PCD=0x3809,
PICT=0x380A,
PNG=0x380B,
TIFF=0x380D,
TIFF_IT=0x380E,
JP2=0x380F,
JPX=0x3810,
DNG=0x3811,
**vendor_object_formats
)
def _DateTime(self):
'''Return desired endianness for DateTime'''
return ExprAdapter(
self._PTPString,
encoder=lambda obj, ctx:
# TODO: Support timezone encoding.
datetime.strftime(obj, '%Y%m%dT%H%M%S.%f')[:-5],
decoder=lambda obj, ctx: iso8601(obj),
)
def _PTPString(self):
'''Returns a PTP String constructor'''
return ExprAdapter(
PrefixedArray(self._UInt8, self._UInt16),
encoder=lambda obj, ctx:
[] if len(obj) == 0 else [ord(c) for c in six.text_type(obj)]+[0],
decoder=lambda obj, ctx:
u''.join(
[six.unichr(o) for o in obj]
).split('\x00')[0],
)
def _PTPArray(self, element):
return PrefixedArray(self._UInt32, element)
def _VendorExtensionID(self):
return Enum(
self._UInt32,
default=Pass,
EastmanKodak=0x00000001,
SeikoEpson=0x00000002,
Agilent=0x00000003,
Polaroid=0x00000004,
AgfaGevaert=0x00000005,
Microsoft=0x00000006,
Equinox=0x00000007,
Viewquest=0x00000008,
STMicroelectronics=0x00000009,
Nikon=0x0000000A,
Canon=0x0000000B,
FotoNation=0x0000000C,
PENTAX=0x0000000D,
Fuji=0x0000000E,
Sony=0x00000011, # Self-imposed.
NDD=0x00000012, # ndd Medical Technologies
Samsung=0x0000001A,
Parrot=0x0000001B,
Panasonic=0x0000001C,
)
def _DeviceInfo(self):
'''Return desired endianness for DeviceInfo'''
return Struct(
'StandardVersion' / self._UInt16,
'VendorExtensionID' / self._VendorExtensionID,
'VendorExtensionVersion' / self._UInt16,
'VendorExtensionDesc' / self._PTPString,
'FunctionalMode' / self._UInt16,
'OperationsSupported' / self._PTPArray(self._OperationCode),
'EventsSupported' / self._PTPArray(self._EventCode),
'DevicePropertiesSupported' / self._PTPArray(self._PropertyCode),
'CaptureFormats' / self._PTPArray(self._ObjectFormatCode),
'ImageFormats' / self._PTPArray(self._ObjectFormatCode),
'Manufacturer' / self._PTPString,
'Model' / self._PTPString,
'DeviceVersion' / self._PTPString,
'SerialNumber' / self._PTPString,
)
def _StorageType(self):
'''Return desired endianness for StorageType'''
return Enum(
self._UInt16,
default=Pass,
Undefined=0x0000,
FixedROM=0x0001,
RemovableROM=0x0002,
FixedRAM=0x0003,
RemovableRAM=0x0004,
)
def _FilesystemType(self, **vendor_filesystem_types):
'''Return desired endianness for known FilesystemType'''
return Enum(
self._UInt16,
default=Pass,
Undefined=0x0000,
GenericFlat=0x0001,
GenericHierarchical=0x0002,
DCF=0x0003,
**vendor_filesystem_types
)
def _AccessCapability(self):
'''Return desired endianness for AccessCapability'''
return Enum(
self._UInt16,
default=Pass,
ReadWrite=0x0000,
ReadOnlyWithoutObjectDeletion=0x0001,
ReadOnlyWithObjectDeletion=0x0002,
)
def _StorageInfo(self):
'''Return desired endianness for StorageInfo'''
return Struct(
'StorageType' / self._StorageType,
'FilesystemType' / self._FilesystemType,
'AccessCapability' / self._AccessCapability,
'MaxCapacity' / self._UInt64,
'FreeSpaceInBytes' / self._UInt64,
'FreeSpaceInImages' / self._UInt32,
'StorageDescription' / self._PTPString,
'VolumeLabel' / self._PTPString,
)
def _StorageID(self):
'''Return desired endianness for StorageID'''
# TODO: automatically set and parse PhysicalID and LogicalID
return self._UInt32
def _StorageIDs(self):
'''Return desired endianness for StorageID'''
# TODO: automatically set and parse PhysicalID and LogicalID
return self._PTPArray(self._StorageID)
def _DataTypeCode(self, **vendor_datatype_codes):
'''Return desired endianness for DevicePropDesc'''
return Enum(
self._UInt16,
default=Pass,
Undefined=0x0000,
Int128=0x0009,
Int128Array=0x4009,
Int16=0x0003,
Int16Array=0x4003,
Int32=0x0005,
Int32Array=0x4005,
Int64=0x0007,
Int64Array=0x4007,
Int8=0x0001,
Int8Array=0x4001,
UInt128=0x000a,
UInt128Array=0x400a,
UInt16=0x0004,
UInt16Array=0x4004,
UInt32=0x0006,
UInt32Array=0x4006,
UInt64=0x0008,
UInt64Array=0x4008,
UInt8=0x0002,
UInt8Array=0x4002,
String=0xFFFF,
**vendor_datatype_codes
)
def _DataType(self, **vendor_datatypes):
datatypes = {
'Int128': self._Int128,
'Int128Array': self._PTPArray(self._Int128),
'Int16': self._Int16,
'Int16Array': self._PTPArray(self._Int16),
'Int32': self._Int32,
'Int32Array': self._PTPArray(self._Int32),
'Int64': self._Int64,
'Int64Array': self._PTPArray(self._Int64),
'Int8': self._Int8,
'Int8Array': self._PTPArray(self._Int8),
'UInt128': self._UInt128,
'UInt128Array': self._PTPArray(self._UInt128),
'UInt16': self._UInt16,
'UInt16Array': self._PTPArray(self._UInt16),
'UInt32': self._UInt32,
'UInt32Array': self._PTPArray(self._UInt32),
'UInt64': self._UInt64,
'UInt64Array': self._PTPArray(self._UInt64),
'UInt8': self._UInt8,
'UInt8Array': self._PTPArray(self._UInt8),
'String': self._PTPString,
}
datatypes.update(vendor_datatypes if vendor_datatypes else {})
def DataTypeCode(ctx):
# Try to get the DataTypeCode from the parent contexts up to 20
# levels...
for i in range(20):
try:
return ctx.DataTypeCode
except AttributeError:
ctx = ctx._
return Switch(
DataTypeCode,
datatypes,
default=Pass
)
def _GetSet(self):
return Enum(
self._UInt8,
default=Pass,
Get=0x00,
GetSet=0x01,
)
def _FormFlag(self):
return Enum(
self._UInt8,
default=Pass,
NoForm=0x00,
Range=0x01,
Enumeration=0x02,
)
def _RangeForm(self, element):
return Struct(
'MinimumValue' / element,
'MaximumValue' / element,
'StepSize' / element,
)
def _EnumerationForm(self, element):
return PrefixedArray(self._UInt16, element)
def _Form(self, element):
return Switch(
lambda x: x.FormFlag,
{
'Range': 'Range' / self._RangeForm(element),
'Enumeration': 'Enumeration' / self._EnumerationForm(element),
'NoForm': Pass
},
default=Pass,
)
def _DevicePropDesc(self):
'''Return desired endianness for DevicePropDesc'''
return Struct(
'PropertyCode' / self._PropertyCode,
'DataTypeCode' / self._DataTypeCode,
'GetSet' / self._GetSet,
'FactoryDefaultValue' / self._DataType,
'CurrentValue' / self._DataType,
'FormFlag' / self._FormFlag,
'Form' / self._Form(self._DataType)
)
def _ProtectionStatus(self):
return Enum(
self._UInt16,
default=Pass,
NoProtection=0x0000,
ReadOnly=0x0001,
)
def _AssociationType(self, **vendor_associations):
return Enum(
self._UInt16,
default=Pass,
Undefined=0x0000,
GenericFolder=0x0001,
Album=0x0002,
TimeSequence=0x0003,
HorizontalPanoramic=0x0004,
VerticalPanoramic=0x0005,
Panoramic2D=0x0006,
AncillaryData=0x0007,
**vendor_associations
)
def _AssociationDesc(self, **vendor_associations):
return Enum(
self._UInt32,
default=Pass,
Undefined=0x00000000,
DefaultPlaybackData=0x00000003,
ImagesPerRow=0x00000006,
**vendor_associations
)
def _ObjectInfo(self):
'''Return desired endianness for ObjectInfo'''
return Struct(
'StorageID' / self._StorageID,
'ObjectFormat' / self._ObjectFormatCode,
'ProtectionStatus' / self._ProtectionStatus,
'ObjectCompressedSize' / self._UInt32,
'ThumbFormat' / self._ObjectFormatCode,
'ThumbCompressedSize' / self._UInt32,
'ThumbPixWidth' / self._UInt32,
'ThumbPixHeight' / self._UInt32,
'ImagePixWidth' / self._UInt32,
'ImagePixHeight' / self._UInt32,
'ImageBitDepth' / self._UInt32,
'ParentObject' / self._ObjectHandle,
'AssociationType' / self._AssociationType,
'AssociationDesc' / self._AssociationDesc,
'SequenceNumber' / self._UInt32,
'Filename' / self._PTPString,
'CaptureDate' / self._DateTime,
'ModificationDate' / self._DateTime,
'Keywords' / self._PTPString,
)
def _VendorExtensionMap(self):
'''Return desired endianness for VendorExtensionMap'''
# TODO: Integrate vendor extensions and their Enums to parse Native
# codes to their name.
return Struct(
'NativeCode' / self._UInt16,
'MappedCode' / self._UInt16,
'MappedVendorExtensionID' / self._VendorExtensionID,
)
def _VendorExtensionMapArray(self):
'''Return desired endianness for VendorExtensionMapArray'''
return PrefixedArray(
self._UInt64,
self._VendorExtensionMap,
)
# Helper to concretize generic constructors to desired endianness
# ---------------------------------------------------------------
def _set_endian(self, endian, explicit=None):
'''Instantiate constructors to given endianness'''
# All constructors need to be instantiated before use by setting their
# endianness. But only those that don't depend on endian-generic
# constructors need to be explicitly instantiated to a given
# endianness.
logger.debug('Set PTP endianness')
if endian == 'little':
self._UInt8 = Int8ul
self._UInt16 = Int16ul
self._UInt32 = Int32ul
self._UInt64 = Int64ul
self._UInt128 = BitsInteger(128, signed=False, swapped=True)
self._Int8 = Int8sl
self._Int16 = Int16sl
self._Int32 = Int32sl
self._Int64 = Int64sl
self._Int128 = BitsInteger(128, signed=True, swapped=True)
elif endian == 'big':
self._UInt8 = Int8ub
self._UInt16 = Int16ub
self._UInt32 = Int32ub
self._UInt64 = Int64ub
self._UInt128 = BitsInteger(128, signed=False, swapped=False)
self._Int8 = Int8sb
self._Int16 = Int16sb
self._Int32 = Int32sb
self._Int64 = Int64sb
self._Int128 = BitsInteger(128, signed=True, swapped=False)
elif endian == 'native':
self._UInt8 = Int8un
self._UInt16 = Int16un
self._UInt32 = Int32un
self._UInt64 = Int64un
self._UInt128 = BitsInteger(128, signed=False)
self._Int8 = Int8sn
self._Int16 = Int16sn
self._Int32 = Int32sn
self._Int64 = Int64sn
self._Int128 = BitsInteger(128, signed=True)
else:
raise PTPError(
'Only little and big endian conventions are supported.'
)
if explicit is not None and explicit:
logger.debug('Initialized explicit constructors only')
return
elif explicit is not None and not explicit:
logger.debug('Initialize implicit constructors')
# Implicit instantiation. Needs to happen after the above.
self._PTPString = self._PTPString()
self._DateTime = self._DateTime()
self._Parameter = self._Parameter()
self._VendorExtensionID = self._VendorExtensionID()
self._OperationCode = self._OperationCode()
self._EventCode = self._EventCode()
self._PropertyCode = self._PropertyCode()
self._ObjectFormatCode = self._ObjectFormatCode()
self._DeviceInfo = self._DeviceInfo()
self._SessionID = self._SessionID()
self._TransactionID = self._TransactionID()
self._ObjectHandle = self._ObjectHandle()
self._ResponseCode = self._ResponseCode()
self._Event = self._Event()
self._Response = self._Response()
self._Operation = self._Operation()
self._StorageID = self._StorageID()
self._StorageIDs = self._StorageIDs()
self._StorageType = self._StorageType()
self._FilesystemType = self._FilesystemType()
self._AccessCapability = self._AccessCapability()
self._StorageInfo = self._StorageInfo()
self._DataTypeCode = self._DataTypeCode()
self._DataType = self._DataType()
self._GetSet = self._GetSet()
self._FormFlag = self._FormFlag()
self._DevicePropDesc = self._DevicePropDesc()
self._VendorExtensionMap = self._VendorExtensionMap()
self._VendorExtensionMapArray = self._VendorExtensionMapArray()
self._AssociationType = self._AssociationType()
self._AssociationDesc = self._AssociationDesc()
self._ProtectionStatus = self._ProtectionStatus()
self._ObjectInfo = self._ObjectInfo()
def __init__(self, *args, **kwargs):
logger.debug('Init PTP')
# Session and transaction helpers
# -------------------------------
self._session = 0
self.__session_open = False
self.__transaction_id = 1
self.__has_the_knowledge = False
super(PTP, self).__init__(*args, **kwargs)
@property
def _transaction(self):
'''Give magical property for the latest TransactionID'''
current_id = 0
if self.__session_open:
current_id = self.__transaction_id
self.__transaction_id += 1
if self.__transaction_id > 0xFFFFFFFE:
self.__transaction_id = 1
return current_id
@_transaction.setter
def _transaction(self, value):
'''Manage reset of TransactionID'''
if value != 1:
raise PTPError(
'Current TransactionID should not be set. Only reset.'
)
else:
self.__transaction_id = 1
@property
def session_id(self):
'''Expose internat SessionID'''
return self._session
@session_id.setter
def session_id(self, value):
'''Ignore external modifications to SessionID'''
pass
@contextmanager
def session(self):
'''
Manage session with context manager.
Once transport specific interfaces are defined, this allows easier,
more nuclear sessions:
from ptpy import PTPy
camera = PTPy()
with camera.session():
camera.get_device_info()
'''
# TODO: Deal with devices that only support one session (where
# SessionID must be always 1, like some older Canon cameras.)
# TODO: Deal with devices that only support one arbitrary session where
# the ID is communicated to the initiator after an OpenSession attempt.
# This might also account for the above.
logger.debug('Session requested')
if not self.__session_open:
logger.debug('Open session')
try:
self.open_session()
yield
finally:
logger.debug('Close session')
if self.__session_open:
self.close_session()
else:
logger.debug('Using outer session')
yield
@contextmanager
def open_capture(self):
'''
Manage open capture with context manager.
This allows easier open capture with automatic closing
'''
# TODO: implement!
# Transport-specific functions
# ----------------------------
def send(self, ptp_container, payload):
'''Operation with dataphase from initiator to responder'''
try:
return super(PTP, self).send(ptp_container, payload)
except Exception as e:
logger.error(e)
raise e
def recv(self, ptp_container):
'''Operation with dataphase from responder to initiator'''
try:
return super(PTP, self).recv(ptp_container)
except Exception as e:
logger.error(e)
raise e
def mesg(self, ptp_container):
'''Operation with no dataphase'''
try:
return super(PTP, self).mesg(ptp_container)
except Exception as e:
logger.error(e)
raise e
def event(self, wait=False):
try:
return super(PTP, self).event(wait=wait)
except Exception as e:
logger.error(e)
raise e
# Operation-specific methods and helpers
# --------------------------------------
def _parse_if_data(self, response, constructor):
'''If the response contains data, parse it with constructor.'''
return (constructor.parse(response.Data)
if hasattr(response, 'Data') else None)
def _build_if_not_data(self, data, constructor):
'''If the data is not binary, build it with constructor.'''
return (constructor.build(data)
if isinstance(data, Container) else data)
def _name(self, name_or_code, constructor):
'''Helper method to get the code for an Enum constructor.'''
name = name_or_code
if isinstance(name_or_code, int):
try:
name = constructor.decoding[name_or_code]
except Exception:
pass
return name
def _code(self, name_or_code, constructor):
'''Helper method to get the code for an Enum constructor.'''
if isinstance(name_or_code, six.string_types):
try:
code = constructor.encoding[name_or_code]
except Exception:
raise PTPError('Unknown property name. Try with a number?')
else:
code = name_or_code
return code
def _obtain_the_knowledge(self):
'''Initialise an internal representation of device behaviour.'''
logger.debug('Gathering info about all device properties')
self.__device_info = self.get_device_info()
self.__prop_desc = {}
with self.session():
for p in self.__device_info.DevicePropertiesSupported:
# TODO: Update __prop_desc with arrival of events
# transparently.
self.__prop_desc[p] = self.get_device_prop_desc(p)
# TODO: Get info regarding ObjectHandles here. And update as
# events are received. This should be transparent for the user.
self.__has_the_knowledge = True
def _update_the_knowledge(self, props=None):
'''Update an internal representation of device behaviour.'''
logger.debug('Gathering info about extra device properties')
with self.session():
for p in props:
self.__prop_desc[p] = self.get_device_prop_desc()
self.__device_info.DevicePropertiesSupported.append(p)
def open_session(self):
self._session += 1
self._transaction = 1
ptp = Container(
OperationCode='OpenSession',
# Only the OpenSession operation is allowed to have a 0
# SessionID, because no session is open yet.
SessionID=0,
TransactionID=0,
Parameter=[self._session]
)
response = self.mesg(ptp)
if response.ResponseCode == 'OK':
self.__session_open = True
return response
def close_session(self):
ptp = Container(
OperationCode='CloseSession',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.mesg(ptp)
if response.ResponseCode == 'OK':
self.__session_open = False
return response
def reset_device(self):
ptp = Container(
OperationCode='ResetDevice',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[],
)
response = self.recv(ptp)
if response.ResponseCode == 'OK':
self.__session_open = False
return response
def power_down(self):
ptp = Container(
OperationCode='PowerDown',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[],
)
response = self.recv(ptp)
if response.ResponseCode == 'OK':
self.__session_open = False
return response
# TODO: Add decorator to check there is an open session.
def reset_device_prop_value(self, device_property, reset_all=False):
'''Reset given device property to factory default.
If `reset_all` is `True`, the device_property can be `None`.
'''
if isinstance(device_property, six.string_types):
try:
code = self._PropertyCode.encoding[device_property]
except Exception:
raise PTPError('Unknown property name. Try with a number?')
else:
code = device_property
ptp = Container(
OperationCode='ResetDevicePropValue',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[0xffffffff if reset_all else code],
)
response = self.recv(ptp)
return response
def get_device_info(self):
ptp = Container(
OperationCode='GetDeviceInfo',
SessionID=self._session,
# GetrDeviceInfo can happen outside a session. But if there is one
# running just use that one.
TransactionID=(self._transaction if self.__session_open else 0),
Parameter=[]
)
response = self.recv(ptp)
return self._parse_if_data(response, self._DeviceInfo)
def get_storage_ids(self):
ptp = Container(
OperationCode='GetStorageIDs',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.recv(ptp)
return self._parse_if_data(response, self._StorageIDs)
def get_storage_info(self, storage_id):
ptp = Container(
OperationCode='GetStorageInfo',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[storage_id]
)
response = self.recv(ptp)
return self._parse_if_data(response, self._StorageInfo)
def get_num_objects(
self,
storage_id,
object_format=0,
object_handle=0,
all_storage_ids=False,
all_formats=False,
in_root=False,
):
'''Total number of objects present in `storage_id`'''
if object_handle != 0 and in_root and object_handle != 0xffffffff:
raise ValueError(
'Cannot get both root and {}'.format(object_handle)
)
code = self._code(object_format, self._ObjectFormatCode)
ptp = Container(
OperationCode='GetNumObjects',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[
0xffffffff if all_storage_ids else storage_id,
0xffffffff if all_formats else code,
0xffffffff if in_root else object_handle
]
)
response = self.recv(ptp)
return response.Parameter[0] if response.Parameter else None
def get_object_handles(
self,
storage_id,
object_format=0,
object_handle=0,
all_storage_ids=False,
all_formats=False,
in_root=False,
):
'''Return array of ObjectHandles present in `storage_id`'''
if object_handle != 0 and in_root and object_handle != 0xffffffff:
raise ValueError(
'Cannot get both root and {}'.format(object_handle)
)
code = self._code(object_format, self._ObjectFormatCode)
ptp = Container(
OperationCode='GetObjectHandles',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[
0xffffffff if all_storage_ids else storage_id,
0xffffffff if all_formats else code,
0xffffffff if in_root else object_handle
]
)
response = self.recv(ptp)
return self._parse_if_data(
response,
self._PTPArray(self._ObjectHandle)
)
def __constructor(self, device_property):
'''Get the correct constructor using the latest GetDevicePropDesc.'''
builder = Struct(
'DataTypeCode' / Computed(
lambda ctx: self.__prop_desc[device_property].DataTypeCode
),
'Value' / self._DataType
)
return builder
def get_device_prop_desc(self, device_property):
'''Retrieve the property description.
Accepts a property name or a number.
'''
code = self._code(device_property, self._PropertyCode)
ptp = Container(
OperationCode='GetDevicePropDesc',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[code]
)
response = self.recv(ptp)
result = self._parse_if_data(response, self._DevicePropDesc)
# Update the knowledge on response.
if self.__has_the_knowledge and hasattr(response, 'Data'):
device_property = self._name(device_property, self._PropertyCode)
logger.debug(
'Updating knowledge of {}'
.format(
hex(device_property)
if isinstance(device_property, int) else device_property
)
)
self.__prop_desc[device_property] = result
return result
def get_device_prop_value(self, device_property):
code = self._code(device_property, self._PropertyCode)
ptp = Container(
OperationCode='GetDevicePropValue',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[code],
)
response = self.recv(ptp)
if self.__has_the_knowledge and hasattr(response, 'Data'):
device_property = self._name(device_property, self._PropertyCode)
c = self.__constructor(device_property)
response = c.parse(response.Data).Value
return response
def set_device_prop_value(self, device_property, value_payload):
code = self._code(device_property, self._PropertyCode)
# Attempt to use current knowledge of properties
if self.__has_the_knowledge:
device_property = self._name(device_property, self._PropertyCode)
c = self.__constructor(device_property)
value_payload = c.build(
Container(
Value=value_payload,
DataTypeCode=(
self.__prop_desc[device_property].DataTypeCode
)
)
)
ptp = Container(
OperationCode='SetDevicePropValue',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[code],
)
response = self.send(ptp, value_payload)
return response
def initiate_capture(self, storage_id=0, object_format=0):
'''Initiate capture with current camera settings.'''
code = self._code(object_format, self._ObjectFormatCode)
ptp = Container(
OperationCode='InitiateCapture',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[
storage_id,
code,
]
)
response = self.recv(ptp)
return response
def initiate_open_capture(self, storage_id=0, object_format=0):
'''Initiate open capture in `storage_id` of type `object_format`.'''
code = self._code(object_format, self._ObjectFormatCode)
ptp = Container(
OperationCode='InitiateOpenCapture',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[
storage_id,
code,
]
)
response = self.recv(ptp)
return response
def terminate_open_capture(self, transaction_id):
'''Terminate the open capture initiated in `transaction_id`'''
ptp = Container(
OperationCode='TerminateOpenCapture',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[
transaction_id,
]
)
response = self.recv(ptp)
return response
def get_object_info(self, handle):
'''Get ObjectInfo dataset for given handle.'''
ptp = Container(
OperationCode='GetObjectInfo',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[handle]
)
response = self.recv(ptp)
return self._parse_if_data(response, self._ObjectInfo)
def send_object_info(self, objectinfo):
'''Send ObjectInfo to responder.
The object should correspond to the latest SendObjectInfo interaction
between Initiator and Responder.
'''
objectinfo = self._build_if_not_data(objectinfo, self._ObjectInfo)
ptp = Container(
OperationCode='SendObjectInfo',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
return self.send(ptp, objectinfo)
def send_object(self, bytes_data):
'''Send object to responder.
The object should correspond to the latest SendObjectInfo interaction
between Initiator and Responder.
'''
ptp = Container(
OperationCode='SendObject',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.send(ptp, bytes_data)
if response.ResponseCode != 'OK':
response = self.send(ptp, bytes_data)
return response
def get_object(self, handle):
'''Retrieve object from responder.
The object should correspond to a previous GetObjectInfo interaction
between Initiator and Responder in the same session.
'''
ptp = Container(
OperationCode='GetObject',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[handle]
)
return self.recv(ptp)
def get_partial_object(self, handle, offset, max_bytes, until_end=False):
'''Retrieve partial object from responder.
The object should correspond to a previous GetObjectInfo interaction
between Initiator and Responder in the same session.
Size fields represent maximum size as opposed to the actual size.
The first response parameter represents the actual number of bytes sent
by responder.
'''
ptp = Container(
OperationCode='GetPartialObject',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[handle,
offset,
0xFFFFFFFF if until_end else max_bytes]
)
return self.recv(ptp)
def delete_object(
self,
handle,
object_format=0,
delete_all=False,
delete_all_images=False
):
'''Delete object for given handle.
Optionally delete all objects or all images.
'''
code = self._code(object_format, self._ObjectFormatCode)
# Do the most destruction:
if delete_all and delete_all_images:
delete_all_images = False
ptp = Container(
OperationCode='DeleteObject',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[
0xFFFFFFFF if delete_all else handle,
code,
]
)
return self.mesg(ptp)
def move_object(
self,
handle,
storage_id=0,
parent_handle=0,
):
'''Move object to parent.
Parent should be an Association. Default parent is the root directory
of `storage_id`
'''
ptp = Container(
OperationCode='MoveObject',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[
handle,
storage_id,
parent_handle,
]
)
return self.mesg(ptp)
def copy_object(
self,
handle,
storage_id=0,
parent_handle=0,
):
'''Copy object to parent.
Parent should be an Association. Default parent is the root directory
of `storage_id`
'''
ptp = Container(
OperationCode='CopyObject',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[
handle,
storage_id,
parent_handle,
]
)
return self.mesg(ptp)
def get_thumb(self, handle):
'''Retrieve thumbnail for object from responder.
'''
ptp = Container(
OperationCode='GetThumb',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[handle]
)
return self.recv(ptp)
def get_resized_image_object(self, handle, width, height=0):
'''Retrieve resized image object from responder.
The object should correspond to a previous GetObjectInfo interaction
between Initiator and Responder in the same session.
If width is provided then the aspect ratio may change. The device may
not support this.
'''
ptp = Container(
OperationCode='GetResizedImageObject',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[handle, width, height]
)
return self.recv(ptp)
def get_vendor_extension_maps(self, handle):
'''Get VendorExtension maps when supporting more than one extension.
'''
ptp = Container(
OperationCode='GetVendorExtensionMaps',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.recv(ptp)
return self._parse_if_data(
response,
self._VendorExtensionMapArray)
def get_vendor_device_info(self, extension):
'''Get VendorExtension maps when supporting more than one extension.
'''
code = self._code(extension, self._VendorExtensionID)
ptp = Container(
OperationCode='GetVendorDeviceInfo',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[code]
)
response = self.recv(ptp)
return self._parse_if_data(
response,
self._DeviceInfo)
# TODO: Implement automatic event management.
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,304 | hypoxic/sequoia-ptpy | refs/heads/master | /test.py | #!/usr/bin/env python
import ptpy
from ptpy import Canon
from time import sleep
camera = ptpy.PTPy()
print("Connected to the camera...")
with camera.session():
while True:
camera.eos_run_command("EnableBootDisk")
sleep(2) | {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,305 | hypoxic/sequoia-ptpy | refs/heads/master | /examples/all_cameras_live.py | #!/usr/bin/env python
import ptpy
from ptpy.transports.usb import find_usb_cameras
from threading import Thread, Event
import sys
import logging
from rainbow_logging_handler import RainbowLoggingHandler
from time import sleep, time
# Set up log
log = logging.getLogger('Live')
formatter = logging.Formatter(
'%(levelname).1s '
'%(relativeCreated)d '
'%(name)s'
'[%(threadName)s] '
'%(message)s'
)
handler = RainbowLoggingHandler(
sys.stderr,
)
level = 'INFO'
log.setLevel(level)
handler.setFormatter(formatter)
log.addHandler(handler)
# Set up threads and events
finished = Event()
def capture_thread(camera):
'''Initiate captures regularly for camera'''
with camera.session():
info = camera.get_device_info()
while not finished.is_set():
capture = camera.initiate_capture()
if capture.ResponseCode == 'OK':
log.info(
'{}: successfully initiated capture'
.format(info.SerialNumber)
)
sleep(.1)
def download_thread(camera):
'''Download all non-folders in events from camera'''
with camera.session():
caminfo = camera.get_device_info()
while not finished.is_set():
event = camera.event()
if event and event.EventCode == 'ObjectAdded':
handle = event.Parameter[0]
info = camera.get_object_info(handle)
# Download all things that are not groups of other things.
if info.ObjectFormat != 'Association':
log.info(
'{}: downloading {}'
.format(caminfo.SerialNumber, info.Filename)
)
tic = time()
obj = camera.get_object(handle)
toc = time()
log.info('{}: {:.1f}MB/s'.format(
caminfo.SerialNumber,
len(obj.Data) / ((toc - tic) * 1e6))
)
with open(info.Filename, mode='w') as f:
f.write(obj.Data)
# Find each connected USB camera try to instantiate it and set up a capture and
# download thread for it if successful.
threads = []
for i, device in enumerate(find_usb_cameras()):
try:
camera = ptpy.PTPy(device=device)
info = camera.get_device_info()
caminfo = (info.Manufacturer, info.Model, info.SerialNumber)
if (
'InitiateCapture' not in info.OperationsSupported or
'GetObject' not in info.OperationsSupported
):
raise Exception(
'{} {} {} does not support capture or download...'
.format(*caminfo)
)
log.info(
'Found {} {} {}'
.format(*caminfo)
)
except Exception as e:
log.error(e)
continue
capture = Thread(
name='PHOTO{:02}'.format(i),
target=capture_thread,
args=(camera,)
)
threads.append(capture)
download = Thread(
name='DWNLD{:02}'.format(i),
target=download_thread,
args=(camera,)
)
threads.append(download)
for thread in threads:
thread.start()
# Let the threads run for 30 seconds.
sleep(30)
finished.set()
# Wait for them to finish running.
for thread in threads:
if thread.is_alive():
thread.join()
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,306 | hypoxic/sequoia-ptpy | refs/heads/master | /ptpy/extensions/canon/properties.py | from datetime import datetime
from construct import (
Array,
Byte,
Container,
Embedded,
Enum,
ExprAdapter,
Pass,
PrefixedArray,
Range,
Struct,
Switch,
)
import logging
logger = logging.getLogger(__name__)
class EOSPropertiesMixin(object):
def _EOSImageSize(self):
return Enum(
self._UInt32,
default=Pass,
Large=0x00,
Medium=0x01,
Small=0x02,
S1=0x0e,
S2=0x0f,
S3=0x10,
)
def _EOSImageType(self):
return Enum(
self._UInt32,
default=Pass,
JPEG=0x01,
RAW=0x06,
)
def _EOSImageCompression(self):
return Enum(
self._UInt32,
default=Pass,
Standard=0x02,
Fine=0x03,
Lossless=0x04,
)
def _EOSImageFormat(self):
return PrefixedArray(
self._UInt32,
Struct(
'Bytes' / self._UInt32,
'Type' / self._EOSImageType,
'Size' / self._EOSImageSize,
'Compression' / self._EOSImageCompression,
)
)
def _EOSWhiteBalance(self):
return Enum(
self._UInt32,
default=Pass,
Auto=0,
Daylight=1,
Cloudy=2,
Tungsten=3,
Fluorescent=4,
Custom=6,
FluorescentH=7,
ColorTemperature=9,
CustomWhitebalancePC1=10,
CustomWhitebalancePC2=11,
CustomWhitebalancePC3=12,
MissingNumber=13,
)
def _EOSFocusMode(self):
return Enum(
self._UInt32,
default=Pass,
OneShot=0,
AIServo=1,
AIFocus=2,
Manual=3,
)
def _DataType(self, **product_datatypes):
'''Dictionary for EOS property constructors'''
canon_datatypes = {
'EpochTime': ExprAdapter(
self._UInt32,
encoder=lambda obj, ctx:
int((obj - datetime(1970, 1, 1)).total_seconds()),
decoder=lambda obj, ctx: datetime.fromtimestamp(obj)
),
'ImageFormat': self._EOSImageFormat,
'Compression': self._EOSImageCompression,
'WhiteBalance': self._EOSWhiteBalance,
'FocusMode': self._EOSFocusMode,
}
canon_datatypes.update(product_datatypes if product_datatypes else {})
return super(EOSPropertiesMixin, self)._DataType(**canon_datatypes)
# Expected datatypes per `_EOSPropertyCode`
_EOSDataTypeCode = {
'Aperture': None,
'ShutterSpeed': None,
'ISO': None,
'ExposureCompensation': None,
'ShootingMode': None,
'DriveMode': None,
'ExposureMeteringMode': None,
'AutoFocusMode': 'FocusMode',
'WhiteBalance': 'WhiteBalance',
'ColorTemperature': None,
'WhiteBalanceAdjustBA': 'Int32',
'WhiteBalanceAdjustMG': 'Int32',
'WhiteBalanceBracketBA': 'UInt32',
'WhiteBalanceBracketMG': 'UInt32',
'ColorSpace': None,
'PictureStyle': None,
'CameraTime': 'EpochTime',
'BatteryPower': None,
'BatterySelect': None,
'AutoPowerOff': None,
'Owner': None,
'ModelID': None,
'PTPExtensionVersion': None,
'DPOFVersion': None,
'AvailableShots': 'UInt32',
'CaptureDestination': None,
'BracketMode': None,
'CurrentStorage': None,
'CurrentFolder': None,
'ImageFormat': 'ImageFormat',
'ImageFormatCF': 'ImageFormat',
'ImageFormatSD': 'ImageFormat',
'ImageFormatHDD': 'ImageFormat',
'CompressionS': 'Compression',
'CompressionM1': 'Compression',
'CompressionM2': 'Compression',
'CompressionL': 'Compression',
'AEModeDial': None,
'AEModeCustom': None,
'MirrorUpSetting': None,
'HighlightTonePriority': None,
'AFSelectFocusArea': None,
'HDRSetting': None,
'PCWhiteBalance1': None,
'PCWhiteBalance2': None,
'PCWhiteBalance3': None,
'PCWhiteBalance4': None,
'PCWhiteBalance5': None,
'MWhiteBalance': None,
'MWhiteBalanceEx': None,
'PictureStyleStandard': None,
'PictureStylePortrait': None,
'PictureStyleLandscape': None,
'PictureStyleNeutral': None,
'PictureStyleFaithful': None,
'PictureStyleBlackWhite': None,
'PictureStyleAuto': None,
'PictureStyleUserSet1': None,
'PictureStyleUserSet2': None,
'PictureStyleUserSet3': None,
'PictureStyleParam1': None,
'PictureStyleParam2': None,
'PictureStyleParam3': None,
'HighISOSettingNoiseReduction': None,
'MovieServoAF': None,
'ContinuousAFValid': None,
'Attenuator': None,
'UTCTime': 'EpochTime',
'Timezone': None,
'Summertime': None,
'FlavorLUTParams': None,
'CustomFunc1': None,
'CustomFunc2': None,
'CustomFunc3': None,
'CustomFunc4': None,
'CustomFunc5': None,
'CustomFunc6': None,
'CustomFunc7': None,
'CustomFunc8': None,
'CustomFunc9': None,
'CustomFunc10': None,
'CustomFunc11': None,
'CustomFunc12': None,
'CustomFunc13': None,
'CustomFunc14': None,
'CustomFunc15': None,
'CustomFunc16': None,
'CustomFunc17': None,
'CustomFunc18': None,
'CustomFunc19': None,
'InnerDevelop': None,
'MultiAspect': None,
'MovieSoundRecord': None,
'MovieRecordVolume': None,
'WindCut': None,
'ExtenderType': None,
'OLCInfoVersion': None,
'CustomFuncEx': None,
'MyMenu': None,
'MyMenuList': None,
'WftStatus': None,
'WftInputTransmission': None,
'HDDDirectoryStructure': None,
'BatteryInfo': None,
'AdapterInfo': None,
'LensStatus': None,
'QuickReviewTime': None,
'CardExtension': None,
'TempStatus': None,
'ShutterCounter': None,
'SpecialOption': None,
'PhotoStudioMode': None,
'SerialNumber': None,
'EVFOutputDevice': None,
'EVFMode': None,
'DepthOfFieldPreview': None,
'EVFSharpness': None,
'EVFWBMode': None,
'EVFClickWBCoeffs': None,
'EVFColorTemp': None,
'ExposureSimMode': None,
'EVFRecordStatus': None,
'LvAfSystem': None,
'MovSize': None,
'LvViewTypeSelect': None,
'MirrorDownStatus': None,
'MovieParam': None,
'MirrorLockupState': None,
'FlashChargingState': None,
'AloMode': None,
'FixedMovie': None,
'OneShotRawOn': None,
'ErrorForDisplay': None,
'AEModeMovie': None,
'BuiltinStroboMode': None,
'StroboDispState': None,
'StroboETTL2Metering': None,
'ContinousAFMode': None,
'MovieParam2': None,
'StroboSettingExpComposition': None,
'MovieParam3': None,
'LVMedicalRotate': None,
'Artist': None,
'Copyright': None,
'BracketValue': None,
'FocusInfoEx': None,
'DepthOfField': None,
'Brightness': None,
'LensAdjustParams': None,
'EFComp': None,
'LensName': None,
'AEB': None,
'StroboSetting': None,
'StroboWirelessSetting': None,
'StroboFiring': None,
'LensID': None,
'LCDBrightness': None,
'CADarkBright': None,
}
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,307 | hypoxic/sequoia-ptpy | refs/heads/master | /tests/context.py | import os
import sys
sys.path.insert(0, os.path.abspath('..'))
# Do not assume all users will have installed the package.
import ptpy # noqa
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,308 | hypoxic/sequoia-ptpy | refs/heads/master | /tests/hardware/tools/open_capture_poll_events.py | #!/usr/bin/env python
from ptpy import PTPy
# TODO Fix import once ptpy module is better structured.
camera = PTPy()
with camera.session():
print('Initiating open capture')
capture = camera.initiate_open_capture()
print(capture)
try:
while True:
evt = camera.event()
if evt:
print(evt)
except KeyboardInterrupt:
pass
finally:
if capture.ResponseCode == 'OK':
print('Terminating open capture.')
print(camera.terminate_open_capture(capture.TransactionID))
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,309 | hypoxic/sequoia-ptpy | refs/heads/master | /ptpy/transports/usb.py | '''This module implements the USB transport layer for PTP.
It exports the PTPUSB class. Both the transport layer and the basic PTP
implementation are Vendor agnostic. Vendor extensions should extend these to
support more operations.
'''
from __future__ import absolute_import
import atexit
import logging
import usb.core
import six
import array
from usb.util import (
endpoint_type, endpoint_direction, ENDPOINT_TYPE_BULK, ENDPOINT_TYPE_INTR,
ENDPOINT_OUT, ENDPOINT_IN,
)
from ..ptp import PTPError
from ..util import _main_thread_alive
from construct import (
Bytes, Container, Embedded, Enum, ExprAdapter, Int16ul, Int32ul, Pass,
Range, Struct,
)
from threading import Thread, Event, RLock
from six.moves.queue import Queue
from hexdump import hexdump
logger = logging.getLogger(__name__)
__all__ = ('USBTransport', 'find_usb_cameras')
__author__ = 'Luis Mario Domenzain'
PTP_USB_CLASS = 6
class find_class(object):
def __init__(self, class_, name=None):
self._class = class_
self._name = name
def __call__(self, device):
if device.bDeviceClass == self._class:
return (
self._name in usb.util.get_string(device, device.iProduct)
if self._name else True
)
for cfg in device:
intf = usb.util.find_descriptor(
cfg,
bInterfaceClass=self._class
)
if intf is not None:
return (
self._name in usb.util.get_string(device, device.iProduct)
if self._name else True
)
return False
def find_usb_cameras(name=None):
return usb.core.find(
find_all=True,
custom_match=find_class(PTP_USB_CLASS, name=name)
)
class USBTransport(object):
'''Implement USB transport.'''
def __init__(self, *args, **kwargs):
device = kwargs.get('device', None)
'''Instantiate the first available PTP device over USB'''
logger.debug('Init USB')
self.__setup_constructors()
# If no device is specified, find all devices claiming to be Cameras
# and get the USB endpoints for the first one that works.
if device is None:
logger.debug('No device provided, probing all USB devices.')
if isinstance(device, six.string_types):
name = device
logger.debug(
'Device name provided, probing all USB devices for {}.'
.format(name)
)
device = None
else:
name = None
devs = (
[device] if (device is not None)
else find_usb_cameras(name=name)
)
self.__claimed = False
self.__acquire_camera(devs)
self.__event_queue = Queue()
self.__event_shutdown = Event()
# Locks for different end points.
self.__inep_lock = RLock()
self.__intep_lock = RLock()
self.__outep_lock = RLock()
# Slightly redundant transaction lock to avoid catching other request's
# response
self.__transaction_lock = RLock()
self.__event_proc = Thread(
name='EvtPolling',
target=self.__poll_events
)
self.__event_proc.daemon = False
atexit.register(self._shutdown)
self.__event_proc.start()
def __available_cameras(self, devs):
for dev in devs:
if self.__setup_device(dev):
logger.debug('Found USB PTP device {}'.format(dev))
yield
else:
message = 'No USB PTP device found.'
logger.error(message)
raise PTPError(message)
def __acquire_camera(self, devs):
'''From the cameras given, get the first one that does not fail'''
for _ in self.__available_cameras(devs):
# Stop system drivers
try:
if self.__dev.is_kernel_driver_active(
self.__intf.bInterfaceNumber):
try:
self.__dev.detach_kernel_driver(
self.__intf.bInterfaceNumber)
except usb.core.USBError:
message = (
'Could not detach kernel driver. '
'Maybe the camera is mounted?'
)
logger.error(message)
except NotImplementedError as e:
logger.debug('Ignoring unimplemented function: {}'.format(e))
# Claim camera
try:
logger.debug('Claiming {}'.format(repr(self.__dev)))
usb.util.claim_interface(self.__dev, self.__intf)
self.__claimed = True
except Exception as e:
logger.warn('Failed to claim PTP device: {}'.format(e))
continue
self.__dev.reset()
break
else:
message = (
'Could not acquire any camera.'
)
logger.error(message)
raise PTPError(message)
def _shutdown(self):
logger.debug('Shutdown request')
self.__event_shutdown.set()
# Free USB resource on shutdown.
# Only join a running thread.
if self.__event_proc.is_alive():
self.__event_proc.join(2)
try:
if self.__claimed:
logger.debug('Release {}'.format(repr(self.__dev)))
usb.util.release_interface(self.__dev, self.__intf)
except Exception as e:
logger.warn(e)
# Helper methods.
# ---------------------
def __setup_device(self, dev):
'''Get endpoints for a device. True on success.'''
self.__inep = None
self.__outep = None
self.__intep = None
self.__cfg = None
self.__dev = None
self.__intf = None
# Attempt to find the USB in, out and interrupt endpoints for a PTP
# interface.
for cfg in dev:
for intf in cfg:
if intf.bInterfaceClass == PTP_USB_CLASS:
for ep in intf:
ep_type = endpoint_type(ep.bmAttributes)
ep_dir = endpoint_direction(ep.bEndpointAddress)
if ep_type == ENDPOINT_TYPE_BULK:
if ep_dir == ENDPOINT_IN:
self.__inep = ep
elif ep_dir == ENDPOINT_OUT:
self.__outep = ep
elif ((ep_type == ENDPOINT_TYPE_INTR) and
(ep_dir == ENDPOINT_IN)):
self.__intep = ep
if not (self.__inep and self.__outep and self.__intep):
self.__inep = None
self.__outep = None
self.__intep = None
else:
logger.debug('Found {}'.format(repr(self.__inep)))
logger.debug('Found {}'.format(repr(self.__outep)))
logger.debug('Found {}'.format(repr(self.__intep)))
self.__cfg = cfg
self.__dev = dev
self.__intf = intf
return True
return False
def __setup_constructors(self):
'''Set endianness and create transport-specific constructors.'''
# Set endianness of constructors before using them.
self._set_endian('little')
self.__Length = Int32ul
self.__Type = Enum(
Int16ul,
default=Pass,
Undefined=0x0000,
Command=0x0001,
Data=0x0002,
Response=0x0003,
Event=0x0004,
)
# This is just a convenience constructor to get the size of a header.
self.__Code = Int16ul
self.__Header = Struct(
'Length' / self.__Length,
'Type' / self.__Type,
'Code' / self.__Code,
'TransactionID' / self._TransactionID,
)
# These are the actual constructors for parsing and building.
self.__CommandHeader = Struct(
'Length' / self.__Length,
'Type' / self.__Type,
'OperationCode' / self._OperationCode,
'TransactionID' / self._TransactionID,
)
self.__ResponseHeader = Struct(
'Length' / self.__Length,
'Type' / self.__Type,
'ResponseCode' / self._ResponseCode,
'TransactionID' / self._TransactionID,
)
self.__EventHeader = Struct(
'Length' / self.__Length,
'Type' / self.__Type,
'EventCode' / self._EventCode,
'TransactionID' / self._TransactionID,
)
# Apparently nobody uses the SessionID field. Even though it is
# specified in ISO15740:2013(E), no device respects it and the session
# number is implicit over USB.
self.__Param = Range(0, 5, self._Parameter)
self.__CommandTransactionBase = Struct(
Embedded(self.__CommandHeader),
'Payload' / Bytes(
lambda ctx, h=self.__Header: ctx.Length - h.sizeof()
)
)
self.__CommandTransaction = ExprAdapter(
self.__CommandTransactionBase,
encoder=lambda obj, ctx, h=self.__Header: Container(
Length=len(obj.Payload) + h.sizeof(),
**obj
),
decoder=lambda obj, ctx: obj,
)
self.__ResponseTransactionBase = Struct(
Embedded(self.__ResponseHeader),
'Payload' / Bytes(
lambda ctx, h=self.__Header: ctx.Length - h.sizeof())
)
self.__ResponseTransaction = ExprAdapter(
self.__ResponseTransactionBase,
encoder=lambda obj, ctx, h=self.__Header: Container(
Length=len(obj.Payload) + h.sizeof(),
**obj
),
decoder=lambda obj, ctx: obj,
)
def __parse_response(self, usbdata):
'''Helper method for parsing USB data.'''
# Build up container with all PTP info.
logger.debug('Transaction:')
usbdata = bytearray(usbdata)
if logger.isEnabledFor(logging.DEBUG):
for l in hexdump(
six.binary_type(usbdata[:512]),
result='generator'
):
logger.debug(l)
transaction = self.__ResponseTransaction.parse(usbdata)
response = Container(
SessionID=self.session_id,
TransactionID=transaction.TransactionID,
)
logger.debug('Interpreting {} transaction'.format(transaction.Type))
if transaction.Type == 'Response':
response['ResponseCode'] = transaction.ResponseCode
response['Parameter'] = self.__Param.parse(transaction.Payload)
elif transaction.Type == 'Event':
event = self.__EventHeader.parse(
usbdata[0:self.__Header.sizeof()]
)
response['EventCode'] = event.EventCode
response['Parameter'] = self.__Param.parse(transaction.Payload)
else:
command = self.__CommandHeader.parse(
usbdata[0:self.__Header.sizeof()]
)
response['OperationCode'] = command.OperationCode
response['Data'] = transaction.Payload
return response
def __recv(self, event=False, wait=False, raw=False):
'''Helper method for receiving data.'''
# TODO: clear stalls automatically
ep = self.__intep if event else self.__inep
lock = self.__intep_lock if event else self.__inep_lock
usbdata = array.array('B', [])
with lock:
tries = 0
# Attempt to read a header
while len(usbdata) < self.__Header.sizeof() and tries < 5:
if tries > 0:
logger.debug('Data smaller than a header')
logger.debug(
'Requesting {} bytes of data'
.format(ep.wMaxPacketSize)
)
try:
usbdata += ep.read(
ep.wMaxPacketSize
)
except usb.core.USBError as e:
# Return None on timeout or busy for events
if (
(e.errno is None and
('timeout' in e.strerror.decode() or
'busy' in e.strerror.decode())) or
(e.errno == 110 or e.errno == 16 or e.errno == 5)
):
if event:
return None
else:
logger.warning('Ignored exception: {}'.format(e))
else:
logger.error(e)
raise e
tries += 1
logger.debug('Read {} bytes of data'.format(len(usbdata)))
if len(usbdata) == 0:
if event:
return None
else:
raise PTPError('Empty USB read')
if (
logger.isEnabledFor(logging.DEBUG) and
len(usbdata) < self.__Header.sizeof()
):
logger.debug('Incomplete header')
for l in hexdump(
six.binary_type(bytearray(usbdata)),
result='generator'
):
logger.debug(l)
header = self.__ResponseHeader.parse(
bytearray(usbdata[0:self.__Header.sizeof()])
)
if header.Type not in ['Response', 'Data', 'Event']:
raise PTPError(
'Unexpected USB transfer type. '
'Expected Response, Event or Data but received {}'
.format(header.Type)
)
while len(usbdata) < header.Length:
usbdata += ep.read(
min(
header.Length - len(usbdata),
# Up to 64kB
64 * 2**10
)
)
if raw:
return usbdata
else:
return self.__parse_response(usbdata)
def __send(self, ptp_container, event=False):
'''Helper method for sending data.'''
ep = self.__intep if event else self.__outep
lock = self.__intep_lock if event else self.__outep_lock
transaction = self.__CommandTransaction.build(ptp_container)
with lock:
try:
sent = 0
while sent < len(transaction):
sent = ep.write(
# Up to 64kB
transaction[sent:(sent + 64*2**10)]
)
except usb.core.USBError as e:
# Ignore timeout or busy device once.
if (
(e.errno is None and
('timeout' in e.strerror.decode() or
'busy' in e.strerror.decode())) or
(e.errno == 110 or e.errno == 16 or e.errno == 5)
):
logger.warning('Ignored USBError {}'.format(e.errno))
ep.write(transaction)
def __send_request(self, ptp_container):
'''Send PTP request without checking answer.'''
# Don't modify original container to keep abstraction barrier.
ptp = Container(**ptp_container)
# Don't send unused parameters
try:
while not ptp.Parameter[-1]:
ptp.Parameter.pop()
if len(ptp.Parameter) == 0:
break
except IndexError:
# The Parameter list is already empty.
pass
# Send request
ptp['Type'] = 'Command'
ptp['Payload'] = self.__Param.build(ptp.Parameter)
self.__send(ptp)
def __send_data(self, ptp_container, data):
'''Send data without checking answer.'''
# Don't modify original container to keep abstraction barrier.
ptp = Container(**ptp_container)
# Send data
ptp['Type'] = 'Data'
ptp['Payload'] = data
self.__send(ptp)
@property
def _dev(self):
return None if self.__event_shutdown.is_set() else self.__dev
@_dev.setter
def _dev(self, value):
raise ValueError('Read-only property')
# Actual implementation
# ---------------------
def send(self, ptp_container, data):
'''Transfer operation with dataphase from initiator to responder'''
datalen = len(data)
logger.debug('SEND {} {} bytes{}'.format(
ptp_container.OperationCode,
datalen,
' ' + str(list(map(hex, ptp_container.Parameter)))
if ptp_container.Parameter else '',
))
with self.__transaction_lock:
self.__send_request(ptp_container)
self.__send_data(ptp_container, data)
# Get response and sneak in implicit SessionID and missing
# parameters.
response = self.__recv()
logger.debug('SEND {} {} bytes {}{}'.format(
ptp_container.OperationCode,
datalen,
response.ResponseCode,
' ' + str(list(map(hex, response.Parameter)))
if ptp_container.Parameter else '',
))
return response
def recv(self, ptp_container):
'''Transfer operation with dataphase from responder to initiator.'''
logger.debug('RECV {}{}'.format(
ptp_container.OperationCode,
' ' + str(list(map(hex, ptp_container.Parameter)))
if ptp_container.Parameter else '',
))
with self.__transaction_lock:
self.__send_request(ptp_container)
dataphase = self.__recv()
if hasattr(dataphase, 'Data'):
response = self.__recv()
if not (ptp_container.SessionID ==
dataphase.SessionID ==
response.SessionID):
self.__dev.reset()
raise PTPError(
'Dataphase session ID missmatch: {}, {}, {}.'
.format(
ptp_container.SessionID,
dataphase.SessionID,
response.SessionID
)
)
if not (ptp_container.TransactionID ==
dataphase.TransactionID ==
response.TransactionID):
self.__dev.reset()
raise PTPError(
'Dataphase transaction ID missmatch: {}, {}, {}.'
.format(
ptp_container.TransactionID,
dataphase.TransactionID,
response.TransactionID
)
)
if not (ptp_container.OperationCode ==
dataphase.OperationCode):
self.__dev.reset()
raise PTPError(
'Dataphase operation code missmatch: {}, {}.'.
format(
ptp_container.OperationCode,
dataphase.OperationCode
)
)
response['Data'] = dataphase.Data
else:
response = dataphase
logger.debug('RECV {} {}{}{}'.format(
ptp_container.OperationCode,
response.ResponseCode,
' {} bytes'.format(len(response.Data))
if hasattr(response, 'Data') else '',
' ' + str(list(map(hex, response.Parameter)))
if response.Parameter else '',
))
return response
def mesg(self, ptp_container):
'''Transfer operation without dataphase.'''
logger.debug('MESG {}{}'.format(
ptp_container.OperationCode,
' ' + str(list(map(hex, ptp_container.Parameter)))
if ptp_container.Parameter else '',
))
with self.__transaction_lock:
self.__send_request(ptp_container)
# Get response and sneak in implicit SessionID and missing
# parameters for FullResponse.
response = self.__recv()
logger.debug('MESG {} {}{}'.format(
ptp_container.OperationCode,
response.ResponseCode,
' ' + str(list(map(hex, response.Parameter)))
if response.Parameter else '',
))
return response
def event(self, wait=False):
'''Check event.
If `wait` this function is blocking. Otherwise it may return None.
'''
evt = None
usbdata = None
if wait:
usbdata = self.__event_queue.get(block=True)
elif not self.__event_queue.empty():
usbdata = self.__event_queue.get(block=False)
if usbdata is not None:
evt = self.__parse_response(usbdata)
return evt
def __poll_events(self):
'''Poll events, adding them to a queue.'''
while not self.__event_shutdown.is_set() and _main_thread_alive():
try:
evt = self.__recv(event=True, wait=False, raw=True)
if evt is not None:
logger.debug('Event queued')
self.__event_queue.put(evt)
except usb.core.USBError as e:
logger.error(
'{} polling exception: {}'.format(repr(self.__dev), e)
)
# check if disconnected
if e.errno == 19:
break
except Exception as e:
logger.error(
'{} polling exception: {}'.format(repr(self.__dev), e)
)
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,310 | hypoxic/sequoia-ptpy | refs/heads/master | /tests/hardware/tools/capture_poll_events.py | #!/usr/bin/env python
from ptpy import PTPy
camera = PTPy()
with camera.session():
print('Initiating capture')
print(camera.initiate_capture())
while True:
evt = camera.event()
if evt:
print(evt)
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,311 | hypoxic/sequoia-ptpy | refs/heads/master | /examples/print_device_info.py | #!/usr/bin/env python
import ptpy
camera = ptpy.PTPy()
print(camera.get_device_info())
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,312 | hypoxic/sequoia-ptpy | refs/heads/master | /setup.py | import os
from setuptools import setup, find_packages
def read(filename):
with open(os.path.join(os.path.dirname(__file__), filename)) as f:
return f.read()
setup(
author_email='luis.domenzain@parrot.com',
author='Luis Mario Domenzain',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'Intended Audience :: Education',
'Intended Audience :: End Users/Desktop',
'Intended Audience :: Other Audience',
'Intended Audience :: Science/Research',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Home Automation',
'Topic :: Multimedia',
'Topic :: Multimedia :: Graphics',
'Topic :: Multimedia :: Graphics :: Capture',
'Topic :: Multimedia :: Graphics :: Capture :: Digital Camera',
'Topic :: Scientific/Engineering',
'Topic :: Software Development :: Libraries',
'Topic :: System :: Filesystems',
'Topic :: System :: Hardware',
'Topic :: System :: Hardware :: Hardware Drivers',
],
description='A pure Python implementation of Picture Transfer Protocol.',
install_requires=read('requirements.txt'),
keywords='ptp mtp usb ip ptpip ptpusb parrot canon nikon microsoft',
license='BSD-3-Clause',
long_description=read('README.md'),
name='ptpy',
packages=find_packages(exclude=['tests', 'examples']),
setup_requires=['pytest-runner'],
tests_require=read('tests/requirements.txt'),
url='https://github.com/Parrot-Developers/sequoia-ptpy',
version='0.3.3',
)
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,313 | hypoxic/sequoia-ptpy | refs/heads/master | /examples/trigger.py | #!/usr/bin/env python
import ptpy
camera = ptpy.PTPy()
with camera.session():
capture = camera.initiate_capture()
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,314 | hypoxic/sequoia-ptpy | refs/heads/master | /examples/download_all_images.py | #!/usr/bin/env python
import ptpy
camera = ptpy.PTPy()
with camera.session():
handles = camera.get_object_handles(
0,
all_storage_ids=True,
all_formats=True,
)
for handle in handles:
info = camera.get_object_info(handle)
print(info)
# Download all things that are not groups of other things.
if info.ObjectFormat != 'Association':
obj = camera.get_object(handle)
with open(info.Filename, mode='w') as f:
f.write(obj.Data)
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,315 | hypoxic/sequoia-ptpy | refs/heads/master | /tests/hardware/test_camera.py | import pytest
@pytest.mark.incremental
@pytest.mark.usefixtures('camera')
class TestCamera:
'''Perform tests on a physical camera.'''
def test_device_info(self, camera):
'''Camera responds to PTP.'''
if camera is None:
pytest.skip('No camera available to test')
device_info = camera.get_device_info()
assert device_info, 'There is no response for DeviceInfo.\n'\
'The camera may not support PTP.'
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,316 | hypoxic/sequoia-ptpy | refs/heads/master | /ptpy/extensions/canon/canon.py | '''This module extends PTPDevice for Canon devices.
Use it in a master module that determines the vendor and automatically uses its
extension. This is why inheritance is not explicit.
'''
from ...util import _main_thread_alive
from .properties import EOSPropertiesMixin
from contextlib import contextmanager
from construct import (
Array, Byte, Container, Embedded, Enum, Pass, PrefixedArray, Range, Struct,
Switch, Computed
)
from six.moves.queue import Queue
from threading import Thread, Event
from time import sleep
import atexit
import logging
logger = logging.getLogger(__name__)
__all__ = ('Canon',)
class Canon(EOSPropertiesMixin, object):
'''This class implements Canon's PTP operations.'''
def __init__(self, *args, **kwargs):
logger.debug('Init Canon')
super(Canon, self).__init__(*args, **kwargs)
# TODO: expose the choice to poll or not Canon events
self.__no_polling = False
self.__eos_event_shutdown = Event()
self.__eos_event_proc = None
@contextmanager
def session(self):
'''
Manage Canon session with context manager.
'''
# When raw device, do not perform
if self.__no_polling:
with super(Canon, self).session():
yield
return
# Within a normal PTP session
with super(Canon, self).session():
# Set up remote mode and extended event info
self.eos_set_remote_mode(1)
self.eos_event_mode(1)
# And launch a polling thread
self.__event_queue = Queue()
self.__eos_event_proc = Thread(
name='EOSEvtPolling',
target=self.__eos_poll_events
)
self.__eos_event_proc.daemon = False
atexit.register(self._eos_shutdown)
self.__eos_event_proc.start()
try:
yield
finally:
self._eos_shutdown()
def _shutdown(self):
self._eos_shutdown()
super(Canon, self)._shutdown()
def _eos_shutdown(self):
logger.debug('Shutdown EOS events request')
self.__eos_event_shutdown.set()
# Only join a running thread.
if self.__eos_event_proc and self.__eos_event_proc.is_alive():
self.__eos_event_proc.join(2)
def _PropertyCode(self, **product_properties):
return super(Canon, self)._PropertyCode(
BeepMode=0xD001,
ViewfinderMode=0xD003,
ImageQuality=0xD006,
CanonImageSize=0xD008,
CanonFlashMode=0xD00A,
TvAvSetting=0xD00C,
MeteringMode=0xD010,
MacroMode=0xD011,
FocusingPoint=0xD012,
CanonWhiteBalance=0xD013,
ISOSpeed=0xD01C,
Aperture=0xD01D,
ShutterSpeed=0xD01E,
ExpCompensation=0xD01F,
Zoom=0xD02A,
SizeQualityMode=0xD02C,
FlashMemory=0xD031,
CameraModel=0xD032,
CameraOwner=0xD033,
UnixTime=0xD034,
ViewfinderOutput=0xD036,
RealImageWidth=0xD039,
PhotoEffect=0xD040,
AssistLight=0xD041,
**product_properties
)
def _OperationCode(self, **product_operations):
return super(Canon, self)._OperationCode(
GetObjectSize=0x9001,
SetObjectArchive=0x9002,
KeepDeviceOn=0x9003,
LockDeviceUI=0x9004,
UnlockDeviceUI=0x9005,
GetObjectHandleByName=0x9006,
InitiateReleaseControl=0x9008,
TerminateReleaseControl=0x9009,
TerminatePlaybackMode=0x900A,
ViewfinderOn=0x900B,
ViewfinderOff=0x900C,
DoAeAfAwb=0x900D,
GetCustomizeSpec=0x900E,
GetCustomizeItemInfo=0x900F,
GetCustomizeData=0x9010,
SetCustomizeData=0x9011,
GetCaptureStatus=0x9012,
CheckEvent=0x9013,
FocusLock=0x9014,
FocusUnlock=0x9015,
GetLocalReleaseParam=0x9016,
SetLocalReleaseParam=0x9017,
AskAboutPcEvf=0x9018,
SendPartialObject=0x9019,
InitiateCaptureInMemory=0x901A,
GetPartialObjectEx=0x901B,
SetObjectTime=0x901C,
GetViewfinderImage=0x901D,
GetObjectAttributes=0x901E,
ChangeUSBProtocol=0x901F,
GetChanges=0x9020,
GetObjectInfoEx=0x9021,
InitiateDirectTransfer=0x9022,
TerminateDirectTransfer=0x9023,
SendObjectInfoByPath=0x9024,
SendObjectByPath=0x9025,
InitiateDirectTansferEx=0x9026,
GetAncillaryObjectHandles=0x9027,
GetTreeInfo=0x9028,
GetTreeSize=0x9029,
NotifyProgress=0x902A,
NotifyCancelAccepted=0x902B,
GetDirectory=0x902D,
SetPairingInfo=0x9030,
GetPairingInfo=0x9031,
DeletePairingInfo=0x9032,
GetMACAddress=0x9033,
SetDisplayMonitor=0x9034,
PairingComplete=0x9035,
GetWirelessMAXChannel=0x9036,
EOSGetStorageIDs=0x9101,
EOSGetStorageInfo=0x9102,
EOSGetObjectInfo=0x9103,
EOSGetObject=0x9104,
EOSDeleteObject=0x9105,
EOSFormatStore=0x9106,
EOSGetPartialObject=0x9107,
EOSGetDeviceInfoEx=0x9108,
EOSGetObjectInfoEx=0x9109,
EOSGetThumbEx=0x910A,
EOSSendPartialObject=0x910B,
EOSSetObjectAttributes=0x910C,
EOSGetObjectTime=0x910D,
EOSSetObjectTime=0x910E,
EOSRemoteRelease=0x910F,
EOSSetDevicePropValueEx=0x9110,
EOSGetRemoteMode=0x9113,
EOSSetRemoteMode=0x9114,
EOSSetEventMode=0x9115,
EOSGetEvent=0x9116,
EOSTransferComplete=0x9117,
EOSCancelTransfer=0x9118,
EOSResetTransfer=0x9119,
EOSPCHDDCapacity=0x911A,
EOSSetUILock=0x911B,
EOSResetUILock=0x911C,
EOSKeepDeviceOn=0x911D,
EOSSetNullPacketMode=0x911E,
EOSUpdateFirmware=0x911F,
EOSTransferCompleteDT=0x9120,
EOSCancelTransferDT=0x9121,
EOSSetWftProfile=0x9122,
EOSGetWftProfile=0x9122,
EOSSetProfileToWft=0x9124,
EOSBulbStart=0x9125,
EOSBulbEnd=0x9126,
EOSRequestDevicePropValue=0x9127,
EOSRemoteReleaseOn=0x9128,
EOSRemoteReleaseOff=0x9129,
EOSInitiateViewfinder=0x9151,
EOSTerminateViewfinder=0x9152,
EOSGetViewFinderImage=0x9153,
EOSDoAf=0x9154,
EOSDriveLens=0x9155,
EOSDepthOfFieldPreview=0x9156,
EOSClickWB=0x9157,
EOSZoom=0x9158,
EOSZoomPosition=0x9159,
EOSSetLiveAfFrame=0x915a,
EOSAfCancel=0x9160,
EOSFAPIMessageTX=0x91FE,
EOSFAPIMessageRX=0x91FF,
EOSSendCanonMessage=0x9052,
EOSProcReturnData=0x9053,
**product_operations
)
def _ObjectFormatCode(self, **product_object_formats):
return super(Canon, self)._ObjectFormatCode(
CRW=0xB101,
CRW3=0xB103,
MOV=0xB104,
**product_object_formats
)
def _ResponseCode(self, **product_responses):
return super(Canon, self)._ResponseCode(
**product_responses
)
def _EventCode(self, **product_events):
return super(Canon, self)._EventCode(
CanonDeviceInfoChanged=0xC008,
CanonRequestObjectTransfer=0xC009,
CameraModeChanged=0xC00C,
**product_events
)
def _FilesystemType(self, **product_filesystem_types):
return super(Canon, self)._FilesystemType(
**product_filesystem_types
)
def _EOSEventCode(self):
'''Return desired endianness for Canon EOS event codes'''
return Enum(
self._UInt32,
default=Pass,
EmptyEvent=0x0000,
RequestGetEvent=0xC101,
ObjectAdded=0xC181,
ObjectRemoved=0xC182,
RequestGetObjectInfoEx=0xC183,
StorageStatusChanged=0xC184,
StorageInfoChanged=0xC185,
RequestObjectTransfer=0xC186,
ObjectInfoChangedEx=0xC187,
ObjectContentChanged=0xC188,
DevicePropChanged=0xC189,
AvailListChanged=0xC18A,
CameraStatusChanged=0xC18B,
WillSoonShutdown=0xC18D,
ShutdownTimerUpdated=0xC18E,
RequestCancelTransfer=0xC18F,
RequestObjectTransferDT=0xC190,
RequestCancelTransferDT=0xC191,
StoreAdded=0xC192,
StoreRemoved=0xC193,
BulbExposureTime=0xC194,
RecordingTime=0xC195,
InnerDevelopParam=0xC196,
RequestObjectTransferDevelop=0xC197,
GPSLogOutputProgress=0xC198,
GPSLogOutputComplete=0xC199,
TouchTrans=0xC19A,
RequestObjectTransferExInfo=0xC19B,
PowerZoomInfoChanged=0xC19D,
RequestPushMode=0xC19F,
RequestObjectTransferTS=0xC1A2,
AfResult=0xC1A3,
CTGInfoCheckComplete=0xC1A4,
OLCInfoChanged=0xC1A5,
ObjectAddedEx64=0xC1A7,
ObjectInfoChangedEx64=0xC1A8,
RequestObjectTransfer64=0xC1A9,
RequestObjectTransferFTP64=0xC1AB,
ImportFailed=0xC1AF,
BlePairing=0xC1B0,
RequestObjectTransferFTP=0xC1F1,
UnknownError=0xFFFFFFFF,
)
def _EOSPropertyCode(self):
'''Return desired endianness for Canon EOS property codes'''
return Enum(
self._UInt32,
default=Pass,
Aperture=0xD101,
ShutterSpeed=0xD102,
ISO=0xD103,
ExposureCompensation=0xD104,
ShootingMode=0xD105,
DriveMode=0xD106,
ExposureMeteringMode=0xD107,
AutoFocusMode=0xD108,
WhiteBalance=0xD109,
ColorTemperature=0xD10A,
WhiteBalanceAdjustBA=0xD10B,
WhiteBalanceAdjustMG=0xD10C,
WhiteBalanceBracketBA=0xD10D,
WhiteBalanceBracketMG=0xD10E,
ColorSpace=0xD10F,
PictureStyle=0xD110,
BatteryPower=0xD111,
BatterySelect=0xD112,
CameraTime=0xD113,
AutoPowerOff=0xD114,
Owner=0xD115,
ModelID=0xD116,
PTPExtensionVersion=0xD119,
DPOFVersion=0xD11A,
AvailableShots=0xD11B,
CaptureDestination=0xD11C,
BracketMode=0xD11D,
CurrentStorage=0xD11E,
CurrentFolder=0xD11F,
ImageFormat=0xD120,
ImageFormatCF=0xD121,
ImageFormatSD=0xD122,
ImageFormatHDD=0xD123,
CompressionS=0xD130,
CompressionM1=0xD131,
CompressionM2=0xD132,
CompressionL=0xD133,
AEModeDial=0xD138,
AEModeCustom=0xD139,
MirrorUpSetting=0xD13A,
HighlightTonePriority=0xD13B,
AFSelectFocusArea=0xD13C,
HDRSetting=0xD13D,
PCWhiteBalance1=0xD140,
PCWhiteBalance2=0xD141,
PCWhiteBalance3=0xD142,
PCWhiteBalance4=0xD143,
PCWhiteBalance5=0xD144,
MWhiteBalance=0xD145,
MWhiteBalanceEx=0xD146,
PictureStyleStandard=0xD150,
PictureStylePortrait=0xD151,
PictureStyleLandscape=0xD152,
PictureStyleNeutral=0xD153,
PictureStyleFaithful=0xD154,
PictureStyleBlackWhite=0xD155,
PictureStyleAuto=0xD156,
PictureStyleUserSet1=0xD160,
PictureStyleUserSet2=0xD161,
PictureStyleUserSet3=0xD162,
PictureStyleParam1=0xD170,
PictureStyleParam2=0xD171,
PictureStyleParam3=0xD172,
HighISOSettingNoiseReduction=0xD178,
MovieServoAF=0xD179,
ContinuousAFValid=0xD17A,
Attenuator=0xD17B,
UTCTime=0xD17C,
Timezone=0xD17D,
Summertime=0xD17E,
FlavorLUTParams=0xD17F,
CustomFunc1=0xD180,
CustomFunc2=0xD181,
CustomFunc3=0xD182,
CustomFunc4=0xD183,
CustomFunc5=0xD184,
CustomFunc6=0xD185,
CustomFunc7=0xD186,
CustomFunc8=0xD187,
CustomFunc9=0xD188,
CustomFunc10=0xD189,
CustomFunc11=0xD18A,
CustomFunc12=0xD18B,
CustomFunc13=0xD18C,
CustomFunc14=0xD18D,
CustomFunc15=0xD18E,
CustomFunc16=0xD18F,
CustomFunc17=0xD190,
CustomFunc18=0xD191,
CustomFunc19=0xD192,
InnerDevelop=0xD193,
MultiAspect=0xD194,
MovieSoundRecord=0xD195,
MovieRecordVolume=0xD196,
WindCut=0xD197,
ExtenderType=0xD198,
OLCInfoVersion=0xD199,
CustomFuncEx=0xD1A0,
MyMenu=0xD1A1,
MyMenuList=0xD1A2,
WftStatus=0xD1A3,
WftInputTransmission=0xD1A4,
HDDDirectoryStructure=0xD1A5,
BatteryInfo=0xD1A6,
AdapterInfo=0xD1A7,
LensStatus=0xD1A8,
QuickReviewTime=0xD1A9,
CardExtension=0xD1AA,
TempStatus=0xD1AB,
ShutterCounter=0xD1AC,
SpecialOption=0xD1AD,
PhotoStudioMode=0xD1AE,
SerialNumber=0xD1AF,
EVFOutputDevice=0xD1B0,
EVFMode=0xD1B1,
DepthOfFieldPreview=0xD1B2,
EVFSharpness=0xD1B3,
EVFWBMode=0xD1B4,
EVFClickWBCoeffs=0xD1B5,
EVFColorTemp=0xD1B6,
ExposureSimMode=0xD1B7,
EVFRecordStatus=0xD1B8,
LvAfSystem=0xD1BA,
MovSize=0xD1BB,
LvViewTypeSelect=0xD1BC,
MirrorDownStatus=0xD1BD,
MovieParam=0xD1BE,
MirrorLockupState=0xD1BF,
FlashChargingState=0xD1C0,
AloMode=0xD1C1,
FixedMovie=0xD1C2,
OneShotRawOn=0xD1C3,
ErrorForDisplay=0xD1C4,
AEModeMovie=0xD1C5,
BuiltinStroboMode=0xD1C6,
StroboDispState=0xD1C7,
StroboETTL2Metering=0xD1C8,
ContinousAFMode=0xD1C9,
MovieParam2=0xD1CA,
StroboSettingExpComposition=0xD1CB,
MovieParam3=0xD1CC,
LVMedicalRotate=0xD1CF,
Artist=0xD1D0,
Copyright=0xD1D1,
BracketValue=0xD1D2,
FocusInfoEx=0xD1D3,
DepthOfField=0xD1D4,
Brightness=0xD1D5,
LensAdjustParams=0xD1D6,
EFComp=0xD1D7,
LensName=0xD1D8,
AEB=0xD1D9,
StroboSetting=0xD1DA,
StroboWirelessSetting=0xD1DB,
StroboFiring=0xD1DC,
LensID=0xD1DD,
LCDBrightness=0xD1DE,
CADarkBright=0xD1DF,
)
def _EOSEventRecords(self):
'''Return desired endianness for EOS Event Records constructor'''
return Range(
# The dataphase can be about as long as a 32 bit unsigned int.
0, 0xFFFFFFFF,
self._EOSEventRecord
)
def _EOSEventRecord(self):
'''Return desired endianness for a single EOS Event Record'''
return Struct(
'Bytes' / self._UInt32,
Embedded(Struct(
'EventCode' / self._EOSEventCode,
'Record' / Switch(
lambda ctx: ctx.EventCode,
{
'AvailListChanged':
Embedded(Struct(
'PropertyCode' / self._EOSPropertyCode,
'Enumeration' / Array(
# TODO: Verify if this is actually an
# enumeration.
lambda ctx: ctx._._.Bytes - 12,
self._UInt8
)
)),
'DevicePropChanged':
Embedded(Struct(
'PropertyCode' / self._EOSPropertyCode,
'DataTypeCode' / Computed(
lambda ctx: self._EOSDataTypeCode[ctx.PropertyCode]
),
'Value' / Switch(
lambda ctx: ctx.DataTypeCode,
{
None: Array(
lambda ctx: ctx._._.Bytes - 12,
self._UInt8
)
},
default=self._DataType
),
)),
# TODO: 'EmptyEvent',
# TODO: 'RequestGetEvent',
# TODO: 'ObjectAdded',
# TODO: 'ObjectRemoved',
# TODO: 'RequestGetObjectInfoEx',
# TODO: 'StorageStatusChanged',
# TODO: 'StorageInfoChanged',
# TODO: 'RequestObjectTransfer',
# TODO: 'ObjectInfoChangedEx',
# TODO: 'ObjectContentChanged',
# TODO: 'DevicePropChanged',
# TODO: 'AvailListChanged',
# TODO: 'CameraStatusChanged',
# TODO: 'WillSoonShutdown',
# TODO: 'ShutdownTimerUpdated',
# TODO: 'RequestCancelTransfer',
# TODO: 'RequestObjectTransferDT',
# TODO: 'RequestCancelTransferDT',
# TODO: 'StoreAdded',
# TODO: 'StoreRemoved',
# TODO: 'BulbExposureTime',
# TODO: 'RecordingTime',
# TODO: 'InnerDevelopParam',
# TODO: 'RequestObjectTransferDevelop',
# TODO: 'GPSLogOutputProgress',
# TODO: 'GPSLogOutputComplete',
# TODO: 'TouchTrans',
# TODO: 'RequestObjectTransferExInfo',
# TODO: 'PowerZoomInfoChanged',
# TODO: 'RequestPushMode',
# TODO: 'RequestObjectTransferTS',
# TODO: 'AfResult',
# TODO: 'CTGInfoCheckComplete',
# TODO: 'OLCInfoChanged',
# TODO: 'ObjectAddedEx64',
# TODO: 'ObjectInfoChangedEx64',
# TODO: 'RequestObjectTransfer64',
# TODO: 'RequestObjectTransferFTP64',
# TODO: 'ImportFailed',
# TODO: 'BlePairing',
# TODO: 'RequestObjectTransferFTP',
# TODO: 'Unknown',
},
default=Array(
lambda ctx: ctx._.Bytes - 8,
self._UInt8
)
)
))
)
def _EOSDeviceInfo(self):
return Struct(
'EventsSupported' / PrefixedArray(
self._UInt32,
self._EOSEventCode
),
'DevicePropertiesSupported' / PrefixedArray(
self._UInt32,
self._EOSPropertyCode
),
'TODO' / PrefixedArray(
self._UInt32,
self._UInt32
),
)
# TODO: Decode Canon specific events and properties.
def _set_endian(self, endian):
logger.debug('Set Canon endianness')
# HACK: The DataType mechanism used for automatic parsing introduces
# HACK: some nasty dependencies, so the PTP types need to be declared
# HACK: before the extension types, and then finally the DataType at
# HACK: the end...
# TODO: This could probably use a decorator to automatically work out the
# TODO: right order...
super(Canon, self)._set_endian(endian, explicit=True)
# Prepare these for DataType
self._EOSPropertyCode = self._EOSPropertyCode()
self._EOSEventCode = self._EOSEventCode()
self._EOSImageSize = self._EOSImageSize()
self._EOSImageType = self._EOSImageType()
self._EOSImageCompression = self._EOSImageCompression()
self._EOSImageFormat = self._EOSImageFormat()
self._EOSWhiteBalance = self._EOSWhiteBalance()
self._EOSFocusMode = self._EOSFocusMode()
# Make sure DataType is available
super(Canon, self)._set_endian(endian, explicit=False)
# Use DataType
self._EOSEventRecord = self._EOSEventRecord()
self._EOSEventRecords = self._EOSEventRecords()
# TODO: implement GetObjectSize
# TODO: implement SetObjectArchive
def keep_device_on(self):
'''Ping non EOS camera so it stays ON'''
ptp = Container(
OperationCode='KeepDeviceOn',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.mesg(ptp)
return response
# TODO: implement LockDeviceUI
# TODO: implement UnlockDeviceUI
# TODO: implement GetObjectHandleByName
# TODO: implement InitiateReleaseControl
# TODO: implement TerminateReleaseControl
# TODO: implement TerminatePlaybackMode
# TODO: implement ViewfinderOn
# TODO: implement ViewfinderOff
# TODO: implement DoAeAfAwb
# TODO: implement GetCustomizeSpec
# TODO: implement GetCustomizeItemInfo
# TODO: implement GetCustomizeData
# TODO: implement SetCustomizeData
# TODO: implement GetCaptureStatus
# TODO: implement CheckEvent
# TODO: implement FocusLock
# TODO: implement FocusUnlock
# TODO: implement GetLocalReleaseParam
# TODO: implement SetLocalReleaseParam
# TODO: implement AskAboutPcEvf
# TODO: implement SendPartialObject
# TODO: implement InitiateCaptureInMemory
# TODO: implement GetPartialObjectEx
# TODO: implement SetObjectTime
# TODO: implement GetViewfinderImage
# TODO: implement GetObjectAttributes
# TODO: implement ChangeUSBProtocol
# TODO: implement GetChanges
# TODO: implement GetObjectInfoEx
# TODO: implement InitiateDirectTransfer
# TODO: implement TerminateDirectTransfer
# TODO: implement SendObjectInfoByPath
# TODO: implement SendObjectByPath
# TODO: implement InitiateDirectTansferEx
# TODO: implement GetAncillaryObjectHandles
# TODO: implement GetTreeInfo
# TODO: implement GetTreeSize
# TODO: implement NotifyProgress
# TODO: implement NotifyCancelAccepted
# TODO: implement GetDirectory
# TODO: implement SetPairingInfo
# TODO: implement GetPairingInfo
# TODO: implement DeletePairingInfo
# TODO: implement GetMACAddress
# TODO: implement SetDisplayMonitor
# TODO: implement PairingComplete
# TODO: implement GetWirelessMAXChannel
# TODO: implement EOSGetStorageIDs
# TODO: implement EOSGetStorageInfo
# TODO: implement EOSGetObjectInfo
# TODO: implement EOSGetObject
# TODO: implement EOSDeleteObject
# TODO: implement EOSFormatStore
# TODO: implement EOSGetPartialObject
# TODO: implement EOSGetDeviceInfoEx
def eos_get_device_info(self):
'''Get EOS camera device information'''
ptp = Container(
OperationCode='EOSGetDeviceInfoEx',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[0x00100000]
)
response = self.recv(ptp)
return self._parse_if_data(response, self._EOSDeviceInfo)
# TODO: implement EOSGetObjectInfoEx
# TODO: implement EOSGetThumbEx
# TODO: implement EOSSendPartialObject
# TODO: implement EOSSetObjectAttributes
# TODO: implement EOSGetObjectTime
# TODO: implement EOSSetObjectTime
def eos_remote_release(self):
'''Release shutter remotely on EOS cameras'''
ptp = Container(
OperationCode='EOSRemoteRelease',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.mesg(ptp)
return response
# TODO: implement EOSSetDevicePropValueEx
# TODO: implement EOSGetRemoteMode
def eos_set_remote_mode(self, mode):
'''Set remote mode on EOS cameras'''
# TODO: Add automatic translation of remote mode codes and names.
code = mode
ptp = Container(
OperationCode='EOSSetRemoteMode',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[code]
)
response = self.mesg(ptp)
return response
def eos_run_command(self, string, params=[]):
'''Run a prodecure command from DryOS Shell (0x9052)'''
ptp = Container(
OperationCode='EOSSendCanonMessage',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=params,
)
# I am not entirely sure what this is, but the camera will crash and
# time out without generous zero padding.
ending = bytearray(30)
# Generate a final command with the ending
command = string.encode() + ending
response = self.send(ptp, command)
return response
def eos_return_command(self, params=[]):
'''Some other thing (0x9053) EOSProcReturnData'''
ptp = Container(
OperationCode='EOSProcReturnData',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=params
)
# Send the string as bytes into the payload (?)
response = self.recv(ptp)
return response
def eos_event_mode(self, mode):
'''Set event mode on EOS cameras'''
# Canon extension uses this to enrich the events returned by the camera
# as well as allowing for polling at the convenience of the initiator.
# TODO: Add automatic translation of event mode codes and names.
code = mode
ptp = Container(
OperationCode='EOSSetEventMode',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[code]
)
response = self.mesg(ptp)
return response
def eos_get_event(self):
'''Poll EOS camera for EOS events'''
ptp = Container(
OperationCode='EOSGetEvent',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.recv(ptp)
return self._parse_if_data(response, self._EOSEventRecords)
def eos_transfer_complete(self, handle):
'''Terminate a transfer for EOS Cameras'''
ptp = Container(
OperationCode='EOSTransferComplete',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[handle]
)
response = self.mesg(ptp)
return response
# TODO: implement EOSCancelTransfer
# TODO: implement EOSResetTransfer
def eos_pc_hdd_capacity(self, todo0=0xfffffff8, todo1=0x1000, todo2=0x1):
'''Tell EOS camera about PC hard drive capacity'''
# TODO: Figure out what to send exactly.
ptp = Container(
OperationCode='EOSPCHDDCapacity',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[todo0, todo1, todo2]
)
response = self.mesg(ptp)
return response
def eos_set_ui_lock(self):
'''Lock user interface on EOS cameras'''
ptp = Container(
OperationCode='EOSSetUILock',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.mesg(ptp)
return response
def eos_reset_ui_lock(self):
'''Unlock user interface on EOS cameras'''
ptp = Container(
OperationCode='EOSResetUILock',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.mesg(ptp)
return response
def eos_keep_device_on(self):
'''Ping EOS camera so it stays ON'''
ptp = Container(
OperationCode='EOSKeepDeviceOn',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.mesg(ptp)
return response
# TODO: implement EOSSetNullPacketMode
# TODO: implement EOSUpdateFirmware
# TODO: implement EOSTransferCompleteDT
# TODO: implement EOSCancelTransferDT
# TODO: implement EOSSetWftProfile
# TODO: implement EOSGetWftProfile
# TODO: implement EOSSetProfileToWft
# TODO: implement method convenience method for bulb captures
def eos_bulb_start(self):
'''Begin bulb capture on EOS cameras'''
ptp = Container(
OperationCode='EOSBulbStart',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.mesg(ptp)
return response
def eos_bulb_end(self):
'''End bulb capture on EOS cameras'''
ptp = Container(
OperationCode='EOSBulbEnd',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.mesg(ptp)
return response
def eos_request_device_prop_value(self, device_property):
'''End bulb capture on EOS cameras'''
ptp = Container(
OperationCode='EOSRequestDevicePropValue',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[device_property]
)
response = self.mesg(ptp)
return response
def eos_remote_release_on(self, full=False, m=False, x=0):
'''
Remote control shutter press for EOS cameras
This is the equivalent of pressing the shutter button: all the way in
if `full` or half-way otherwise.
For Canon EOS M, there is only full press with a special argument.
'''
ptp = Container(
OperationCode='EOSRemoteReleaseOn',
SessionID=self._session,
TransactionID=self._transaction,
# TODO: figure out what x means.
Parameter=[0x3 if m else (0x2 if full else 0x1), x]
)
response = self.mesg(ptp)
return response
def eos_remote_release_off(self, full=False, m=False):
'''
Remote control shutter release for EOS cameras
This is the equivalent of releasing the shutter button: from all the
way in if `full` or from half-way otherwise.
For Canon EOS M, there is only full press with a special argument.
'''
ptp = Container(
OperationCode='EOSRemoteReleaseOff',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[0x3 if m else (0x2 if full else 0x1)]
)
response = self.mesg(ptp)
return response
# TODO: implement EOSInitiateViewfinder
# TODO: implement EOSTerminateViewfinder
# TODO: implement EOSGetViewFinderImage
def eos_get_viewfinder_image(self):
'''Get viefinder image for EOS cameras'''
ptp = Container(
OperationCode='EOSGetViewFinderImage',
SessionID=self._session,
TransactionID=self._transaction,
# TODO: Find out what this parameter does.
Parameter=[0x00100000]
)
return self.recv(ptp)
def eos_do_af(self):
'''Perform auto-focus with AF lenses set to AF'''
ptp = Container(
OperationCode='EOSDoAf',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.mesg(ptp)
return response
def eos_drive_lens(self, infinity=True, step=2):
'''
Drive lens focus on EOS cameras with an auto-focus lens on.
`step` lies in the interval [-3, 3]. Its sign reverses the infinity
argument. If `infinity` is `True`, the focal plane is driven away from
the camera with the given step.
The magnitude of `step` is qualitatively `1` for "fine", `2` for
"normal" and `3` for "coarse".
'''
if step not in range(-3, 4):
raise ValueError(
'The step must be within [-3, 3].'
)
infinity = not infinity if step < 0 else infinity
step = -step if step < 0 else step
instruction = 0x8000 if infinity else 0x0000
instruction |= step
ptp = Container(
OperationCode='EOSDriveLens',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[instruction]
)
response = self.mesg(ptp)
return response
# TODO: implement EOSDepthOfFieldPreview
# TODO: implement EOSClickWB
# TODO: implement EOSZoom
# TODO: implement EOSZoomPosition
# TODO: implement EOSSetLiveAfFrame
def eos_af_cancel(self):
'''Stop driving AF on EOS cameras.'''
ptp = Container(
OperationCode='EOSAfCancel',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.mesg(ptp)
return response
# TODO: implement EOSFAPIMessageTX
# TODO: implement EOSFAPIMessageRX
def event(self, wait=False):
'''Check Canon or PTP events
If `wait` this function is blocking. Otherwise it may return None.
'''
# TODO: Do something reasonable on wait=True
evt = None
timeout = None if wait else 0.001
# TODO: Join queues to preserve order of Canon and PTP events.
if not self.__event_queue.empty():
evt = self.__event_queue.get(block=not wait, timeout=timeout)
else:
evt = super(Canon, self).event(wait=wait)
return evt
def __eos_poll_events(self):
'''Poll events, adding them to a queue.'''
while not self.__eos_event_shutdown.is_set() and _main_thread_alive():
try:
evts = self.eos_get_event()
if evts:
for evt in evts:
logger.debug('Event queued')
logger.debug(evt)
self.__event_queue.put(evt)
except Exception as e:
logger.error(e)
sleep(0.2)
self.__eos_event_shutdown.clear()
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,317 | hypoxic/sequoia-ptpy | refs/heads/master | /bootflag.py | #!/usr/bin/env python
import ptpy
from ptpy import Canon
from time import sleep
camera = ptpy.PTPy()
print("Connected to the camera...")
with camera.session():
info = camera.get_device_info()
print("Model: " + info.Model)
print("Version: " + info.DeviceVersion)
result = camera.eos_run_command("EnableBootDisk")
if result.ResponseCode == 'OK':
print("Boot flag enabled.")
else:
print("Error running command")
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,318 | hypoxic/sequoia-ptpy | refs/heads/master | /tests/hardware/test_properties_get_set_reset.py | from .test_camera import TestCamera
from construct import Computed, Struct
def assert_response_code_different(response, value, reason):
'Check that the code of a response is not value.'
try:
assert response.ResponseCode != value, reason
except AttributeError:
pass
def assert_response_code_equal(response, value, reason):
'Check that the code of a response is not value.'
try:
assert response.ResponseCode == value, reason
except AttributeError:
pass
class TestGetSetResetProperties(TestCamera):
def test_get_set_property(self, camera, device_property):
'''Set property to their current value to check for writability'''
with camera.session():
value = camera.get_device_prop_value(device_property)
desc = camera.get_device_prop_desc(device_property)
set_response = camera.set_device_prop_value(
device_property,
value.Data
)
assert_response_code_different(
value,
'DevicePropNotSupported',
'Device property is reported to be supported in DeviceInfo, '
'but then unsupported in GetDevicePropValue'
)
assert_response_code_different(
desc,
'DevicePropNotSupported',
'Device property is reported to be supported in DeviceInfo, '
'but then unsupported in ResponseCode for GetDevicePropDesc'
)
assert_response_code_different(
set_response,
'DevicePropNotSupported',
'Device property is reported to be supported in DeviceInfo, '
'but then unsupported in SetDevicePropValue'
)
assert_response_code_different(
set_response,
'InvalidDevicePropValue',
'Setting a property to a value it already has '
'should never give InvalidDevicePropValue'
)
if desc.GetSet == 'Get':
assert_response_code_equal(
set_response,
'AccessDenied',
'A get-only property should return '
'AccessDenied on SetDevicePropValue.'
)
else:
assert_response_code_different(
set_response,
'AccessDenied',
'The property is reported as GetSet but access is denied.'
)
def test_reset_property(self, camera, device_property):
'''Set property to their current value to check for writability'''
with camera.session():
reset = camera.reset_device_prop_value(device_property)
assert_response_code_different(
reset,
'DevicePropNotSupported',
'Device property is reported to be supported in DeviceInfo, '
'but then unsupported in ResetDevicePropValue'
)
desc = camera.get_device_prop_desc(device_property)
assert desc.CurrentValue == desc.FactoryDefaultValue,\
'The value after ResetDevicePropValue '\
'and the FactoryDefaultValue differ.'
def test_desc_get_property_identical(self, camera, device_property):
'''
Check property description and property get share the same value.
GetDevicePropValue == GetDevicePropDesc.CurrentValue
'''
with camera.session():
value = camera.get_device_prop_value(device_property)
desc = camera.get_device_prop_desc(device_property)
# TODO: refactor this into PTPy core to automatically parse and
# build properties for which a GetDevicePropDesc has been issued.
builder = 'Builder' / Struct(
'DataTypeCode' / Computed(lambda ctx: desc.DataTypeCode),
'CurrentValue' / camera._DataType
)
data = builder.build(desc)
assert value.Data == data,\
'GetDevicePropDesc.CurrentValue and '\
'GetDevicePropValue should match.'
# TODO: test setting all possible values of all possible properties.
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,319 | hypoxic/sequoia-ptpy | refs/heads/master | /tests/hardware/parrot/sequoia/test_enable_capture.py | #! /usr/bin/env python
from time import sleep, time
from .test_sequoia import TestSequoia
import pytest
# Verify that there are at least N images added after an InitiateCapture with N
# cameras activated. Do this for all combinations of activated sensors.
number_of_cameras = 5
# TODO: Put this function in a separate module of test helpers.
def initiate_capture(sequoia):
'''Initiate capture.'''
capture_response = sequoia.initiate_capture()
# If the device is doing something else, try again ten times waiting a
# second.
tries = 0
while capture_response.ResponseCode != 'OK' and tries < 10:
tries += 1
sleep(1)
capture_response = sequoia.initiate_capture()
if capture_response.ResponseCode != 'OK':
print(capture_response)
assert capture_response.ResponseCode == 'OK', \
'Could not initiate capture after 10 tries.'
return capture_response
def set_valid_mask(sequoia, mask):
'''Set PhotoSensorEnableMask. Return false when invalid.'''
enable_response = sequoia.set_device_prop_value(
'PhotoSensorEnableMask',
sequoia._UInt32.build(mask)
)
# If the combination of enabled cameras is invalid, skip it.
if enable_response.ResponseCode == 'InvalidDevicePropValue':
return False
# If the device is busy, try again ten times waiting a second.
tries = 0
while enable_response.ResponseCode != 'OK' and tries < 10:
tries += 1
sleep(1)
enable_response = sequoia.set_device_prop_value(
'PhotoSensorEnableMask',
sequoia._UInt32.build(mask)
)
if enable_response.ResponseCode != 'OK':
print(enable_response)
assert enable_response.ResponseCode == 'OK', \
'Could not set PhotoSensorEnableMask {}'.format(bin(mask))
return True
def set_keep_on(sequoia, mask):
'''Turn masked sensors on'''
set_valid_mask(sequoia, mask)
tries = 0
keep_on = sequoia.get_device_prop_desc('PhotoSensorsKeepOn')
while keep_on.CurrentValue != 1 and tries < 10:
tries += 1
sleep(1)
sequoia.set_device_prop_value(
'PhotoSensorsKeepOn',
sequoia._UInt32.build(1)
)
keep_on = sequoia.get_device_prop_desc('PhotoSensorsKeepOn')
assert keep_on.CurrentValue == 1, \
'Could not turn sensors on after 10 tries (10 s).'
def unset_keep_on(sequoia):
'''Turn masked sensors on'''
tries = 0
keep_on = sequoia.get_device_prop_desc('PhotoSensorsKeepOn')
while keep_on.CurrentValue != 0 and tries < 10:
tries += 1
sleep(1)
sequoia.set_device_prop_value(
'PhotoSensorsKeepOn',
sequoia._UInt32.build(0)
)
keep_on = sequoia.get_device_prop_desc('PhotoSensorsKeepOn')
assert keep_on.CurrentValue == 0, \
'Could not turn sensors off after 10 tries (10 s).'
class TestSequoiaEnableCapture(TestSequoia):
def test_keep_on(self, sequoia):
'''Verify a PhotoSensorsKeepOn does not block the Sequoia.'''
with sequoia.session():
set_keep_on(sequoia, 31)
unset_keep_on(sequoia)
def test_keep_on_capture(self, sequoia):
'''Verify that a capture finishes with sensors on.'''
with sequoia.session():
# Capture image and wait for CaptureComplete
set_keep_on(sequoia, 31)
capture = initiate_capture(sequoia)
tic = time()
while True:
evt = sequoia.event()
if (
evt and
evt.EventCode == 'CaptureComplete' and
evt.TransactionID == capture.TransactionID
):
break
assert time() - tic <= 40,\
'Waited for 40 seconds before giving up.\n'\
'No CaptureComplete received for InitiateCapture.'
keep_on = sequoia.get_device_prop_desc('PhotoSensorsKeepOn')
if keep_on.CurrentValue == 1:
sequoia.set_device_prop_value(
'PhotoSensorsKeepOn',
sequoia._UInt32.build(0)
)
sleep(5)
unset_keep_on(sequoia)
@pytest.mark.parametrize(
('mask'),
range(2**number_of_cameras),
)
def test_enable_capture(self, mask, sequoia):
'''Verify that a capture with N enabled sensors poduces N images.'''
with sequoia.session():
keep_on = sequoia.get_device_prop_desc('PhotoSensorsKeepOn')
if keep_on.CurrentValue == 1:
sequoia.set_device_prop_value(
'PhotoSensorsKeepOn',
sequoia._UInt32.build(0)
)
# If mask is invalid, skip.
if not set_valid_mask(sequoia, mask):
return
# Capture image and count the ObjectAdded events.
capture = initiate_capture(sequoia)
acquired = 0
n_added = 0
expected = bin(mask).count('1')
tic = time()
while acquired < expected:
# Check events
evt = sequoia.event()
# If object added verify is it is an image
if (
evt and
evt.TransactionID == capture.TransactionID and
evt.EventCode == 'ObjectAdded'
):
n_added += 1
info = sequoia.get_object_info(evt.Parameter[0])
if (
info and
('TIFF' in info.ObjectFormat or
'EXIF_JPEG' in info.ObjectFormat)
):
acquired += 1
# Otherwise if the capture is complete, tally up.
elif evt and evt.EventCode == 'CaptureComplete':
if not pytest.config.getoption('--ideal'):
pytest.skip('Use --ideal to check for non-PTP errors.')
assert acquired == expected,\
'{} images were expected than received. '\
'This is not a violation of PTP.'\
.format('More' if acquired < expected else 'Less')
return
# Allow for sixty second delays in events... Though the
# asynchronous event may take an indefinite amount of time,
# anything longer than about ten seconds indicates there's
# something wrong.
assert time() - tic <= 40,\
'Waited for 40 seconds before giving up.\n'\
'No CaptureComplete received.\n'\
'Failed with {} images ({} ObjectAdded) for mask {} {} {}'\
.format(acquired, n_added, mask, hex(mask), bin(mask))
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,320 | hypoxic/sequoia-ptpy | refs/heads/master | /tests/hardware/test_captures.py | from time import time
from .test_camera import TestCamera
import pytest
class TestCapture(TestCamera):
def test_event_order(self, camera):
device_info = camera.get_device_info()
if 'InitiateCapture' not in device_info.OperationsSupported:
pytest.skip('InitiateCapture is not supported by camera.')
with camera.session():
tic = time()
print('Clearing all events (10s)')
while time() - tic < 10:
evt = camera.event()
print('Initiating capture')
capture = camera.initiate_capture()
codes = []
tic = time()
print('Waiting for capture events (10s)')
while time() - tic < 10:
evt = camera.event()
if evt:
print(evt)
if evt.TransactionID == capture.TransactionID:
codes.append(evt.EventCode)
assert 'CaptureComplete' in codes, 'No CaptureComplete received.'
assert 'ObjectAdded' in codes,\
'No ObjectAdded received for capture transaction.'
capture_complete_index = codes.index('CaptureComplete')
last_object_added_index = (
(len(codes) - 1) - codes[::-1].index('ObjectAdded')
)
assert last_object_added_index < capture_complete_index,\
'ObjectAdded happened after CaptureComplete.'
class TestOpenCapture(TestCamera):
def test_termination(self, camera):
'''Verify TerminateOpenCapture behaviour.'''
device_info = camera.get_device_info()
if 'InitiateOpenCapture' not in device_info.OperationsSupported:
pytest.skip('InitiateOpenCapture is not supported by camera.')
with camera.session():
capture = camera.initiate_open_capture()
# Attempt to close the wrong open capture.
wrong_transaction = camera.terminate_open_capture(
capture.TransactionID + 1
)
right_transaction = camera.terminate_open_capture(
capture.TransactionID
)
assert wrong_transaction.ResponseCode ==\
'InvalidTransactionID',\
\
'When terminating the wrong open capture, '\
'we expect InvalidTransactionID as ResponseCode.'
assert right_transaction.ResponseCode != 'InvalidTransactionID',\
'The response should never be InvalidTransactionID '\
'for the right transaction.'
assert (
right_transaction.ResponseCode == 'OK' or
right_transaction.ResponseCode == 'CaptureAlreadyTerminated'
),\
'When terminating the correct open capture, '\
'we expect the session to be successfully closed '\
'or already closed.'
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,321 | hypoxic/sequoia-ptpy | refs/heads/master | /examples/parrot/sequoia/toggle_sensors.py | #!/usr/bin/env python
from ptpy import PTPy
from time import sleep
camera = PTPy()
with camera.session():
tries = 0
keep_on = camera.get_device_prop_desc('PhotoSensorsKeepOn')
state = keep_on.CurrentValue
while keep_on.CurrentValue == state and tries < 10:
tries += 1
sleep(1)
attempt = camera.set_device_prop_value('PhotoSensorsKeepOn', int(not state))
keep_on = camera.get_device_prop_desc('PhotoSensorsKeepOn')
print('Tries:{}'.format(tries))
print('Attempt response: {}'.format(attempt))
print('Current value: {}'.format(keep_on))
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,322 | hypoxic/sequoia-ptpy | refs/heads/master | /tests/hardware/parrot/sequoia/test_sequoia.py | from ...test_camera import TestCamera
import pytest
@pytest.mark.incremental
class TestSequoia(TestCamera):
@pytest.fixture(autouse=True)
def sequoia(self, camera):
device_info = camera.get_device_info()
if 'Sequoia' not in device_info.Model:
pytest.skip('The camera is not a Sequoia')
return camera
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,323 | hypoxic/sequoia-ptpy | refs/heads/master | /tests/hardware/parrot/sequoia/test_operation_values.py | from .test_sequoia import TestSequoia
class TestOperationValues(TestSequoia):
'''Check values for different operations.'''
def test_hotness(self, sequoia):
'''Verify temperature values are reasonable.'''
with sequoia.session():
temperatures = sequoia.get_temperature_values()
for t in temperatures:
print('Checking {} temperature.'.format(t))
assert temperatures[t] <= 200000,\
'A temperature over 200C means something\'s gone wrong.'
def test_absolute_zero(self, sequoia):
'''Verify temperature values are reasonable.'''
with sequoia.session():
temperatures = sequoia.get_temperature_values()
for t in temperatures:
print('Checking {} temperature.'.format(t))
# -999 degrees C means invalid value.
if temperatures[t] != -999000:
assert temperatures[t] > -273150,\
'Reported temperature is under absolute zero...'
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,324 | hypoxic/sequoia-ptpy | refs/heads/master | /bootflag_old.py | #!/usr/bin/env python
import ptpy
from ptpy import Canon
from time import sleep
# Commands to try:
# EnableBootDisk
# DisableBootDisk
# TurnOffDisplay
command = "EnableBootDisk"
camera = ptpy.PTPy()
print("Connected to the camera...")
with camera.session():
#print("You can kill the script (ctrl+z) if you get timeouts.")
print("Waiting for a good time to send command...")
while True:
evt = camera.event()
if not evt:
result = camera.eos_run_command(command)
print(result)
if result.ResponseCode == "OK":
print("DryOS command run successfully.")
break
else:
print("Bad ResponseCode. Will keep trying.")
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,325 | hypoxic/sequoia-ptpy | refs/heads/master | /examples/list_all_properties.py | #!/usr/bin/env python
import ptpy
camera = ptpy.PTPy()
with camera.session():
device_info = camera.get_device_info()
for prop in device_info.DevicePropertiesSupported:
print(camera.get_device_prop_desc(prop))
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,326 | hypoxic/sequoia-ptpy | refs/heads/master | /ptpy/__init__.py | '''Master module that instantiates the correct extension and transport.'''
from __future__ import absolute_import
from .extensions.canon import Canon
from .extensions.microsoft import Microsoft
from .extensions.parrot import Parrot
from .extensions.nikon import Nikon
from .extensions.sony import Sony
from .ptp import PTP, PTPError
from .transports.usb import USBTransport as USB
from .transports.ip import IPTransport as IP
import os
import sys
import logging
from rainbow_logging_handler import RainbowLoggingHandler
# Set up logging
logger = logging.getLogger(__name__)
formatter = logging.Formatter(
'%(levelname).1s '
'%(relativeCreated)d '
'%(name)s'
'[%(threadName)s:%(funcName)s:%(lineno)s] '
'%(message)s'
)
handler = RainbowLoggingHandler(
sys.stderr,
)
level = 'DEBUG' if 'PTPY_DEBUG' in os.environ else 'INFO'
logger.setLevel(level)
handler.setFormatter(formatter)
logger.addHandler(handler)
if 'PTPY_DEBUG_LOG' in os.environ:
logger.addHandler(logging.FileHandler(os.environ['PTPY_DEBUG_LOG']))
__all__ = (
# Extensions
'Canon',
'Microsoft',
'Nikon',
'Sony',
# Transports
'IP',
'USB',
# Classes and errors
'PTPError',
'PTPy',
)
# As extensions are implemented, they should be added here, so they are
# automatically used. The names here need to match those in ptp.py
# VendorExtensionID.
known_extensions = {
'EastmanKodak': None,
'SeikoEpson': None,
'Agilent': None,
'Polaroid': None,
'AgfaGevaert': None,
'Microsoft': Microsoft,
'Equinox': None,
'Viewquest': None,
'STMicroelectronics': None,
'Nikon': Nikon,
'Canon': Canon,
'FotoNation': None,
'PENTAX': None,
'Fuji': None,
'Sony': Sony,
'Samsung': None,
'Parrot': Parrot,
}
def ptpy_factory(transport, extension=None):
# The order needs to be Transport inherits Extension inherits Base. This is
# so that the extension can extend the base and the transport can
# instantiate the correct endianness.
inheritance = ((extension, PTP, transport)
if extension is not None
else (PTP, transport))
return type('PTPy', inheritance, {})
def choose_extension(device_info):
if 'Canon' in device_info.Manufacturer:
return Canon
elif 'Nikon' in device_info.Manufacturer:
return Nikon
else:
return known_extensions[device_info.VendorExtensionID]
class PTPy(object):
'''Class for all transports, extensions and basic PTP functionality'''
def __new__(cls, device=None, extension=None, transport=None,
knowledge=True, raw=False, **kwargs):
'''Instantiate the correct class for a device automatically.'''
# Determine transport
logger.debug('New PTPy')
if transport is None:
logger.debug('Determining available transports')
# TODO: Implement discovery across transports once PTPIP is added.
transport = USB
# Determine extension
if extension is None and not raw:
plain = ptpy_factory(transport)
try:
plain_camera = plain(device=device)
except PTPError:
plain_camera = None
if plain_camera is not None:
device_info = plain_camera.get_device_info()
plain_camera._shutdown()
try:
extension = choose_extension(device_info)
except KeyError:
pass
# Instantiate and construct.
if raw:
logger.debug('Raw PTP only')
PTPy = ptpy_factory(transport)
else:
logger.debug('Imposing {} extension'.format(extension))
if extension is None:
logger.warning('Could not choose camera extension')
PTPy = ptpy_factory(
transport,
extension
)
# Query the device for information on all its properties and update
# when there are changes.
instance = PTPy(device=device)
if knowledge and not raw:
instance._obtain_the_knowledge()
return instance
def __init__(self, *args, **kwargs):
logger.debug('Init PTPy')
super(PTPy, self).__init__(*args, **kwargs)
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,327 | hypoxic/sequoia-ptpy | refs/heads/master | /ptpy/extensions/parrot.py | '''This module extends PTP for Parrot devices.
Use it in a master module that determines the vendor and automatically uses its
extension.
'''
from construct import (
Container, Enum, ExprAdapter, Pass, Struct,
)
import logging
logger = logging.getLogger(__name__)
__all__ = ('Parrot',)
class Parrot(object):
'''This class implements Parrot's PTP operations.'''
def __init__(self, *args, **kwargs):
logger.debug('Init Parrot')
super(Parrot, self).__init__(*args, **kwargs)
def _PropertyCode(self, **product_properties):
return super(Parrot, self)._PropertyCode(
PhotoSensorEnableMask=0xD201,
PhotoSensorsKeepOn=0xD202,
MultispectralImageSize=0xD203,
MainBitDepth=0xD204,
MultispectralBitDepth=0xD205,
HeatingEnable=0xD206,
WifiStatus=0xD207,
WifiSSID=0xD208,
WifiEncryptionType=0xD209,
WifiPassphrase=0xD20A,
WifiChannel=0xD20B,
Localization=0xD20C,
WifiMode=0xD20D,
AntiFlickeringFrequency=0xD210,
DisplayOverlayMask=0xD211,
GPSInterval=0xD212,
MultisensorsExposureMeteringMode=0xD213,
MultisensorsExposureTime=0xD214,
MultisensorsExposureProgramMode=0xD215,
MultisensorsExposureIndex=0xD216,
MultisensorsIrradianceGain=0xD217,
MultisensorsIrradianceIntegrationTime=0xD218,
OverlapRate=0xD219,
LEDsEnableMask=0xD220,
GPSEnable=0xD221,
SelectedStorage=0xD222,
MediaFolderName=0xD223,
XMPTag=0xD224,
**product_properties
)
def _OperationCode(self, **product_operations):
return super(Parrot, self)._OperationCode(
GetSunshineValues=0x9201,
GetTemperatureValues=0x9202,
GetAngleValues=0x9203,
GetGpsValues=0x9204,
GetGyroscopeValues=0x9205,
GetAccelerometerValues=0x9206,
GetMagnetometerValues=0x9207,
GetImuValues=0x9208,
GetStatusMask=0x9209,
EjectStorage=0x920A,
StartMagnetoCalib=0x9210,
StopMagnetoCalib=0x9211,
MagnetoCalibStatus=0x9212,
SendFirmwareUpdate=0x9213,
SetGeotag=0x9400,
**product_operations
)
def _ResponseCode(self, **product_responses):
return super(Parrot, self)._ResponseCode(
**product_responses
)
def _EventCode(self, **product_events):
return super(Parrot, self)._EventCode(
Status=0xC201,
MagnetoCalibrationStatus=0xC202,
**product_events
)
def _FilesystemType(self, **product_filesystem_types):
return super(Parrot, self)._FilesystemType(
**product_filesystem_types
)
def _Sunshine(self):
return ExprAdapter(
self._PTPArray(self._UInt32),
encoder=lambda obj, ctx: [
obj.Green[0], obj.Red[0], obj.RedEdge[0], obj.NIR[0],
obj.Green[1], obj.Red[1], obj.RedEdge[1], obj.NIR[1],
],
decoder=lambda obj, ctx: Container(
Green=(obj[0], obj[4]),
Red=(obj[1], obj[5]),
RedEdge=(obj[2], obj[6]),
NIR=(obj[3], obj[7]),
),
)
def _Temperature(self):
return ExprAdapter(
self._PTPArray(self._Int32),
encoder=lambda obj, ctx: [
obj.P7, obj.P7MU, obj.DDR. obj.WiFi, obj.IMU, obj.IMUSunshine
],
decoder=lambda obj, ctx: Container(
P7=obj[0], P7MU=obj[1], DDR=obj[2],
WiFi=obj[3], IMU=obj[4], IMUSunshine=obj[5],
),
)
def _Angle(self):
return ExprAdapter(
self._PTPArray(self._UInt32),
encoder=lambda obj, ctx: [obj.Yaw, obj.Pitch, obj.Roll],
decoder=lambda obj, ctx: Container(
Yaw=obj[0], Pitch=obj[1], Roll=obj[2]
),
)
def _GPS(self):
return ExprAdapter(
self._PTPArray(self._UInt32),
encoder=lambda obj, ctx: [
obj.Longitude.Deg, obj.Longitude.Min, obj.Longitude.Sec,
obj.Latitude.Deg, obj.Latitude.Min, obj.Latitude.Sec,
obj.Altitude,
],
decoder=lambda obj, ctx: Container(
Longitude=Container(Deg=obj[0], Min=obj[1], Sec=obj[2]),
Latitude=Container(Deg=obj[3], Min=obj[4], Sec=obj[5]),
Altitude=obj[6]
),
)
def _Gyroscope(self):
return ExprAdapter(
self._PTPArray(self._UInt32),
encoder=lambda obj, ctx: [obj.X, obj.Y, obj.Z],
decoder=lambda obj, ctx: Container(
X=obj[0], Y=obj[1], Z=obj[2],
),
)
def _Accelerometer(self):
return ExprAdapter(
self._PTPArray(self._UInt32),
encoder=lambda obj, ctx: [obj.X, obj.Y, obj.Z],
decoder=lambda obj, ctx: Container(
X=obj[0], Y=obj[1], Z=obj[2],
),
)
def _Magnetometer(self):
return ExprAdapter(
self._PTPArray(self._UInt32),
encoder=lambda obj, ctx: [obj.X, obj.Y, obj.Z],
decoder=lambda obj, ctx: Container(
X=obj[0], Y=obj[1], Z=obj[2],
),
)
def _IMU(self):
return ExprAdapter(
self._PTPArray(self._UInt32),
encoder=lambda obj, ctx: [
obj.Gyroscope.X,
obj.Gyroscope.Y,
obj.Gyroscope.Z,
obj.Accelerometer.X,
obj.Accelerometer.Y,
obj.Accelerometer.Z,
obj.Magnetometer.X,
obj.Magnetometer.Y,
obj.Magnetometer.Z,
obj.Angle.Yaw,
obj.Angle.Pitch,
obj.Angle.Roll,
],
decoder=lambda obj, ctx: Container(
Gyroscope=Container(X=obj[0], Y=obj[1], Z=obj[2]),
Accelerometer=Container(X=obj[3], Y=obj[4], Z=obj[5]),
Magnetometer=Container(X=obj[6], Y=obj[7], Z=obj[8]),
Angle=Container(Yaw=obj[9], Pitch=obj[10], Roll=obj[11]),
),
)
def _Status(self):
# Status flags from LSB to MSB
status = [
'SnapshotRequested',
'BodyImuCalibRunning',
'AuxiliaryImuCalibRunning',
'AuxiliaryConnected',
'AuxiliaryGpsRunning',
'RemoteGpsRunning',
'CamRGBError',
'CamGreenError',
'CamRedError',
'CamRedEdgeError',
'CamNIRError',
'BodySensorsInitDone',
'AuxiliarySensorsInitDone',
'CameraRunning',
]
return ExprAdapter(
self._UInt32,
encoder=lambda obj, ctx: sum(
[
0x1 << i if getattr(obj, n, False) else 0
for i, n in enumerate(status)
]
),
decoder=lambda obj, ctx: Container(
{n: (obj & (0x01 << i)) != 0 for i, n in enumerate(status)}
),
)
def _LEDsEnable(self):
# Status flags from LSB to MSB
leds = [
'Body',
'Auxiliary',
]
return ExprAdapter(
self._UInt32,
encoder=lambda obj, ctx: sum(
[
0x1 << i if getattr(obj, n, False) else 0
for i, n in enumerate(leds)
]
),
decoder=lambda obj, ctx: Container(
{n: (obj & (0x01 << i)) != 0 for i, n in enumerate(leds)}
),
)
def _MagnetoStatus(self):
return Enum(
self._UInt32,
default=Pass,
CalibrationOk=1,
CalibrationRunning=2,
CalibrationRollPending=3,
CalibrationPitchPending=4,
CalibrationYawPending=5,
CalibrationFailed=6,
CalibrationAborted=7,
)
def _Geotag(self):
return ExprAdapter(
Struct(
'ValidityMask' / self._UInt32,
'Timestamp' / self._Int64,
'Latitude' / self._Int32,
'Longitude' / self._Int32,
'Altitude' / self._Int32,
'Satellites' / self._UInt32,
'AccuracyXY' / self._UInt32,
'AccuracyZ' / self._UInt32,
'NorthSpeed' / self._Int32,
'EastSpeed' / self._Int32,
'UpSpeed' / self._Int32,
'Roll' / self._Int32,
'Pitch' / self._Int32,
'Yaw' / self._Int32,
),
encoder=lambda obj, ctx:
Container(
ValidityMask=obj.ValidityMask,
Timestamp=obj.Timestamp,
Latitude=int(obj.Latitude * 10**7),
Longitude=int(obj.Longitude * 10**7),
Altitude=int(obj.Altitude * 1000),
Satellites=obj.Satellites,
AccuracyXY=int(obj.AccuracyXY * 1000),
AccuracyZ=int(obj.AccuracyZ * 1000),
NorthSpeed=int(obj.NorthSpeed * 1000),
EastSpeed=int(obj.EastSpeed * 1000),
UpSpeed=int(obj.UpSpeed * 1000),
Roll=int(obj.Roll * 1000),
Pitch=int(obj.Pitch * 1000),
Yaw=int(obj.Yaw * 1000),
),
decoder=lambda obj, ctx: Container(
obj.ValidityMask,
obj.Timestamp,
obj.Latitude / 10.**7.,
obj.Longitude / 10.**7.,
obj.Altitude / 1000.,
obj.Satellites,
obj.AccuracyXY / 1000.,
obj.AccuracyZ / 1000.,
obj.NorthSpeed / 1000.,
obj.EastSpeed / 1000.,
obj.UpSpeed / 1000.,
obj.Roll / 1000.,
obj.Pitch / 1000.,
obj.Yaw / 1000.,
),
)
def _set_endian(self, endian):
super(Parrot, self)._set_endian(endian)
logger.debug('Set Parrot endianness')
self._Sunshine = self._Sunshine()
self._Temperature = self._Temperature()
self._Angle = self._Angle()
self._GPS = self._GPS()
self._Gyroscope = self._Gyroscope()
self._Accelerometer = self._Accelerometer()
self._Magnetometer = self._Magnetometer()
self._IMU = self._IMU()
self._Status = self._Status()
self._LEDsEnable = self._LEDsEnable()
self._MagnetoStatus = self._MagnetoStatus()
self._Geotag = self._Geotag()
def get_sunshine_values(self):
ptp = Container(
OperationCode='GetSunshineValues',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.recv(ptp)
return self._parse_if_data(response, self._Sunshine)
def get_temperature_values(self):
ptp = Container(
OperationCode='GetTemperatureValues',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.recv(ptp)
return self._parse_if_data(response, self._Temperature)
def get_angle_values(self, imu_id=0):
ptp = Container(
OperationCode='GetAngleValues',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[imu_id]
)
response = self.recv(ptp)
return self._parse_if_data(response, self._Angle)
def get_gps_values(self):
ptp = Container(
OperationCode='GetGpsValues',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
response = self.recv(ptp)
return self._parse_if_data(response, self._GPS)
def get_gyroscope_values(self, imu_id=0):
ptp = Container(
OperationCode='GetGyroscopeValues',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[imu_id]
)
response = self.recv(ptp)
return self._parse_if_data(response, self._Gyroscope)
def get_accelerometer_values(self, imu_id=0):
ptp = Container(
OperationCode='GetAccelerometerValues',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[imu_id]
)
response = self.recv(ptp)
return self._parse_if_data(response, self._Accelerometer)
def get_magnetometer_values(self, imu_id=0):
ptp = Container(
OperationCode='GetMagnetometerValues',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[imu_id]
)
response = self.recv(ptp)
return self._parse_if_data(response, self._Magnetometer)
def get_imu_values(self, imu_id=0):
ptp = Container(
OperationCode='GetImuValues',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[imu_id]
)
response = self.recv(ptp)
return self._parse_if_data(response, self._IMU)
def get_status_mask(self, imu_id=0):
ptp = Container(
OperationCode='GetStatusMask',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[imu_id]
)
response = self.recv(ptp)
return self._parse_if_data(response, self._Status)
def eject_storage(self, storage_id):
ptp = Container(
OperationCode='EjectStorage',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[storage_id]
)
return self.mesg(ptp)
def start_magneto_calib(self, imu_id=0):
ptp = Container(
OperationCode='StartMagnetoCalib',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[imu_id]
)
return self.mesg(ptp)
def stop_magneto_calib(self, imu_id=0):
ptp = Container(
OperationCode='StopMagnetoCalib',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[imu_id]
)
return self.mesg(ptp)
def get_magneto_calib_status(self, imu_id=0):
ptp = Container(
OperationCode='MagnetoCalibStatus',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[imu_id]
)
response = self.recv(ptp)
return self._parse_if_data(response, self._MagnetoStatus)
def send_firmware(self, firmware):
'''Send PLF for update'''
ptp = Container(
OperationCode='SendFirmwareUpdate',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[len(firmware)]
)
return self.send(ptp, firmware)
def set_geotag(self, geotag):
geotag = self._build_if_not_data(geotag, self._Geotag)
ptp = Container(
OperationCode='SetGeotag',
SessionID=self._session,
TransactionID=self._transaction,
Parameter=[]
)
return self.send(ptp, geotag)
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,328 | hypoxic/sequoia-ptpy | refs/heads/master | /ptpy/extensions/canon/__init__.py | from .canon import Canon
__all__ = ('Canon',)
| {"/ptpy/transports/ip.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/conftest.py": ["/tests/context.py"], "/tests/hardware/test_compliance.py": ["/tests/hardware/test_camera.py"], "/examples/poll_events.py": ["/ptpy/__init__.py"], "/ptpy/extensions/nikon.py": ["/ptpy/util.py"], "/tests/conftest.py": ["/tests/context.py"], "/ptpy/extensions/sony.py": ["/ptpy/ptp.py"], "/examples/timelapse.py": ["/ptpy/__init__.py"], "/test.py": ["/ptpy/__init__.py"], "/examples/all_cameras_live.py": ["/ptpy/__init__.py", "/ptpy/transports/usb.py"], "/tests/context.py": ["/ptpy/__init__.py"], "/tests/hardware/tools/open_capture_poll_events.py": ["/ptpy/__init__.py"], "/ptpy/transports/usb.py": ["/ptpy/ptp.py", "/ptpy/util.py"], "/tests/hardware/tools/capture_poll_events.py": ["/ptpy/__init__.py"], "/examples/print_device_info.py": ["/ptpy/__init__.py"], "/examples/trigger.py": ["/ptpy/__init__.py"], "/examples/download_all_images.py": ["/ptpy/__init__.py"], "/ptpy/extensions/canon/canon.py": ["/ptpy/util.py", "/ptpy/extensions/canon/properties.py"], "/bootflag.py": ["/ptpy/__init__.py"], "/tests/hardware/test_properties_get_set_reset.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_enable_capture.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/tests/hardware/test_captures.py": ["/tests/hardware/test_camera.py"], "/examples/parrot/sequoia/toggle_sensors.py": ["/ptpy/__init__.py"], "/tests/hardware/parrot/sequoia/test_sequoia.py": ["/tests/hardware/test_camera.py"], "/tests/hardware/parrot/sequoia/test_operation_values.py": ["/tests/hardware/parrot/sequoia/test_sequoia.py"], "/bootflag_old.py": ["/ptpy/__init__.py"], "/examples/list_all_properties.py": ["/ptpy/__init__.py"], "/ptpy/__init__.py": ["/ptpy/extensions/canon/__init__.py", "/ptpy/extensions/microsoft.py", "/ptpy/extensions/parrot.py", "/ptpy/extensions/nikon.py", "/ptpy/extensions/sony.py", "/ptpy/ptp.py", "/ptpy/transports/usb.py", "/ptpy/transports/ip.py"], "/ptpy/extensions/canon/__init__.py": ["/ptpy/extensions/canon/canon.py"]} |
74,329 | addNaNs/NegyTV | refs/heads/master | /register.py | import tkinter as tk
import pickle
import functools
import main
from main import User
import os
def create_account(username, name, surname, password, repeat_password, tk_root):
if password.get() != repeat_password.get():
print("Not matching passwords")
return
all_users = pickle.load(open('./users.obj', 'rb'))
for i, user in enumerate(all_users):
if user.username == username.get():
print("Username is taken")
return
all_users.append(main.User(username.get(), name.get(), surname.get(), password.get()))
pickle.dump(all_users, open('./users.obj', 'wb'))
print("Account created successfully")
tk_root.quit()
root = tk.Tk()
root.geometry('400x150')
root.title('Create a new account')
username_label = tk.Label(root, text="Username").grid(row=0, column=0)
username_str = tk.StringVar()
username_entry = tk.Entry(root, textvariable=username_str).grid(row=0, column=1)
name_label = tk.Label(root, text="Name").grid(row=1, column=0)
name_str = tk.StringVar()
name_entry = tk.Entry(root, textvariable=name_str).grid(row=1, column=1)
surname_label = tk.Label(root, text="Surname").grid(row=2, column=0)
surname_str = tk.StringVar()
surname_entry = tk.Entry(root, textvariable=surname_label).grid(row=2, column=1)
password_label = tk.Label(root, text="Password").grid(row=3, column=0)
password_str = tk.StringVar()
password_entry = tk.Entry(root, textvariable=password_str, show='*').grid(row=3, column=1)
repeat_password_label = tk.Label(root, text="Repeat password").grid(row=4, column=0)
repeat_password_str = tk.StringVar()
repeat_password_entry = tk.Entry(root, textvariable=repeat_password_str, show='*').grid(row=4, column=1)
create_account_partial = functools.partial(create_account,
username_str, name_str, surname_str, password_str, repeat_password_str, root)
login_btn = tk.Button(root, text="Create Account", command=create_account_partial).grid(row=5, column=0)
quit_btn = tk.Button(root, text="Quit", command=root.quit).grid(row=5, column=2)
root.mainloop()
| {"/register.py": ["/main.py"], "/main.py": ["/login.py", "/new_account_setup.py"], "/new_account_setup.py": ["/main.py"], "/login.py": ["/main.py"]} |
74,330 | addNaNs/NegyTV | refs/heads/master | /gymfix.py | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import pickle
import tkinter
class Gym:
num_users = -1
num_movies = -1
num_features = -1
user_features = None
movie_features = None
ratings = None
mean_ratings = None
has_rated = None
userwise_rated_movies = None
moviewise_rated_movies = None
total_rated_movies = None
titles = None
__du_old__ = None
__dm_old__ = None
def __init__(self, ratings, num_features, titles):
self.ratings = ratings
self.has_rated = np.sign(ratings)
self.num_features = num_features
self.userwise_rated_movies = self.has_rated.sum(axis=1)
self.moviewise_rated_movies = self.has_rated.sum(axis=0)
self.total_rated_movies = self.userwise_rated_movies.sum()
self.titles = titles
self.num_users, self.num_movies = ratings.shape
self.user_features = np.random.randn(self.num_users, num_features)
self.movie_features = np.random.randn(self.num_movies, num_features)
self.mean_ratings = ratings.sum(axis=0) / self.has_rated.sum(axis=0).clip(min=1)
self.ratings = (self.ratings - self.mean_ratings) * self.has_rated
def print_all(self):
print('num_users :', self.num_users)
print('num_movies :', self.num_movies)
print('num_features :', self.num_features)
print('user_features :\n', self.user_features)
print('movie_features :\n', self.movie_features)
print('mean_ratings :\n', self.mean_ratings)
print('ratings :\n', self.ratings)
print('has_rated :\n', self.has_rated)
print('userwise_rated_movies :\n', self.userwise_rated_movies)
print('moviewise_rated_movies :\n', self.moviewise_rated_movies)
print('total_rated_movies :\n', self.total_rated_movies)
def get_cost_elementwise(self):
return (((self.user_features.dot(self.movie_features.T) - self.ratings)
* self.has_rated) ** 2 / (self.total_rated_movies) * 2)
def get_cost(self):
return self.get_cost_elementwise().sum()
def get_user_feature_gradient(self):
return ((self.user_features.dot(self.movie_features.T) * self.has_rated - self.ratings)
* self.has_rated).dot(self.movie_features)
def get_movie_feature_gradient(self):
return ((self.user_features.dot(self.movie_features.T) * self.has_rated - self.ratings)
* self.has_rated).T.dot(self.user_features)
def get_gradients(self):
return self.get_user_feature_gradient(), self.get_movie_feature_gradient()
def gradient_step(self, alpha=0.00015, beta=0.9):
du, dm = self.get_gradients()
du = beta * self.__du_old__ + (1 - beta) * du
dm = beta * self.__dm_old__ + (1 - beta) * dm
self.user_features = self.user_features - du * alpha
self.movie_features = self.movie_features - dm * alpha
self.__du_old__ = du
self.__dm_old__ = dm
def gradient_descent(self, epochs=100, alpha=0.00015, beta=0.9):
costs = [self.get_cost()]
self.__du_old__ = 0
self.__dm_old__ = 0
for i in range(epochs):
self.gradient_step(alpha, beta)
costs.append(self.get_cost())
print(self.get_cost())
plt.plot(range(epochs + 1), costs)
def predict(self, sur, num_it=500):
suf = np.random.randn(1, self.num_features)
suhr = np.sign(sur)
sutrm = suhr.sum()
sur = sur - self.mean_ratings * suhr
for i in range(num_it):
sufg = ((suf.dot(self.movie_features.T) * suhr - sur)
* suhr).dot(self.movie_features)
suf = suf - sufg * 0.0015
if i % 50 == 0:
print((((suf.dot(self.movie_features.T) - sur)
* suhr) ** 2 / (sutrm) * 2).sum())
return suf.dot(self.movie_features.T) + self.mean_ratings
def recommend(self, user):
sur = user.ratings
preds = list(self.predict(sur, 5000).flatten())
suhr = list(np.sign(sur))
recommends = list(zip(self.titles, preds, suhr))
recommends.sort(key=lambda arg: -arg[1])
return recommends
trained_model = pickle.load(open('gym.obj', 'rb'))
trained_model.ratings = None
trained_model.has_rated = None
pickle.dump(trained_model, open('gym.obj', 'wb'))
| {"/register.py": ["/main.py"], "/main.py": ["/login.py", "/new_account_setup.py"], "/new_account_setup.py": ["/main.py"], "/login.py": ["/main.py"]} |
74,331 | addNaNs/NegyTV | refs/heads/master | /main.py | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import pickle
import tkinter as tk
import functools
class Gym:
num_users = -1
num_movies = -1
num_features = -1
user_features = None
movie_features = None
ratings = None
mean_ratings = None
has_rated = None
userwise_rated_movies = None
moviewise_rated_movies = None
total_rated_movies = None
titles = None
__du_old__ = None
__dm_old__ = None
def __init__(self, ratings, num_features, titles):
self.ratings = ratings
self.has_rated = np.sign(ratings)
self.num_features = num_features
self.userwise_rated_movies = self.has_rated.sum(axis=1)
self.moviewise_rated_movies = self.has_rated.sum(axis=0)
self.total_rated_movies = self.userwise_rated_movies.sum()
self.titles = titles
self.num_users, self.num_movies = ratings.shape
self.user_features = np.random.randn(self.num_users, num_features)
self.movie_features = np.random.randn(self.num_movies, num_features)
self.mean_ratings = ratings.sum(axis=0) / self.has_rated.sum(axis=0).clip(min=1)
self.ratings = (self.ratings - self.mean_ratings) * self.has_rated
def print_all(self):
print('num_users :', self.num_users)
print('num_movies :', self.num_movies)
print('num_features :', self.num_features)
print('user_features :\n', self.user_features)
print('movie_features :\n', self.movie_features)
print('mean_ratings :\n', self.mean_ratings)
print('ratings :\n', self.ratings)
print('has_rated :\n', self.has_rated)
print('userwise_rated_movies :\n', self.userwise_rated_movies)
print('moviewise_rated_movies :\n', self.moviewise_rated_movies)
print('total_rated_movies :\n', self.total_rated_movies)
def get_cost_elementwise(self):
return (((self.user_features.dot(self.movie_features.T) - self.ratings)
* self.has_rated) ** 2 / self.total_rated_movies * 2)
def get_cost(self):
return self.get_cost_elementwise().sum()
def get_user_feature_gradient(self):
return ((self.user_features.dot(self.movie_features.T) * self.has_rated - self.ratings)
* self.has_rated).dot(self.movie_features)
def get_movie_feature_gradient(self):
return ((self.user_features.dot(self.movie_features.T) * self.has_rated - self.ratings)
* self.has_rated).T.dot(self.user_features)
def get_gradients(self):
return self.get_user_feature_gradient(), self.get_movie_feature_gradient()
def gradient_step(self, alpha=0.00015, beta=0.9):
du, dm = self.get_gradients()
du = beta * self.__du_old__ + (1 - beta) * du
dm = beta * self.__dm_old__ + (1 - beta) * dm
self.user_features = self.user_features - du * alpha
self.movie_features = self.movie_features - dm * alpha
self.__du_old__ = du
self.__dm_old__ = dm
def gradient_descent(self, epochs=100, alpha=0.00015, beta=0.9):
costs = [self.get_cost()]
self.__du_old__ = 0
self.__dm_old__ = 0
for i in range(epochs):
self.gradient_step(alpha, beta)
costs.append(self.get_cost())
print(self.get_cost())
plt.plot(range(epochs + 1), costs)
def predict(self, sur, num_it=500):
suf = np.zeros((1, self.num_features))
suhr = np.sign(sur)
sutrm = suhr.sum()
sur = sur - self.mean_ratings * suhr
for i in range(num_it):
sufg = ((suf.dot(self.movie_features.T) * suhr - sur)
* suhr).dot(self.movie_features)
suf = suf - sufg * 0.0015
if i % 500 == 0:
print(i, (((suf.dot(self.movie_features.T) - sur)
* suhr) ** 2 / np.clip(sutrm, a_min=1, a_max=5) * 2).sum())
return suf.dot(self.movie_features.T) + self.mean_ratings
def recommend(self, user):
if user.ratings is None:
user.set_ratings(np.zeros(self.num_movies))
sur = user.ratings
preds = list(self.predict(sur, 5000).flatten())
suhr = list(np.sign(sur))
recommends = list(zip(range(self.num_movies), self.titles, preds, suhr))
recommends.sort(key=lambda arg: -arg[2])
return recommends
def most_viewed(self):
vies_list = list(zip(range(self.num_movies), self.titles, self.moviewise_rated_movies))
vies_list.sort(key=lambda arg: -arg[2])
return vies_list
def say(self, s):
print(s)
class User:
name = None
surname = None
username = None
__password__ = None
ratings = None
def __init__(self, username, name, surname, password, ratings=None):
self.username = username
self.name = name
self.surname = surname
self.__password__ = password
self.ratings = ratings
def validate(self, username, password):
return username == self.username and password == self.__password__
def set_ratings(self, new_ratings):
self.ratings = new_ratings
def total_has_rated(self):
if self.ratings is None:
return 0
return np.sign(self.ratings).sum()
def __str__(self):
return 'Username: ' + self.username + ', Name: ' + self.name + ' ' + self.surname
def not_watched(text_var):
next_movie(text_var)
def next_movie(text_var):
global movie_index
global recommended
movie_index += 1
text_var.set(recommended[movie_index][1])
print(recommended[movie_index][1])
def rate(text_var, stars):
global user
global recommended
global movie_index
user.ratings[recommended[movie_index][0]] = stars
next_movie(text_var)
if __name__ == '__main__':
trained_model = pickle.load(open('gym.obj', 'rb'))
try:
pickle.load(open('./users.obj', 'rb'))
except FileNotFoundError:
all_users = list()
pickle.dump(all_users, open('./users.obj', 'wb'))
import login as login
# print(login.index)
# print(len(pickle.load(open('users.obj', 'rb'))))
# trained_model.say('Hello there, General Kenobi')
all_users = pickle.load(open('./users.obj', 'rb'))
user = all_users[login.index]
print(user)
# print(trained_model.most_viewed())
# print(trained_model.recommend(user))
if user.total_has_rated() == 0:
import new_account_setup as nas
user.set_ratings(nas.setup_ratings)
root = tk.Tk()
root.title('NegyTV')
welcome_label = tk.Label(root, text=("Welcome "+user.name+" to NegyTV")).grid(row=0, column=0)
setup_welcome_string = "We recommend movies that we think you will like based on your previous ratings"
setup_welcome_label = tk.Label(root, text=setup_welcome_string).grid(row=0, column=0, columnspan=6)
setup_instructions_string = "How about watching: "
setup_instructions_label = tk.Label(root, text=setup_instructions_string).grid(row=1, column=0, columnspan=6)
recommended = trained_model.recommend(user)
movie_index = -1
movie_str = tk.StringVar(root, "If you're seeing this, there's an error")
next_movie(movie_str)
movie_label = tk.Label(root, textvariable=movie_str).grid(row=2, column=0, columnspan=6)
not_watched_partial = functools.partial(not_watched, movie_str)
rate_1_partial = functools.partial(rate, movie_str, 1)
rate_2_partial = functools.partial(rate, movie_str, 2)
rate_3_partial = functools.partial(rate, movie_str, 3)
rate_4_partial = functools.partial(rate, movie_str, 4)
rate_5_partial = functools.partial(rate, movie_str, 5)
rate_1_star_btn = tk.Button(root, text='1 star', command=rate_1_partial).grid(row=4, column=0)
rate_2_star_btn = tk.Button(root, text='2 star', command=rate_2_partial).grid(row=4, column=1)
rate_3_star_btn = tk.Button(root, text='3 star', command=rate_3_partial).grid(row=4, column=2)
rate_4_star_btn = tk.Button(root, text='4 star', command=rate_4_partial).grid(row=4, column=3)
rate_5_star_btn = tk.Button(root, text='5 star', command=rate_5_partial).grid(row=4, column=4)
not_watched_btn = tk.Button(root, text='Did not watch', command=not_watched_partial).grid(row=4, column=5)
done_btn = tk.Button(root, text='Quit', command=root.quit).grid(row=5, column=0)
root.mainloop()
all_users[login.index] = user
pickle.dump(all_users, open('./users.obj', 'wb'))
| {"/register.py": ["/main.py"], "/main.py": ["/login.py", "/new_account_setup.py"], "/new_account_setup.py": ["/main.py"], "/login.py": ["/main.py"]} |
74,332 | addNaNs/NegyTV | refs/heads/master | /new_account_setup.py | import tkinter as tk
import pickle
import numpy as np
import functools
import main
from main import User
from main import Gym
import os
import functools
def not_watched(text_var):
next_movie(text_var)
def next_movie(text_var):
global movie_index
movie_index += 1
text_var.set(most_viewed[movie_index][1])
def rate(text_var, stars):
global setup_ratings
global most_viewed
global movie_index
setup_ratings[most_viewed[movie_index][0]] = stars
next_movie(text_var)
root = tk.Tk()
root.title('Account setup')
setup_welcome_string = "Hi! We need you to enter a few movies you've watched, so we can give you the best experience"
setup_welcome_label = tk.Label(root, text=setup_welcome_string).grid(row=0, column=0, columnspan=6)
setup_instructions_string = "Please rate the movies you have watched, and skip the ones you haven't"
setup_instructions_label = tk.Label(root, text=setup_instructions_string).grid(row=1, column=0, columnspan=6)
trained_model = pickle.load(open('gym.obj', 'rb'))
most_viewed = trained_model.most_viewed()
setup_ratings = np.zeros(trained_model.num_movies)
movie_index = 0
movie_str = tk.StringVar(root, most_viewed[movie_index][1])
movie_label = tk.Label(root, textvariable=movie_str).grid(row=2, column=0, columnspan=6)
not_watched_partial = functools.partial(not_watched, movie_str)
rate_1_partial = functools.partial(rate, movie_str, 1)
rate_2_partial = functools.partial(rate, movie_str, 2)
rate_3_partial = functools.partial(rate, movie_str, 3)
rate_4_partial = functools.partial(rate, movie_str, 4)
rate_5_partial = functools.partial(rate, movie_str, 5)
rate_1_star_btn = tk.Button(root, text='1 star', command=rate_1_partial).grid(row=4, column=0)
rate_2_star_btn = tk.Button(root, text='2 star', command=rate_2_partial).grid(row=4, column=1)
rate_3_star_btn = tk.Button(root, text='3 star', command=rate_3_partial).grid(row=4, column=2)
rate_4_star_btn = tk.Button(root, text='4 star', command=rate_4_partial).grid(row=4, column=3)
rate_5_star_btn = tk.Button(root, text='5 star', command=rate_5_partial).grid(row=4, column=4)
not_watched_btn = tk.Button(root, text='Did not watch', command=not_watched_partial).grid(row=4, column=5)
done_btn = tk.Button(root, text='Done', command=root.quit).grid(row=5, column=0)
root.mainloop()
| {"/register.py": ["/main.py"], "/main.py": ["/login.py", "/new_account_setup.py"], "/new_account_setup.py": ["/main.py"], "/login.py": ["/main.py"]} |
74,333 | addNaNs/NegyTV | refs/heads/master | /login.py | import tkinter as tk
import main
import pickle
import functools
import os
index = None
def validate_login(username, password, tk_root):
global index
print("username entered :", username.get())
print("password entered :", password.get())
all_users = pickle.load(open('./users.obj', 'rb'))
for i, user in enumerate(all_users):
if user.validate(username.get(), password.get()):
index = i
tk.messagebox.showinfo(title='Hello', message='Hello ' + user.name)
tk_root.quit()
return i
tk.messagebox.showwarning(title='Bad input', message='Wrong credentials')
return None
def register():
os.system('python register.py')
root = tk.Tk()
root.geometry('400x150')
root.title('Please login or register')
username_label = tk.Label(root, text="Username").grid(row=0, column=0)
username_str = tk.StringVar()
username_entry = tk.Entry(root, textvariable=username_str).grid(row=0, column=1)
password_label = tk.Label(root, text="Password").grid(row=1, column=0)
password_str = tk.StringVar()
password_entry = tk.Entry(root, textvariable=password_str, show='*').grid(row=1, column=1)
validate_login_partial = functools.partial(validate_login, username_str, password_str, root)
login_btn = tk.Button(root, text="Login", command=validate_login_partial).grid(row=4, column=0)
register_btn = tk.Button(root, text="Register", command=register).grid(row=4, column=1)
quit_btn = tk.Button(root, text="Quit", command=quit).grid(row=4, column=2)
root.mainloop()
| {"/register.py": ["/main.py"], "/main.py": ["/login.py", "/new_account_setup.py"], "/new_account_setup.py": ["/main.py"], "/login.py": ["/main.py"]} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.