rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
Column('notes', String(50)), useexisting = True ) table_metadata.create_all() mapper(TimeOpen, time_open_table) | useexisting = True ) table_metadata.create_all() mapper(TimeOpenDays, time_open_days_table) | def time_open_2010_map(self): table_metadata = MetaData(bind=self.pg_db, reflect=True) time_open_table = Table( 'time_open_2010', table_metadata, Column('id', Integer, primary_key=True), Column('site_index_id', Integer, ForeignKey(Site.c.id)), Column('languages_index_id', Integer, ForeignKey(Languages.c.id)), Column('s... |
class NonCashBenefitsSub(baseObject): pass | def __repr__(self): field_dict = vars(self) out = '' if len(field_dict) > 0: for x, y in field_dict.iteritems(): if x[0] != "_": out = out + "%s = %s, " % (x,y) return "<%s(%s)>" % (self.__class__.__name__, out) else: return '' | |
mapper(Export, export_table, properties={ | themap=mapper(Export, export_table, properties={ | def export_map(self): table_metadata = MetaData(bind=self.pg_db, reflect=True) #table_metadata = MetaData(bind=self.sqlite_db, reflect=True) export_table = Table( 'export', table_metadata, Column('export_id', String(50), primary_key=True, unique=True), Column('export_id_date_collected', DateTime(timezone=True)), Column... |
xpAgencyDelete = '@hmis:Delete' xpAgencyDeleteOccurredDate = '@hmis:DeleteOccurredDate' xpAgencyDeleteEffective = '@hmis:DeleteEffective' | xpAgencyDelete = '../hmis:Agency/@Delete' xpAgencyDeleteOccurredDate = '../hmis:Agency/@DeleteOccurredDate' xpAgencyDeleteEffective = '../hmis:Agency/@DeleteEffective' | def parse_agency(self, element): ''' Element paths ''' xpAgency = 'hmis:Agency' xpAgencyDelete = '@hmis:Delete' xpAgencyDeleteOccurredDate = '@hmis:DeleteOccurredDate' xpAgencyDeleteEffective = '@hmis:DeleteEffective' xpAirsKey = 'airs:Key' xpAirsName = 'airs:Name' xpAgencyDescription = 'airs:AgencyDescription' xpIRSSt... |
xpRecordOwner = '@hmis:RecordOwner' xpFEIN = '@hmis:FEIN' xpYearInc = '@hmis:YearInc' xpAnnualBudgetTotal = '@hmis:AnnualBudgetTotal' xpLegalStatus = '@hmis:LegalStatus' xpExcludeFromWebsite = '@hmis:ExcludeFromWebsite' xpExcludeFromDirectory = '@hmis:ExcludeFromDirectory' | xpRecordOwner = '../hmis:Agency/@RecordOwner' xpFEIN = '../hmis:Agency/@FEIN' xpYearInc = '../hmis:Agency/@YearInc' xpAnnualBudgetTotal = '../hmis:Agency/@AnnualBudgetTotal' xpLegalStatus = '../hmis:Agency/@LegalStatus' xpExcludeFromWebsite = '../hmis:Agency/@ExcludeFromWebsite' xpExcludeFromDirectory = '../hmis:Agenc... | def parse_agency(self, element): ''' Element paths ''' xpAgency = 'hmis:Agency' xpAgencyDelete = '@hmis:Delete' xpAgencyDeleteOccurredDate = '@hmis:DeleteOccurredDate' xpAgencyDeleteEffective = '@hmis:DeleteEffective' xpAirsKey = 'airs:Key' xpAirsName = 'airs:Name' xpAgencyDescription = 'airs:AgencyDescription' xpIRSSt... |
self.existence_test_and_add('fein', item.xpath(xpFEIN, namespaces={'hmis':self.hmis_namespace,'airs':self.airs_namespace}), 'text') self.existence_test_and_add('record_owner', item.xpath(xpRecordOwner, namespaces={'hmis':self.hmis_namespace,'airs':self.airs_namespace}), 'text') self.existence_test_and_add('year_inc', i... | self.existence_test_and_add('fein', item.xpath(xpFEIN, namespaces={'hmis':self.hmis_namespace,'airs':self.airs_namespace}), 'attribute_text') self.existence_test_and_add('record_owner', item.xpath(xpRecordOwner, namespaces={'hmis':self.hmis_namespace,'airs':self.airs_namespace}), 'attribute_text') self.existence_test_a... | def parse_agency(self, element): ''' Element paths ''' xpAgency = 'hmis:Agency' xpAgencyDelete = '@hmis:Delete' xpAgencyDeleteOccurredDate = '@hmis:DeleteOccurredDate' xpAgencyDeleteEffective = '@hmis:DeleteEffective' xpAirsKey = 'airs:Key' xpAirsName = 'airs:Name' xpAgencyDescription = 'airs:AgencyDescription' xpIRSSt... |
self.isIsoTimeFormat = '%Y-%m-%dT%H:%M:%S' if settings.DEBUG: print "XML File to be dumped to: %s" % poutDirectory self.log = clsLogger.clsLogger(configFile='logging.ini', loglevel=40) self.outDirectory = poutDirectory self.pickList = interpretPickList() self.intakes = {} self.outcomes = None self.daily_census = []... | self.isIsoTimeFormat = '%Y-%m-%dT%H:%M:%S' if settings.DEBUG: print "XML File to be dumped to: %s" % poutDirectory self.log = clsLogger.clsLogger(configFile='logging.ini', loglevel=40) self.outDirectory = poutDirectory self.pickList = interpretPickList() self.intakes = {} self.outcomes = None self.daily_census = []... | def __init__(self, poutDirectory, processingOptions, debug=False, debugMessages=None): |
try: if self.debug: print 'Updating reporting for object: %s' % currentObject.__class__ currentObject.reported = True self.commitTransaction() except: print "Exception occured during update the 'reported' flag" pass | try: if self.debug: print 'Updating reporting for object: %s' % currentObject.__class__ currentObject.reported = True self.commitTransaction() except: print "Exception occurred during update the 'reported' flag" pass | def updateReported(self, currentObject): |
if recordset.person_legal_first_name_unhashed <> "" and recordset.person_legal_first_name_unhashed <> None: first_name = ET.SubElement(client, "first_name") first_name.text = recordset.person_legal_first_name_unhashed if recordset.person_legal_last_name_unhashed <> "" and recordset.person_legal_last_name_unhashed <> N... | if recordset.person_legal_first_name_unhashed <> "" and recordset.person_legal_first_name_unhashed <> None: first_name = ET.SubElement(client, "first_name") first_name.text = recordset.person_legal_first_name_unhashed if recordset.person_legal_last_name_unhashed <> "" and recordset.person_legal_last_name_unhashed <> N... | def customizeClientPersonalIdentifiers(self,client,recordset): |
fixedSSN = self.fixSSN(recordset.person_SSN_unhashed) if fixedSSN <> "" and fixedSSN <> None: soc_sec_no = ET.SubElement(client, "soc_sec_no") soc_sec_no.text = fixedSSN | def customizeClientPersonalIdentifiersForEntryExit(self,client,recordset): first_name = ET.SubElement(client, "first_name") first_name.text = recordset['First Name'] last_name = ET.SubElement(client, "last_name") last_name.text = recordset['Last Name'] if recordset['MI'] <> "": mi_initial = ET.SubElement(client, "m... | def customizeClientPersonalIdentifiers(self,client,recordset): |
ssn_data_quality = ET.SubElement(client, "ssn_data_quality") ssn_data_quality.text = "full ssn reported (hud)" def customizeClientPersonalIdentifiersForEntryExit(self,client,recordset): first_name = ET.SubElement(client, "first_name") first_name.text = recordset['First Name'] last_name = ET.SubElement(client, "last_... | def customizeClientPersonalIdentifiers(self,client,recordset): | |
provider_id = ET.SubElement(need, "provider_id") provider_id.text = '%s' % self.configurationRec.providerid status = ET.SubElement(need, "status") status.text = needData.need_status code = ET.SubElement(need, "code") code.attrib["type"] = "airs taxonomy" code.text = needData.taxonomy date_set = ET.SubElement(need, "... | provider_id = ET.SubElement(need, "provider_id") provider_id.text = '%s' % self.configurationRec.providerid status = ET.SubElement(need, "status") global converted_status converted_status = None if needData.need_status is not None: if needData.need_status == "1": converted_status = "identified" elif nee... | def customizeNeed(self, need, needData): |
tree = ET.ElementTree(self.root_element) if self.debug == True: print "trying to write XML to: %s " % os.path.join(self.outDirectory, "page.xml") tree.write(os.path.join(self.outDirectory, "page.xml")) | tree = ET.ElementTree(self.root_element) if self.debug == True: print "trying to write XML to: %s " % os.path.join(self.outDirectory, "page.xml") fileutil = fileutils.FileUtilities() fileutil.checkPath(self.outDirectory) attempted_filename = 'page.xml' unique_filename = fileutil.getUniqueFileName(attempted_filename, ... | def writeOutXML(self): |
self.table_metadata = MetaData() self.employee_table = Table( 'employee', self.table_metadata, Column('id', Integer, primary_key=True), Column('name', String(40)), Column('fullname', String(100)), Column('password', String(15)) ) mapper(Employee, self.employee_table) print 'entered the module' self.pg_db = create_engi... | self.metadata = MetaData() self.synthesis_engine = create_engine('postgres://%s:%s@%s:%s/%s' % (settings.DB_USER, settings.DB_PASSWD, settings.DB_HOST, settings.DB_PORT, settings.DB_DATABASE) , echo=settings.DEBUG_DB) self.synthesis_metadata = MetaData(self.synthesis_engine) Session = sessionmaker(bind=self.synthesis_e... | def __init__(self): self.table_metadata = MetaData() self.employee_table = Table( 'employee', self.table_metadata, Column('id', Integer, primary_key=True), Column('name', String(40)), Column('fullname', String(100)), Column('password', String(15)) ) mapper(Employee, self.employee_table) print 'entered the module' #self... |
print 'entered the function' self.employee_table.drop(bind=self.pg_db) | self.employee_table.drop(bind=self.synthesis_engine) | def blank_table(self): print 'entered the function' #self.metadata.drop(bind=self.pg_db) self.employee_table.drop(bind=self.pg_db) self.session.commit() print 'cleared the database' |
print 'cleared the database' | print 'cleared the employee_table table' | def blank_table(self): print 'entered the function' #self.metadata.drop(bind=self.pg_db) self.employee_table.drop(bind=self.pg_db) self.session.commit() print 'cleared the database' |
def create_database(): '''creates a new, empty database.''' metadata = MetaData() metadata.create_all(bind=synthesis_engine) | def create_database(self, databaseName): if not databaseName == '': parameters = ['--host=localhost', '--username=%s' % settings.DB_USER, settings.DB_DATABASE, "Synthesis Project Database for %s" % settings.MODE] compileCommand = '/usr/bin/createdb' if settings.DEBUG: print 'creating db with command: %s %s' % (compil... | |
print 'entered the function' self.table_metadata.create_all(bind=self.pg_db) | self.employee_table = Table( 'employee', self.metadata, Column('id', Integer, primary_key=True), Column('name', String(40)), Column('fullname', String(100)), Column('password', String(15)) ) mapper(Employee, self.employee_table) self.metadata.create_all(bind=self.synthesis_engine) | def create_test_table(self): print 'entered the function' self.table_metadata.create_all(bind=self.pg_db) self.session.commit() print 'created the employee table' |
print 'entered the function' self.session self.db_metadata.reflect() self.db_metadata.drop_all() self.db_metadata.create_all(bind=self.pg_db) self.session.commit() | self.synthesis_metadata.reflect() for table in self.synthesis_metadata.table_iterator(reverse=True, tables=None): print table, "found" table.drop(checkfirst=True) print "dropped", table | def blank_database(self): print 'entered the function' self.session self.db_metadata.reflect() self.db_metadata.drop_all() self.db_metadata.create_all(bind=self.pg_db) self.session.commit() print 'all tables dropped' |
UTILS = Utils() UTILS.create_test_table() UTILS.blank_table() UTILS.blank_database() | utils = Utils() print "uncomment the things you want to run, or else nothing will happen" | def blank_database(self): print 'entered the function' self.session self.db_metadata.reflect() self.db_metadata.drop_all() self.db_metadata.create_all(bind=self.pg_db) self.session.commit() print 'all tables dropped' |
barrierCd = barrier.barried_code | barrierCd = barrier.barrier_code | def getSchoolBarrier(self, cesIndex): barrier = self.session.query(DBObjects.ChildEnrollmentStatusBarrier)\ .filter(DBObjects.ChildEnrollmentStatusBarrier.\ child_enrollment_status_index_id == cesIndex).first() # TBD: Do we care which zipCode_status record gets returned? |
def getPersonHistoricalData(self, sspIndex, personId): | def getPersonHistoricalData(self, personIndex, personId): | def getPersonHistoricalData(self, sspIndex, personId): historicals = self.session.query(DBObjects.PersonHistorical)\ .filter(DBObjects.PersonHistorical.site_service_index_id == sspIndex) |
.filter(DBObjects.PersonHistorical.site_service_index_id == sspIndex) | .filter(DBObjects.PersonHistorical.person_index_id == personIndex) | def getPersonHistoricalData(self, sspIndex, personId): historicals = self.session.query(DBObjects.PersonHistorical)\ .filter(DBObjects.PersonHistorical.site_service_index_id == sspIndex) |
def createClientHistoricalRecs(self, sspIndex, personId): for historical in self.getPersonHistoricalData(sspIndex, personId): | def createClientHistoricalRecs(self, personIndex, personId): for historical in self.getPersonHistoricalData(personIndex, personId): | def createClientHistoricalRecs(self, sspIndex, personId): for historical in self.getPersonHistoricalData(sspIndex, personId): try: # Get the fields in site_service_participation table: phIndex = historical.id |
"domestic_violence_survivor", "dvo_occurred") | "domestic_violence_survivor", "dv_occurred") | def createClientHistoricalRecs(self, sspIndex, personId): for historical in self.getPersonHistoricalData(sspIndex, personId): try: # Get the fields in site_service_participation table: phIndex = historical.id |
self.store.install_ez("dist/%s.ez" % (ezname,), | self.store.install_ez(self, "dist/%s.ez" % (ezname,), | def install_ezs(self): for (ezname, ezdesc, ezrundeps) in self.ezs: if ezrundeps is None: ezrundeps = [] registerForPackaging = False else: registerForPackaging = True self.store.install_ez("dist/%s.ez" % (ezname,), ezdesc, self.version_str(), ezrundeps, registerForPackaging = registerForPackaging) |
def __init__(self, package_name): | def __init__(self, package_name, extra_packages = []): | def __init__(self, package_name): self.package_name = package_name |
def installed_debian_source_path(self): return self.store.binary_path_for("%s_%s-1.tar.gz" % (self.package_name, self.version_str())) | def all_package_names(self): return [self.package_name] + self.extra_packages def dirty_test_paths(self): if not self.store.want_debian(): return [] v = self.version_str() return [self.store.binary_path_for("%s_%s-1.tar.gz" % (self.package_name, v))] | def installed_debian_source_path(self): return self.store.binary_path_for("%s_%s-1.tar.gz" % (self.package_name, self.version_str())) |
def install_debian_artifacts(self): | def install_debian_artifacts(self, build_dir): | def install_debian_artifacts(self): if not self.store.want_debian(): return b = "%s_%s-1" % (self.package_name, self.version_str()) for f in glob.glob(b+"_*.deb"): self.store.install_binary(f) for f in glob.glob(b+"_*.changes"): self.store.install_binary(f) for f in glob.glob(b+".dsc"): self.store.install_binary(f) for... |
b = "%s_%s-1" % (self.package_name, self.version_str()) for f in glob.glob(b+"_*.deb"): self.store.install_binary(f) for f in glob.glob(b+"_*.changes"): self.store.install_binary(f) for f in glob.glob(b+".dsc"): self.store.install_binary(f) for f in glob.glob(b+".tar.gz"): self.store.install_binary(f) | with cwd_set_to(build_dir): for n in self.all_package_names(): b = "%s_%s-1" % (n, self.version_str()) for f in glob.glob(b+"_*.deb"): self.store.install_binary(f) for f in glob.glob(b+"_*.changes"): self.store.install_binary(f) for f in glob.glob(b+".dsc"): self.store.install_binary(f) for f in glob.glob(b+".tar.gz"):... | def install_debian_artifacts(self): if not self.store.want_debian(): return b = "%s_%s-1" % (self.package_name, self.version_str()) for f in glob.glob(b+"_*.deb"): self.store.install_binary(f) for f in glob.glob(b+"_*.changes"): self.store.install_binary(f) for f in glob.glob(b+".dsc"): self.store.install_binary(f) for... |
ezs = []): | ezs = [], extra_packages = []): | def __init__(self, store, directory, source_repo, build_deps, package_name = None, ezs = []): Project.__init__(self, store, directory, source_repo, build_deps, ezs = ezs) DebianMixin.__init__(self, package_name or self.shortname) |
DebianMixin.__init__(self, package_name or self.shortname) | DebianMixin.__init__(self, package_name or self.shortname, extra_packages = extra_packages) | def __init__(self, store, directory, source_repo, build_deps, package_name = None, ezs = []): Project.__init__(self, store, directory, source_repo, build_deps, ezs = ezs) DebianMixin.__init__(self, package_name or self.shortname) |
result = Project.dirty_test_paths(self) if self.store.want_debian(): result.append(self.installed_debian_source_path()) return result | return Project.dirty_test_paths(self) + \ DebianMixin.dirty_test_paths(self) | def dirty_test_paths(self): result = Project.dirty_test_paths(self) if self.store.want_debian(): result.append(self.installed_debian_source_path()) return result |
self.install_debian_artifacts() | self.install_debian_artifacts(build_dir) | def build(self, build_dir): srcdir = self.srcdir_for(build_dir) self.repo().clone(srcdir) self.buildpackage_in(srcdir) self.install_debian_artifacts() with cwd_set_to(srcdir): ssc("make") self.install_ezs() |
def __init__(self, store, directory, source_repo, build_deps, package_name, ezs = []): | def __init__(self, store, directory, source_repo, build_deps, package_name, ezs = [], extra_packages = []): | def __init__(self, store, directory, source_repo, build_deps, package_name, ezs = []): Project.__init__(self, store, directory, source_repo, build_deps, ezs = ezs) DebianMixin.__init__(self, package_name) |
DebianMixin.__init__(self, package_name) | DebianMixin.__init__(self, package_name, extra_packages = extra_packages) | def __init__(self, store, directory, source_repo, build_deps, package_name, ezs = []): Project.__init__(self, store, directory, source_repo, build_deps, ezs = ezs) DebianMixin.__init__(self, package_name) |
return [self.source_tarball()] + Project.dirty_test_paths(self) | return [self.source_tarball()] + \ Project.dirty_test_paths(self) + \ DebianMixin.dirty_test_paths(self) | def dirty_test_paths(self): return [self.source_tarball()] + Project.dirty_test_paths(self) |
self.install_debian_artifacts() | self.install_debian_artifacts(build_dir) | def build(self, build_dir): with cwd_set_to(self.directory): if os.path.exists("Makefile"): ssc("make squeakyclean") if not os.path.exists("configure"): ssc("autoreconf -i") with cwd_set_to(build_dir): ssc("%s/configure --prefix=%s/_install" % (self.directory, build_dir)) ssc("make VERSION=%s distcheck" % (self.version... |
class Ez(object): | class Ez(DebianMixin): | def build(self, build_dir): with cwd_set_to(self.mochiweb_dir()): ssc("make mochiweb-svn") EzProject.build(self, build_dir) |
def __init__(self, store, name, description, version, runtime_deps): | def __init__(self, store, name, description, version, runtime_deps, timestamp): DebianMixin.__init__(self, self.fullname(name)) | def __init__(self, store, name, description, version, runtime_deps): self.store = store self.name = name self.description = description self.version = version self.runtime_deps = runtime_deps |
with file(os.path.join(tmpdir, "plugindir"), "w") as f: f.write("usr/lib/rabbitmq/lib/rabbitmq_server-%s/plugins\n" % (rabbit_server_version,)) with file(os.path.join(tmpdir, "debian/control"), "w") as f: f.write("Source: %s\n" % (self.fullname(self.name),)) f.write(Ez.control_boilerplate) f.write("Package: %s\n" % (... | with cwd_set_to(tmpdir): with file("plugindir", "w") as f: f.write("usr/lib/rabbitmq/lib/rabbitmq_server-%s/plugins\n" % (rabbit_server_version,)) with file("debian/control", "w") as f: f.write("Source: %s\n" % (self.package_name,)) f.write(Ez.control_boilerplate) f.write("Package: %s\n" % (self.package_name,)) f.wri... | def prepare_package(self, build_dir): tmpdir = os.path.join(build_dir, "tmp") ensure_clean_dir(tmpdir) cp_p("-r", "ez-debian", os.path.join(tmpdir, "debian")) cp_p(self.store.ez_path_for(self.name, self.version), tmpdir) |
with cwd_set_to(os.path.join(build_dir, "tmp")): ssc("dpkg-buildpackage -b -rfakeroot -us -uc") | self.buildpackage_in(os.path.join(build_dir, "tmp"), binaryOnly = True) self.install_debian_artifacts(build_dir) | def build_package(self, build_dir): with cwd_set_to(os.path.join(build_dir, "tmp")): ssc("dpkg-buildpackage -b -rfakeroot -us -uc") |
def install_source(self, fname): cp_p(fname, self.source_dir) def install_binary(self, fname): cp_p(fname, self.binary_dir) def install_ez(self, ez_fname, desc, v, runtime_deps, registerForPackaging = True): | def install_source(self, fname): log(LOG_INSTALL, "Installing", fname, "to", self.source_dir) cp_p(fname, self.source_dir) def install_binary(self, fname): log(LOG_INSTALL, "Installing", fname, "to", self.binary_dir) cp_p(fname, self.binary_dir) def install_ez(self, project, ez_fname, desc, v, runtime_deps, registerFo... | def install_source(self, fname): cp_p(fname, self.source_dir) |
self.built_ezs.append(Ez(self, ezname, desc, v, runtime_deps)) | self.built_ezs.append(Ez(self, ezname, desc, v, runtime_deps, project.timestamp())) | def install_ez(self, ez_fname, desc, v, runtime_deps, registerForPackaging = True): ezname = os.path.splitext(os.path.basename(ez_fname))[0] cp_p(ez_fname, self.ez_path_for(ezname, v)) if registerForPackaging: self.built_ezs.append(Ez(self, ezname, desc, v, runtime_deps)) |
"librabbitmq") | "librabbitmq", extra_packages = ["librabbitmq-dev"]) | def _main(): store = Store() rfc4627 = GenericSimpleDebianProject( store, "erlang-rfc4627", lshiftHg("erlang-rfc4627"), [], "rfc4627-erlang", ezs = [("rfc4627_jsonrpc", "JSON (RFC 4627) codec and generic JSON-RPC server implementation", [])]) # Weird. This should depend on the server. xmpp = RabbitMQXmppProject(store... |
rdeps = ['rabbitmq-server (= %s)' % (rabbit_server_version,)] + \ | rdeps = ['rabbitmq-server (= %s-1)' % (rabbit_server_version,)] + \ | def prepare_package(self, build_dir): tmpdir = os.path.join(build_dir, "tmp") ensure_clean_dir(tmpdir) cp_p("-r", "ez-debian", os.path.join(tmpdir, "debian")) cp_p(self.store.ez_path_for(self.name, self.version), tmpdir) |
convert_msg = 'You should convert it to a PNG (or possibly GIF, if it is essentially all text; or JPEG, if it is mostly images).', | convert_msg = 'You should convert it to a PNG (or possibly GIF, if it is essentially all text; or JPEG, if it is mostly images).' | def check_image_field(fysm, label, image): good_ext = ['png', 'jpg', 'jpeg', 'gif', ] ext = image.name.rsplit('.')[-1] convert_msg = 'You should convert it to a PNG (or possibly GIF, if it is essentially all text; or JPEG, if it is mostly images).', if not image.name: return { 'heading': 'No %s provided' % (label, ), '... |
'body': 'You submitted a TIFF file for your %s. TIFF files are generally large and poorly supported by browsers. ' % (label, ) + convert_msg, | 'body': ('You submitted a TIFF file for your %s. TIFF files are generally large and poorly supported by browsers. ' % (label, )) + convert_msg, | def check_image_field(fysm, label, image): good_ext = ['png', 'jpg', 'jpeg', 'gif', ] ext = image.name.rsplit('.')[-1] convert_msg = 'You should convert it to a PNG (or possibly GIF, if it is essentially all text; or JPEG, if it is mostly images).', if not image.name: return { 'heading': 'No %s provided' % (label, ), '... |
'body': 'You submitted a BMP file for your %s. BMP files are generally extremely large. ' % (label, ) + convert_msg, | 'body': ('You submitted a BMP file for your %s. BMP files are generally extremely large. ' % (label, )) + convert_msg, | def check_image_field(fysm, label, image): good_ext = ['png', 'jpg', 'jpeg', 'gif', ] ext = image.name.rsplit('.')[-1] convert_msg = 'You should convert it to a PNG (or possibly GIF, if it is essentially all text; or JPEG, if it is mostly images).', if not image.name: return { 'heading': 'No %s provided' % (label, ), '... |
__version__ = '0.4' __version_tag__ = 'dev' | __version__ = '0.3.1' __version_tag__ = '' | ... def configure(self, binder): |
text = "[\"" + type(packet).__name__ + "\", \"" + sender + "\", " + str(packet.to_dict()) + "]" log(text) | text = "['" + type(packet).__name__ + "', '" + sender + "', " + str(packet.to_dict()) + "]" log_file.write("log.append(" + text + ")\n") if config.host_device == HOST_DEVICE_PC: sys.stdout.write(text + "\n") sys.stdout.flush() | def log_packet(sender, packet): text = "[\"" + type(packet).__name__ + "\", \"" + sender + "\", " + str(packet.to_dict()) + "]" log(text) |
self.incoming_packet_buffer += self.socket.readAll() if self.incoming_packet == None: self.incoming_packet = packets.create_packet(self.incoming_packet_buffer) if len(self.incoming_packet_buffer) >= self.incoming_packet.MAX_SIZE: buf = self.incoming_packet_buffer[:self.incoming_packet.MAX_SIZE] self.incoming_packet_buf... | if self.socket != None: self.incoming_packet_buffer += self.socket.readAll() if self.incoming_packet == None: self.incoming_packet = packets.create_packet(self.incoming_packet_buffer) if len(self.incoming_packet_buffer) >= self.incoming_packet.MAX_SIZE: buf = self.incoming_packet_buffer[:self.incoming_packet.MAX_SIZE] ... | def read_packet(self): self.incoming_packet_buffer += self.socket.readAll() if self.incoming_packet == None: self.incoming_packet = packets.create_packet(self.incoming_packet_buffer) if len(self.incoming_packet_buffer) >= self.incoming_packet.MAX_SIZE: buf = self.incoming_packet_buffer[:self.incoming_packet.MAX_SIZE] s... |
cls.FORMAT += str(self.MAX_SIZE - size) + "x" | pad_size = self.MAX_SIZE - size if pad_size != 0: cls.FORMAT += str(pad_size) + "x" | def __init__(self, format): cls = type(self) if cls.FORMAT == None: cls.FORMAT = "!B" + format size = struct.calcsize(cls.FORMAT) cls.FORMAT += str(self.MAX_SIZE - size) + "x" |
MAX_SIZE = 32 | MAX_SIZE = 5 | def serialize(self): values = [] values.append(self.whatever) return self.do_serialize(*values) |
call(["wget", archive_url, "-O", archive]) | call(["wget", archive_url, "-O", package]) | def install_package(archive_url, archive): package = os.path.join(OUTPUT_DIR, "target", "root", archive) if not os.path.exists(package): call(["wget", archive_url, "-O", archive]) |
team_indicator = QGraphicsEllipseItem(-25.0, 15.0, 50.0, 50.0) | team_indicator = QGraphicsEllipseItem(-65.0, -25.0, 50.0, 50.0) | def __init__(self, team, parent = None): QObject.__init__(self, parent) |
self.scene.removeItem(self.field_item) self.field_item = None | if self.field_item != None: self.scene.removeItem(self.field_item) self.field_item = None | def remove_field_item(self): self.scene.removeItem(self.field_item) self.field_item = None |
channel_data.packet = None | def handle_read(self, channel): channel_data = self.channels[channel] if channel_data.packet == None: channel_data.buffer += channel.recv(1) channel_data.packet = packets.create_packet(channel_data.buffer) else: try: channel_data.buffer += channel.recv(channel_data.packet.MAX_SIZE - len(channel_data.buffer)) if len(cha... | |
if action.__class__.__base__ == SaveAction: | if action.__class__.__base__ == SaveAction or action.__class__ == SendByMail: | def execute(self, items): logger.debug('execute') actions = self.get_actions() |
preview_available = tasks_pending.filter(component__variant__name = 'preview', component__item=item).count() | preview_available = tasks_pending.filter(component__variant__name = 'preview', component__item=item).count() if item.type.name == 'audio': inprogress = int(not (preview_available == 0)) else: inprogress = int(not thumb_ready) | def _get_items_info(user, workspace, items): items_id = [i.pk for i in items] user_basket = Basket.get_basket(user, workspace) basket_items = user_basket.items.all().values_list('pk', flat=True) ws_tasks = Task.objects.filter(component__workspace=workspace) tasks_pending = ws_tasks.filter(state='pending') #tasks_do... |
'inprogress': int(not thumb_ready), | 'inprogress': inprogress, | def _get_items_info(user, workspace, items): items_id = [i.pk for i in items] user_basket = Basket.get_basket(user, workspace) basket_items = user_basket.items.all().values_list('pk', flat=True) ws_tasks = Task.objects.filter(component__workspace=workspace) tasks_pending = ws_tasks.filter(state='pending') #tasks_do... |
thumb_url, thumb_ready = _get_thumb_url(item, workspace) my_caption = _get_thumb_caption(item, thumb_caption, default_language) item_in_basket = 0 if item.pk in basket_items: item_in_basket = 1 geotagged = 0 if GeoInfo.objects.filter(item=item).count() > 0: geotagged = 1 preview_available = tasks_pending.filter(com... | try: thumb_url, thumb_ready = _get_thumb_url(item, workspace) my_caption = _get_thumb_caption(item, thumb_caption, default_language) item_in_basket = 0 if item.pk in basket_items: item_in_basket = 1 geotagged = 0 if GeoInfo.objects.filter(item=item).count() > 0: geotagged = 1 preview_available = tasks_pending.filt... | def _get_items_info(user, workspace, items): items_id = [i.pk for i in items] user_basket = Basket.get_basket(user, workspace) basket_items = user_basket.items.all().values_list('pk', flat=True) ws_tasks = Task.objects.filter(component__workspace=workspace) tasks_pending = ws_tasks.filter(state='pending') #tasks_do... |
EventRegistration.objects.filter( listener = script, workspace = workspace).delete() | EventRegistration.objects.filter( script = script, workspace = workspace).delete() | def _new_script(name = None, description = None, workspace = None, pipeline = None, events = [], script = None): if script: if pipeline: ActionList.objects.filter(script = script).delete() else: script = Script.objects.create(name = name, description = description, workspace = workspace) if pipeline: pipeline = simpl... |
EventRegistration.objects.filter(event = event, workspace = workspace).delete() | def set_script_associations(request): workspace = request.session.get('workspace') event_id = request.POST['event_id'] script_id = request.POST.getlist('script_id') scripts = Script.objects.filter(pk__in = script_id) event = Event.objects.get(pk = event_id) for script in scripts: EventRegistration.objects.filter(event ... | |
pattern = re.compile('%(?P<namespace>\w+):(?P<field>\w+)%') groups = re.finditer(pattern, template_string) values_dict = {} for g in groups: values_dict[g.group(0)] = _replace_groups(g, item, language) caption = template_string for schema in values_dict.keys(): caption = caption.replace(schema, values_dict[schema]) ... | caption = 'no_valid_caption_available' try: pattern = re.compile('%(?P<namespace>\w+):(?P<field>\w+)%') groups = re.finditer(pattern, template_string) values_dict = {} for g in groups: values_dict[g.group(0)] = _replace_groups(g, item, language) caption = template_string for schema in values_dict.keys(): caption = ca... | def _get_thumb_caption(item, template_string, language): pattern = re.compile('%(?P<namespace>\w+):(?P<field>\w+)%') groups = re.finditer(pattern, template_string) values_dict = {} for g in groups: values_dict[g.group(0)] = _replace_groups(g, item, language) caption = template_string for schema in values_dict.keys()... |
_new_script(name = glob_script.name, description = glob_script.description, workspace = ws, pipeline = glob_script.pipeline, events = ['upload', 'item copy']) | _new_script(name = glob_script.name, description = glob_script.description, workspace = ws, pipeline = glob_script.pipeline, events = ['upload', 'item copy'], is_global = True) | def create_workspace(self, name, description, creator): """ Creates a new workspace @param name name of the new workspace (string) @param description description of the new workspace (optional string) @param creator an instance of auth.User """ from dam.scripts.models import ScriptDefault, Script from dam.scripts.views... |
xmp_values[m.xmp_property.id] = m.value | logger.debug('m is %s while m.value is %s' % (m,m.value)) if not isinstance(m.value, unicode): xmp_values[m.xmp_property.id] = m.value.decode('utf-8') else: xmp_values[m.xmp_property.id] = m.value | def save_rights_value(self, license_value, workspace): """ Save license to the given component and set xmp values according to right rules (as defined in XMPRightsValue) @param license_value an instance of metadata.RightsValue @param workspace an instance of workspace.DAMWorkspace """ from metadata.models import Right... |
return { 'type': self.verbose_name, 'parameters': { 'watermark_filename': self.parameters['watermark_filename'], 'pos_y_percent': self.parameters['watermark_top_percent'], 'pos_x_percent': self.parameters['watermark_left_percent'], }} | if self.media_type == 'video': return { 'type': self.verbose_name, 'parameters': { 'watermark_filename': self.parameters['watermark_filename'], 'pos_y_percent': self.parameters['watermark_top_percent'], 'pos_x_percent': self.parameters['watermark_left_percent'], }} else: return super(Watermark, self)._get_params() | def _get_params(self): return { 'type': self.verbose_name, 'parameters': { 'watermark_filename': self.parameters['watermark_filename'], |
logger.debug(' | logger.debug('-------- | def get_status(request): """ Returns information for the given items, including name, size, url of thumbnail and preview Called every 10 seconds by the GUI for refreshing information on pending items """ try: items = simplejson.loads(request.POST.get('items')) #logger.debug('######## items: %s' % items) #logger.debug('... |
for i in items: | logger.debug('items_done %s'%items_done) logger.debug('items %s'%items) logger.debug('items_pending %s'%items_pending) for i in items_done: | def get_status(request): """ Returns information for the given items, including name, size, url of thumbnail and preview Called every 10 seconds by the GUI for refreshing information on pending items """ try: items = simplejson.loads(request.POST.get('items')) #logger.debug('######## items: %s' % items) #logger.debug('... |
resource_url = SERVER_PUBLIC_ADDRESS + "/resources/%s/%s/"% (comp.id, workspace.pk) | resource_url = "/resources/%s/%s/"% (comp.id, workspace.pk) abs_resource_url = SERVER_PUBLIC_ADDRESS + resource_url | def get_variants(request): workspace = request.session['workspace'] item_id = request.POST.get('items') logger.debug('item_id %s'%item_id) item = Item.objects.get(pk = item_id) logger.debug('before comps') user = User.objects.get(pk=request.session['_auth_user_id']) item_variants = Variant.objects.filter(Q(workspace ... |
resp['variants'].append({'data_basic': info_list, 'data_full':info_list_full, 'variant_name': v.name, 'resource_url': resource_url, 'pk': v.pk, 'imported':imported, 'item_id': item_id, 'auto_generated':auto_generated, 'media_type': media_type, 'extension':extension, 'work_in_progress':work_in_progress, 'width'... | resp['variants'].append({'data_basic': info_list, 'data_full':info_list_full, 'variant_name': v.name, 'resource_url': resource_url, 'abs_resource_url': abs_resource_url, 'pk': v.pk, 'imported':imported, 'item_id': item_id, 'auto_generated':auto_generated, 'media_type': media_type, 'extension':extension, 'work_in_progre... | def get_variants(request): workspace = request.session['workspace'] item_id = request.POST.get('items') logger.debug('item_id %s'%item_id) item = Item.objects.get(pk = item_id) logger.debug('before comps') user = User.objects.get(pk=request.session['_auth_user_id']) item_variants = Variant.objects.filter(Q(workspace ... |
items= items.filter(node = node) | items = items.filter(node__in = node.get_branch()) | def _search_complex_query(complex_query, items): logger.debug('items %s'%items) if complex_query['condition'] == 'and': for node_id in complex_query['nodes']: node = Node.objects.get(pk = node_id['id']) if node_id['negated']: items = items.exclude(node = node) else: items= items.filter(node = node) logger.debug('ite... |
original = components.filter(variant__name='original')[0] end = MachineState.objects.create(name='finished') embed_action = Action.objects.create(component=original, function='embed_xmp') embed_state = MachineState.objects.create(name='comp_xmp', action=embed_action) embed_state.next_state = end embed_state.save() ... | if 'all' in variants: sync_comp = components else: sync_comp = components.filter(variant__name__in=variants) for component in sync_comp: add_sync_machine(component) | def sync_component(request): items = request.POST.getlist('items') workspace = request.session['workspace'] for pk in items: item = Item.objects.get(pk=pk) components = item.get_variants(workspace) original = components.filter(variant__name='original')[0] end = MachineState.objects.create(name='finished') embed_... |
def get_adapt_params(self): tmp = dict(self.parameters) tmp['bitrate'] = tmp.pop('audio_bitrate') tmp['rate'] = tmp.pop('audio_erate') return tmp | def __init__(self, media_type, source_variant, workspace, script, rate, bitrate): super(AudioEncode, self).__init__(media_type, source_variant, workspace, script) | |
self.node_set.filter(type = 'keyword').values('id','label') | return self.node_set.filter(type = 'keyword').values('id','label') | def keywords(self): """ Retrieve all the keywords (taxonomy nodes) """ self.node_set.filter(type = 'keyword').values('id','label') |
_id = models.CharField(max_length=41, primary_key = True, db_column = 'id') | _id = models.CharField(max_length=41) | def filter(self, tags, user = None, and_ = True): """It is a facility for searching objects by a list of tags. If an user is passed, search is performed only on his own tags. Moreover, search can be done with an 'AND' or a 'OR' logic. @param tags: a list of tags @type tags: list @param user: if passed, search is perfor... |
script_id = request.getlist('script_id') | script_id = request.POST.getlist('script_id') | def set_script_associations(request): workspace = request.session.get('workspace') event_id = request.POST['event_id'] script_id = request.getlist('script_id') scripts = Script.objects.filter(pk__in = script_id) event = Event.objects.get(pk = event_id) for script in scripts: EventRegistration.objects.filter(event = eve... |
ws = Workspace.objects.get(pk = ws_pk) | ws = DAMWorkspace.objects.get(pk = ws_pk) | def test_add_members(self): ws_pk = 1 ws = Workspace.objects.get(pk = ws_pk) u = User.objects.create(username = 'test') params = self.get_final_parameters({'users': u.username, 'permissions':'admin'}) response = self.client.post('/api/workspace/%s/add_members/'%ws_pk, params) self.assertTrue(response.content == '') ... |
ws = Workspace.objects.get(pk = ws_pk) | ws = DAMWorkspace.objects.get(pk = ws_pk) | def test_set_permissions(self): ws_pk = 1 ws = Workspace.objects.get(pk = ws_pk) u = User.objects.create(username = 'test') params = self.get_final_parameters({'users': u.username, 'permissions':'admin'}) response = self.client.post('/api/workspace/%s/add_members/'%ws_pk, params) self.assertTrue(response.content == ... |
ws = Workspace.objects.get(pk = ws_pk) | ws = DAMWorkspace.objects.get(pk = ws_pk) | def test_remove_members(self): ws_pk = 1 ws = Workspace.objects.get(pk = ws_pk) u = User.objects.create(username = 'test') params = self.get_final_parameters({'users': u.username, 'permissions':'admin'}) response = self.client.post('/api/workspace/%s/add_members/'%ws_pk, params) self.assertTrue(response.content == '... |
workspace = Workspace.objects.get(pk = ws_pk) | workspace = DAMWorkspace.objects.get(pk = ws_pk) | def test_set_variants(self): ws_pk = 1 variant = Variant.objects.get(name = 'preview', media_type__name = 'image') workspace = Workspace.objects.get(pk = ws_pk) params = { 'codec': 'gif', 'max_dim': 400, |
workspace = Workspace.objects.get(pk = 1) | workspace = DAMWorkspace.objects.get(pk = 1) | def test_search(self): workspace = Workspace.objects.get(pk = 1) params = self.get_final_parameters({ 'query': 'test', 'media_type': 'image', 'start':0, 'limit':1, 'metadata': 'dc_description' }) response = self.client.post('/api/workspace/%s/search/'%workspace.pk, params) resp_dict = json.loads(response.content) pri... |
workspace = Workspace.objects.get(pk = 1) | workspace = DAMWorkspace.objects.get(pk = 1) | def test_search_keywords(self): workspace = Workspace.objects.get(pk = 1) node = Node.objects.get(label = 'test_remove_1') params = self.get_final_parameters({ 'keyword': node.pk, 'media_type': 'image', 'start':0, 'limit':1, 'metadata': 'dc_description' }) response = self.client.post('/api/workspace/%s/search/'%works... |
workspace = Workspace.objects.get(pk = 1) | workspace = DAMWorkspace.objects.get(pk = 1) | def test_search_collections(self): workspace = Workspace.objects.get(pk = 1) collection = Node.objects.get(label = 'test_with_item') params = self.get_final_parameters({ 'collection': collection.pk, 'media_type': 'image', 'start':0, 'limit':1, 'metadata': 'dc_description' }) response = self.client.post('/api/workspace... |
workspace = Workspace.objects.get(pk = 1) | workspace = DAMWorkspace.objects.get(pk = 1) | def test_search_smart_folders(self): workspace = Workspace.objects.get(pk = 1) smart_folder = SmartFolder.objects.get(pk = 1) params = self.get_final_parameters({ 'smart_folder': smart_folder.pk, 'media_type': 'image', 'start':0, 'limit':1, 'metadata': 'dc_description' }) response = self.client.post('/api/workspace/%... |
workspace = Workspace.objects.get(pk = 1) | workspace = DAMWorkspace.objects.get(pk = 1) | def test_search_complex(self): workspace = Workspace.objects.get(pk = 1) params = self.get_final_parameters({ 'keyword': 18, 'query': '"test prova"' , 'media_type': 'image', 'start':0, 'limit':1, 'metadata': 'dc_description' }) response = self.client.post('/api/workspace/%s/search/'%workspace.pk, params) resp_dict = j... |
workspace = Workspace.objects.get(pk = 1) | workspace = DAMWorkspace.objects.get(pk = 1) | def test_search_collections_no_results(self): workspace = Workspace.objects.get(pk = 1) params = self.get_final_parameters({ 'collection': -1, 'media_type': 'image', 'start':0, 'limit':1, 'metadata': 'dc_description' }) response = self.client.post('/api/workspace/%s/search/'%workspace.pk, params) resp_dict = json.load... |
ws = Workspace.objects.get(pk = ws_pk) | ws = DAMWorkspace.objects.get(pk = ws_pk) | def test_keywords(self): ws_pk = 1 params = {'workspace_id':ws_pk} params = self.get_final_parameters(params) response = self.client.get('/api/workspace/%s/get_keywords/'%ws_pk, params, ) resp_dict = json.loads(response.content) |
ws = Workspace.objects.get(pk = ws_pk) | ws = DAMWorkspace.objects.get(pk = ws_pk) | def test_set_name(self): ws_pk = 1 params = self.get_final_parameters({'name':'test_', }) response = self.client.post('/api/workspace/%s/set_name/'%ws_pk, params,) self.assertTrue(response.content == '') ws = Workspace.objects.get(pk = ws_pk) self.assertTrue(ws.name == 'test_') |
ws = Workspace.objects.get(pk = ws_pk) | ws = DAMWorkspace.objects.get(pk = ws_pk) | def test_set_description(self): ws_pk = 1 params = self.get_final_parameters({'description':'test_'}) response = self.client.post('/api/workspace/%s/set_description/'%ws_pk, params) self.assertTrue(response.content == '') ws = Workspace.objects.get(pk = ws_pk) self.assertTrue(ws.description == 'test_') |
ws = Workspace.objects.get(pk = ws_pk) | ws = DAMWorkspace.objects.get(pk = ws_pk) | def test_get(self): ws_pk = 1 params = self.get_final_parameters({}) response = self.client.get('/api/workspace/%s/get/'%ws_pk, params, ) resp_dict = json.loads(response.content) print 'resp_dict ', resp_dict ws = Workspace.objects.get(pk = ws_pk) self.assertTrue(resp_dict['id'] == str(ws.pk)) self.assertTrue(resp_... |
self.assertRaises(Workspace.DoesNotExist, Workspace.objects.get, pk = ws_pk) | self.assertRaises(DAMWorkspace.DoesNotExist, DAMWorkspace.objects.get, pk = ws_pk) | def test_delete(self): name = 'test_2' params = self.get_final_parameters({'name':name, }) response = self.client.post('/api/workspace/new/', params) resp_dict = json.loads(response.content) ws_pk = resp_dict['id'] params = self.get_final_parameters({}) response = self.client.get('/api/workspace/%s/delete/'%ws_pk, pa... |
ws = Workspace.objects.get(pk = ws_pk) | ws = DAMWorkspace.objects.get(pk = ws_pk) | def test_create(self): name = 'test_1' params = self.get_final_parameters({'name':name, }) response = self.client.post('/api/workspace/new/', params, ) resp_dict = json.loads(response.content) ws_pk = resp_dict['id'] ws = Workspace.objects.get(pk = ws_pk) self.assertTrue(ws.name == name) self.assertTrue(resp_dict.ha... |
ws = Workspace.objects.get(pk = ws_id) | ws = DAMWorkspace.objects.get(pk = ws_id) | def test_set_creator(self): u = User.objects.create(username = 'test') ws_id = 1 |
ws = Workspace.objects.get(pk = ws_id) | ws = DAMWorkspace.objects.get(pk = ws_id) | def test_get_smartfolders(self): ws_id = 1 params = self.get_final_parameters({}) response = self.client.get('/api/workspace/%s/get_smartfolders/'%ws_id, params, ) |
ws_new = Workspace.objects.create_workspace('test', '', user) | ws_new = DAMWorkspace.objects.create_workspace('test', '', user) | def test_move(self): workspace_id = 1 item_id = Item.objects.all()[0].pk user = User.objects.get(pk = 1) ws_new = Workspace.objects.create_workspace('test', '', user) params = self.get_final_parameters({'workspace_id':ws_new.pk}) response = self.client.post('/api/item/%s/add_to_workspace/'%item_id, params, ) self.as... |
ws = Workspace.objects.get(pk = workspace_id) | ws = DAMWorkspace.objects.get(pk = workspace_id) | def test_add_keywords(self): workspace_id = 1 ws = Workspace.objects.get(pk = workspace_id) new_node = Node.objects.get(label = 'test', type = 'keyword', workspace = ws) item = Item.objects.all()[0] item_id = item.pk self.assertTrue(item.node_set.filter(pk = new_node.pk).count() == 0) params = self.get_final_paramete... |
ws = Workspace.objects.get(pk = workspace_id) | ws = DAMWorkspace.objects.get(pk = workspace_id) | def test_remove_keywords(self): workspace_id = 1 ws = Workspace.objects.get(pk = workspace_id) new_node = Node.objects.get(label = 'test_remove_1', type = 'keyword', workspace = ws) item = Item.objects.all()[0] item_id = item.pk label = 'test' params = self.get_final_parameters({ 'keywords':new_node.pk}) self.assertT... |
ws = Workspace.objects.get(pk = workspace_id) | ws = DAMWorkspace.objects.get(pk = workspace_id) | def test_add_to_collection(self): workspace_id = 1 ws = Workspace.objects.get(pk = workspace_id) collection_node = Node.objects.get(label = 'test1', type = 'collection') item = Item.objects.all()[0] params = self.get_final_parameters({ 'collection_id': collection_node.pk}) response = self.client.post('/api/item/%s/ad... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.