file_name
large_stringlengths 4
140
| prefix
large_stringlengths 0
12.1k
| suffix
large_stringlengths 0
12k
| middle
large_stringlengths 0
7.51k
| fim_type
large_stringclasses 4
values |
|---|---|---|---|---|
marketplace.js |
return formatted;
};
var searchReports = function(search, callback) {
$.ajax({
url: './handlers/MarketplaceReportSearchHandler.ashx',
data: { language: languageId, instance: instanceId, search: JSON.stringify(search) },
success: function (d) {
if (callback) callback(d);
},
dataType: 'json',
type: 'POST'
});
}
var getStandardResults = function (reportId, standardId, profileId, callback) {
$.ajax({
url: './handlers/MarketplaceSeriesDataHandler.ashx',
data: { report: reportId, standard: standardId, profile: profileId },
success: function (d) {
if (callback) callback(d);
},
dataType: 'json',
type: 'POST'
});
}
var getCompanyDetails = function (companyId, profileId, languageId, callback) {
$.ajax({
url: './handlers/MarketplaceCompanyDetailsHandler.ashx',
data: { company: companyId, profile: profileId, language: languageId },
success: function (d) {
if (callback) callback(d);
},
dataType: 'json',
type: 'POST'
});
}
$(function () {
$('.form-group select').selectize({ clearOnOpen: true }).on('change', filterSearch);
$('#CompanyName').on('change', filterSearch);
$('#Filters input.percentslider')
.slider({tooltip: 'show',selection: 'after', orientation: 'horizontal', step: 5, min: -1, max: 100, value: -1})
.on('slide', function(ev){ $(ev.currentTarget).closest('.percentageFilter').find('span.percentage').text(-1 < ev.value ? ev.value + '%' : 'na');})
.on('slideStop', filterSearch)
.closest('.percentageFilter')
.append('<span class="percentage">na</span>');
filterSearch();
});
function max(a, b)
{
if (!a || !isNumber(a)) return b;
if (!b || !isNumber(b)) return a;
return Math.max(a, b);
}
function isNumber(n) {
return !isNaN(parseFloat(n)) && isFinite(n);
}
function filterSearch() {
var fs = {};
fs.CompanyName = '';
fs.Products = [];
fs.ProductCategories = []
fs.ProducingCountries = [];
fs.ProducingRegions = [];
fs.StandardsCertified = []
fs.StandardsAssessed = [];
fs.Compliance = {};
fs.Compliance.Overall = max(-1, $('#overallPercentage').val());
fs.Compliance.Environment = max(-1, $('#environmentPercentage').val());
fs.Compliance.Social = max(-1, $('#sociallPercentage').val());
fs.Compliance.Economic = max(-1, $('#economicPercentage').val());
fs.Compliance.Quality = max(-1, $('#qualityPercentage').val());
fs.Compliance.BusinessIntegrity = max(-1, $('#businessIntegrityPercentage').val());
var sd;
sd = $('#CompanyName').val();
if (sd && 0 < sd.length) {
fs.CompanyName = sd;
}
sd = $('#DropDownProduct').val();
if (sd && 0 < sd.length) {
sd.forEach(function (o, i) {
var p = o.split(':')[2];
if (p && 0 < p) fs.Products.push(p);
else fs.ProductCategories.push(o.split(':')[0]);
});
}
sd = $('#DropDownProducingCountry').val();
if (sd && 0 < sd.length) {
sd.forEach(function (o, i) {
var p = o.split(':')[1];
if (p && 0 < p) fs.ProducingCountries.push(p);
else fs.ProducingRegions.push(o.split(':')[0]);
});
}
sd = $('#StandardsCertifiedList').val();
if (sd && 0 < sd.length) {
sd.forEach(function (o, i) {
fs.StandardsCertified.push(o);
});
}
sd = $('#StandardsAssessedList').val();
if (sd && 0 < sd.length) {
sd.forEach(function (o, i) {
fs.StandardsAssessed.push(o);
});
}
searchReports(fs, buildResultsTable);
}
var buildResultsTable = function (d) {
var results_container = $('#ResultsTable tbody');
var standard_template = '<span class="standard" data-id="{0}" data-name="{1}" data-logolarge="{3}"><a href="marketplace.aspx#"><img src="http://search.standardsmap.org:8080/{2}" title="{1}" width="45" height="45" /></a></span>';
var row_template = '<tr class="report_result" data-id="{0}"><td class="company"><a href="marketplace.aspx#">{1}</a></td><td>{2}</td><td>{3}</td><td>{4}</td><td>{5}</td><td><a href="http://search.standardsmap.org:8080/reportfinal.aspx?report={0}">View</a></td></tr>';
var report_template = '<tr class="standard_result" data-id="{0}" id="{3}-{0}"><td colspan="6"><span class="standard_title"><img src="http://search.standardsmap.org:8080/{2}" width="90" height="90" /><h4>{1}</h4></span><span id="data-{3}-{0}"></span></td></tr>';
var company_template = '<tr class="company_result" data-id="{0}" id="{1}-{0}"><td colspan="6"><span id="company-{1}-{0}"></span></td></tr>';
results_container.empty();
if (d) {
var rpt_list = [];
d.forEach(function (r, i) {
rpt_list.push(r.ReportID);
var standards = '';
if (r.Standards) {
r.Standards.forEach(function (s, i) { standards += standard_template.format(s.Id, s.Name, s.LogoSmall, s.LogoLarge); });
}
var row = $(row_template.format(r.ReportID, r.CompanyName, r.Product, r.Country, standards, formatDate(fixJsonDate(r.Modified))));
row.find('td.company a').on('click', function (ev) {
ev.preventDefault();
var result = $(ev.currentTarget).closest('.report_result');
var cmp_row = results_container.find('#' + r.ReportID + '-' + r.CompanyID + '.company_result');
// does the row exist? if so toggle visibility
if (cmp_row.length) {
cmp_row.toggle();
}
else {
cmp_row = result.after(company_template.format(r.CompanyID, r.ReportID));
getCompanyDetails(r.CompanyID, 0, 1, function (d) {
showCompanyDetails(d, '#company-' + r.ReportID + '-' + r.CompanyID);
});
}
});
results_container.append(row);
});
results_container.find('.standard a').on('click', function (ev) {
ev.preventDefault();
var std = $(ev.currentTarget).closest('.standard');
var result = std.closest('.report_result');
var id = std.attr('data-id');
var name = std.attr('data-name');
var logo = std.attr('data-logolarge');
var rid = result.attr('data-id');
var std_row = results_container.find('#' + rid + '-' + id + '.standard_result');
// does the row exist? if so toggle visibility
if (std_row.length) {
std_row.toggle();
}
else {
var cmp_row = result.next('.company_result');
if (cmp_row.length) {
std_row = cmp_row.after(report_template.format(id, name, logo, rid));
}
else {
std_row = result.after(report_template.format(id, name, logo, rid));
}
getStandardResults(rid, id, 0, function (d) {
showStandardResults(d.Data, '#data-' + rid + '-' + id);
});
}
});
$('#ReportIDs').val(rpt_list.join(','));
}
}
var fixJsonDate = function (dt) {
var date = new Date(parseInt(dt.replace(/[^0-9 +]/g, '')));
return date;
}
var formatDate = function (d) {
var dd = d.getDate();
if ( dd < 10 ) dd = '0' + dd;
var mm = d.getMonth()+1;
if ( mm < 10 ) mm = '0' + mm;
var yy = d.getFullYear() % 100;
if ( yy < 10 ) yy = '0' + yy;
return dd+'/'+mm+'/'+yy;
}
var showCompanyDetails = function (d, el) {
var template = '<span class="standard_title"><img src="http://search.standardsmap.org:8080/{5}" width="90" height="90"><h4>{1}</h4></span><span class="company_details"><p class="lead">{2}</p><p>Products/Services: { | {
var regexp = new RegExp('\\{' + i + '\\}', 'gi');
formatted = formatted.replace(regexp, arguments[i]);
} | conditional_block |
|
marketplace.js | rid));
}
else {
std_row = result.after(report_template.format(id, name, logo, rid));
}
getStandardResults(rid, id, 0, function (d) {
showStandardResults(d.Data, '#data-' + rid + '-' + id);
});
}
});
$('#ReportIDs').val(rpt_list.join(','));
}
}
var fixJsonDate = function (dt) {
var date = new Date(parseInt(dt.replace(/[^0-9 +]/g, '')));
return date;
}
var formatDate = function (d) {
var dd = d.getDate();
if ( dd < 10 ) dd = '0' + dd;
var mm = d.getMonth()+1;
if ( mm < 10 ) mm = '0' + mm;
var yy = d.getFullYear() % 100;
if ( yy < 10 ) yy = '0' + yy;
return dd+'/'+mm+'/'+yy;
}
var showCompanyDetails = function (d, el) {
var template = '<span class="standard_title"><img src="http://search.standardsmap.org:8080/{5}" width="90" height="90"><h4>{1}</h4></span><span class="company_details"><p class="lead">{2}</p><p>Products/Services: {6}<br />Destination markets: {7}</p><p>Contact: <a href="mailto:{4}">{4}</a><br />Website: <a href="http://search.standardsmap.org:8080/{3}" target="_blank">{3}</a></p></span>{8}';
var standards = '';
var standard_template = '<span class="standard" data-id="{0}" data-name="{1}" data-logolarge="{3}"><img src="http://search.standardsmap.org:8080/{2}" title="{1}" alt="{1}" width="45" height="45" /></span>';
if (d.Standards) {
standards = '<span class="standards_certified">';
d.Standards.forEach(function (s, i) { standards += standard_template.format(s.Id, s.Name, s.LogoSmall, s.LogoLarge); });
standards += '</span>';
}
$(el).append(template.format(d.Id, d.Name, d.Description, d.Website, d.ContactEmail, d.Logo, d.Products, d.DestinationMarkets, standards));
}
var showStandardResults = function (d, el) {
//var overview_template = '<table class="table overview_table"><thead><tr><th>Overall</th><th>Environment</th><th>Social</th><th>Economic</th><th>Quality management</th><th>Ethics</th></tr></thead><tbody><tr><td>{0}</td><td>{1}</td><td>{2}</td><td>{3}</td><td>{4}</td><td>{5}</td></tr></tbody></table>';
var overview_template = '<table class="overview_table"><caption>Latest compliance assessment {6}</caption><thead><tr class="hotspot-background-colors"><th class=""><i>∑</i>Overall</th><th class="hotspot-environment "><i class="icon-sm-environment"></i> Environment</th><th class="hotspot-social "><i class="icon-sm-social"></i> Social</th><th class="hotspot-economic "><i class="icon-sm-economic"></i> Economic</th><th class="hotspot-quality-management"><i class="icon-sm-quality"></i> Quality</th><th class="hotspot-ethics"><i class="icon-sm-ethics"></i> Ethics</th></tr></thead><tfoot><tr><td colspan="6">Met: {7} Nearly: {8} Missed: {9} Total: {10}</td></tr></tfoot><tbody><tr class="hotspot-background-colors"><td>{0}%</td><td class="hotspot-environment ">{1}%</td><td class="hotspot-social ">{2}%</td><td class="hotspot-economic ">{3}%</td><td class="hotspot-quality-management">{4}%</td><td class="hotspot-ethics">{5}%</td></tr></tbody></table>';
var nd = d[d.length - 1];
var history_template = '<table class="table history_table"><thead><tr><th>Date</th><th>Overall</th><th>Environment</th><th>Social</th><th>Economic</th><th>Quality</th><th>Ethics</th></tr></thead><tbody>{0}</tbody></table>';
var history_row_template = '<tr><td>{0}</td><td>{1}</td><td>{2}</td><td>{3}</td><td>{4}</td><td>{5}</td><td>{6}</td></tr>';
var html = '';
var seriesOv = { name: 'Overall', data: [] };
var seriesEn = { name: 'Environmental', data: [] };
var seriesSc = { name: 'Social', data: [] };
var seriesEc = { name: 'Economic', data: [] };
var seriesQm = { name: 'Quality', data: [] };
var seriesEt = { name: 'Ethics', data: [] };
for (var i = d.length - 1; i > -1; --i) {
var date = fixJsonDate(d[i].DateCreated);
var datestring = formatDate(date);
var datadate = Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes());
html += history_row_template.format(datestring, d[i].Ranking, d[i].RankingEnvironmental, d[i].RankingSocial, d[i].RankingEconomic, d[i].RankingQualitymanagement, d[i].RankingEthics);
seriesOv.data.push([datadate, d[i].Ranking]);
seriesEn.data.push([datadate, d[i].RankingEnvironmental]);
seriesSc.data.push([datadate, d[i].RankingSocial]);
seriesEc.data.push([datadate, d[i].RankingEconomic]);
seriesQm.data.push([datadate, d[i].RankingQualitymanagement]);
seriesEt.data.push([datadate, d[i].RankingEthics]);
}
$(el).append(history_template.format(html));
var uid = "{0}-{1}".format(nd.StandardId, nd.UserReportId);
$(el).append('<div class="history_graph" id="graph-' + uid + '"></div>');
$(el).append(overview_template.format(
nd.Ranking.toFixed(0)
, nd.RankingEnvironmental.toFixed(0)
, nd.RankingSocial.toFixed(0)
, nd.RankingEconomic.toFixed(0)
, nd.RankingQualitymanagement.toFixed(0)
, nd.RankingEthics.toFixed(0)
, formatDate(fixJsonDate(nd.DateCreated))
, nd.NumberPass
, nd.NumberAlmost
, nd.NumberFail
, nd.NumberPass + nd.NumberAlmost + nd.NumberFail
));
$('#graph-' + uid).highcharts({
chart: {
zoomType: 'x',
type: 'line'
},
colors : [
'#36A7E9',
'#95a644',
'#636363',
'#172944',
'#C1413B',
'#8F0063',
'#424884',
'#789C3C',
'#5695AF'
],
title: {
text: 'Compliance history'
}/*,
subtitle: {
text: 'Progress over time'
}*/,
xAxis: {
type: 'datetime',
dateTimeLabelFormats: {
second: '%Y-%m-%d',
minute: '%Y-%m-%d',
hour: '%Y-%m-%d',
day: '%Y %m-%d',
week: '%Y %m-%d',
month: '%Y-%m',
year: '%Y'
}/*,
title: {
text: 'Date'
}*/
},
yAxis: {
title: {
text: 'Compliance (%)'
},
min: 0,
max: 100
},
tooltip: {
headerFormat: '<b>{series.name}</b><br>',
pointFormat: '{point.x:%e. %b}: {point.y:.0f} %'
},
series: [seriesOv,seriesEn,seriesSc,seriesEc,seriesQm,seriesEt]
});
}
$(function () {
$.getJSON('http://www.highcharts.com/samples/data/jsonp.php?filename=world-population-history.csv&callback=?', function (csv) {
// Parse the CSV Data
/*Highcharts.data({
csv: data,
switchRowsAndColumns: true,
parsed: function () {
console.log(this.columns);
}
});*/
// Very simple and case-specific CSV string splitting
function CSVtoArray(text) {
| return text.replace(/^"/, '')
.replace(/",$/, '')
.split('","');
};
| identifier_body |
|
marketplace.js | type: 'POST'
});
}
var getCompanyDetails = function (companyId, profileId, languageId, callback) {
$.ajax({
url: './handlers/MarketplaceCompanyDetailsHandler.ashx',
data: { company: companyId, profile: profileId, language: languageId },
success: function (d) {
if (callback) callback(d);
},
dataType: 'json',
type: 'POST'
});
}
$(function () {
$('.form-group select').selectize({ clearOnOpen: true }).on('change', filterSearch);
$('#CompanyName').on('change', filterSearch);
$('#Filters input.percentslider')
.slider({tooltip: 'show',selection: 'after', orientation: 'horizontal', step: 5, min: -1, max: 100, value: -1})
.on('slide', function(ev){ $(ev.currentTarget).closest('.percentageFilter').find('span.percentage').text(-1 < ev.value ? ev.value + '%' : 'na');})
.on('slideStop', filterSearch)
.closest('.percentageFilter')
.append('<span class="percentage">na</span>');
filterSearch();
});
function max(a, b)
{
if (!a || !isNumber(a)) return b;
if (!b || !isNumber(b)) return a;
return Math.max(a, b);
}
function isNumber(n) {
return !isNaN(parseFloat(n)) && isFinite(n);
}
function filterSearch() {
var fs = {};
fs.CompanyName = '';
fs.Products = [];
fs.ProductCategories = []
fs.ProducingCountries = [];
fs.ProducingRegions = [];
fs.StandardsCertified = []
fs.StandardsAssessed = [];
fs.Compliance = {};
fs.Compliance.Overall = max(-1, $('#overallPercentage').val());
fs.Compliance.Environment = max(-1, $('#environmentPercentage').val());
fs.Compliance.Social = max(-1, $('#sociallPercentage').val());
fs.Compliance.Economic = max(-1, $('#economicPercentage').val());
fs.Compliance.Quality = max(-1, $('#qualityPercentage').val());
fs.Compliance.BusinessIntegrity = max(-1, $('#businessIntegrityPercentage').val());
var sd;
sd = $('#CompanyName').val();
if (sd && 0 < sd.length) {
fs.CompanyName = sd;
}
sd = $('#DropDownProduct').val();
if (sd && 0 < sd.length) {
sd.forEach(function (o, i) {
var p = o.split(':')[2];
if (p && 0 < p) fs.Products.push(p);
else fs.ProductCategories.push(o.split(':')[0]);
});
}
sd = $('#DropDownProducingCountry').val();
if (sd && 0 < sd.length) {
sd.forEach(function (o, i) {
var p = o.split(':')[1];
if (p && 0 < p) fs.ProducingCountries.push(p);
else fs.ProducingRegions.push(o.split(':')[0]);
});
}
sd = $('#StandardsCertifiedList').val();
if (sd && 0 < sd.length) {
sd.forEach(function (o, i) {
fs.StandardsCertified.push(o);
});
}
sd = $('#StandardsAssessedList').val();
if (sd && 0 < sd.length) {
sd.forEach(function (o, i) {
fs.StandardsAssessed.push(o);
});
}
searchReports(fs, buildResultsTable);
}
var buildResultsTable = function (d) {
var results_container = $('#ResultsTable tbody');
var standard_template = '<span class="standard" data-id="{0}" data-name="{1}" data-logolarge="{3}"><a href="marketplace.aspx#"><img src="http://search.standardsmap.org:8080/{2}" title="{1}" width="45" height="45" /></a></span>';
var row_template = '<tr class="report_result" data-id="{0}"><td class="company"><a href="marketplace.aspx#">{1}</a></td><td>{2}</td><td>{3}</td><td>{4}</td><td>{5}</td><td><a href="http://search.standardsmap.org:8080/reportfinal.aspx?report={0}">View</a></td></tr>';
var report_template = '<tr class="standard_result" data-id="{0}" id="{3}-{0}"><td colspan="6"><span class="standard_title"><img src="http://search.standardsmap.org:8080/{2}" width="90" height="90" /><h4>{1}</h4></span><span id="data-{3}-{0}"></span></td></tr>';
var company_template = '<tr class="company_result" data-id="{0}" id="{1}-{0}"><td colspan="6"><span id="company-{1}-{0}"></span></td></tr>';
results_container.empty();
if (d) {
var rpt_list = [];
d.forEach(function (r, i) {
rpt_list.push(r.ReportID);
var standards = '';
if (r.Standards) {
r.Standards.forEach(function (s, i) { standards += standard_template.format(s.Id, s.Name, s.LogoSmall, s.LogoLarge); });
}
var row = $(row_template.format(r.ReportID, r.CompanyName, r.Product, r.Country, standards, formatDate(fixJsonDate(r.Modified))));
row.find('td.company a').on('click', function (ev) {
ev.preventDefault();
var result = $(ev.currentTarget).closest('.report_result');
var cmp_row = results_container.find('#' + r.ReportID + '-' + r.CompanyID + '.company_result');
// does the row exist? if so toggle visibility
if (cmp_row.length) {
cmp_row.toggle();
}
else {
cmp_row = result.after(company_template.format(r.CompanyID, r.ReportID));
getCompanyDetails(r.CompanyID, 0, 1, function (d) {
showCompanyDetails(d, '#company-' + r.ReportID + '-' + r.CompanyID);
});
}
});
results_container.append(row);
});
results_container.find('.standard a').on('click', function (ev) {
ev.preventDefault();
var std = $(ev.currentTarget).closest('.standard');
var result = std.closest('.report_result');
var id = std.attr('data-id');
var name = std.attr('data-name');
var logo = std.attr('data-logolarge');
var rid = result.attr('data-id');
var std_row = results_container.find('#' + rid + '-' + id + '.standard_result');
// does the row exist? if so toggle visibility
if (std_row.length) {
std_row.toggle();
}
else {
var cmp_row = result.next('.company_result');
if (cmp_row.length) {
std_row = cmp_row.after(report_template.format(id, name, logo, rid));
}
else {
std_row = result.after(report_template.format(id, name, logo, rid));
}
getStandardResults(rid, id, 0, function (d) {
showStandardResults(d.Data, '#data-' + rid + '-' + id);
});
}
});
$('#ReportIDs').val(rpt_list.join(','));
}
}
var fixJsonDate = function (dt) {
var date = new Date(parseInt(dt.replace(/[^0-9 +]/g, '')));
return date;
}
var formatDate = function (d) {
var dd = d.getDate();
if ( dd < 10 ) dd = '0' + dd;
var mm = d.getMonth()+1;
if ( mm < 10 ) mm = '0' + mm;
var yy = d.getFullYear() % 100;
if ( yy < 10 ) yy = '0' + yy;
return dd+'/'+mm+'/'+yy;
}
var showCompanyDetails = function (d, el) {
var template = '<span class="standard_title"><img src="http://search.standardsmap.org:8080/{5}" width="90" height="90"><h4>{1}</h4></span><span class="company_details"><p class="lead">{2}</p><p>Products/Services: {6}<br />Destination markets: {7}</p><p>Contact: <a href="mailto:{4}">{4}</a><br />Website: <a href="http://search.standardsmap.org:8080/{3}" target="_blank">{3}</a></p></span>{8}';
var standards = '';
var standard_template = '<span class="standard" data-id="{0}" data-name="{1}" data-logolarge="{3}"><img src="http://search.standardsmap.org:8080/{2}" title="{1}" alt="{1}" width="45" height="45" /></span>';
if (d.Standards) {
standards = '<span class="stand | data: { report: reportId, standard: standardId, profile: profileId },
success: function (d) {
if (callback) callback(d);
},
dataType: 'json', | random_line_split |
|
copy.go | - If the root node is a manifest list, it will be mapped to the first
// matching manifest if exists, otherwise ErrNotFound will be returned.
// - Otherwise ErrUnsupported will be returned.
func (opts *CopyOptions) WithTargetPlatform(p *ocispec.Platform) {
if p == nil {
return
}
mapRoot := opts.MapRoot
opts.MapRoot = func(ctx context.Context, src content.ReadOnlyStorage, root ocispec.Descriptor) (desc ocispec.Descriptor, err error) {
if mapRoot != nil {
if root, err = mapRoot(ctx, src, root); err != nil {
return ocispec.Descriptor{}, err
}
}
return platform.SelectManifest(ctx, src, root, p)
}
}
// defaultCopyMaxMetadataBytes is the default value of
// CopyGraphOptions.MaxMetadataBytes.
const defaultCopyMaxMetadataBytes int64 = 4 * 1024 * 1024 // 4 MiB
// DefaultCopyGraphOptions provides the default CopyGraphOptions.
var DefaultCopyGraphOptions CopyGraphOptions
// CopyGraphOptions contains parameters for [oras.CopyGraph].
type CopyGraphOptions struct {
// Concurrency limits the maximum number of concurrent copy tasks.
// If less than or equal to 0, a default (currently 3) is used.
Concurrency int
// MaxMetadataBytes limits the maximum size of the metadata that can be
// cached in the memory.
// If less than or equal to 0, a default (currently 4 MiB) is used.
MaxMetadataBytes int64
// PreCopy handles the current descriptor before copying it.
PreCopy func(ctx context.Context, desc ocispec.Descriptor) error
// PostCopy handles the current descriptor after copying it.
PostCopy func(ctx context.Context, desc ocispec.Descriptor) error
// OnCopySkipped will be called when the sub-DAG rooted by the current node
// is skipped.
OnCopySkipped func(ctx context.Context, desc ocispec.Descriptor) error
// FindSuccessors finds the successors of the current node.
// fetcher provides cached access to the source storage, and is suitable
// for fetching non-leaf nodes like manifests. Since anything fetched from
// fetcher will be cached in the memory, it is recommended to use original
// source storage to fetch large blobs.
// If FindSuccessors is nil, content.Successors will be used.
FindSuccessors func(ctx context.Context, fetcher content.Fetcher, desc ocispec.Descriptor) ([]ocispec.Descriptor, error)
}
// Copy copies a rooted directed acyclic graph (DAG) with the tagged root node
// in the source Target to the destination Target.
// The destination reference will be the same as the source reference if the
// destination reference is left blank.
//
// Returns the descriptor of the root node on successful copy.
func Copy(ctx context.Context, src ReadOnlyTarget, srcRef string, dst Target, dstRef string, opts CopyOptions) (ocispec.Descriptor, error) {
if src == nil {
return ocispec.Descriptor{}, errors.New("nil source target")
}
if dst == nil {
return ocispec.Descriptor{}, errors.New("nil destination target")
}
if dstRef == "" {
dstRef = srcRef
}
// use caching proxy on non-leaf nodes
if opts.MaxMetadataBytes <= 0 {
opts.MaxMetadataBytes = defaultCopyMaxMetadataBytes
}
proxy := cas.NewProxyWithLimit(src, cas.NewMemory(), opts.MaxMetadataBytes)
root, err := resolveRoot(ctx, src, srcRef, proxy)
if err != nil {
return ocispec.Descriptor{}, fmt.Errorf("failed to resolve %s: %w", srcRef, err)
}
if opts.MapRoot != nil {
proxy.StopCaching = true
root, err = opts.MapRoot(ctx, proxy, root)
if err != nil {
return ocispec.Descriptor{}, err
}
proxy.StopCaching = false
}
if err := prepareCopy(ctx, dst, dstRef, proxy, root, &opts); err != nil {
return ocispec.Descriptor{}, err
}
if err := copyGraph(ctx, src, dst, root, proxy, nil, nil, opts.CopyGraphOptions); err != nil {
return ocispec.Descriptor{}, err
}
return root, nil
}
// CopyGraph copies a rooted directed acyclic graph (DAG) from the source CAS to
// the destination CAS.
func CopyGraph(ctx context.Context, src content.ReadOnlyStorage, dst content.Storage, root ocispec.Descriptor, opts CopyGraphOptions) error {
return copyGraph(ctx, src, dst, root, nil, nil, nil, opts)
}
// copyGraph copies a rooted directed acyclic graph (DAG) from the source CAS to
// the destination CAS with specified caching, concurrency limiter and tracker.
func copyGraph(ctx context.Context, src content.ReadOnlyStorage, dst content.Storage, root ocispec.Descriptor,
proxy *cas.Proxy, limiter *semaphore.Weighted, tracker *status.Tracker, opts CopyGraphOptions) error {
if proxy == nil {
// use caching proxy on non-leaf nodes
if opts.MaxMetadataBytes <= 0 {
opts.MaxMetadataBytes = defaultCopyMaxMetadataBytes
}
proxy = cas.NewProxyWithLimit(src, cas.NewMemory(), opts.MaxMetadataBytes)
}
if limiter == nil {
// if Concurrency is not set or invalid, use the default concurrency
if opts.Concurrency <= 0 {
opts.Concurrency = defaultConcurrency
}
limiter = semaphore.NewWeighted(int64(opts.Concurrency))
}
if tracker == nil {
// track content status
tracker = status.NewTracker()
}
// if FindSuccessors is not provided, use the default one
if opts.FindSuccessors == nil {
opts.FindSuccessors = content.Successors
}
// traverse the graph
var fn syncutil.GoFunc[ocispec.Descriptor]
fn = func(ctx context.Context, region *syncutil.LimitedRegion, desc ocispec.Descriptor) (err error) {
// skip the descriptor if other go routine is working on it
done, committed := tracker.TryCommit(desc)
if !committed {
return nil
}
defer func() {
if err == nil {
// mark the content as done on success
close(done)
}
}()
// skip if a rooted sub-DAG exists
exists, err := dst.Exists(ctx, desc)
if err != nil {
return err
}
if exists {
if opts.OnCopySkipped != nil {
if err := opts.OnCopySkipped(ctx, desc); err != nil {
return err
}
}
return nil
}
// find successors while non-leaf nodes will be fetched and cached
successors, err := opts.FindSuccessors(ctx, proxy, desc)
if err != nil {
return err
}
successors = removeForeignLayers(successors)
if len(successors) != 0 {
// for non-leaf nodes, process successors and wait for them to complete
region.End()
if err := syncutil.Go(ctx, limiter, fn, successors...); err != nil {
return err
}
for _, node := range successors {
done, committed := tracker.TryCommit(node)
if committed {
return fmt.Errorf("%s: %s: successor not committed", desc.Digest, node.Digest)
}
select {
case <-done:
case <-ctx.Done():
return ctx.Err()
}
}
if err := region.Start(); err != nil {
return err
}
}
exists, err = proxy.Cache.Exists(ctx, desc)
if err != nil {
return err
}
if exists {
return copyNode(ctx, proxy.Cache, dst, desc, opts)
}
return copyNode(ctx, src, dst, desc, opts)
}
return syncutil.Go(ctx, limiter, fn, root)
}
// doCopyNode copies a single content from the source CAS to the destination CAS.
func doCopyNode(ctx context.Context, src content.ReadOnlyStorage, dst content.Storage, desc ocispec.Descriptor) error {
rc, err := src.Fetch(ctx, desc)
if err != nil {
return err
}
defer rc.Close()
err = dst.Push(ctx, desc, rc)
if err != nil && !errors.Is(err, errdef.ErrAlreadyExists) {
return err
}
return nil
}
// copyNode copies a single content from the source CAS to the destination CAS,
// and apply the given options.
func copyNode(ctx context.Context, src content.ReadOnlyStorage, dst content.Storage, desc ocispec.Descriptor, opts CopyGraphOptions) error | {
if opts.PreCopy != nil {
if err := opts.PreCopy(ctx, desc); err != nil {
if err == errSkipDesc {
return nil
}
return err
}
}
if err := doCopyNode(ctx, src, dst, desc); err != nil {
return err
}
if opts.PostCopy != nil {
return opts.PostCopy(ctx, desc)
}
return nil
} | identifier_body |
|
copy.go | , error)
}
// WithTargetPlatform configures opts.MapRoot to select the manifest whose
// platform matches the given platform. When MapRoot is provided, the platform
// selection will be applied on the mapped root node.
// - If the given platform is nil, no platform selection will be applied.
// - If the root node is a manifest, it will remain the same if platform
// matches, otherwise ErrNotFound will be returned.
// - If the root node is a manifest list, it will be mapped to the first
// matching manifest if exists, otherwise ErrNotFound will be returned.
// - Otherwise ErrUnsupported will be returned.
func (opts *CopyOptions) WithTargetPlatform(p *ocispec.Platform) {
if p == nil {
return
}
mapRoot := opts.MapRoot
opts.MapRoot = func(ctx context.Context, src content.ReadOnlyStorage, root ocispec.Descriptor) (desc ocispec.Descriptor, err error) {
if mapRoot != nil {
if root, err = mapRoot(ctx, src, root); err != nil {
return ocispec.Descriptor{}, err
}
}
return platform.SelectManifest(ctx, src, root, p)
}
}
// defaultCopyMaxMetadataBytes is the default value of
// CopyGraphOptions.MaxMetadataBytes.
const defaultCopyMaxMetadataBytes int64 = 4 * 1024 * 1024 // 4 MiB
// DefaultCopyGraphOptions provides the default CopyGraphOptions.
var DefaultCopyGraphOptions CopyGraphOptions
// CopyGraphOptions contains parameters for [oras.CopyGraph].
type CopyGraphOptions struct {
// Concurrency limits the maximum number of concurrent copy tasks.
// If less than or equal to 0, a default (currently 3) is used.
Concurrency int
// MaxMetadataBytes limits the maximum size of the metadata that can be
// cached in the memory.
// If less than or equal to 0, a default (currently 4 MiB) is used.
MaxMetadataBytes int64
// PreCopy handles the current descriptor before copying it.
PreCopy func(ctx context.Context, desc ocispec.Descriptor) error
// PostCopy handles the current descriptor after copying it.
PostCopy func(ctx context.Context, desc ocispec.Descriptor) error
// OnCopySkipped will be called when the sub-DAG rooted by the current node
// is skipped.
OnCopySkipped func(ctx context.Context, desc ocispec.Descriptor) error
// FindSuccessors finds the successors of the current node.
// fetcher provides cached access to the source storage, and is suitable
// for fetching non-leaf nodes like manifests. Since anything fetched from
// fetcher will be cached in the memory, it is recommended to use original
// source storage to fetch large blobs.
// If FindSuccessors is nil, content.Successors will be used.
FindSuccessors func(ctx context.Context, fetcher content.Fetcher, desc ocispec.Descriptor) ([]ocispec.Descriptor, error)
}
// Copy copies a rooted directed acyclic graph (DAG) with the tagged root node
// in the source Target to the destination Target.
// The destination reference will be the same as the source reference if the
// destination reference is left blank.
//
// Returns the descriptor of the root node on successful copy.
func Copy(ctx context.Context, src ReadOnlyTarget, srcRef string, dst Target, dstRef string, opts CopyOptions) (ocispec.Descriptor, error) {
if src == nil {
return ocispec.Descriptor{}, errors.New("nil source target")
}
if dst == nil {
return ocispec.Descriptor{}, errors.New("nil destination target")
}
if dstRef == "" {
dstRef = srcRef
}
// use caching proxy on non-leaf nodes
if opts.MaxMetadataBytes <= 0 {
opts.MaxMetadataBytes = defaultCopyMaxMetadataBytes
}
proxy := cas.NewProxyWithLimit(src, cas.NewMemory(), opts.MaxMetadataBytes)
root, err := resolveRoot(ctx, src, srcRef, proxy)
if err != nil {
return ocispec.Descriptor{}, fmt.Errorf("failed to resolve %s: %w", srcRef, err)
}
if opts.MapRoot != nil {
proxy.StopCaching = true
root, err = opts.MapRoot(ctx, proxy, root)
if err != nil {
return ocispec.Descriptor{}, err
}
proxy.StopCaching = false
}
if err := prepareCopy(ctx, dst, dstRef, proxy, root, &opts); err != nil {
return ocispec.Descriptor{}, err
}
if err := copyGraph(ctx, src, dst, root, proxy, nil, nil, opts.CopyGraphOptions); err != nil {
return ocispec.Descriptor{}, err
}
return root, nil
}
// CopyGraph copies a rooted directed acyclic graph (DAG) from the source CAS to
// the destination CAS.
func CopyGraph(ctx context.Context, src content.ReadOnlyStorage, dst content.Storage, root ocispec.Descriptor, opts CopyGraphOptions) error {
return copyGraph(ctx, src, dst, root, nil, nil, nil, opts)
}
// copyGraph copies a rooted directed acyclic graph (DAG) from the source CAS to
// the destination CAS with specified caching, concurrency limiter and tracker.
func copyGraph(ctx context.Context, src content.ReadOnlyStorage, dst content.Storage, root ocispec.Descriptor,
proxy *cas.Proxy, limiter *semaphore.Weighted, tracker *status.Tracker, opts CopyGraphOptions) error {
if proxy == nil {
// use caching proxy on non-leaf nodes
if opts.MaxMetadataBytes <= 0 {
opts.MaxMetadataBytes = defaultCopyMaxMetadataBytes
}
proxy = cas.NewProxyWithLimit(src, cas.NewMemory(), opts.MaxMetadataBytes)
}
if limiter == nil {
// if Concurrency is not set or invalid, use the default concurrency
if opts.Concurrency <= 0 {
opts.Concurrency = defaultConcurrency
}
limiter = semaphore.NewWeighted(int64(opts.Concurrency))
}
if tracker == nil {
// track content status
tracker = status.NewTracker()
}
// if FindSuccessors is not provided, use the default one
if opts.FindSuccessors == nil {
opts.FindSuccessors = content.Successors
}
// traverse the graph
var fn syncutil.GoFunc[ocispec.Descriptor]
fn = func(ctx context.Context, region *syncutil.LimitedRegion, desc ocispec.Descriptor) (err error) {
// skip the descriptor if other go routine is working on it
done, committed := tracker.TryCommit(desc)
if !committed {
return nil
}
defer func() {
if err == nil {
// mark the content as done on success
close(done)
}
}()
// skip if a rooted sub-DAG exists
exists, err := dst.Exists(ctx, desc)
if err != nil {
return err
}
if exists {
if opts.OnCopySkipped != nil {
if err := opts.OnCopySkipped(ctx, desc); err != nil {
return err
}
}
return nil
}
// find successors while non-leaf nodes will be fetched and cached
successors, err := opts.FindSuccessors(ctx, proxy, desc)
if err != nil {
return err
}
successors = removeForeignLayers(successors)
if len(successors) != 0 {
// for non-leaf nodes, process successors and wait for them to complete
region.End()
if err := syncutil.Go(ctx, limiter, fn, successors...); err != nil {
return err
}
for _, node := range successors {
done, committed := tracker.TryCommit(node)
if committed {
return fmt.Errorf("%s: %s: successor not committed", desc.Digest, node.Digest)
}
select {
case <-done:
case <-ctx.Done():
return ctx.Err()
}
}
if err := region.Start(); err != nil {
return err
}
}
exists, err = proxy.Cache.Exists(ctx, desc)
if err != nil {
return err
}
if exists {
return copyNode(ctx, proxy.Cache, dst, desc, opts)
}
return copyNode(ctx, src, dst, desc, opts)
}
return syncutil.Go(ctx, limiter, fn, root)
}
// doCopyNode copies a single content from the source CAS to the destination CAS.
func | (ctx context.Context, src content.ReadOnlyStorage, dst content.Storage, desc ocispec.Descriptor) error {
rc, err := src.Fetch(ctx, desc)
if err != nil {
return err
}
defer rc.Close()
err = dst.Push(ctx, desc, rc)
if err != nil && !errors.Is(err, errdef.ErrAlreadyExists) {
return err
}
return nil
}
// copyNode copies a single content from the source CAS to the destination CAS,
// and apply the given options.
func copyNode(ctx context.Context, src content.ReadOnlyStorage, dst content.Storage, desc ocispec.Descriptor, opts CopyGraphOptions) | doCopyNode | identifier_name |
copy.go | error)
}
// WithTargetPlatform configures opts.MapRoot to select the manifest whose
// platform matches the given platform. When MapRoot is provided, the platform
// selection will be applied on the mapped root node.
// - If the given platform is nil, no platform selection will be applied.
// - If the root node is a manifest, it will remain the same if platform
// matches, otherwise ErrNotFound will be returned.
// - If the root node is a manifest list, it will be mapped to the first
// matching manifest if exists, otherwise ErrNotFound will be returned.
// - Otherwise ErrUnsupported will be returned.
func (opts *CopyOptions) WithTargetPlatform(p *ocispec.Platform) {
if p == nil {
return
}
mapRoot := opts.MapRoot
opts.MapRoot = func(ctx context.Context, src content.ReadOnlyStorage, root ocispec.Descriptor) (desc ocispec.Descriptor, err error) {
if mapRoot != nil {
if root, err = mapRoot(ctx, src, root); err != nil {
return ocispec.Descriptor{}, err
}
}
return platform.SelectManifest(ctx, src, root, p)
}
}
// defaultCopyMaxMetadataBytes is the default value of
// CopyGraphOptions.MaxMetadataBytes.
const defaultCopyMaxMetadataBytes int64 = 4 * 1024 * 1024 // 4 MiB
// DefaultCopyGraphOptions provides the default CopyGraphOptions.
var DefaultCopyGraphOptions CopyGraphOptions
// CopyGraphOptions contains parameters for [oras.CopyGraph].
type CopyGraphOptions struct {
// Concurrency limits the maximum number of concurrent copy tasks.
// If less than or equal to 0, a default (currently 3) is used.
Concurrency int
// MaxMetadataBytes limits the maximum size of the metadata that can be
// cached in the memory.
// If less than or equal to 0, a default (currently 4 MiB) is used.
MaxMetadataBytes int64
// PreCopy handles the current descriptor before copying it.
PreCopy func(ctx context.Context, desc ocispec.Descriptor) error
// PostCopy handles the current descriptor after copying it.
PostCopy func(ctx context.Context, desc ocispec.Descriptor) error
// OnCopySkipped will be called when the sub-DAG rooted by the current node
// is skipped.
OnCopySkipped func(ctx context.Context, desc ocispec.Descriptor) error
// FindSuccessors finds the successors of the current node.
// fetcher provides cached access to the source storage, and is suitable
// for fetching non-leaf nodes like manifests. Since anything fetched from
// fetcher will be cached in the memory, it is recommended to use original
// source storage to fetch large blobs.
// If FindSuccessors is nil, content.Successors will be used.
FindSuccessors func(ctx context.Context, fetcher content.Fetcher, desc ocispec.Descriptor) ([]ocispec.Descriptor, error)
}
// Copy copies a rooted directed acyclic graph (DAG) with the tagged root node
// in the source Target to the destination Target.
// The destination reference will be the same as the source reference if the
// destination reference is left blank.
//
// Returns the descriptor of the root node on successful copy.
func Copy(ctx context.Context, src ReadOnlyTarget, srcRef string, dst Target, dstRef string, opts CopyOptions) (ocispec.Descriptor, error) {
if src == nil {
return ocispec.Descriptor{}, errors.New("nil source target")
}
if dst == nil {
return ocispec.Descriptor{}, errors.New("nil destination target")
}
if dstRef == "" {
dstRef = srcRef
}
// use caching proxy on non-leaf nodes
if opts.MaxMetadataBytes <= 0 {
opts.MaxMetadataBytes = defaultCopyMaxMetadataBytes
}
proxy := cas.NewProxyWithLimit(src, cas.NewMemory(), opts.MaxMetadataBytes)
root, err := resolveRoot(ctx, src, srcRef, proxy)
if err != nil {
return ocispec.Descriptor{}, fmt.Errorf("failed to resolve %s: %w", srcRef, err)
}
if opts.MapRoot != nil {
proxy.StopCaching = true
root, err = opts.MapRoot(ctx, proxy, root)
if err != nil {
return ocispec.Descriptor{}, err
}
proxy.StopCaching = false
}
if err := prepareCopy(ctx, dst, dstRef, proxy, root, &opts); err != nil {
return ocispec.Descriptor{}, err
}
if err := copyGraph(ctx, src, dst, root, proxy, nil, nil, opts.CopyGraphOptions); err != nil {
return ocispec.Descriptor{}, err
}
return root, nil
}
// CopyGraph copies a rooted directed acyclic graph (DAG) from the source CAS to
// the destination CAS.
func CopyGraph(ctx context.Context, src content.ReadOnlyStorage, dst content.Storage, root ocispec.Descriptor, opts CopyGraphOptions) error {
return copyGraph(ctx, src, dst, root, nil, nil, nil, opts)
}
// copyGraph copies a rooted directed acyclic graph (DAG) from the source CAS to
// the destination CAS with specified caching, concurrency limiter and tracker.
func copyGraph(ctx context.Context, src content.ReadOnlyStorage, dst content.Storage, root ocispec.Descriptor,
proxy *cas.Proxy, limiter *semaphore.Weighted, tracker *status.Tracker, opts CopyGraphOptions) error {
if proxy == nil {
// use caching proxy on non-leaf nodes
if opts.MaxMetadataBytes <= 0 {
opts.MaxMetadataBytes = defaultCopyMaxMetadataBytes
}
proxy = cas.NewProxyWithLimit(src, cas.NewMemory(), opts.MaxMetadataBytes)
}
if limiter == nil {
// if Concurrency is not set or invalid, use the default concurrency
if opts.Concurrency <= 0 {
opts.Concurrency = defaultConcurrency
}
limiter = semaphore.NewWeighted(int64(opts.Concurrency))
}
if tracker == nil {
// track content status
tracker = status.NewTracker()
}
// if FindSuccessors is not provided, use the default one
if opts.FindSuccessors == nil {
opts.FindSuccessors = content.Successors
}
// traverse the graph
var fn syncutil.GoFunc[ocispec.Descriptor]
fn = func(ctx context.Context, region *syncutil.LimitedRegion, desc ocispec.Descriptor) (err error) {
// skip the descriptor if other go routine is working on it
done, committed := tracker.TryCommit(desc)
if !committed {
return nil
}
defer func() {
if err == nil {
// mark the content as done on success
close(done)
}
}()
// skip if a rooted sub-DAG exists
exists, err := dst.Exists(ctx, desc)
if err != nil {
return err
}
if exists {
if opts.OnCopySkipped != nil {
if err := opts.OnCopySkipped(ctx, desc); err != nil |
}
return nil
}
// find successors while non-leaf nodes will be fetched and cached
successors, err := opts.FindSuccessors(ctx, proxy, desc)
if err != nil {
return err
}
successors = removeForeignLayers(successors)
if len(successors) != 0 {
// for non-leaf nodes, process successors and wait for them to complete
region.End()
if err := syncutil.Go(ctx, limiter, fn, successors...); err != nil {
return err
}
for _, node := range successors {
done, committed := tracker.TryCommit(node)
if committed {
return fmt.Errorf("%s: %s: successor not committed", desc.Digest, node.Digest)
}
select {
case <-done:
case <-ctx.Done():
return ctx.Err()
}
}
if err := region.Start(); err != nil {
return err
}
}
exists, err = proxy.Cache.Exists(ctx, desc)
if err != nil {
return err
}
if exists {
return copyNode(ctx, proxy.Cache, dst, desc, opts)
}
return copyNode(ctx, src, dst, desc, opts)
}
return syncutil.Go(ctx, limiter, fn, root)
}
// doCopyNode copies a single content from the source CAS to the destination CAS.
func doCopyNode(ctx context.Context, src content.ReadOnlyStorage, dst content.Storage, desc ocispec.Descriptor) error {
rc, err := src.Fetch(ctx, desc)
if err != nil {
return err
}
defer rc.Close()
err = dst.Push(ctx, desc, rc)
if err != nil && !errors.Is(err, errdef.ErrAlreadyExists) {
return err
}
return nil
}
// copyNode copies a single content from the source CAS to the destination CAS,
// and apply the given options.
func copyNode(ctx context.Context, src content.ReadOnlyStorage, dst content.Storage, desc ocispec.Descriptor, opts CopyGraphOptions) | {
return err
} | conditional_block |
copy.go | // reference will be passed to MapRoot, and the mapped descriptor will be
// used as the root node for copy.
MapRoot func(ctx context.Context, src content.ReadOnlyStorage, root ocispec.Descriptor) (ocispec.Descriptor, error)
}
// WithTargetPlatform configures opts.MapRoot to select the manifest whose
// platform matches the given platform. When MapRoot is provided, the platform
// selection will be applied on the mapped root node.
// - If the given platform is nil, no platform selection will be applied.
// - If the root node is a manifest, it will remain the same if platform
// matches, otherwise ErrNotFound will be returned.
// - If the root node is a manifest list, it will be mapped to the first
// matching manifest if exists, otherwise ErrNotFound will be returned.
// - Otherwise ErrUnsupported will be returned.
func (opts *CopyOptions) WithTargetPlatform(p *ocispec.Platform) {
if p == nil {
return
}
mapRoot := opts.MapRoot
opts.MapRoot = func(ctx context.Context, src content.ReadOnlyStorage, root ocispec.Descriptor) (desc ocispec.Descriptor, err error) {
if mapRoot != nil {
if root, err = mapRoot(ctx, src, root); err != nil {
return ocispec.Descriptor{}, err
}
}
return platform.SelectManifest(ctx, src, root, p)
}
}
// defaultCopyMaxMetadataBytes is the default value of
// CopyGraphOptions.MaxMetadataBytes.
const defaultCopyMaxMetadataBytes int64 = 4 * 1024 * 1024 // 4 MiB
// DefaultCopyGraphOptions provides the default CopyGraphOptions.
var DefaultCopyGraphOptions CopyGraphOptions
// CopyGraphOptions contains parameters for [oras.CopyGraph].
type CopyGraphOptions struct {
// Concurrency limits the maximum number of concurrent copy tasks.
// If less than or equal to 0, a default (currently 3) is used.
Concurrency int
// MaxMetadataBytes limits the maximum size of the metadata that can be
// cached in the memory.
// If less than or equal to 0, a default (currently 4 MiB) is used.
MaxMetadataBytes int64
// PreCopy handles the current descriptor before copying it.
PreCopy func(ctx context.Context, desc ocispec.Descriptor) error
// PostCopy handles the current descriptor after copying it.
PostCopy func(ctx context.Context, desc ocispec.Descriptor) error
// OnCopySkipped will be called when the sub-DAG rooted by the current node
// is skipped.
OnCopySkipped func(ctx context.Context, desc ocispec.Descriptor) error
// FindSuccessors finds the successors of the current node.
// fetcher provides cached access to the source storage, and is suitable
// for fetching non-leaf nodes like manifests. Since anything fetched from
// fetcher will be cached in the memory, it is recommended to use original
// source storage to fetch large blobs.
// If FindSuccessors is nil, content.Successors will be used.
FindSuccessors func(ctx context.Context, fetcher content.Fetcher, desc ocispec.Descriptor) ([]ocispec.Descriptor, error)
}
// Copy copies a rooted directed acyclic graph (DAG) with the tagged root node
// in the source Target to the destination Target.
// The destination reference will be the same as the source reference if the
// destination reference is left blank.
//
// Returns the descriptor of the root node on successful copy.
func Copy(ctx context.Context, src ReadOnlyTarget, srcRef string, dst Target, dstRef string, opts CopyOptions) (ocispec.Descriptor, error) {
if src == nil {
return ocispec.Descriptor{}, errors.New("nil source target")
}
if dst == nil {
return ocispec.Descriptor{}, errors.New("nil destination target")
}
if dstRef == "" {
dstRef = srcRef
}
// use caching proxy on non-leaf nodes
if opts.MaxMetadataBytes <= 0 {
opts.MaxMetadataBytes = defaultCopyMaxMetadataBytes
}
proxy := cas.NewProxyWithLimit(src, cas.NewMemory(), opts.MaxMetadataBytes)
root, err := resolveRoot(ctx, src, srcRef, proxy)
if err != nil {
return ocispec.Descriptor{}, fmt.Errorf("failed to resolve %s: %w", srcRef, err)
}
if opts.MapRoot != nil {
proxy.StopCaching = true
root, err = opts.MapRoot(ctx, proxy, root)
if err != nil {
return ocispec.Descriptor{}, err
}
proxy.StopCaching = false
}
if err := prepareCopy(ctx, dst, dstRef, proxy, root, &opts); err != nil {
return ocispec.Descriptor{}, err
}
if err := copyGraph(ctx, src, dst, root, proxy, nil, nil, opts.CopyGraphOptions); err != nil {
return ocispec.Descriptor{}, err
}
return root, nil
}
// CopyGraph copies a rooted directed acyclic graph (DAG) from the source CAS to
// the destination CAS.
func CopyGraph(ctx context.Context, src content.ReadOnlyStorage, dst content.Storage, root ocispec.Descriptor, opts CopyGraphOptions) error {
return copyGraph(ctx, src, dst, root, nil, nil, nil, opts)
}
// copyGraph copies a rooted directed acyclic graph (DAG) from the source CAS to
// the destination CAS with specified caching, concurrency limiter and tracker.
func copyGraph(ctx context.Context, src content.ReadOnlyStorage, dst content.Storage, root ocispec.Descriptor,
proxy *cas.Proxy, limiter *semaphore.Weighted, tracker *status.Tracker, opts CopyGraphOptions) error {
if proxy == nil {
// use caching proxy on non-leaf nodes
if opts.MaxMetadataBytes <= 0 {
opts.MaxMetadataBytes = defaultCopyMaxMetadataBytes
}
proxy = cas.NewProxyWithLimit(src, cas.NewMemory(), opts.MaxMetadataBytes)
}
if limiter == nil {
// if Concurrency is not set or invalid, use the default concurrency
if opts.Concurrency <= 0 {
opts.Concurrency = defaultConcurrency
}
limiter = semaphore.NewWeighted(int64(opts.Concurrency))
}
if tracker == nil {
// track content status
tracker = status.NewTracker()
}
// if FindSuccessors is not provided, use the default one
if opts.FindSuccessors == nil {
opts.FindSuccessors = content.Successors
}
// traverse the graph
var fn syncutil.GoFunc[ocispec.Descriptor]
fn = func(ctx context.Context, region *syncutil.LimitedRegion, desc ocispec.Descriptor) (err error) {
// skip the descriptor if other go routine is working on it
done, committed := tracker.TryCommit(desc)
if !committed {
return nil
}
defer func() {
if err == nil {
// mark the content as done on success
close(done)
}
}()
// skip if a rooted sub-DAG exists
exists, err := dst.Exists(ctx, desc)
if err != nil {
return err
}
if exists {
if opts.OnCopySkipped != nil {
if err := opts.OnCopySkipped(ctx, desc); err != nil {
return err
}
}
return nil
}
// find successors while non-leaf nodes will be fetched and cached
successors, err := opts.FindSuccessors(ctx, proxy, desc)
if err != nil {
return err
}
successors = removeForeignLayers(successors)
if len(successors) != 0 {
// for non-leaf nodes, process successors and wait for them to complete
region.End()
if err := syncutil.Go(ctx, limiter, fn, successors...); err != nil {
return err
}
for _, node := range successors {
done, committed := tracker.TryCommit(node)
if committed {
return fmt.Errorf("%s: %s: successor not committed", desc.Digest, node.Digest)
}
select {
case <-done:
case <-ctx.Done():
return ctx.Err()
}
}
if err := region.Start(); err != nil {
return err
}
}
exists, err = proxy.Cache.Exists(ctx, desc)
if err != nil {
return err
}
if exists {
return copyNode(ctx, proxy.Cache, dst, desc, opts)
}
return copyNode(ctx, src, dst, desc, opts)
}
return syncutil.Go(ctx, limiter, fn, root)
}
// doCopyNode copies a single content from the source CAS to the destination CAS.
func doCopyNode(ctx context.Context, src content.ReadOnlyStorage, dst content.Storage, desc ocispec.Descriptor) error {
rc, err := src.Fetch(ctx, desc)
if err != nil {
return err
}
defer rc.Close()
err = dst.Push(ctx, desc, rc)
if err != nil && !errors.Is(err, errdef.ErrAlreadyExists) {
return err
}
return nil
}
| random_line_split |
||
alumniMap-controller.js | results"]
if (results.length > 0){
result = results[0];
lat = parseFloat(result["geometry"]["lat"]);
lon = parseFloat(result["geometry"]["lng"]);
return [lat, lon];
} else {
throw new Error('No Results');
}
})
.catch( error => console.error('Error fetching lat & lon:', error) );
} catch (err) {
console.log(`opencagedata API error: ${err}`);
return {};
}
}
async function process_results(results) {
var name_list = {}
var organized_by_alumn = {};
var location_dict = {}
results.forEach(element => {
alumn = element[1];
year = element[2];
us = element[5];
timestamp = Date.parse(element[0]);
lat = element[9]
lon = element[10]
console.log(lat,lon)
area = element[7]
console.log(area)
if (us == "Yes"){
city = element[3];
state = element[4];
if (alumn in organized_by_alumn) {
if (organized_by_alumn[alumn]["timestamp"] < timestamp){
organized_by_alumn[alumn] = {
"location": city+", "+state,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
if (element[7]) {
organized_by_alumn[alumn]["location"] = element[7]+", "+state;
console.log("area");
}
}
}else{
organized_by_alumn[alumn] = {
"location": city+", "+state,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
if (element[7]) {
organized_by_alumn[alumn]["location"] = element[7]+", "+state;
console.log("area");
}
}
if (alumn in name_list) {
if (name_list[alumn]["timestamp"] < timestamp){
name_list[alumn] = {
"location": city+", "+state,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
}
}else{
name_list[alumn] = {
"location": city+", "+state,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
}
} else {
if (alumn in organized_by_alumn) {
if (organized_by_alumn[alumn]["timestamp"] < timestamp){
delete organized_by_alumn[alumn];
}
}
place = element[6];
if (alumn in name_list) {
if (name_list[alumn]["timestamp"] < timestamp){
name_list[alumn] = {
"location": place,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
}
}else{
name_list[alumn] = {
"location": place,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
}
}
});
organized_by_location = {};
for (let [alumn, val] of Object.entries(organized_by_alumn)) {
console.log("Organized by location");
loc = val.location;
console.log(loc);
if(loc in location_dict){
//
}
else{
location_dict[loc] = [val.lat,val.lon]
}
year = val.year;
alumn_with_year = alumn + " '"+year;
if (loc in organized_by_location){
organized_by_location[loc].push(alumn_with_year);
}else{
organized_by_location[loc] = [alumn_with_year];
}
}
bubble_list = []
for ( let [loc, alumn_list] of Object.entries(organized_by_location)) {
// let geo = await get_lat_and_lon(loc+", US");
let lat = location_dict[loc][0];
let lon = location_dict[loc][1];
bubble_list.push({location: loc, latitude: lat,
longitude: lon, radius: 3, fillKey: 'bubble',
alumns: alumn_list});
}
all_alumni = []
for (let [alumn, val] of Object.entries(name_list)) {
loc = val.location;
year = val.year;
list_entry = alumn + " '"+year+" • "+loc;
all_alumni.push(list_entry);
}
return [bubble_list, all_alumni];
}
async function convert_sheet_to_bubble_list(id) {
const options = {
sheetId: id,
sheetNumber: 1,
returnAllResults: true
};
return await gsheetProcessor(options, process_results);
}
async function create_bubble_list() |
function create_popup(location, alumns) {
alumns_html = 'Residents:'
alumns_html += '<br><ul class="popup">\n'
for (var i=0; i<alumns.length; i++){
alumn = alumns[i];
alumns_html += "<li>"+alumn+"</li>\n";
}
alumns_html += "</ul>"
return "<b>"+location+"</b>"+"<br>"+alumns_html;
}
function create_table(list) {
alumns_html = "<ul id='alumni' class='alumni' style='list-style: none;'><li>"
for (var i=0; i<list.length; i++){
item = list[i];
alumns_html += "<p>"+item+"</p>"
}
alumns_html += "</li></ul>"
return alumns_html;
}
//--------------------------------------------------------
/* Credit: https://github.com/bpk68/g-sheets-api */
/* Used with slight modifications */
//import GSheetsapi from './gsheetsapi.js';
function matchValues(valToMatch, valToMatchAgainst, matchingType) {
try {
if (typeof valToMatch != 'undefined') {
valToMatch = valToMatch.toLowerCase().trim();
valToMatchAgainst = valToMatchAgainst.toLowerCase().trim();
if (matchingType === 'strict') {
return valToMatch === valToMatchAgainst;
}
if (matchingType === 'loose') {
return valToMatch.includes(valToMatchAgainst) || (valToMatch == valToMatchAgainst);
}
}
} catch (e) {
console.log(`error in matchValues: ${e.message}`);
return false;
}
return false;
};
function filterResults(resultsToFilter, filter, options) {
let filteredData = [];
// now we have a list of rows, we can filter by various things
return resultsToFilter.filter(item => {
let addRow = null;
let filterMatches = [];
if (typeof item === 'undefined' ||
item.length <= 0 ||
Object.keys(item).length <= 0) {
return false;
}
Object.keys(filter).forEach(key => {
const filterValue = filter[key]; // e.g. 'archaeology'
const itemValue = item[key]; // e.g. 'department' or 'undefined'
filterMatches.push(matchValues(itemValue, filterValue, options.matching || 'loose'));
});
if (options.operator === 'or') {
addRow = filterMatches.some(match => match === true);
}
if (options.operator === 'and') {
addRow = filterMatches.every(match => match === true);
}
return addRow;
});
}
function processGSheetResults(JSONResponse, returnAllResults, filter, filterOptions) {
const data = JSONResponse.feed.entry;
const startRow = 2; // skip the header row(1), don't need it
let processedResults = [{}];
let colNames = {};
for (let item of data) {
const cell = item['gs$cell']; // gets cell data
const val = cell['$t']; // gets cell value
const columnNum = cell['col']; // gets the col number
const thisRow = cell['row']; // gets the row number
const colNameToAdd = colNames[columnNum]; // careful, this will be undefined if we hit it on the first pass
// don't add this row to the return data, but add it to list of column names
if (thisRow < startRow) {
colNames[columnNum] = val.toLowerCase();
continue; // skip the header row
}
if (typeof processedResults[thisRow] === 'undefined') {
processedResults[thisRow] = {};
}
if (typeof colNameToAdd !== 'undefined' && colNameToAdd.length > 0) {
processedResults[thisRow][colNameToAdd] = val;
}
}
// make sure we're only returning valid, filled data items
processedResults = processedResults.filter(result => Object.keys(result).length);
// if we're not filtering, | {
let id = "12lGrmIhj2dlLHt2GNucD69IktFoOA5k9Zi9rnLR0OoI";
let bubble_list = await convert_sheet_to_bubble_list(id);
return bubble_list;
} | identifier_body |
alumniMap-controller.js | results"]
if (results.length > 0){
result = results[0];
lat = parseFloat(result["geometry"]["lat"]);
lon = parseFloat(result["geometry"]["lng"]);
return [lat, lon];
} else {
throw new Error('No Results');
}
})
.catch( error => console.error('Error fetching lat & lon:', error) );
} catch (err) {
console.log(`opencagedata API error: ${err}`);
return {};
}
}
async function process_results(results) {
var name_list = {}
var organized_by_alumn = {};
var location_dict = {}
results.forEach(element => {
alumn = element[1];
year = element[2];
us = element[5];
timestamp = Date.parse(element[0]);
lat = element[9]
lon = element[10]
console.log(lat,lon)
area = element[7]
console.log(area)
if (us == "Yes"){
city = element[3];
state = element[4];
if (alumn in organized_by_alumn) {
if (organized_by_alumn[alumn]["timestamp"] < timestamp){
organized_by_alumn[alumn] = {
"location": city+", "+state,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
if (element[7]) {
organized_by_alumn[alumn]["location"] = element[7]+", "+state;
console.log("area");
}
}
}else{
organized_by_alumn[alumn] = {
"location": city+", "+state,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
if (element[7]) {
organized_by_alumn[alumn]["location"] = element[7]+", "+state;
console.log("area");
}
}
if (alumn in name_list) {
if (name_list[alumn]["timestamp"] < timestamp){
name_list[alumn] = {
"location": city+", "+state,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
}
}else{
name_list[alumn] = {
"location": city+", "+state,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
}
} else {
if (alumn in organized_by_alumn) {
if (organized_by_alumn[alumn]["timestamp"] < timestamp){
delete organized_by_alumn[alumn];
}
}
place = element[6];
if (alumn in name_list) {
if (name_list[alumn]["timestamp"] < timestamp){
name_list[alumn] = {
"location": place,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
}
}else{
name_list[alumn] = {
"location": place,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
}
}
});
organized_by_location = {};
for (let [alumn, val] of Object.entries(organized_by_alumn)) {
console.log("Organized by location");
loc = val.location;
console.log(loc);
if(loc in location_dict){
//
}
else{
location_dict[loc] = [val.lat,val.lon]
}
year = val.year;
alumn_with_year = alumn + " '"+year;
if (loc in organized_by_location){
organized_by_location[loc].push(alumn_with_year);
}else{
organized_by_location[loc] = [alumn_with_year]; |
bubble_list = []
for ( let [loc, alumn_list] of Object.entries(organized_by_location)) {
// let geo = await get_lat_and_lon(loc+", US");
let lat = location_dict[loc][0];
let lon = location_dict[loc][1];
bubble_list.push({location: loc, latitude: lat,
longitude: lon, radius: 3, fillKey: 'bubble',
alumns: alumn_list});
}
all_alumni = []
for (let [alumn, val] of Object.entries(name_list)) {
loc = val.location;
year = val.year;
list_entry = alumn + " '"+year+" • "+loc;
all_alumni.push(list_entry);
}
return [bubble_list, all_alumni];
}
async function convert_sheet_to_bubble_list(id) {
const options = {
sheetId: id,
sheetNumber: 1,
returnAllResults: true
};
return await gsheetProcessor(options, process_results);
}
async function create_bubble_list() {
let id = "12lGrmIhj2dlLHt2GNucD69IktFoOA5k9Zi9rnLR0OoI";
let bubble_list = await convert_sheet_to_bubble_list(id);
return bubble_list;
}
function create_popup(location, alumns) {
alumns_html = 'Residents:'
alumns_html += '<br><ul class="popup">\n'
for (var i=0; i<alumns.length; i++){
alumn = alumns[i];
alumns_html += "<li>"+alumn+"</li>\n";
}
alumns_html += "</ul>"
return "<b>"+location+"</b>"+"<br>"+alumns_html;
}
function create_table(list) {
alumns_html = "<ul id='alumni' class='alumni' style='list-style: none;'><li>"
for (var i=0; i<list.length; i++){
item = list[i];
alumns_html += "<p>"+item+"</p>"
}
alumns_html += "</li></ul>"
return alumns_html;
}
//--------------------------------------------------------
/* Credit: https://github.com/bpk68/g-sheets-api */
/* Used with slight modifications */
//import GSheetsapi from './gsheetsapi.js';
function matchValues(valToMatch, valToMatchAgainst, matchingType) {
try {
if (typeof valToMatch != 'undefined') {
valToMatch = valToMatch.toLowerCase().trim();
valToMatchAgainst = valToMatchAgainst.toLowerCase().trim();
if (matchingType === 'strict') {
return valToMatch === valToMatchAgainst;
}
if (matchingType === 'loose') {
return valToMatch.includes(valToMatchAgainst) || (valToMatch == valToMatchAgainst);
}
}
} catch (e) {
console.log(`error in matchValues: ${e.message}`);
return false;
}
return false;
};
function filterResults(resultsToFilter, filter, options) {
let filteredData = [];
// now we have a list of rows, we can filter by various things
return resultsToFilter.filter(item => {
let addRow = null;
let filterMatches = [];
if (typeof item === 'undefined' ||
item.length <= 0 ||
Object.keys(item).length <= 0) {
return false;
}
Object.keys(filter).forEach(key => {
const filterValue = filter[key]; // e.g. 'archaeology'
const itemValue = item[key]; // e.g. 'department' or 'undefined'
filterMatches.push(matchValues(itemValue, filterValue, options.matching || 'loose'));
});
if (options.operator === 'or') {
addRow = filterMatches.some(match => match === true);
}
if (options.operator === 'and') {
addRow = filterMatches.every(match => match === true);
}
return addRow;
});
}
function processGSheetResults(JSONResponse, returnAllResults, filter, filterOptions) {
const data = JSONResponse.feed.entry;
const startRow = 2; // skip the header row(1), don't need it
let processedResults = [{}];
let colNames = {};
for (let item of data) {
const cell = item['gs$cell']; // gets cell data
const val = cell['$t']; // gets cell value
const columnNum = cell['col']; // gets the col number
const thisRow = cell['row']; // gets the row number
const colNameToAdd = colNames[columnNum]; // careful, this will be undefined if we hit it on the first pass
// don't add this row to the return data, but add it to list of column names
if (thisRow < startRow) {
colNames[columnNum] = val.toLowerCase();
continue; // skip the header row
}
if (typeof processedResults[thisRow] === 'undefined') {
processedResults[thisRow] = {};
}
if (typeof colNameToAdd !== 'undefined' && colNameToAdd.length > 0) {
processedResults[thisRow][colNameToAdd] = val;
}
}
// make sure we're only returning valid, filled data items
processedResults = processedResults.filter(result => Object.keys(result).length);
// if we're not filtering, then | }
} | random_line_split |
alumniMap-controller.js | results"]
if (results.length > 0){
result = results[0];
lat = parseFloat(result["geometry"]["lat"]);
lon = parseFloat(result["geometry"]["lng"]);
return [lat, lon];
} else {
throw new Error('No Results');
}
})
.catch( error => console.error('Error fetching lat & lon:', error) );
} catch (err) {
console.log(`opencagedata API error: ${err}`);
return {};
}
}
async function process_results(results) {
var name_list = {}
var organized_by_alumn = {};
var location_dict = {}
results.forEach(element => {
alumn = element[1];
year = element[2];
us = element[5];
timestamp = Date.parse(element[0]);
lat = element[9]
lon = element[10]
console.log(lat,lon)
area = element[7]
console.log(area)
if (us == "Yes"){
city = element[3];
state = element[4];
if (alumn in organized_by_alumn) {
if (organized_by_alumn[alumn]["timestamp"] < timestamp){
organized_by_alumn[alumn] = {
"location": city+", "+state,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
if (element[7]) {
organized_by_alumn[alumn]["location"] = element[7]+", "+state;
console.log("area");
}
}
}else{
organized_by_alumn[alumn] = {
"location": city+", "+state,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
if (element[7]) {
organized_by_alumn[alumn]["location"] = element[7]+", "+state;
console.log("area");
}
}
if (alumn in name_list) {
if (name_list[alumn]["timestamp"] < timestamp){
name_list[alumn] = {
"location": city+", "+state,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
}
}else{
name_list[alumn] = {
"location": city+", "+state,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
}
} else {
if (alumn in organized_by_alumn) {
if (organized_by_alumn[alumn]["timestamp"] < timestamp){
delete organized_by_alumn[alumn];
}
}
place = element[6];
if (alumn in name_list) {
if (name_list[alumn]["timestamp"] < timestamp){
name_list[alumn] = {
"location": place,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
}
}else{
name_list[alumn] = {
"location": place,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
}
}
});
organized_by_location = {};
for (let [alumn, val] of Object.entries(organized_by_alumn)) {
console.log("Organized by location");
loc = val.location;
console.log(loc);
if(loc in location_dict){
//
}
else{
location_dict[loc] = [val.lat,val.lon]
}
year = val.year;
alumn_with_year = alumn + " '"+year;
if (loc in organized_by_location){
organized_by_location[loc].push(alumn_with_year);
}else{
organized_by_location[loc] = [alumn_with_year];
}
}
bubble_list = []
for ( let [loc, alumn_list] of Object.entries(organized_by_location)) {
// let geo = await get_lat_and_lon(loc+", US");
let lat = location_dict[loc][0];
let lon = location_dict[loc][1];
bubble_list.push({location: loc, latitude: lat,
longitude: lon, radius: 3, fillKey: 'bubble',
alumns: alumn_list});
}
all_alumni = []
for (let [alumn, val] of Object.entries(name_list)) {
loc = val.location;
year = val.year;
list_entry = alumn + " '"+year+" • "+loc;
all_alumni.push(list_entry);
}
return [bubble_list, all_alumni];
}
async function | (id) {
const options = {
sheetId: id,
sheetNumber: 1,
returnAllResults: true
};
return await gsheetProcessor(options, process_results);
}
async function create_bubble_list() {
let id = "12lGrmIhj2dlLHt2GNucD69IktFoOA5k9Zi9rnLR0OoI";
let bubble_list = await convert_sheet_to_bubble_list(id);
return bubble_list;
}
function create_popup(location, alumns) {
alumns_html = 'Residents:'
alumns_html += '<br><ul class="popup">\n'
for (var i=0; i<alumns.length; i++){
alumn = alumns[i];
alumns_html += "<li>"+alumn+"</li>\n";
}
alumns_html += "</ul>"
return "<b>"+location+"</b>"+"<br>"+alumns_html;
}
function create_table(list) {
alumns_html = "<ul id='alumni' class='alumni' style='list-style: none;'><li>"
for (var i=0; i<list.length; i++){
item = list[i];
alumns_html += "<p>"+item+"</p>"
}
alumns_html += "</li></ul>"
return alumns_html;
}
//--------------------------------------------------------
/* Credit: https://github.com/bpk68/g-sheets-api */
/* Used with slight modifications */
//import GSheetsapi from './gsheetsapi.js';
function matchValues(valToMatch, valToMatchAgainst, matchingType) {
try {
if (typeof valToMatch != 'undefined') {
valToMatch = valToMatch.toLowerCase().trim();
valToMatchAgainst = valToMatchAgainst.toLowerCase().trim();
if (matchingType === 'strict') {
return valToMatch === valToMatchAgainst;
}
if (matchingType === 'loose') {
return valToMatch.includes(valToMatchAgainst) || (valToMatch == valToMatchAgainst);
}
}
} catch (e) {
console.log(`error in matchValues: ${e.message}`);
return false;
}
return false;
};
function filterResults(resultsToFilter, filter, options) {
let filteredData = [];
// now we have a list of rows, we can filter by various things
return resultsToFilter.filter(item => {
let addRow = null;
let filterMatches = [];
if (typeof item === 'undefined' ||
item.length <= 0 ||
Object.keys(item).length <= 0) {
return false;
}
Object.keys(filter).forEach(key => {
const filterValue = filter[key]; // e.g. 'archaeology'
const itemValue = item[key]; // e.g. 'department' or 'undefined'
filterMatches.push(matchValues(itemValue, filterValue, options.matching || 'loose'));
});
if (options.operator === 'or') {
addRow = filterMatches.some(match => match === true);
}
if (options.operator === 'and') {
addRow = filterMatches.every(match => match === true);
}
return addRow;
});
}
function processGSheetResults(JSONResponse, returnAllResults, filter, filterOptions) {
const data = JSONResponse.feed.entry;
const startRow = 2; // skip the header row(1), don't need it
let processedResults = [{}];
let colNames = {};
for (let item of data) {
const cell = item['gs$cell']; // gets cell data
const val = cell['$t']; // gets cell value
const columnNum = cell['col']; // gets the col number
const thisRow = cell['row']; // gets the row number
const colNameToAdd = colNames[columnNum]; // careful, this will be undefined if we hit it on the first pass
// don't add this row to the return data, but add it to list of column names
if (thisRow < startRow) {
colNames[columnNum] = val.toLowerCase();
continue; // skip the header row
}
if (typeof processedResults[thisRow] === 'undefined') {
processedResults[thisRow] = {};
}
if (typeof colNameToAdd !== 'undefined' && colNameToAdd.length > 0) {
processedResults[thisRow][colNameToAdd] = val;
}
}
// make sure we're only returning valid, filled data items
processedResults = processedResults.filter(result => Object.keys(result).length);
// if we're not filtering, then | convert_sheet_to_bubble_list | identifier_name |
alumniMap-controller.js | results"]
if (results.length > 0){
result = results[0];
lat = parseFloat(result["geometry"]["lat"]);
lon = parseFloat(result["geometry"]["lng"]);
return [lat, lon];
} else {
throw new Error('No Results');
}
})
.catch( error => console.error('Error fetching lat & lon:', error) );
} catch (err) {
console.log(`opencagedata API error: ${err}`);
return {};
}
}
async function process_results(results) {
var name_list = {}
var organized_by_alumn = {};
var location_dict = {}
results.forEach(element => {
alumn = element[1];
year = element[2];
us = element[5];
timestamp = Date.parse(element[0]);
lat = element[9]
lon = element[10]
console.log(lat,lon)
area = element[7]
console.log(area)
if (us == "Yes"){
city = element[3];
state = element[4];
if (alumn in organized_by_alumn) {
if (organized_by_alumn[alumn]["timestamp"] < timestamp){
organized_by_alumn[alumn] = {
"location": city+", "+state,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
if (element[7]) {
organized_by_alumn[alumn]["location"] = element[7]+", "+state;
console.log("area");
}
}
}else{
organized_by_alumn[alumn] = {
"location": city+", "+state,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
if (element[7]) {
organized_by_alumn[alumn]["location"] = element[7]+", "+state;
console.log("area");
}
}
if (alumn in name_list) {
if (name_list[alumn]["timestamp"] < timestamp){
name_list[alumn] = {
"location": city+", "+state,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
}
}else{
name_list[alumn] = {
"location": city+", "+state,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
}
} else {
if (alumn in organized_by_alumn) {
if (organized_by_alumn[alumn]["timestamp"] < timestamp){
delete organized_by_alumn[alumn];
}
}
place = element[6];
if (alumn in name_list) {
if (name_list[alumn]["timestamp"] < timestamp) |
}else{
name_list[alumn] = {
"location": place,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
}
}
});
organized_by_location = {};
for (let [alumn, val] of Object.entries(organized_by_alumn)) {
console.log("Organized by location");
loc = val.location;
console.log(loc);
if(loc in location_dict){
//
}
else{
location_dict[loc] = [val.lat,val.lon]
}
year = val.year;
alumn_with_year = alumn + " '"+year;
if (loc in organized_by_location){
organized_by_location[loc].push(alumn_with_year);
}else{
organized_by_location[loc] = [alumn_with_year];
}
}
bubble_list = []
for ( let [loc, alumn_list] of Object.entries(organized_by_location)) {
// let geo = await get_lat_and_lon(loc+", US");
let lat = location_dict[loc][0];
let lon = location_dict[loc][1];
bubble_list.push({location: loc, latitude: lat,
longitude: lon, radius: 3, fillKey: 'bubble',
alumns: alumn_list});
}
all_alumni = []
for (let [alumn, val] of Object.entries(name_list)) {
loc = val.location;
year = val.year;
list_entry = alumn + " '"+year+" • "+loc;
all_alumni.push(list_entry);
}
return [bubble_list, all_alumni];
}
async function convert_sheet_to_bubble_list(id) {
const options = {
sheetId: id,
sheetNumber: 1,
returnAllResults: true
};
return await gsheetProcessor(options, process_results);
}
async function create_bubble_list() {
let id = "12lGrmIhj2dlLHt2GNucD69IktFoOA5k9Zi9rnLR0OoI";
let bubble_list = await convert_sheet_to_bubble_list(id);
return bubble_list;
}
function create_popup(location, alumns) {
alumns_html = 'Residents:'
alumns_html += '<br><ul class="popup">\n'
for (var i=0; i<alumns.length; i++){
alumn = alumns[i];
alumns_html += "<li>"+alumn+"</li>\n";
}
alumns_html += "</ul>"
return "<b>"+location+"</b>"+"<br>"+alumns_html;
}
function create_table(list) {
alumns_html = "<ul id='alumni' class='alumni' style='list-style: none;'><li>"
for (var i=0; i<list.length; i++){
item = list[i];
alumns_html += "<p>"+item+"</p>"
}
alumns_html += "</li></ul>"
return alumns_html;
}
//--------------------------------------------------------
/* Credit: https://github.com/bpk68/g-sheets-api */
/* Used with slight modifications */
//import GSheetsapi from './gsheetsapi.js';
function matchValues(valToMatch, valToMatchAgainst, matchingType) {
try {
if (typeof valToMatch != 'undefined') {
valToMatch = valToMatch.toLowerCase().trim();
valToMatchAgainst = valToMatchAgainst.toLowerCase().trim();
if (matchingType === 'strict') {
return valToMatch === valToMatchAgainst;
}
if (matchingType === 'loose') {
return valToMatch.includes(valToMatchAgainst) || (valToMatch == valToMatchAgainst);
}
}
} catch (e) {
console.log(`error in matchValues: ${e.message}`);
return false;
}
return false;
};
function filterResults(resultsToFilter, filter, options) {
let filteredData = [];
// now we have a list of rows, we can filter by various things
return resultsToFilter.filter(item => {
let addRow = null;
let filterMatches = [];
if (typeof item === 'undefined' ||
item.length <= 0 ||
Object.keys(item).length <= 0) {
return false;
}
Object.keys(filter).forEach(key => {
const filterValue = filter[key]; // e.g. 'archaeology'
const itemValue = item[key]; // e.g. 'department' or 'undefined'
filterMatches.push(matchValues(itemValue, filterValue, options.matching || 'loose'));
});
if (options.operator === 'or') {
addRow = filterMatches.some(match => match === true);
}
if (options.operator === 'and') {
addRow = filterMatches.every(match => match === true);
}
return addRow;
});
}
function processGSheetResults(JSONResponse, returnAllResults, filter, filterOptions) {
const data = JSONResponse.feed.entry;
const startRow = 2; // skip the header row(1), don't need it
let processedResults = [{}];
let colNames = {};
for (let item of data) {
const cell = item['gs$cell']; // gets cell data
const val = cell['$t']; // gets cell value
const columnNum = cell['col']; // gets the col number
const thisRow = cell['row']; // gets the row number
const colNameToAdd = colNames[columnNum]; // careful, this will be undefined if we hit it on the first pass
// don't add this row to the return data, but add it to list of column names
if (thisRow < startRow) {
colNames[columnNum] = val.toLowerCase();
continue; // skip the header row
}
if (typeof processedResults[thisRow] === 'undefined') {
processedResults[thisRow] = {};
}
if (typeof colNameToAdd !== 'undefined' && colNameToAdd.length > 0) {
processedResults[thisRow][colNameToAdd] = val;
}
}
// make sure we're only returning valid, filled data items
processedResults = processedResults.filter(result => Object.keys(result).length);
// if we're not filtering, | {
name_list[alumn] = {
"location": place,
"timestamp": timestamp,
"year": year,
"lat": lat,
"lon":lon
};
} | conditional_block |
db.go | merge attempts, giving up")
}
func mkCommit(r *git.Repository, refname string, msg string, tree *git.Tree, parent *git.Commit, extraParents ...*git.Commit) (*git.Commit, error) {
var parents []*git.Commit
if parent != nil {
parents = append(parents, parent)
}
if len(extraParents) > 0 {
parents = append(parents, extraParents...)
}
id, err := r.CreateCommit(
refname,
&git.Signature{"libpack", "libpack", time.Now()}, // author
&git.Signature{"libpack", "libpack", time.Now()}, // committer
msg,
tree, // git tree to commit
parents...,
)
if err != nil {
return nil, err
}
return lookupCommit(r, id)
}
func isGitConcurrencyErr(err error) bool {
gitErr, ok := err.(*git.GitError)
if !ok {
return false
}
return gitErr.Class == 11 && gitErr.Code == -15
}
func isGitIterOver(err error) bool {
gitErr, ok := err.(*git.GitError)
if !ok {
return false
}
return gitErr.Code == git.ErrIterOver
}
// Pull downloads objects at the specified url and remote ref name,
// and updates the local ref of db.
// The uncommitted tree is left unchanged (ie uncommitted changes are
// not merged or rebased).
func (db *DB) Pull(url, ref string) error {
if ref == "" {
ref = db.ref
}
refspec := fmt.Sprintf("%s:%s", ref, db.ref)
fmt.Printf("Creating anonymous remote url=%s refspec=%s\n", url, refspec)
remote, err := db.repo.CreateAnonymousRemote(url, refspec)
if err != nil {
return err
}
defer remote.Free()
if err := remote.Fetch(nil, nil, fmt.Sprintf("libpack.pull %s %s", url, refspec)); err != nil {
return err
}
return db.Update()
}
// Push uploads the committed contents of the db at the specified url and
// remote ref name. The remote ref is created if it doesn't exist.
func (db *DB) Push(url, ref string) error {
if ref == "" {
ref = db.ref
}
// The '+' prefix sets force=true,
// so the remote ref is created if it doesn't exist.
refspec := fmt.Sprintf("+%s:%s", db.ref, ref)
remote, err := db.repo.CreateAnonymousRemote(url, refspec)
if err != nil {
return err
}
defer remote.Free()
push, err := remote.NewPush()
if err != nil {
return fmt.Errorf("git_push_new: %v", err)
}
defer push.Free()
if err := push.AddRefspec(refspec); err != nil {
return fmt.Errorf("git_push_refspec_add: %v", err)
}
if err := push.Finish(); err != nil {
return fmt.Errorf("git_push_finish: %v", err)
}
return nil
}
// Checkout populates the directory at dir with the committed
// contents of db. Uncommitted changes are ignored.
//
// As a convenience, if dir is an empty string, a temporary directory
// is created and returned, and the caller is responsible for removing it.
//
func (db *DB) Checkout(dir string) (checkoutDir string, err error) {
if db.parent != nil {
return db.parent.Checkout(path.Join(db.scope, dir))
}
head := db.Head()
if head == nil {
return "", fmt.Errorf("no head to checkout")
}
if dir == "" {
dir, err = ioutil.TempDir("", "libpack-checkout-")
if err != nil {
return "", err
}
defer func() {
if err != nil {
os.RemoveAll(dir)
}
}()
}
stderr := new(bytes.Buffer)
args := []string{
"--git-dir", db.repo.Path(), "--work-tree", dir,
"checkout", head.String(), ".",
}
cmd := exec.Command("git", args...)
cmd.Stderr = stderr
if err := cmd.Run(); err != nil {
return "", fmt.Errorf("%s", stderr.String())
}
// FIXME: enforce scoping in the git checkout command instead
// of here.
d := path.Join(dir, db.scope)
fmt.Printf("--> %s\n", d)
return d, nil
}
// Checkout populates the directory at dir with the uncommitted
// contents of db.
// FIXME: this does not work properly at the moment.
func (db *DB) CheckoutUncommitted(dir string) error {
if db.tree == nil {
return fmt.Errorf("no tree")
}
tree, err := TreeScope(db.repo, db.tree, db.scope)
if err != nil {
return err
}
// If the tree is empty, checkout will fail and there is
// nothing to do anyway
if tree.EntryCount() == 0 {
return nil
}
idx, err := ioutil.TempFile("", "libpack-index")
if err != nil {
return err
}
defer os.RemoveAll(idx.Name())
readTree := exec.Command(
"git",
"--git-dir", db.repo.Path(),
"--work-tree", dir,
"read-tree", tree.Id().String(),
)
readTree.Env = append(readTree.Env, "GIT_INDEX_FILE="+idx.Name())
stderr := new(bytes.Buffer)
readTree.Stderr = stderr
if err := readTree.Run(); err != nil {
return fmt.Errorf("%s", stderr.String())
}
checkoutIndex := exec.Command(
"git",
"--git-dir", db.repo.Path(),
"--work-tree", dir,
"checkout-index",
)
checkoutIndex.Env = append(checkoutIndex.Env, "GIT_INDEX_FILE="+idx.Name())
stderr = new(bytes.Buffer)
checkoutIndex.Stderr = stderr
if err := checkoutIndex.Run(); err != nil {
return fmt.Errorf("%s", stderr.String())
}
return nil
}
// ExecInCheckout checks out the committed contents of the database into a
// temporary directory, executes the specified command in a new subprocess
// with that directory as the working directory, then removes the directory.
//
// The standard input, output and error streams of the command are the same
// as the current process's.
func (db *DB) ExecInCheckout(path string, args ...string) error {
checkout, err := db.Checkout("")
if err != nil {
return fmt.Errorf("checkout: %v", err)
}
defer os.RemoveAll(checkout)
cmd := exec.Command(path, args...)
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
cmd.Dir = checkout
return cmd.Run()
}
// lookupTree looks up an object at hash `id` in `repo`, and returns
// it as a git tree. If the object is not a tree, an error is returned.
func (db *DB) lookupTree(id *git.Oid) (*git.Tree, error) {
return lookupTree(db.repo, id)
}
func lookupTree(r *git.Repository, id *git.Oid) (*git.Tree, error) {
obj, err := r.Lookup(id)
if err != nil {
return nil, err
}
if tree, ok := obj.(*git.Tree); ok {
return tree, nil
}
return nil, fmt.Errorf("hash %v exist but is not a tree", id)
}
// lookupBlob looks up an object at hash `id` in `repo`, and returns
// it as a git blob. If the object is not a blob, an error is returned.
func lookupBlob(r *git.Repository, id *git.Oid) (*git.Blob, error) {
obj, err := r.Lookup(id)
if err != nil {
return nil, err
}
if blob, ok := obj.(*git.Blob); ok {
return blob, nil
}
return nil, fmt.Errorf("hash %v exist but is not a blob", id)
}
// lookupTip looks up the object referenced by refname, and returns it
// as a Commit object. If the reference does not exist, or if object is
// not a commit, nil is returned. Other errors cannot be detected.
func lookupTip(r *git.Repository, refname string) *git.Commit {
ref, err := r.LookupReference(refname)
if err != nil {
return nil
}
commit, err := lookupCommit(r, ref.Target())
if err != nil {
return nil
}
return commit
}
// lookupCommit looks up an object at hash `id` in `repo`, and returns
// it as a git commit. If the object is not a commit, an error is returned.
func lookupCommit(r *git.Repository, id *git.Oid) (*git.Commit, error) {
obj, err := r.Lookup(id)
if err != nil {
return nil, err
}
if commit, ok := obj.(*git.Commit); ok {
return commit, nil
}
return nil, fmt.Errorf("hash %v exist but is not a commit", id)
}
// emptyTree creates an empty Git tree and returns its ID
// (the ID will always be the same)
func emptyTree(repo *git.Repository) (*git.Oid, error) | {
builder, err := repo.TreeBuilder()
if err != nil {
return nil, err
}
return builder.Write()
} | identifier_body |
|
db.go | of the Git blob at path `key`.
// If there is no blob at the specified key, an error
// is returned.
func (db *DB) Get(key string) (string, error) {
if db.parent != nil {
return db.parent.Get(path.Join(db.scope, key))
}
return TreeGet(db.repo, db.tree, path.Join(db.scope, key))
}
// Set writes the specified value in a Git blob, and updates the
// uncommitted tree to point to that blob as `key`.
func (db *DB) Set(key, value string) error {
if db.parent != nil {
return db.parent.Set(path.Join(db.scope, key), value)
}
p := NewPipeline(db.repo)
newTree, err := p.Base(db.tree).Set(path.Join(db.scope, key), value).Run()
if err != nil {
return err
}
db.tree = newTree
return nil
}
// SetStream writes the data from `src` to a new Git blob,
// and updates the uncommitted tree to point to that blob as `key`.
func (db *DB) SetStream(key string, src io.Reader) error {
// FIXME: instead of buffering the entire value, use
// libgit2 CreateBlobFromChunks to stream the data straight
// into git.
buf := new(bytes.Buffer)
_, err := io.Copy(buf, src)
if err != nil {
return err
}
return db.Set(key, buf.String())
}
func TreePath(p string) string {
p = path.Clean(p)
if p == "/" || p == "." {
return "/"
}
// Remove leading / from the path
// as libgit2.TreeEntryByPath does not accept it
p = strings.TrimLeft(p, "/")
return p
}
// List returns a list of object names at the subtree `key`.
// If there is no subtree at `key`, an error is returned.
func (db *DB) List(key string) ([]string, error) {
return TreeList(db.repo, db.tree, path.Join(db.scope, key))
}
// Commit atomically stores all database changes since the last commit
// into a new Git commit object, and updates the database's reference
// to point to that commit.
func (db *DB) Commit(msg string) error {
if db.parent != nil {
return db.parent.Commit(msg)
}
db.l.Lock()
defer db.l.Unlock()
if db.tree == nil {
// Nothing to commit
return nil
}
commit, err := CommitToRef(db.repo, db.tree, db.commit, db.ref, msg)
if err != nil {
return err
}
if db.commit != nil {
db.commit.Free()
}
db.commit = commit
return nil
}
func CommitToRef(r *git.Repository, tree *git.Tree, parent *git.Commit, refname, msg string) (*git.Commit, error) {
// Retry loop in case of conflict
// FIXME: use a custom inter-process lock as a first attempt for performance
var (
needMerge bool
tmpCommit *git.Commit
)
for {
if !needMerge {
// Create simple commit
commit, err := mkCommit(r, refname, msg, tree, parent)
if isGitConcurrencyErr(err) {
needMerge = true
continue
}
return commit, err
} else {
if tmpCommit == nil {
var err error
// Create a temporary intermediary commit, to pass to MergeCommits
// NOTE: this commit will not be part of the final history.
tmpCommit, err = mkCommit(r, "", msg, tree, parent)
if err != nil {
return nil, err
}
defer tmpCommit.Free()
}
// Lookup tip from ref
tip := lookupTip(r, refname)
if tip == nil {
// Ref may have been deleted after previous merge error
needMerge = false
continue
}
// Merge simple commit with the tip
opts, err := git.DefaultMergeOptions()
if err != nil {
return nil, err
}
idx, err := r.MergeCommits(tmpCommit, tip, &opts)
if err != nil {
return nil, err
}
conflicts, err := idx.ConflictIterator()
if err != nil {
return nil, err
}
defer conflicts.Free()
for {
c, err := conflicts.Next()
if isGitIterOver(err) {
break
} else if err != nil {
return nil, err
}
if c.Our != nil {
idx.RemoveConflict(c.Our.Path)
if err := idx.Add(c.Our); err != nil {
return nil, fmt.Errorf("error resolving merge conflict for '%s': %v", c.Our.Path, err)
}
}
}
mergedId, err := idx.WriteTreeTo(r)
if err != nil {
return nil, fmt.Errorf("WriteTree: %v", err)
}
mergedTree, err := lookupTree(r, mergedId)
if err != nil {
return nil, err
}
// Create new commit from merged tree (discarding simple commit)
commit, err := mkCommit(r, refname, msg, mergedTree, parent, tip)
if isGitConcurrencyErr(err) {
// FIXME: enforce a maximum number of retries to avoid infinite loops
continue
}
return commit, err
}
}
return nil, fmt.Errorf("too many failed merge attempts, giving up")
}
func mkCommit(r *git.Repository, refname string, msg string, tree *git.Tree, parent *git.Commit, extraParents ...*git.Commit) (*git.Commit, error) {
var parents []*git.Commit
if parent != nil {
parents = append(parents, parent)
}
if len(extraParents) > 0 {
parents = append(parents, extraParents...)
}
id, err := r.CreateCommit(
refname,
&git.Signature{"libpack", "libpack", time.Now()}, // author
&git.Signature{"libpack", "libpack", time.Now()}, // committer
msg,
tree, // git tree to commit
parents...,
)
if err != nil {
return nil, err
}
return lookupCommit(r, id)
}
func isGitConcurrencyErr(err error) bool {
gitErr, ok := err.(*git.GitError)
if !ok {
return false
}
return gitErr.Class == 11 && gitErr.Code == -15
}
func isGitIterOver(err error) bool {
gitErr, ok := err.(*git.GitError)
if !ok {
return false
}
return gitErr.Code == git.ErrIterOver
}
// Pull downloads objects at the specified url and remote ref name,
// and updates the local ref of db.
// The uncommitted tree is left unchanged (ie uncommitted changes are
// not merged or rebased).
func (db *DB) Pull(url, ref string) error {
if ref == "" {
ref = db.ref
}
refspec := fmt.Sprintf("%s:%s", ref, db.ref)
fmt.Printf("Creating anonymous remote url=%s refspec=%s\n", url, refspec)
remote, err := db.repo.CreateAnonymousRemote(url, refspec)
if err != nil {
return err
}
defer remote.Free()
if err := remote.Fetch(nil, nil, fmt.Sprintf("libpack.pull %s %s", url, refspec)); err != nil {
return err
}
return db.Update()
}
// Push uploads the committed contents of the db at the specified url and
// remote ref name. The remote ref is created if it doesn't exist.
func (db *DB) Push(url, ref string) error {
if ref == "" {
ref = db.ref
}
// The '+' prefix sets force=true,
// so the remote ref is created if it doesn't exist.
refspec := fmt.Sprintf("+%s:%s", db.ref, ref)
remote, err := db.repo.CreateAnonymousRemote(url, refspec)
if err != nil {
return err
}
defer remote.Free()
push, err := remote.NewPush()
if err != nil {
return fmt.Errorf("git_push_new: %v", err)
}
defer push.Free()
if err := push.AddRefspec(refspec); err != nil {
return fmt.Errorf("git_push_refspec_add: %v", err)
}
if err := push.Finish(); err != nil {
return fmt.Errorf("git_push_finish: %v", err)
}
return nil
}
// Checkout populates the directory at dir with the committed
// contents of db. Uncommitted changes are ignored.
//
// As a convenience, if dir is an empty string, a temporary directory
// is created and returned, and the caller is responsible for removing it.
//
func (db *DB) Checkout(dir string) (checkoutDir string, err error) {
if db.parent != nil {
return db.parent.Checkout(path.Join(db.scope, dir))
}
head := db.Head()
if head == nil {
return "", fmt.Errorf("no head to checkout")
} | if dir == "" {
dir, err = ioutil.TempDir("", "libpack-checkout-")
if err != nil {
return "", err
} | random_line_split |
|
db.go |
return db, nil
}
func newRepo(repo *git.Repository, ref string) (*DB, error) {
db := &DB{
repo: repo,
ref: ref,
}
if err := db.Update(); err != nil {
db.Free()
return nil, err
}
return db, nil
}
// Free must be called to release resources when a database is no longer
// in use.
// This is required in addition to Golang garbage collection, because
// of the libgit2 C bindings.
func (db *DB) Free() {
db.l.Lock()
db.repo.Free()
if db.commit != nil {
db.commit.Free()
}
db.l.Unlock()
}
// Head returns the id of the latest commit
func (db *DB) Head() *git.Oid {
db.l.RLock()
defer db.l.RUnlock()
if db.commit != nil {
return db.commit.Id()
}
return nil
}
func (db *DB) Latest() *git.Oid {
if db.tree != nil {
return db.tree.Id()
}
return nil
}
func (db *DB) Repo() *git.Repository {
return db.repo
}
func (db *DB) Tree() (*git.Tree, error) {
return TreeScope(db.repo, db.tree, db.scope)
}
func (db *DB) Dump(dst io.Writer) error {
return TreeDump(db.repo, db.tree, path.Join(db.scope, "/"), dst)
}
// AddDB copies the contents of src into db at prefix key.
// The resulting content is the union of the new tree and
// the pre-existing tree, if any.
// In case of a conflict, the content of the new tree wins.
// Conflicts are resolved at the file granularity (content is
// never merged).
func (db *DB) AddDB(key string, src *DB) error {
// No tree to add, nothing to do
src.l.RLock()
defer src.l.RUnlock()
if src.tree == nil {
return nil
}
return db.Add(key, src.tree.Id())
}
func (db *DB) Add(key string, obj interface{}) error {
db.l.Lock()
defer db.l.Unlock()
if db.parent != nil {
return db.parent.Add(path.Join(db.scope, key), obj)
}
newTree, err := NewPipeline(db.repo).Base(db.tree).Add(key, obj, true).Run()
if err != nil {
return err
}
db.tree = newTree
return nil
}
func (db *DB) Walk(key string, h func(string, git.Object) error) error {
return TreeWalk(db.repo, db.tree, path.Join(db.scope, key), h)
}
// Update looks up the value of the database's reference, and changes
// the memory representation accordingly.
// If the committed tree is changed, then uncommitted changes are lost.
func (db *DB) Update() error {
db.l.Lock()
defer db.l.Unlock()
tip, err := db.repo.LookupReference(db.ref)
if err != nil {
db.commit = nil
return nil
}
// If we already have the latest commit, don't do anything
if db.commit != nil && db.commit.Id().Equal(tip.Target()) {
return nil
}
commit, err := lookupCommit(db.repo, tip.Target())
if err != nil {
return err
}
if db.commit != nil {
db.commit.Free()
}
db.commit = commit
if db.tree != nil {
db.tree.Free()
}
if commitTree, err := commit.Tree(); err != nil {
return err
} else {
db.tree = commitTree
}
return nil
}
// Mkdir adds an empty subtree at key if it doesn't exist.
func (db *DB) Mkdir(key string) error {
db.l.Lock()
defer db.l.Unlock()
if db.parent != nil {
return db.parent.Mkdir(path.Join(db.scope, key))
}
p := NewPipeline(db.repo)
newTree, err := p.Base(db.tree).Mkdir(path.Join(db.scope, key)).Run()
if err != nil {
return err
}
db.tree = newTree
return nil
}
// Get returns the value of the Git blob at path `key`.
// If there is no blob at the specified key, an error
// is returned.
func (db *DB) Get(key string) (string, error) {
if db.parent != nil {
return db.parent.Get(path.Join(db.scope, key))
}
return TreeGet(db.repo, db.tree, path.Join(db.scope, key))
}
// Set writes the specified value in a Git blob, and updates the
// uncommitted tree to point to that blob as `key`.
func (db *DB) Set(key, value string) error {
if db.parent != nil {
return db.parent.Set(path.Join(db.scope, key), value)
}
p := NewPipeline(db.repo)
newTree, err := p.Base(db.tree).Set(path.Join(db.scope, key), value).Run()
if err != nil {
return err
}
db.tree = newTree
return nil
}
// SetStream writes the data from `src` to a new Git blob,
// and updates the uncommitted tree to point to that blob as `key`.
func (db *DB) SetStream(key string, src io.Reader) error {
// FIXME: instead of buffering the entire value, use
// libgit2 CreateBlobFromChunks to stream the data straight
// into git.
buf := new(bytes.Buffer)
_, err := io.Copy(buf, src)
if err != nil {
return err
}
return db.Set(key, buf.String())
}
func TreePath(p string) string {
p = path.Clean(p)
if p == "/" || p == "." {
return "/"
}
// Remove leading / from the path
// as libgit2.TreeEntryByPath does not accept it
p = strings.TrimLeft(p, "/")
return p
}
// List returns a list of object names at the subtree `key`.
// If there is no subtree at `key`, an error is returned.
func (db *DB) List(key string) ([]string, error) {
return TreeList(db.repo, db.tree, path.Join(db.scope, key))
}
// Commit atomically stores all database changes since the last commit
// into a new Git commit object, and updates the database's reference
// to point to that commit.
func (db *DB) Commit(msg string) error {
if db.parent != nil {
return db.parent.Commit(msg)
}
db.l.Lock()
defer db.l.Unlock()
if db.tree == nil {
// Nothing to commit
return nil
}
commit, err := CommitToRef(db.repo, db.tree, db.commit, db.ref, msg)
if err != nil {
return err
}
if db.commit != nil {
db.commit.Free()
}
db.commit = commit
return nil
}
func CommitToRef(r *git.Repository, tree *git.Tree, parent *git.Commit, refname, msg string) (*git.Commit, error) {
// Retry loop in case of conflict
// FIXME: use a custom inter-process lock as a first attempt for performance
var (
needMerge bool
tmpCommit *git.Commit
)
for {
if !needMerge {
// Create simple commit
commit, err := mkCommit(r, refname, msg, tree, parent)
if isGitConcurrencyErr(err) {
needMerge = true
continue
}
return commit, err
} else {
if tmpCommit == nil {
var err error
// Create a temporary intermediary commit, to pass to MergeCommits
// NOTE: this commit will not be part of the final history.
tmpCommit, err = mkCommit(r, "", msg, tree, parent)
if err != nil {
return nil, err
}
defer tmpCommit.Free()
}
// Lookup tip from ref
tip := lookupTip(r, refname)
if tip == nil {
// Ref may have been deleted after previous merge error
needMerge = false
continue
}
// Merge simple commit with the tip
opts, err := git.DefaultMergeOptions()
if err != nil {
return nil, err
}
idx, err := r.MergeCommits(tmpCommit, tip, &opts)
if err != nil {
return nil, err
}
conflicts, err := idx.ConflictIterator()
if err != nil {
return nil, err
}
defer conflicts.Free()
for {
c, err := conflicts.Next()
if isGitIterOver(err) {
break
} else if err != nil {
return nil, err
}
if c.Our != nil {
idx.RemoveConflict(c.Our.Path)
if err := idx.Add(c.Our); err != nil {
return nil, fmt.Errorf("error resolving merge conflict for '%s': %v", c.Our.Path, err)
}
}
}
mergedId, err := idx.WriteTreeTo(r)
if err != nil {
return nil, fmt.Errorf("WriteTree: %v", err)
}
mergedTree, err := lookupTree(r, mergedId)
if err != nil {
return nil, err
}
// Create new commit from merged tree (discarding simple commit)
commit, err | {
return nil, err
} | conditional_block |
|
db.go | ()
if isGitIterOver(err) {
break
} else if err != nil {
return nil, err
}
if c.Our != nil {
idx.RemoveConflict(c.Our.Path)
if err := idx.Add(c.Our); err != nil {
return nil, fmt.Errorf("error resolving merge conflict for '%s': %v", c.Our.Path, err)
}
}
}
mergedId, err := idx.WriteTreeTo(r)
if err != nil {
return nil, fmt.Errorf("WriteTree: %v", err)
}
mergedTree, err := lookupTree(r, mergedId)
if err != nil {
return nil, err
}
// Create new commit from merged tree (discarding simple commit)
commit, err := mkCommit(r, refname, msg, mergedTree, parent, tip)
if isGitConcurrencyErr(err) {
// FIXME: enforce a maximum number of retries to avoid infinite loops
continue
}
return commit, err
}
}
return nil, fmt.Errorf("too many failed merge attempts, giving up")
}
func mkCommit(r *git.Repository, refname string, msg string, tree *git.Tree, parent *git.Commit, extraParents ...*git.Commit) (*git.Commit, error) {
var parents []*git.Commit
if parent != nil {
parents = append(parents, parent)
}
if len(extraParents) > 0 {
parents = append(parents, extraParents...)
}
id, err := r.CreateCommit(
refname,
&git.Signature{"libpack", "libpack", time.Now()}, // author
&git.Signature{"libpack", "libpack", time.Now()}, // committer
msg,
tree, // git tree to commit
parents...,
)
if err != nil {
return nil, err
}
return lookupCommit(r, id)
}
func isGitConcurrencyErr(err error) bool {
gitErr, ok := err.(*git.GitError)
if !ok {
return false
}
return gitErr.Class == 11 && gitErr.Code == -15
}
func isGitIterOver(err error) bool {
gitErr, ok := err.(*git.GitError)
if !ok {
return false
}
return gitErr.Code == git.ErrIterOver
}
// Pull downloads objects at the specified url and remote ref name,
// and updates the local ref of db.
// The uncommitted tree is left unchanged (ie uncommitted changes are
// not merged or rebased).
func (db *DB) Pull(url, ref string) error {
if ref == "" {
ref = db.ref
}
refspec := fmt.Sprintf("%s:%s", ref, db.ref)
fmt.Printf("Creating anonymous remote url=%s refspec=%s\n", url, refspec)
remote, err := db.repo.CreateAnonymousRemote(url, refspec)
if err != nil {
return err
}
defer remote.Free()
if err := remote.Fetch(nil, nil, fmt.Sprintf("libpack.pull %s %s", url, refspec)); err != nil {
return err
}
return db.Update()
}
// Push uploads the committed contents of the db at the specified url and
// remote ref name. The remote ref is created if it doesn't exist.
func (db *DB) Push(url, ref string) error {
if ref == "" {
ref = db.ref
}
// The '+' prefix sets force=true,
// so the remote ref is created if it doesn't exist.
refspec := fmt.Sprintf("+%s:%s", db.ref, ref)
remote, err := db.repo.CreateAnonymousRemote(url, refspec)
if err != nil {
return err
}
defer remote.Free()
push, err := remote.NewPush()
if err != nil {
return fmt.Errorf("git_push_new: %v", err)
}
defer push.Free()
if err := push.AddRefspec(refspec); err != nil {
return fmt.Errorf("git_push_refspec_add: %v", err)
}
if err := push.Finish(); err != nil {
return fmt.Errorf("git_push_finish: %v", err)
}
return nil
}
// Checkout populates the directory at dir with the committed
// contents of db. Uncommitted changes are ignored.
//
// As a convenience, if dir is an empty string, a temporary directory
// is created and returned, and the caller is responsible for removing it.
//
func (db *DB) Checkout(dir string) (checkoutDir string, err error) {
if db.parent != nil {
return db.parent.Checkout(path.Join(db.scope, dir))
}
head := db.Head()
if head == nil {
return "", fmt.Errorf("no head to checkout")
}
if dir == "" {
dir, err = ioutil.TempDir("", "libpack-checkout-")
if err != nil {
return "", err
}
defer func() {
if err != nil {
os.RemoveAll(dir)
}
}()
}
stderr := new(bytes.Buffer)
args := []string{
"--git-dir", db.repo.Path(), "--work-tree", dir,
"checkout", head.String(), ".",
}
cmd := exec.Command("git", args...)
cmd.Stderr = stderr
if err := cmd.Run(); err != nil {
return "", fmt.Errorf("%s", stderr.String())
}
// FIXME: enforce scoping in the git checkout command instead
// of here.
d := path.Join(dir, db.scope)
fmt.Printf("--> %s\n", d)
return d, nil
}
// Checkout populates the directory at dir with the uncommitted
// contents of db.
// FIXME: this does not work properly at the moment.
func (db *DB) CheckoutUncommitted(dir string) error {
if db.tree == nil {
return fmt.Errorf("no tree")
}
tree, err := TreeScope(db.repo, db.tree, db.scope)
if err != nil {
return err
}
// If the tree is empty, checkout will fail and there is
// nothing to do anyway
if tree.EntryCount() == 0 {
return nil
}
idx, err := ioutil.TempFile("", "libpack-index")
if err != nil {
return err
}
defer os.RemoveAll(idx.Name())
readTree := exec.Command(
"git",
"--git-dir", db.repo.Path(),
"--work-tree", dir,
"read-tree", tree.Id().String(),
)
readTree.Env = append(readTree.Env, "GIT_INDEX_FILE="+idx.Name())
stderr := new(bytes.Buffer)
readTree.Stderr = stderr
if err := readTree.Run(); err != nil {
return fmt.Errorf("%s", stderr.String())
}
checkoutIndex := exec.Command(
"git",
"--git-dir", db.repo.Path(),
"--work-tree", dir,
"checkout-index",
)
checkoutIndex.Env = append(checkoutIndex.Env, "GIT_INDEX_FILE="+idx.Name())
stderr = new(bytes.Buffer)
checkoutIndex.Stderr = stderr
if err := checkoutIndex.Run(); err != nil {
return fmt.Errorf("%s", stderr.String())
}
return nil
}
// ExecInCheckout checks out the committed contents of the database into a
// temporary directory, executes the specified command in a new subprocess
// with that directory as the working directory, then removes the directory.
//
// The standard input, output and error streams of the command are the same
// as the current process's.
func (db *DB) ExecInCheckout(path string, args ...string) error {
checkout, err := db.Checkout("")
if err != nil {
return fmt.Errorf("checkout: %v", err)
}
defer os.RemoveAll(checkout)
cmd := exec.Command(path, args...)
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
cmd.Dir = checkout
return cmd.Run()
}
// lookupTree looks up an object at hash `id` in `repo`, and returns
// it as a git tree. If the object is not a tree, an error is returned.
func (db *DB) lookupTree(id *git.Oid) (*git.Tree, error) {
return lookupTree(db.repo, id)
}
func lookupTree(r *git.Repository, id *git.Oid) (*git.Tree, error) {
obj, err := r.Lookup(id)
if err != nil {
return nil, err
}
if tree, ok := obj.(*git.Tree); ok {
return tree, nil
}
return nil, fmt.Errorf("hash %v exist but is not a tree", id)
}
// lookupBlob looks up an object at hash `id` in `repo`, and returns
// it as a git blob. If the object is not a blob, an error is returned.
func lookupBlob(r *git.Repository, id *git.Oid) (*git.Blob, error) {
obj, err := r.Lookup(id)
if err != nil {
return nil, err
}
if blob, ok := obj.(*git.Blob); ok {
return blob, nil
}
return nil, fmt.Errorf("hash %v exist but is not a blob", id)
}
// lookupTip looks up the object referenced by refname, and returns it
// as a Commit object. If the reference does not exist, or if object is
// not a commit, nil is returned. Other errors cannot be detected.
func | lookupTip | identifier_name |
|
file_hook.rs | 0x00, 0x00, 0x00, 0x00, 0x02, 0x10];
static DUMMY_SKINS: &[u8] = br#"{"skins":[]}"#;
fn check_dummied_out_hd(path: &[u8]) -> Option<&'static [u8]> {
if path.ends_with(b".anim") {
// Avoid touching tileset/foliage.anim
if path.starts_with(b"anim/") {
return Some(DUMMY_ANIM);
}
} else if path.ends_with(b".dds") {
// Font dds files are used (only) in SD, but they aren't loaded
// on file param SD.
if !path.starts_with(b"font/") {
// Anim happens to have a dds inside it :)
let dummy_dds = &DUMMY_ANIM[0x174..];
return Some(dummy_dds);
}
} else if path.ends_with(b".dds.vr4") {
return Some(DUMMY_DDSGRP);
} else if path.ends_with(b".dds.grp") {
// Avoid tileset.dds.grps, they need their frames
if path.starts_with(b"unit/") || path.starts_with(b"effect/") {
return Some(DUMMY_DDSGRP);
}
} else if path == b"anim/skins.json" {
return Some(DUMMY_SKINS);
}
None
}
/// If `params` has a file extension set, it will override whatever
/// extension `path` has.
///
/// Why it is done like that, I have no idea.
///
/// This function also normalizes to ascii lowercase and replaces any '\\' with '/'
unsafe fn real_path<'a>(
path: *const u8,
params: *const scr::OpenParams,
buffer: &'a mut ArrayVec<[u8; 256]>,
) -> Option<&'a [u8]> {
let c_path = CStr::from_ptr(path as *const i8);
let c_path = c_path.to_bytes();
let alt_extension = if (*params).extension.is_null() {
None
} else {
Some(CStr::from_ptr((*params).extension as *const i8))
};
let c_path_for_switched_extension = match alt_extension.is_some() {
true => match c_path.iter().rev().position(|&x| x == b'.') {
Some(period) => &c_path[..c_path.len() - period - 1],
None => c_path,
},
false => c_path,
};
if let Err(_) = buffer.try_extend_from_slice(c_path_for_switched_extension) {
return None;
}
if let Some(ext) = alt_extension {
if let Err(_) = buffer.try_extend_from_slice(ext.to_bytes()) {
return None;
}
}
let slice = &mut buffer[..];
for val in slice.iter_mut() {
match *val {
b'A' ..= b'Z' => {
*val = b'a' + (*val - b'A');
}
b'\\' => {
*val = b'/';
}
_ => (),
}
}
Some(slice)
}
unsafe fn memory_buffer_to_bw_file_handle(buffer: &'static [u8], handle: *mut scr::FileHandle) {
let inner = Box::new(FileAllocation {
file: FileState {
buffer,
pos: 0,
},
read: scr::FileRead {
vtable: &*FILE_READ_VTABLE,
inner: null_mut(),
},
peek: scr::FilePeek {
vtable: &*FILE_PEEK_VTABLE,
inner: null_mut(),
},
metadata: scr::FileMetadata {
vtable: &*FILE_METADATA_VTABLE,
inner: null_mut(),
},
});
let inner_ptr = Box::into_raw(inner);
(*inner_ptr).metadata.inner = inner_ptr as *mut c_void;
(*inner_ptr).peek.inner = inner_ptr as *mut c_void;
(*inner_ptr).read.inner = inner_ptr as *mut c_void;
let close_callback = scr::Function {
vtable: &*FUNCTION_VTABLE,
inner: inner_ptr as *mut c_void,
};
*handle = scr::FileHandle {
vtable: &*FILE_HANDLE_VTABLE1,
vtable2: &*FILE_HANDLE_VTABLE2,
vtable3: &*FILE_HANDLE_VTABLE3,
metadata: &mut (*inner_ptr).metadata,
peek: &mut (*inner_ptr).peek,
read: &mut (*inner_ptr).read,
file_ok: 1,
close_callback,
};
}
struct FileAllocation {
file: FileState,
read: scr::FileRead,
peek: scr::FilePeek,
metadata: scr::FileMetadata,
}
struct FileState {
buffer: &'static [u8],
pos: u32,
}
lazy_static! {
static ref FILE_HANDLE_VTABLE1: scr::V_FileHandle1 = scr::V_FileHandle1 {
destroy: Thiscall::new(file_handle_destroy_nop),
read: Thiscall::new(read_file_wrap),
skip: Thiscall::new(skip_wrap),
safety_padding: [0; 0x20],
};
static ref FILE_HANDLE_VTABLE2: scr::V_FileHandle2 = scr::V_FileHandle2 {
unk0: [0; 1],
peek: Thiscall::new(peek_wrap),
safety_padding: [0; 0x20],
};
static ref FILE_HANDLE_VTABLE3: scr::V_FileHandle3 = scr::V_FileHandle3 {
unk0: [0; 1],
tell: Thiscall::new(tell_wrap),
seek: Thiscall::new(seek_wrap),
file_size: Thiscall::new(file_size_wrap),
safety_padding: [0; 0x20],
};
static ref FILE_METADATA_VTABLE: scr::V_FileMetadata = scr::V_FileMetadata {
unk0: [0; 1],
tell: Thiscall::new(tell),
seek: Thiscall::new(seek),
file_size: Thiscall::new(file_size),
safety_padding: [0; 0x20],
};
static ref FILE_READ_VTABLE: scr::V_FileRead = scr::V_FileRead {
destroy: 0,
read: Thiscall::new(read_file),
skip: Thiscall::new(skip),
safety_padding: [0; 0x20],
};
static ref FILE_PEEK_VTABLE: scr::V_FilePeek = scr::V_FilePeek {
destroy: 0,
peek: Thiscall::new(peek),
safety_padding: [0; 0x20],
};
static ref FUNCTION_VTABLE: scr::V_Function = scr::V_Function {
destroy_inner: Thiscall::new(function_nop_destory),
invoke: Thiscall::new(close_file),
get_sizes: Thiscall::new(function_object_size),
copy: Thiscall::new(function_copy),
copy2: Thiscall::new(function_copy),
safety_padding: [0; 0x20],
};
}
unsafe extern fn file_handle_destroy_nop(_file: *mut scr::FileHandle, _dyn_free: u32) {
}
unsafe extern fn function_nop_destory(_file: *mut scr::Function, _unk: u32) {
}
unsafe extern fn function_object_size(
_file: *mut scr::Function,
size: *mut u32,
) {
*size = 0xc;
*size.add(1) = 0x4;
*(size.add(2) as *mut u8) = 0x1;
}
unsafe extern fn function_copy(this: *mut scr::Function, other: *mut scr::Function) {
*other = *this;
}
unsafe extern fn read_file_wrap(file: *mut scr::FileHandle, out: *mut u8, size: u32) -> u32 {
let read = (*file).read;
let vtable = (*read).vtable;
(*vtable).read.call3(read, out, size)
}
unsafe extern fn skip_wrap(file: *mut scr::FileHandle, size: u32) |
unsafe extern fn read_file(file: *mut scr::FileRead, out: *mut u8, size: u32) -> u32 {
let file = (*file).inner as *mut FileAllocation;
let buf = std::slice::from_raw_parts_mut(out, size as usize);
(*file).file.read(buf)
}
unsafe extern fn skip(file: *mut scr::FileRead, size: u32) {
let file = (*file).inner as *mut FileAllocation;
let pos = (*file).file.tell();
(*file).file.seek(pos.saturating_add(size));
}
unsafe extern fn peek_wrap(file: *mut c_void, out: *mut u8, size: u32) -> u32 {
let file = (file as usize - 4) as *mut scr::FileHandle;
let peek = (*file). | {
let read = (*file).read;
let vtable = (*read).vtable;
(*vtable).skip.call2(read, size)
} | identifier_body |
file_hook.rs | 0x00, 0x00, 0x00, 0x00, 0x02, 0x10];
static DUMMY_SKINS: &[u8] = br#"{"skins":[]}"#;
fn check_dummied_out_hd(path: &[u8]) -> Option<&'static [u8]> {
if path.ends_with(b".anim") {
// Avoid touching tileset/foliage.anim
if path.starts_with(b"anim/") {
return Some(DUMMY_ANIM);
}
} else if path.ends_with(b".dds") {
// Font dds files are used (only) in SD, but they aren't loaded
// on file param SD.
if !path.starts_with(b"font/") {
// Anim happens to have a dds inside it :)
let dummy_dds = &DUMMY_ANIM[0x174..];
return Some(dummy_dds);
}
} else if path.ends_with(b".dds.vr4") {
return Some(DUMMY_DDSGRP);
} else if path.ends_with(b".dds.grp") {
// Avoid tileset.dds.grps, they need their frames
if path.starts_with(b"unit/") || path.starts_with(b"effect/") {
return Some(DUMMY_DDSGRP);
}
} else if path == b"anim/skins.json" {
return Some(DUMMY_SKINS);
}
None
}
/// If `params` has a file extension set, it will override whatever
/// extension `path` has.
///
/// Why it is done like that, I have no idea.
///
/// This function also normalizes to ascii lowercase and replaces any '\\' with '/'
unsafe fn real_path<'a>(
path: *const u8,
params: *const scr::OpenParams,
buffer: &'a mut ArrayVec<[u8; 256]>,
) -> Option<&'a [u8]> {
let c_path = CStr::from_ptr(path as *const i8);
let c_path = c_path.to_bytes();
let alt_extension = if (*params).extension.is_null() {
None
} else {
Some(CStr::from_ptr((*params).extension as *const i8))
};
| true => match c_path.iter().rev().position(|&x| x == b'.') {
Some(period) => &c_path[..c_path.len() - period - 1],
None => c_path,
},
false => c_path,
};
if let Err(_) = buffer.try_extend_from_slice(c_path_for_switched_extension) {
return None;
}
if let Some(ext) = alt_extension {
if let Err(_) = buffer.try_extend_from_slice(ext.to_bytes()) {
return None;
}
}
let slice = &mut buffer[..];
for val in slice.iter_mut() {
match *val {
b'A' ..= b'Z' => {
*val = b'a' + (*val - b'A');
}
b'\\' => {
*val = b'/';
}
_ => (),
}
}
Some(slice)
}
unsafe fn memory_buffer_to_bw_file_handle(buffer: &'static [u8], handle: *mut scr::FileHandle) {
let inner = Box::new(FileAllocation {
file: FileState {
buffer,
pos: 0,
},
read: scr::FileRead {
vtable: &*FILE_READ_VTABLE,
inner: null_mut(),
},
peek: scr::FilePeek {
vtable: &*FILE_PEEK_VTABLE,
inner: null_mut(),
},
metadata: scr::FileMetadata {
vtable: &*FILE_METADATA_VTABLE,
inner: null_mut(),
},
});
let inner_ptr = Box::into_raw(inner);
(*inner_ptr).metadata.inner = inner_ptr as *mut c_void;
(*inner_ptr).peek.inner = inner_ptr as *mut c_void;
(*inner_ptr).read.inner = inner_ptr as *mut c_void;
let close_callback = scr::Function {
vtable: &*FUNCTION_VTABLE,
inner: inner_ptr as *mut c_void,
};
*handle = scr::FileHandle {
vtable: &*FILE_HANDLE_VTABLE1,
vtable2: &*FILE_HANDLE_VTABLE2,
vtable3: &*FILE_HANDLE_VTABLE3,
metadata: &mut (*inner_ptr).metadata,
peek: &mut (*inner_ptr).peek,
read: &mut (*inner_ptr).read,
file_ok: 1,
close_callback,
};
}
struct FileAllocation {
file: FileState,
read: scr::FileRead,
peek: scr::FilePeek,
metadata: scr::FileMetadata,
}
struct FileState {
buffer: &'static [u8],
pos: u32,
}
lazy_static! {
static ref FILE_HANDLE_VTABLE1: scr::V_FileHandle1 = scr::V_FileHandle1 {
destroy: Thiscall::new(file_handle_destroy_nop),
read: Thiscall::new(read_file_wrap),
skip: Thiscall::new(skip_wrap),
safety_padding: [0; 0x20],
};
static ref FILE_HANDLE_VTABLE2: scr::V_FileHandle2 = scr::V_FileHandle2 {
unk0: [0; 1],
peek: Thiscall::new(peek_wrap),
safety_padding: [0; 0x20],
};
static ref FILE_HANDLE_VTABLE3: scr::V_FileHandle3 = scr::V_FileHandle3 {
unk0: [0; 1],
tell: Thiscall::new(tell_wrap),
seek: Thiscall::new(seek_wrap),
file_size: Thiscall::new(file_size_wrap),
safety_padding: [0; 0x20],
};
static ref FILE_METADATA_VTABLE: scr::V_FileMetadata = scr::V_FileMetadata {
unk0: [0; 1],
tell: Thiscall::new(tell),
seek: Thiscall::new(seek),
file_size: Thiscall::new(file_size),
safety_padding: [0; 0x20],
};
static ref FILE_READ_VTABLE: scr::V_FileRead = scr::V_FileRead {
destroy: 0,
read: Thiscall::new(read_file),
skip: Thiscall::new(skip),
safety_padding: [0; 0x20],
};
static ref FILE_PEEK_VTABLE: scr::V_FilePeek = scr::V_FilePeek {
destroy: 0,
peek: Thiscall::new(peek),
safety_padding: [0; 0x20],
};
static ref FUNCTION_VTABLE: scr::V_Function = scr::V_Function {
destroy_inner: Thiscall::new(function_nop_destory),
invoke: Thiscall::new(close_file),
get_sizes: Thiscall::new(function_object_size),
copy: Thiscall::new(function_copy),
copy2: Thiscall::new(function_copy),
safety_padding: [0; 0x20],
};
}
unsafe extern fn file_handle_destroy_nop(_file: *mut scr::FileHandle, _dyn_free: u32) {
}
unsafe extern fn function_nop_destory(_file: *mut scr::Function, _unk: u32) {
}
unsafe extern fn function_object_size(
_file: *mut scr::Function,
size: *mut u32,
) {
*size = 0xc;
*size.add(1) = 0x4;
*(size.add(2) as *mut u8) = 0x1;
}
unsafe extern fn function_copy(this: *mut scr::Function, other: *mut scr::Function) {
*other = *this;
}
unsafe extern fn read_file_wrap(file: *mut scr::FileHandle, out: *mut u8, size: u32) -> u32 {
let read = (*file).read;
let vtable = (*read).vtable;
(*vtable).read.call3(read, out, size)
}
unsafe extern fn skip_wrap(file: *mut scr::FileHandle, size: u32) {
let read = (*file).read;
let vtable = (*read).vtable;
(*vtable).skip.call2(read, size)
}
unsafe extern fn read_file(file: *mut scr::FileRead, out: *mut u8, size: u32) -> u32 {
let file = (*file).inner as *mut FileAllocation;
let buf = std::slice::from_raw_parts_mut(out, size as usize);
(*file).file.read(buf)
}
unsafe extern fn skip(file: *mut scr::FileRead, size: u32) {
let file = (*file).inner as *mut FileAllocation;
let pos = (*file).file.tell();
(*file).file.seek(pos.saturating_add(size));
}
unsafe extern fn peek_wrap(file: *mut c_void, out: *mut u8, size: u32) -> u32 {
let file = (file as usize - 4) as *mut scr::FileHandle;
let peek = (*file).peek | let c_path_for_switched_extension = match alt_extension.is_some() { | random_line_split |
file_hook.rs | 0x00, 0x00, 0x00, 0x00, 0x02, 0x10];
static DUMMY_SKINS: &[u8] = br#"{"skins":[]}"#;
fn check_dummied_out_hd(path: &[u8]) -> Option<&'static [u8]> {
if path.ends_with(b".anim") {
// Avoid touching tileset/foliage.anim
if path.starts_with(b"anim/") {
return Some(DUMMY_ANIM);
}
} else if path.ends_with(b".dds") {
// Font dds files are used (only) in SD, but they aren't loaded
// on file param SD.
if !path.starts_with(b"font/") {
// Anim happens to have a dds inside it :)
let dummy_dds = &DUMMY_ANIM[0x174..];
return Some(dummy_dds);
}
} else if path.ends_with(b".dds.vr4") {
return Some(DUMMY_DDSGRP);
} else if path.ends_with(b".dds.grp") {
// Avoid tileset.dds.grps, they need their frames
if path.starts_with(b"unit/") || path.starts_with(b"effect/") {
return Some(DUMMY_DDSGRP);
}
} else if path == b"anim/skins.json" {
return Some(DUMMY_SKINS);
}
None
}
/// If `params` has a file extension set, it will override whatever
/// extension `path` has.
///
/// Why it is done like that, I have no idea.
///
/// This function also normalizes to ascii lowercase and replaces any '\\' with '/'
unsafe fn real_path<'a>(
path: *const u8,
params: *const scr::OpenParams,
buffer: &'a mut ArrayVec<[u8; 256]>,
) -> Option<&'a [u8]> {
let c_path = CStr::from_ptr(path as *const i8);
let c_path = c_path.to_bytes();
let alt_extension = if (*params).extension.is_null() {
None
} else {
Some(CStr::from_ptr((*params).extension as *const i8))
};
let c_path_for_switched_extension = match alt_extension.is_some() {
true => match c_path.iter().rev().position(|&x| x == b'.') {
Some(period) => &c_path[..c_path.len() - period - 1],
None => c_path,
},
false => c_path,
};
if let Err(_) = buffer.try_extend_from_slice(c_path_for_switched_extension) {
return None;
}
if let Some(ext) = alt_extension {
if let Err(_) = buffer.try_extend_from_slice(ext.to_bytes()) {
return None;
}
}
let slice = &mut buffer[..];
for val in slice.iter_mut() {
match *val {
b'A' ..= b'Z' => {
*val = b'a' + (*val - b'A');
}
b'\\' => {
*val = b'/';
}
_ => (),
}
}
Some(slice)
}
unsafe fn | (buffer: &'static [u8], handle: *mut scr::FileHandle) {
let inner = Box::new(FileAllocation {
file: FileState {
buffer,
pos: 0,
},
read: scr::FileRead {
vtable: &*FILE_READ_VTABLE,
inner: null_mut(),
},
peek: scr::FilePeek {
vtable: &*FILE_PEEK_VTABLE,
inner: null_mut(),
},
metadata: scr::FileMetadata {
vtable: &*FILE_METADATA_VTABLE,
inner: null_mut(),
},
});
let inner_ptr = Box::into_raw(inner);
(*inner_ptr).metadata.inner = inner_ptr as *mut c_void;
(*inner_ptr).peek.inner = inner_ptr as *mut c_void;
(*inner_ptr).read.inner = inner_ptr as *mut c_void;
let close_callback = scr::Function {
vtable: &*FUNCTION_VTABLE,
inner: inner_ptr as *mut c_void,
};
*handle = scr::FileHandle {
vtable: &*FILE_HANDLE_VTABLE1,
vtable2: &*FILE_HANDLE_VTABLE2,
vtable3: &*FILE_HANDLE_VTABLE3,
metadata: &mut (*inner_ptr).metadata,
peek: &mut (*inner_ptr).peek,
read: &mut (*inner_ptr).read,
file_ok: 1,
close_callback,
};
}
struct FileAllocation {
file: FileState,
read: scr::FileRead,
peek: scr::FilePeek,
metadata: scr::FileMetadata,
}
struct FileState {
buffer: &'static [u8],
pos: u32,
}
lazy_static! {
static ref FILE_HANDLE_VTABLE1: scr::V_FileHandle1 = scr::V_FileHandle1 {
destroy: Thiscall::new(file_handle_destroy_nop),
read: Thiscall::new(read_file_wrap),
skip: Thiscall::new(skip_wrap),
safety_padding: [0; 0x20],
};
static ref FILE_HANDLE_VTABLE2: scr::V_FileHandle2 = scr::V_FileHandle2 {
unk0: [0; 1],
peek: Thiscall::new(peek_wrap),
safety_padding: [0; 0x20],
};
static ref FILE_HANDLE_VTABLE3: scr::V_FileHandle3 = scr::V_FileHandle3 {
unk0: [0; 1],
tell: Thiscall::new(tell_wrap),
seek: Thiscall::new(seek_wrap),
file_size: Thiscall::new(file_size_wrap),
safety_padding: [0; 0x20],
};
static ref FILE_METADATA_VTABLE: scr::V_FileMetadata = scr::V_FileMetadata {
unk0: [0; 1],
tell: Thiscall::new(tell),
seek: Thiscall::new(seek),
file_size: Thiscall::new(file_size),
safety_padding: [0; 0x20],
};
static ref FILE_READ_VTABLE: scr::V_FileRead = scr::V_FileRead {
destroy: 0,
read: Thiscall::new(read_file),
skip: Thiscall::new(skip),
safety_padding: [0; 0x20],
};
static ref FILE_PEEK_VTABLE: scr::V_FilePeek = scr::V_FilePeek {
destroy: 0,
peek: Thiscall::new(peek),
safety_padding: [0; 0x20],
};
static ref FUNCTION_VTABLE: scr::V_Function = scr::V_Function {
destroy_inner: Thiscall::new(function_nop_destory),
invoke: Thiscall::new(close_file),
get_sizes: Thiscall::new(function_object_size),
copy: Thiscall::new(function_copy),
copy2: Thiscall::new(function_copy),
safety_padding: [0; 0x20],
};
}
unsafe extern fn file_handle_destroy_nop(_file: *mut scr::FileHandle, _dyn_free: u32) {
}
unsafe extern fn function_nop_destory(_file: *mut scr::Function, _unk: u32) {
}
unsafe extern fn function_object_size(
_file: *mut scr::Function,
size: *mut u32,
) {
*size = 0xc;
*size.add(1) = 0x4;
*(size.add(2) as *mut u8) = 0x1;
}
unsafe extern fn function_copy(this: *mut scr::Function, other: *mut scr::Function) {
*other = *this;
}
unsafe extern fn read_file_wrap(file: *mut scr::FileHandle, out: *mut u8, size: u32) -> u32 {
let read = (*file).read;
let vtable = (*read).vtable;
(*vtable).read.call3(read, out, size)
}
unsafe extern fn skip_wrap(file: *mut scr::FileHandle, size: u32) {
let read = (*file).read;
let vtable = (*read).vtable;
(*vtable).skip.call2(read, size)
}
unsafe extern fn read_file(file: *mut scr::FileRead, out: *mut u8, size: u32) -> u32 {
let file = (*file).inner as *mut FileAllocation;
let buf = std::slice::from_raw_parts_mut(out, size as usize);
(*file).file.read(buf)
}
unsafe extern fn skip(file: *mut scr::FileRead, size: u32) {
let file = (*file).inner as *mut FileAllocation;
let pos = (*file).file.tell();
(*file).file.seek(pos.saturating_add(size));
}
unsafe extern fn peek_wrap(file: *mut c_void, out: *mut u8, size: u32) -> u32 {
let file = (file as usize - 4) as *mut scr::FileHandle;
let peek = (*file).peek | memory_buffer_to_bw_file_handle | identifier_name |
evaluate.ts | max = 6;
private localIds = [];
private serverIds = [];
private isweb = false;
private allowDelete: boolean = true;
private len = 0;
private imgUrl = [];
private WimgUrl = [];
constructor(public navCtrl: NavController,
public navParams: NavParams,
private httpService: HttpService,
private nativeService: NativeService,
private storage: Storage,
private viewCtrl: ViewController,
public alertCtrl: AlertController, ) {
this.goodslist = navParams.get("goodsDetail");
this.typenum = navParams.get("num");
this.goodsDetail = this.goodslist.Items[this.typenum];
this.storage.get("userinfo").then(val => {
// //console.info(val);
if (val != "") {
if (val.userinform.ID == "") {
this.navCtrl.push("LoginPage", { showflag: true });
} else {
this.userID = val.userinform.ID;
}
} else {
this.navCtrl.push("LoginPage", { showflag: true });
}
});
this.isweb = !this.nativeService.isMobile();
}
ionViewDidLoad() {
}
givestaar(i) {
this.list = [{ "statue": false }, { "statue": false }, { "statue": false }, { "statue": false }, { "statue": false },];
for (var n = 0; n < (i + 1); n++) {
this.list[n].statue = true;
};
this.num = (i + 1)
if (i == 0) {
this.status = "非常差";
} else if (i == 1) {
this.status = "差";
} else if (i == 2) {
this.status = "一般";
} else if (i == 3) {
this.status = "好";
} else if (i == 4) {
this.status = "非常好";
};
////console.info(i);
}
comment() {
if (this.textarea == '') {
this.nativeService.showToast("评论内容不能为空！");
return;
} else {
if (!this.isweb) {
if (this.fileObjList == null || this.fileObjList.length <= 0) {
this.login([]);
} else {
this.login(this.fileObjList);
// this.HaveImage = 1;
// var filearray: any[] = [];
// for (var i = 0; i < this.fileObjList.length; i++) {
// filearray.push(this.fileObjList[i].origPath);
// }
// this.nativeService.showLoading("提交中");
// this.nativeService.uploadFileByMutiTranser(filearray).then(val => {
// this.login(val);
// });
}
} else {
if (this.imgUrl == null || this.imgUrl.length <= 0) {
this.login([]);
} else {
this.login(this.imgUrl);
}
}
}
}
login(filearray: any[]) {
//console.info(this.fileObjList[0])
var userInfo = {
Userid: this.userID,
goodsID: this.goodsDetail.ProductID,
Detail: this.textarea,
anonymity: 0,
Degree: this.num,
orderID: this.goodslist.ID,
file: this.fileObjList,
HaveImage: this.HaveImage,
itemID: this.goodsDetail.itemID
};
//console.info(userInfo);
var parameter = new Parameter();
parameter.jyh = "1024";
parameter.parm = JSON.stringify(userInfo);
this.nativeService.showLoading("提交中");
this.httpService.post("/MobService/Index", parameter).map(res => res.json()).subscribe(res => {
this.nativeService.hideLoading();
var result = JSON.parse(res.result);
//console.info(result);
if (result.Code == 1) {
this.nativeService.showToast(result.Msg);
this.goodslist.Items[this.typenum].IsEvaluate = 1
this.viewCtrl.dismiss(this.goodslist);
} else {
this.nativeService.showToast(result.Msg);
}
});
}
slice(string) {
if (string != "" && string != null) {
return string.slice(0, 18) + "...";
}
}
closealert() {
let confirm = this.alertCtrl.create({
title: '是否放弃评价',
buttons: [
{
text: '否',
handler: () => {
//console.log('Disagree clicked');
}
},
{
text: '是',
handler: () => {
this.viewCtrl.dismiss();
}
}
]
});
confirm.present();
}
addWxPicture() {
var that = this;
wx.chooseImage({
count: that.max - that.len, // 默认9
sizeType: ['original', 'compressed'], // 可以指定是原图还是压缩图，默认二者都有
sourceType: ['album', 'camera'], // 可以指定来源是相册还是相机，默认二者都有
success: function (res) {
var localIds = res.localIds;
that.len = localIds.length; // 返回选定照片的本地ID列表，localId可以作为img标签的src属性显示图片
// for (var i = 0; i < localIds.length; i++) {
that.WxUpLoad(localIds);
// }
// wx.getLocalImgData({
// localId: localIds, // 图片的localID
// success: function (res) {
// var localData = res.localData;
// that.localIds = localData; // localData是图片的base64数据，可以用img标签显示
// }
// });
}
});
}
WxUpLoad(localIds: string[]) {
var that = this;
var localId = localIds.pop();
wx.uploadImage({
localId: localId,
success: function (res) {
var serverId = res.serverId;
that.serverIds.push(serverId);
//console.info("serverId》》》》》" + serverId)
if (localIds.length > 0) {
that.WxUpLoad(localIds);
} else {
// setTimeout(() => {
// that.input.setFocus();
// }, 500);
}
that.WxDownLoadImage(serverId);
// if (that.len == that.serverIds.length) {
// that.WxDownLoadImage(serverId);
// }
}
});
}
viewerWxPicture(item) {
alert(item);
var that = this;
wx.previewImage({
current: item, // 当前显示图片的http链接
urls: that.localIds // 需要预览的图片http链接列表
});
}
deleteWxPicture(i) {//删除照片
if (!this.allowDelete) {
return;
}
this.alertCtrl.create({
title: '确认删除？',
buttons: [{ text: '取消' },
{
text: '确定',
handler: () => {
// this.imgUrl.splice(i, 1);
// this.WimgUrl.splice(i, 1);
this.fileObjList.splice(i, 1);
// this.len--;
}
}
]
}).present();
}
WxDownLoadImage(serverId) {
this.nativeService.uploadWxFile(serverId).subscribe(res => {
var result = JSON.parse(res.result);
if (result.Code == "1") {
this.WimgUrl.push(fileViewPath + result.Msg);
this.imgUrl.push(result.Msg);
//console.info("成功" + this.WimgUrl)
| sole.info("不成功" + result)
});
}
getImg() {
if (!this.nativeService.isMobile()) {
this.addWxPicture();
}
}
onChange1(event: any) {
if(this.fileObjList.length<6){
}else{
this.nativeService.showToast("最多只能上传6张图片");
return
}
let files = event.target.files;
var file = files[0];
var size = files[0].size / 1024 > 1024 ? (~~(10 * files[0].size / 1024 / 1024)) / 10 + "MB" : ~~(files[0].size / 1024) + "KB";
this.nativeService.showLoading("获取中");
//console.info("大小" + size)
//console.info(file);
if (file == undefined) {
this.IDUrl = "";
//console.info("undefiend1")
} else {
//console.info("undefiend2")
let fileReader = new FileReader();
fileReader.readAsDataURL(file);
var that = this;
fileReader.onload = function (e) {
var name: any;
name = e.target
that.IDUrl = name.result;
//console.info(that.IDUrl);
that.fileObjList.push(that.IDUrl);
// that.takeimg(name.result, 1);
}
}
this.nativeService.hideLoading();
}
takeimg(result, num) {
var result = result;
var that = this;
var maxSize = 100 * | }
//con | identifier_name |
evaluate.ts | max = 6;
private localIds = [];
private serverIds = [];
private isweb = false;
private allowDelete: boolean = true;
private len = 0;
private imgUrl = [];
private WimgUrl = [];
constructor(public navCtrl: NavController,
public navParams: NavParams,
private httpService: HttpService,
private nativeService: NativeService,
private storage: Storage,
private viewCtrl: ViewController,
public alertCtrl: AlertController, ) {
this.goodslist = navParams.get("goodsDetail");
this.typenum = navParams.get("num");
this.goodsDetail = this.goodslist.Items[this.typenum];
this.storage.get("userinfo").then(val => {
// //console.info(val);
if (val != "") {
if (val.userinform.ID == "") {
this.navCtrl.push("LoginPage", { showflag: true });
} else {
this.userID = val.userinform.ID;
}
} else {
this.navCtrl.push("LoginPage", { showflag: true });
}
});
this.isweb = !this.nativeService.isMobile();
}
ionViewDidLoad() |
givestaar(i) {
this.list = [{ "statue": false }, { "statue": false }, { "statue": false }, { "statue": false }, { "statue": false },];
for (var n = 0; n < (i + 1); n++) {
this.list[n].statue = true;
};
this.num = (i + 1)
if (i == 0) {
this.status = "非常差";
} else if (i == 1) {
this.status = "差";
} else if (i == 2) {
this.status = "一般";
} else if (i == 3) {
this.status = "好";
} else if (i == 4) {
this.status = "非常好";
};
////console.info(i);
}
comment() {
if (this.textarea == '') {
this.nativeService.showToast("评论内容不能为空！");
return;
} else {
if (!this.isweb) {
if (this.fileObjList == null || this.fileObjList.length <= 0) {
this.login([]);
} else {
this.login(this.fileObjList);
// this.HaveImage = 1;
// var filearray: any[] = [];
// for (var i = 0; i < this.fileObjList.length; i++) {
// filearray.push(this.fileObjList[i].origPath);
// }
// this.nativeService.showLoading("提交中");
// this.nativeService.uploadFileByMutiTranser(filearray).then(val => {
// this.login(val);
// });
}
} else {
if (this.imgUrl == null || this.imgUrl.length <= 0) {
this.login([]);
} else {
this.login(this.imgUrl);
}
}
}
}
login(filearray: any[]) {
//console.info(this.fileObjList[0])
var userInfo = {
Userid: this.userID,
goodsID: this.goodsDetail.ProductID,
Detail: this.textarea,
anonymity: 0,
Degree: this.num,
orderID: this.goodslist.ID,
file: this.fileObjList,
HaveImage: this.HaveImage,
itemID: this.goodsDetail.itemID
};
//console.info(userInfo);
var parameter = new Parameter();
parameter.jyh = "1024";
parameter.parm = JSON.stringify(userInfo);
this.nativeService.showLoading("提交中");
this.httpService.post("/MobService/Index", parameter).map(res => res.json()).subscribe(res => {
this.nativeService.hideLoading();
var result = JSON.parse(res.result);
//console.info(result);
if (result.Code == 1) {
this.nativeService.showToast(result.Msg);
this.goodslist.Items[this.typenum].IsEvaluate = 1
this.viewCtrl.dismiss(this.goodslist);
} else {
this.nativeService.showToast(result.Msg);
}
});
}
slice(string) {
if (string != "" && string != null) {
return string.slice(0, 18) + "...";
}
}
closealert() {
let confirm = this.alertCtrl.create({
title: '是否放弃评价',
buttons: [
{
text: '否',
handler: () => {
//console.log('Disagree clicked');
}
},
{
text: '是',
handler: () => {
this.viewCtrl.dismiss();
}
}
]
});
confirm.present();
}
addWxPicture() {
var that = this;
wx.chooseImage({
count: that.max - that.len, // 默认9
sizeType: ['original', 'compressed'], // 可以指定是原图还是压缩图，默认二者都有
sourceType: ['album', 'camera'], // 可以指定来源是相册还是相机，默认二者都有
success: function (res) {
var localIds = res.localIds;
that.len = localIds.length; // 返回选定照片的本地ID列表，localId可以作为img标签的src属性显示图片
// for (var i = 0; i < localIds.length; i++) {
that.WxUpLoad(localIds);
// }
// wx.getLocalImgData({
// localId: localIds, // 图片的localID
// success: function (res) {
// var localData = res.localData;
// that.localIds = localData; // localData是图片的base64数据，可以用img标签显示
// }
// });
}
});
}
WxUpLoad(localIds: string[]) {
var that = this;
var localId = localIds.pop();
wx.uploadImage({
localId: localId,
success: function (res) {
var serverId = res.serverId;
that.serverIds.push(serverId);
//console.info("serverId》》》》》" + serverId)
if (localIds.length > 0) {
that.WxUpLoad(localIds);
} else {
// setTimeout(() => {
// that.input.setFocus();
// }, 500);
}
that.WxDownLoadImage(serverId);
// if (that.len == that.serverIds.length) {
// that.WxDownLoadImage(serverId);
// }
}
});
}
viewerWxPicture(item) {
alert(item);
var that = this;
wx.previewImage({
current: item, // 当前显示图片的http链接
urls: that.localIds // 需要预览的图片http链接列表
});
}
deleteWxPicture(i) {//删除照片
if (!this.allowDelete) {
return;
}
this.alertCtrl.create({
title: '确认删除？',
buttons: [{ text: '取消' },
{
text: '确定',
handler: () => {
// this.imgUrl.splice(i, 1);
// this.WimgUrl.splice(i, 1);
this.fileObjList.splice(i, 1);
// this.len--;
}
}
]
}).present();
}
WxDownLoadImage(serverId) {
this.nativeService.uploadWxFile(serverId).subscribe(res => {
var result = JSON.parse(res.result);
if (result.Code == "1") {
this.WimgUrl.push(fileViewPath + result.Msg);
this.imgUrl.push(result.Msg);
//console.info("成功" + this.WimgUrl)
}
//console.info("不成功" + result)
});
}
getImg() {
if (!this.nativeService.isMobile()) {
this.addWxPicture();
}
}
onChange1(event: any) {
if(this.fileObjList.length<6){
}else{
this.nativeService.showToast("最多只能上传6张图片");
return
}
let files = event.target.files;
var file = files[0];
var size = files[0].size / 1024 > 1024 ? (~~(10 * files[0].size / 1024 / 1024)) / 10 + "MB" : ~~(files[0].size / 1024) + "KB";
this.nativeService.showLoading("获取中");
//console.info("大小" + size)
//console.info(file);
if (file == undefined) {
this.IDUrl = "";
//console.info("undefiend1")
} else {
//console.info("undefiend2")
let fileReader = new FileReader();
fileReader.readAsDataURL(file);
var that = this;
fileReader.onload = function (e) {
var name: any;
name = e.target
that.IDUrl = name.result;
//console.info(that.IDUrl);
that.fileObjList.push(that.IDUrl);
// that.takeimg(name.result, 1);
}
}
this.nativeService.hideLoading();
}
takeimg(result, num) {
var result = result;
var that = this;
var maxSize = 100 * | {
} | identifier_body |
evaluate.ts | private max = 6;
private localIds = [];
private serverIds = [];
private isweb = false;
private allowDelete: boolean = true;
private len = 0;
private imgUrl = [];
private WimgUrl = [];
constructor(public navCtrl: NavController,
public navParams: NavParams,
private httpService: HttpService,
private nativeService: NativeService,
private storage: Storage,
private viewCtrl: ViewController,
public alertCtrl: AlertController, ) {
this.goodslist = navParams.get("goodsDetail");
this.typenum = navParams.get("num");
this.goodsDetail = this.goodslist.Items[this.typenum];
this.storage.get("userinfo").then(val => {
// //console.info(val);
if (val != "") {
if (val.userinform.ID == "") {
this.navCtrl.push("LoginPage", { showflag: true });
} else {
this.userID = val.userinform.ID;
}
} else {
this.navCtrl.push("LoginPage", { showflag: true });
}
});
this.isweb = !this.nativeService.isMobile();
}
ionViewDidLoad() {
}
givestaar(i) {
this.list = [{ "statue": false }, { "statue": false }, { "statue": false }, { "statue": false }, { "statue": false },];
for (var n = 0; n < (i + 1); n++) {
this.list[n].statue = true;
};
this.num = (i + 1)
if (i == 0) {
this.status = "非常差";
} else if (i == 1) {
this.status = "差";
} else if (i == 2) {
this.status = "一般";
} else if (i == 3) {
this.status = "好";
} else if (i == 4) {
this.status = "非常好";
};
////console.info(i);
}
comment() {
if (this.textarea == '') {
this.nativeService.showToast("评论内容不能为空！");
return;
} else {
if (!this.isweb) {
if (this.fileObjList == null || this.fileObjList.length <= 0) {
this.login([]);
} else {
this.login(this.fileObjList);
// this.HaveImage = 1;
// var filearray: any[] = [];
// for (var i = 0; i < this.fileObjList.length; i++) {
// filearray.push(this.fileObjList[i].origPath);
// }
// this.nativeService.showLoading("提交中");
// this.nativeService.uploadFileByMutiTranser(filearray).then(val => {
// this.login(val);
// });
}
} else {
if (this.imgUrl == null || this.imgUrl.length <= 0) {
this.login([]);
} else {
this.login(this.imgUrl);
}
}
}
}
login(filearray: any[]) {
//console.info(this.fileObjList[0])
var userInfo = {
Userid: this.userID,
goodsID: this.goodsDetail.ProductID,
Detail: this.textarea,
anonymity: 0,
Degree: this.num,
orderID: this.goodslist.ID,
file: this.fileObjList,
HaveImage: this.HaveImage,
itemID: this.goodsDetail.itemID
};
//console.info(userInfo);
var parameter = new Parameter();
parameter.jyh = "1024";
parameter.parm = JSON.stringify(userInfo);
this.nativeService.showLoading("提交中");
this.httpService.post("/MobService/Index", parameter).map(res => res.json()).subscribe(res => {
this.nativeService.hideLoading();
var result = JSON.parse(res.result);
//console.info(result);
if (result.Code == 1) {
this.nativeService.showToast(result.Msg);
this.goodslist.Items[this.typenum].IsEvaluate = 1
this.viewCtrl.dismiss(this.goodslist);
} else {
this.nativeService.showToast(result.Msg);
}
});
}
slice(string) {
if (string != "" && string != null) {
return string.slice(0, 18) + "...";
}
}
closealert() {
let confirm = this.alertCtrl.create({
title: '是否放弃评价',
buttons: [
{
text: '否',
handler: () => {
//console.log('Disagree clicked');
}
},
{
text: '是',
handler: () => {
this.viewCtrl.dismiss();
}
}
]
});
confirm.present();
}
addWxPicture() {
var that = this;
wx.chooseImage({
count: that.max - that.len, // 默认9
sizeType: ['original', 'compressed'], // 可以指定是原图还是压缩图，默认二者都有 | // for (var i = 0; i < localIds.length; i++) {
that.WxUpLoad(localIds);
// }
// wx.getLocalImgData({
// localId: localIds, // 图片的localID
// success: function (res) {
// var localData = res.localData;
// that.localIds = localData; // localData是图片的base64数据，可以用img标签显示
// }
// });
}
});
}
WxUpLoad(localIds: string[]) {
var that = this;
var localId = localIds.pop();
wx.uploadImage({
localId: localId,
success: function (res) {
var serverId = res.serverId;
that.serverIds.push(serverId);
//console.info("serverId》》》》》" + serverId)
if (localIds.length > 0) {
that.WxUpLoad(localIds);
} else {
// setTimeout(() => {
// that.input.setFocus();
// }, 500);
}
that.WxDownLoadImage(serverId);
// if (that.len == that.serverIds.length) {
// that.WxDownLoadImage(serverId);
// }
}
});
}
viewerWxPicture(item) {
alert(item);
var that = this;
wx.previewImage({
current: item, // 当前显示图片的http链接
urls: that.localIds // 需要预览的图片http链接列表
});
}
deleteWxPicture(i) {//删除照片
if (!this.allowDelete) {
return;
}
this.alertCtrl.create({
title: '确认删除？',
buttons: [{ text: '取消' },
{
text: '确定',
handler: () => {
// this.imgUrl.splice(i, 1);
// this.WimgUrl.splice(i, 1);
this.fileObjList.splice(i, 1);
// this.len--;
}
}
]
}).present();
}
WxDownLoadImage(serverId) {
this.nativeService.uploadWxFile(serverId).subscribe(res => {
var result = JSON.parse(res.result);
if (result.Code == "1") {
this.WimgUrl.push(fileViewPath + result.Msg);
this.imgUrl.push(result.Msg);
//console.info("成功" + this.WimgUrl)
}
//console.info("不成功" + result)
});
}
getImg() {
if (!this.nativeService.isMobile()) {
this.addWxPicture();
}
}
onChange1(event: any) {
if(this.fileObjList.length<6){
}else{
this.nativeService.showToast("最多只能上传6张图片");
return
}
let files = event.target.files;
var file = files[0];
var size = files[0].size / 1024 > 1024 ? (~~(10 * files[0].size / 1024 / 1024)) / 10 + "MB" : ~~(files[0].size / 1024) + "KB";
this.nativeService.showLoading("获取中");
//console.info("大小" + size)
//console.info(file);
if (file == undefined) {
this.IDUrl = "";
//console.info("undefiend1")
} else {
//console.info("undefiend2")
let fileReader = new FileReader();
fileReader.readAsDataURL(file);
var that = this;
fileReader.onload = function (e) {
var name: any;
name = e.target
that.IDUrl = name.result;
//console.info(that.IDUrl);
that.fileObjList.push(that.IDUrl);
// that.takeimg(name.result, 1);
}
}
this.nativeService.hideLoading();
}
takeimg(result, num) {
var result = result;
var that = this;
var maxSize = 100 * 102 | sourceType: ['album', 'camera'], // 可以指定来源是相册还是相机，默认二者都有
success: function (res) {
var localIds = res.localIds;
that.len = localIds.length; // 返回选定照片的本地ID列表，localId可以作为img标签的src属性显示图片 | random_line_split |
evaluate.ts | max = 6;
private localIds = [];
private serverIds = [];
private isweb = false;
private allowDelete: boolean = true;
private len = 0;
private imgUrl = [];
private WimgUrl = [];
constructor(public navCtrl: NavController,
public navParams: NavParams,
private httpService: HttpService,
private nativeService: NativeService,
private storage: Storage,
private viewCtrl: ViewController,
public alertCtrl: AlertController, ) {
this.goodslist = navParams.get("goodsDetail");
this.typenum = navParams.get("num");
this.goodsDetail = this.goodslist.Items[this.typenum];
this.storage.get("userinfo").then(val => {
// //console.info(val);
if (val != "") {
if (val.userinform.ID == "") {
this.navCtrl.push("LoginPage", { showflag: true });
} else {
this.userID = val.userinform.ID;
}
} else {
this.navCtrl.push("LoginPage", { showflag: true });
}
});
this.isweb = !this.nativeService.isMobile();
}
ionViewDidLoad() {
}
givestaar(i) {
this.list = [{ "statue": false }, { "statue": false }, { "statue": false }, { "statue": false }, { "statue": false },];
for (var n = 0; n < (i + 1); n++) {
this.list[n].statue = true;
};
this.num = (i + 1)
if (i == 0) {
this.status = "非常差";
} else if (i == 1) {
this.status = "差";
} else if (i == 2) {
this.status = "一般";
} else if (i == 3) {
this.status = "好";
} else if (i == 4) {
this.status = "非常好";
};
////console.info(i);
}
comment() {
if (this.textarea == '') {
this.nativeService.showToast("评论内容不能为空！");
return;
} else {
if (!this.isweb) {
if (this.fileObjList == null || this.fileObjList.length <= 0) {
this.login([]);
} else {
this.login(this.fileObjList);
// this.HaveImage = 1;
// var filearray: any[] = [];
// for (var i = 0; i < this.fileObjList.length; i++) {
// filearray.push(this.fileObjList[i].origPath);
// }
// this.nativeService.showLoading("提交中");
// this.nativeService.uploadFileByMutiTranser(filearray).then(val => {
// this.login(val);
// });
}
} else {
if (this.imgUrl == null || this.imgUrl.length <= 0) {
this.login([]);
} else { | }
}
}
}
login(filearray: any[]) {
//console.info(this.fileObjList[0])
var userInfo = {
Userid: this.userID,
goodsID: this.goodsDetail.ProductID,
Detail: this.textarea,
anonymity: 0,
Degree: this.num,
orderID: this.goodslist.ID,
file: this.fileObjList,
HaveImage: this.HaveImage,
itemID: this.goodsDetail.itemID
};
//console.info(userInfo);
var parameter = new Parameter();
parameter.jyh = "1024";
parameter.parm = JSON.stringify(userInfo);
this.nativeService.showLoading("提交中");
this.httpService.post("/MobService/Index", parameter).map(res => res.json()).subscribe(res => {
this.nativeService.hideLoading();
var result = JSON.parse(res.result);
//console.info(result);
if (result.Code == 1) {
this.nativeService.showToast(result.Msg);
this.goodslist.Items[this.typenum].IsEvaluate = 1
this.viewCtrl.dismiss(this.goodslist);
} else {
this.nativeService.showToast(result.Msg);
}
});
}
slice(string) {
if (string != "" && string != null) {
return string.slice(0, 18) + "...";
}
}
closealert() {
let confirm = this.alertCtrl.create({
title: '是否放弃评价',
buttons: [
{
text: '否',
handler: () => {
//console.log('Disagree clicked');
}
},
{
text: '是',
handler: () => {
this.viewCtrl.dismiss();
}
}
]
});
confirm.present();
}
addWxPicture() {
var that = this;
wx.chooseImage({
count: that.max - that.len, // 默认9
sizeType: ['original', 'compressed'], // 可以指定是原图还是压缩图，默认二者都有
sourceType: ['album', 'camera'], // 可以指定来源是相册还是相机，默认二者都有
success: function (res) {
var localIds = res.localIds;
that.len = localIds.length; // 返回选定照片的本地ID列表，localId可以作为img标签的src属性显示图片
// for (var i = 0; i < localIds.length; i++) {
that.WxUpLoad(localIds);
// }
// wx.getLocalImgData({
// localId: localIds, // 图片的localID
// success: function (res) {
// var localData = res.localData;
// that.localIds = localData; // localData是图片的base64数据，可以用img标签显示
// }
// });
}
});
}
WxUpLoad(localIds: string[]) {
var that = this;
var localId = localIds.pop();
wx.uploadImage({
localId: localId,
success: function (res) {
var serverId = res.serverId;
that.serverIds.push(serverId);
//console.info("serverId》》》》》" + serverId)
if (localIds.length > 0) {
that.WxUpLoad(localIds);
} else {
// setTimeout(() => {
// that.input.setFocus();
// }, 500);
}
that.WxDownLoadImage(serverId);
// if (that.len == that.serverIds.length) {
// that.WxDownLoadImage(serverId);
// }
}
});
}
viewerWxPicture(item) {
alert(item);
var that = this;
wx.previewImage({
current: item, // 当前显示图片的http链接
urls: that.localIds // 需要预览的图片http链接列表
});
}
deleteWxPicture(i) {//删除照片
if (!this.allowDelete) {
return;
}
this.alertCtrl.create({
title: '确认删除？',
buttons: [{ text: '取消' },
{
text: '确定',
handler: () => {
// this.imgUrl.splice(i, 1);
// this.WimgUrl.splice(i, 1);
this.fileObjList.splice(i, 1);
// this.len--;
}
}
]
}).present();
}
WxDownLoadImage(serverId) {
this.nativeService.uploadWxFile(serverId).subscribe(res => {
var result = JSON.parse(res.result);
if (result.Code == "1") {
this.WimgUrl.push(fileViewPath + result.Msg);
this.imgUrl.push(result.Msg);
//console.info("成功" + this.WimgUrl)
}
//console.info("不成功" + result)
});
}
getImg() {
if (!this.nativeService.isMobile()) {
this.addWxPicture();
}
}
onChange1(event: any) {
if(this.fileObjList.length<6){
}else{
this.nativeService.showToast("最多只能上传6张图片");
return
}
let files = event.target.files;
var file = files[0];
var size = files[0].size / 1024 > 1024 ? (~~(10 * files[0].size / 1024 / 1024)) / 10 + "MB" : ~~(files[0].size / 1024) + "KB";
this.nativeService.showLoading("获取中");
//console.info("大小" + size)
//console.info(file);
if (file == undefined) {
this.IDUrl = "";
//console.info("undefiend1")
} else {
//console.info("undefiend2")
let fileReader = new FileReader();
fileReader.readAsDataURL(file);
var that = this;
fileReader.onload = function (e) {
var name: any;
name = e.target
that.IDUrl = name.result;
//console.info(that.IDUrl);
that.fileObjList.push(that.IDUrl);
// that.takeimg(name.result, 1);
}
}
this.nativeService.hideLoading();
}
takeimg(result, num) {
var result = result;
var that = this;
var maxSize = 100 * |
this.login(this.imgUrl);
| conditional_block |
activity.py | ("activityobj", idx+1, c)
with open(dataset_json_path) as dataset_json_file:
self.json_data = json.load(dataset_json_file)
print("Elements in the json file:", str(len(self.json_data)))
for image_path, masks in self.json_data.items():
image = skimage.io.imread(image_path)
height, width = image.shape[:2]
self.add_image("activityobj",
image_id=image_path, # use file path as a unique image id
path=image_path,
width=width, height=height)
def load_mask(self, image_id, coco_offset=0):
"""Generate instance masks for an image.
Returns:
masks: A bool array of shape [height, width, instance count] with
one mask per instance.
class_ids: a 1D array of class IDs of the instance masks.
"""
info = self.image_info[image_id]
mask = np.zeros([info["height"], info["width"], len(self.json_data[info["id"]])], dtype=np.uint8)
lbls = np.zeros(len(self.json_data[info["id"]]), dtype=np.int32)
for idx, (mask_path, mask_info) in enumerate(self.json_data[info["id"]].items()):
mask_class = mask_info["class"]
mask[:,:,idx] = np.array(PIL.Image.open(mask_path), dtype=np.uint8)
lbls[idx] = common.activity_classes_names.index(mask_class) + 1 + coco_offset
# Return mask, and array of class IDs of each instance. Since we have
# one class ID only, we return an array of 1s
return mask.astype(np.bool), lbls
class ExtendedCocoDataset(ActivityDataset):
def load_coco(self, dataset_dir, subset, year=DEFAULT_DATASET_YEAR, class_ids=None, class_names=None,
class_map=None, return_coco=False, auto_download=False):
"""Load a subset of the COCO dataset.
dataset_dir: The root directory of the COCO dataset.
subset: What to load (train, val, minival, valminusminival)
year: What dataset year to load (2014, 2017) as a string, not an integer
class_ids: If provided, only loads images that have the given classes.
class_map: TODO: Not implemented yet. Supports maping classes from
different datasets to the same class ID.
return_coco: If True, returns the COCO object.
auto_download: Automatically download and unzip MS-COCO images and annotations
"""
if auto_download is True:
self.auto_download(dataset_dir, subset, year)
coco = COCO("{}/annotations/instances_{}{}.json".format(dataset_dir, subset, year))
if subset == "minival" or subset == "valminusminival":
subset = "val"
image_dir = "{}/{}{}".format(dataset_dir, subset, year)
# Select class_ids from class_names:
if class_names:
class_ids = sorted(coco.getCatIds(catNms=class_names))
# Load all classes or a subset?
if not class_ids:
# All classes
class_ids = sorted(coco.getCatIds())
# All images or a subset?
if class_ids:
image_ids = []
for id in class_ids:
imgs = [] # list of images to add to image_ids
# Select at most COCO_IMAGES_PER_OBJECT and select only the images
# that have at most COCO_MAX_NUM_MASK_PER_IMAGE masks inside them:
for imgid in list(coco.getImgIds(catIds=[id])):
if len(imgs) >= COCO_IMAGES_PER_OBJECT:
break
if len(coco.loadAnns(coco.getAnnIds(imgIds=[imgid], catIds=class_ids, iscrowd=None))) <= COCO_MAX_NUM_MASK_PER_IMAGE:
imgs.append(imgid)
image_ids.extend(imgs)
#image_ids.extend(list(coco.getImgIds(catIds=[id]))[:COCO_IMAGES_PER_OBJECT])
# Remove duplicates
image_ids = list(set(image_ids))
else:
# All images
image_ids = list(coco.imgs.keys())
# Add classes
for i in class_ids:
self.add_class("coco", i, coco.loadCats(i)[0]["name"])
# Add images
for i in image_ids:
#print(len(coco.loadAnns(coco.getAnnIds(imgIds=[i], catIds=class_ids, iscrowd=None))))
|
if return_coco:
return coco
def auto_download(self, dataDir, dataType, dataYear):
"""Download the COCO dataset/annotations if requested.
dataDir: The root directory of the COCO dataset.
dataType: What to load (train, val, minival, valminusminival)
dataYear: What dataset year to load (2014, 2017) as a string, not an integer
Note:
For 2014, use "train", "val", "minival", or "valminusminival"
For 2017, only "train" and "val" annotations are available
"""
# Setup paths and file names
if dataType == "minival" or dataType == "valminusminival":
imgDir = "{}/{}{}".format(dataDir, "val", dataYear)
imgZipFile = "{}/{}{}.zip".format(dataDir, "val", dataYear)
imgURL = "http://images.cocodataset.org/zips/{}{}.zip".format("val", dataYear)
else:
imgDir = "{}/{}{}".format(dataDir, dataType, dataYear)
imgZipFile = "{}/{}{}.zip".format(dataDir, dataType, dataYear)
imgURL = "http://images.cocodataset.org/zips/{}{}.zip".format(dataType, dataYear)
# print("Image paths:"); print(imgDir); print(imgZipFile); print(imgURL)
# Create main folder if it doesn't exist yet
if not os.path.exists(dataDir):
os.makedirs(dataDir)
# Download images if not available locally
if not os.path.exists(imgDir):
os.makedirs(imgDir)
print("Downloading images to " + imgZipFile + " ...")
with urllib.request.urlopen(imgURL) as resp, open(imgZipFile, 'wb') as out:
shutil.copyfileobj(resp, out)
print("... done downloading.")
print("Unzipping " + imgZipFile)
with zipfile.ZipFile(imgZipFile, "r") as zip_ref:
zip_ref.extractall(dataDir)
print("... done unzipping")
print("Will use images in " + imgDir)
# Setup annotations data paths
annDir = "{}/annotations".format(dataDir)
if dataType == "minival":
annZipFile = "{}/instances_minival2014.json.zip".format(dataDir)
annFile = "{}/instances_minival2014.json".format(annDir)
annURL = "https://dl.dropboxusercontent.com/s/o43o90bna78omob/instances_minival2014.json.zip?dl=0"
unZipDir = annDir
elif dataType == "valminusminival":
annZipFile = "{}/instances_valminusminival2014.json.zip".format(dataDir)
annFile = "{}/instances_valminusminival2014.json".format(annDir)
annURL = "https://dl.dropboxusercontent.com/s/s3tw5zcg7395368/instances_valminusminival2014.json.zip?dl=0"
unZipDir = annDir
else:
annZipFile = "{}/annotations_trainval{}.zip".format(dataDir, dataYear)
annFile = "{}/instances_{}{}.json".format(annDir, dataType, dataYear)
annURL = "http://images.cocodataset.org/annotations/annotations_trainval{}.zip".format(dataYear)
unZipDir = dataDir
# print("Annotations paths:"); print(annDir); print(annFile); print(annZipFile); print(annURL)
# Download annotations if not available locally
if not os.path.exists(annDir):
os.makedirs(annDir)
if not os.path.exists(annFile):
if not os.path.exists(annZipFile):
print("Downloading zipped annotations to " + annZipFile + " ...")
with urllib.request.urlopen(annURL) as resp, open(annZipFile, 'wb') as out:
shutil.copyfileobj(resp, out)
print("... done downloading.")
print("Unzipping " + annZipFile)
with zipfile.ZipFile(annZipFile, "r") as zip_ref:
zip_ref.extractall(unZipDir)
print("... done unzipping")
print("Will use annotations in " + annFile)
| self.add_image(
"coco", image_id=i,
path=os.path.join(image_dir, coco.imgs[i]['file_name']),
width=coco.imgs[i]["width"],
height=coco.imgs[i]["height"],
annotations=coco.loadAnns(coco.getAnnIds(imgIds=[i], catIds=class_ids, iscrowd=None))) | conditional_block |
activity.py | # Import Mask RCNN
#sys.path.append(ROOT_DIR) # To find local version of the library
sys.path.append("third_party/Mask_RCNN/") # To find local version of the library
from mrcnn.config import Config
from mrcnn import model as modellib, utils
import common
#from train import ActivityConfig, ActivityDataset
# Path to trained weights file
#COCO_MODEL_PATH = os.path.join(ROOT_DIR, "weights/mask_rcnn_coco.h5")
COCO_MODEL_PATH = "weights/mask_rcnn_coco.h5"
# Directory to save logs and model checkpoints, if not provided
# through the command line argument --logs
#DEFAULT_LOGS_DIR = os.path.join(ROOT_DIR, "logs")
DEFAULT_LOGS_DIR = "logs"
DEFAULT_DATASET_YEAR = "2014"
COCO_IMAGES_PER_OBJECT = 40
COCO_MAX_NUM_MASK_PER_IMAGE = 3
############################################################
# Configurations
############################################################
class ActivityConfig(Config):
"""Configuration for training on the toy dataset.
Derives from the base Config class and overrides some values.
"""
# Give the configuration a recognizable name
NAME = "activityobj"
# We use a GPU with 12GB memory, which can fit two images.
# Adjust down if you use a smaller GPU.
IMAGES_PER_GPU = 2
# Number of classes (including background)
#NUM_CLASSES = 1 + 1 # Background + balloon
NUM_CLASSES = 1 + common.ACTIVITY_NUM_CLASSES
# Number of training steps per epoch
STEPS_PER_EPOCH = 20
# Skip detections with < 90% confidence
DETECTION_MIN_CONFIDENCE = 0.9
class ExtendedCocoConfig(Config):
"""Configuration for training on MS COCO.
Derives from the base Config class and overrides values specific
to the COCO dataset.
"""
# Give the configuration a recognizable name
NAME = "coco"
# We use a GPU with 12GB memory, which can fit two images.
# Adjust down if you use a smaller GPU.
IMAGES_PER_GPU = 2
# Uncomment to train on 8 GPUs (default is 1)
# GPU_COUNT = 8
# Number of classes (including background)
NUM_CLASSES = 1 + common.COCO_NUM_CLASSES + common.ACTIVITY_NUM_CLASSES
# Number of training steps per epoch
STEPS_PER_EPOCH = 30
class ActivityInferenceConfig(ActivityConfig):
# Set batch size to 1 since we'll be running inference on
# one image at a time. Batch size = GPU_COUNT * IMAGES_PER_GPU
GPU_COUNT = 1
IMAGES_PER_GPU = 1
DETECTION_MIN_CONFIDENCE = 0
class ExtendedInferenceConfig(ExtendedCocoConfig):
# Set batch size to 1 since we'll be running inference on
# one image at a time. Batch size = GPU_COUNT * IMAGES_PER_GPU
GPU_COUNT = 1
IMAGES_PER_GPU = 1
DETECTION_MIN_CONFIDENCE = 0
############################################################
# Dataset
############################################################
class ActivityDataset(utils.Dataset):
def load_activity(self, dataset_json_path):
for idx, c in enumerate(common.activity_classes_names):
self.add_class("activityobj", idx+1, c)
with open(dataset_json_path) as dataset_json_file:
self.json_data = json.load(dataset_json_file)
print("Elements in the json file:", str(len(self.json_data)))
for image_path, masks in self.json_data.items():
image = skimage.io.imread(image_path)
height, width = image.shape[:2]
self.add_image("activityobj",
image_id=image_path, # use file path as a unique image id
path=image_path,
width=width, height=height)
def load_mask(self, image_id, coco_offset=0):
"""Generate instance masks for an image.
Returns:
masks: A bool array of shape [height, width, instance count] with
one mask per instance.
class_ids: a 1D array of class IDs of the instance masks.
"""
info = self.image_info[image_id]
mask = np.zeros([info["height"], info["width"], len(self.json_data[info["id"]])], dtype=np.uint8)
lbls = np.zeros(len(self.json_data[info["id"]]), dtype=np.int32)
for idx, (mask_path, mask_info) in enumerate(self.json_data[info["id"]].items()):
mask_class = mask_info["class"]
mask[:,:,idx] = np.array(PIL.Image.open(mask_path), dtype=np.uint8)
lbls[idx] = common.activity_classes_names.index(mask_class) + 1 + coco_offset
# Return mask, and array of class IDs of each instance. Since we have
# one class ID only, we return an array of 1s
return mask.astype(np.bool), lbls
class ExtendedCocoDataset(ActivityDataset):
def load_coco(self, dataset_dir, subset, year=DEFAULT_DATASET_YEAR, class_ids=None, class_names=None,
class_map=None, return_coco=False, auto_download=False):
"""Load a subset of the COCO dataset.
dataset_dir: The root directory of the COCO dataset.
subset: What to load (train, val, minival, valminusminival)
year: What dataset year to load (2014, 2017) as a string, not an integer
class_ids: If provided, only loads images that have the given classes.
class_map: TODO: Not implemented yet. Supports maping classes from
different datasets to the same class ID.
return_coco: If True, returns the COCO object.
auto_download: Automatically download and unzip MS-COCO images and annotations
"""
if auto_download is True:
self.auto_download(dataset_dir, subset, year)
coco = COCO("{}/annotations/instances_{}{}.json".format(dataset_dir, subset, year))
if subset == "minival" or subset == "valminusminival":
subset = "val"
image_dir = "{}/{}{}".format(dataset_dir, subset, year)
# Select class_ids from class_names:
if class_names:
class_ids = sorted(coco.getCatIds(catNms=class_names))
# Load all classes or a subset?
if not class_ids:
# All classes
class_ids = sorted(coco.getCatIds())
# All images or a subset?
if class_ids:
image_ids = []
for id in class_ids:
imgs = [] # list of images to add to image_ids
# Select at most COCO_IMAGES_PER_OBJECT and select only the images
# that have at most COCO_MAX_NUM_MASK_PER_IMAGE masks inside them:
for imgid in list(coco.getImgIds(catIds=[id])):
if len(imgs) >= COCO_IMAGES_PER_OBJECT:
break
if len(coco.loadAnns(coco.getAnnIds(imgIds=[imgid], catIds=class_ids, iscrowd=None))) <= COCO_MAX_NUM_MASK_PER_IMAGE:
imgs.append(imgid)
image_ids.extend(imgs)
#image_ids.extend(list(coco.getImgIds(catIds=[id]))[:COCO_IMAGES_PER_OBJECT])
# Remove duplicates
image_ids = list(set(image_ids))
else:
# All images
image_ids = list(coco.imgs.keys())
# Add classes
for i in class_ids:
self.add_class("coco", i, coco.loadCats(i)[0]["name"])
# Add images
for i in image_ids:
#print(len(coco.loadAnns(coco.getAnnIds(imgIds=[i], catIds=class_ids, iscrowd=None))))
self.add_image(
"coco", image_id=i,
path=os.path.join(image_dir, coco.imgs[i]['file_name']),
width=coco.imgs[i]["width"],
height=coco.imgs[i]["height"],
annotations=coco.loadAnns(coco.getAnnIds(imgIds=[i], catIds=class_ids, iscrowd=None)))
if return_coco:
return coco
def auto_download(self, dataDir, dataType, dataYear):
"""Download the COCO dataset/annotations if requested.
dataDir: The root directory of the COCO dataset.
dataType: What to load (train, val, minival, valminusminival)
dataYear: What dataset year to load (2014, 2017) as a string, not an integer
Note:
For 2014, use "train", "val", "minival", or "valminusminival"
For 2017, only "train" and "val" annotations are available
"""
# Setup paths and file names
if dataType == "minival" or dataType == "valminusminival":
imgDir = "{}/{}{}".format(dataDir, "val", dataYear)
imgZipFile = "{}/{}{}.zip".format(dataDir, "val", dataYear)
imgURL = "http://images.cocodataset.org/zips/{}{}.zip".format("val", dataYear)
else:
imgDir = "{}/{}{}".format(dataDir, dataType | random_line_split |
||
activity.py | ["width"], len(self.json_data[info["id"]])], dtype=np.uint8)
lbls = np.zeros(len(self.json_data[info["id"]]), dtype=np.int32)
for idx, (mask_path, mask_info) in enumerate(self.json_data[info["id"]].items()):
mask_class = mask_info["class"]
mask[:,:,idx] = np.array(PIL.Image.open(mask_path), dtype=np.uint8)
lbls[idx] = common.activity_classes_names.index(mask_class) + 1 + coco_offset
# Return mask, and array of class IDs of each instance. Since we have
# one class ID only, we return an array of 1s
return mask.astype(np.bool), lbls
class ExtendedCocoDataset(ActivityDataset):
def load_coco(self, dataset_dir, subset, year=DEFAULT_DATASET_YEAR, class_ids=None, class_names=None,
class_map=None, return_coco=False, auto_download=False):
"""Load a subset of the COCO dataset.
dataset_dir: The root directory of the COCO dataset.
subset: What to load (train, val, minival, valminusminival)
year: What dataset year to load (2014, 2017) as a string, not an integer
class_ids: If provided, only loads images that have the given classes.
class_map: TODO: Not implemented yet. Supports maping classes from
different datasets to the same class ID.
return_coco: If True, returns the COCO object.
auto_download: Automatically download and unzip MS-COCO images and annotations
"""
if auto_download is True:
self.auto_download(dataset_dir, subset, year)
coco = COCO("{}/annotations/instances_{}{}.json".format(dataset_dir, subset, year))
if subset == "minival" or subset == "valminusminival":
subset = "val"
image_dir = "{}/{}{}".format(dataset_dir, subset, year)
# Select class_ids from class_names:
if class_names:
class_ids = sorted(coco.getCatIds(catNms=class_names))
# Load all classes or a subset?
if not class_ids:
# All classes
class_ids = sorted(coco.getCatIds())
# All images or a subset?
if class_ids:
image_ids = []
for id in class_ids:
imgs = [] # list of images to add to image_ids
# Select at most COCO_IMAGES_PER_OBJECT and select only the images
# that have at most COCO_MAX_NUM_MASK_PER_IMAGE masks inside them:
for imgid in list(coco.getImgIds(catIds=[id])):
if len(imgs) >= COCO_IMAGES_PER_OBJECT:
break
if len(coco.loadAnns(coco.getAnnIds(imgIds=[imgid], catIds=class_ids, iscrowd=None))) <= COCO_MAX_NUM_MASK_PER_IMAGE:
imgs.append(imgid)
image_ids.extend(imgs)
#image_ids.extend(list(coco.getImgIds(catIds=[id]))[:COCO_IMAGES_PER_OBJECT])
# Remove duplicates
image_ids = list(set(image_ids))
else:
# All images
image_ids = list(coco.imgs.keys())
# Add classes
for i in class_ids:
self.add_class("coco", i, coco.loadCats(i)[0]["name"])
# Add images
for i in image_ids:
#print(len(coco.loadAnns(coco.getAnnIds(imgIds=[i], catIds=class_ids, iscrowd=None))))
self.add_image(
"coco", image_id=i,
path=os.path.join(image_dir, coco.imgs[i]['file_name']),
width=coco.imgs[i]["width"],
height=coco.imgs[i]["height"],
annotations=coco.loadAnns(coco.getAnnIds(imgIds=[i], catIds=class_ids, iscrowd=None)))
if return_coco:
return coco
def auto_download(self, dataDir, dataType, dataYear):
"""Download the COCO dataset/annotations if requested.
dataDir: The root directory of the COCO dataset.
dataType: What to load (train, val, minival, valminusminival)
dataYear: What dataset year to load (2014, 2017) as a string, not an integer
Note:
For 2014, use "train", "val", "minival", or "valminusminival"
For 2017, only "train" and "val" annotations are available
"""
# Setup paths and file names
if dataType == "minival" or dataType == "valminusminival":
imgDir = "{}/{}{}".format(dataDir, "val", dataYear)
imgZipFile = "{}/{}{}.zip".format(dataDir, "val", dataYear)
imgURL = "http://images.cocodataset.org/zips/{}{}.zip".format("val", dataYear)
else:
imgDir = "{}/{}{}".format(dataDir, dataType, dataYear)
imgZipFile = "{}/{}{}.zip".format(dataDir, dataType, dataYear)
imgURL = "http://images.cocodataset.org/zips/{}{}.zip".format(dataType, dataYear)
# print("Image paths:"); print(imgDir); print(imgZipFile); print(imgURL)
# Create main folder if it doesn't exist yet
if not os.path.exists(dataDir):
os.makedirs(dataDir)
# Download images if not available locally
if not os.path.exists(imgDir):
os.makedirs(imgDir)
print("Downloading images to " + imgZipFile + " ...")
with urllib.request.urlopen(imgURL) as resp, open(imgZipFile, 'wb') as out:
shutil.copyfileobj(resp, out)
print("... done downloading.")
print("Unzipping " + imgZipFile)
with zipfile.ZipFile(imgZipFile, "r") as zip_ref:
zip_ref.extractall(dataDir)
print("... done unzipping")
print("Will use images in " + imgDir)
# Setup annotations data paths
annDir = "{}/annotations".format(dataDir)
if dataType == "minival":
annZipFile = "{}/instances_minival2014.json.zip".format(dataDir)
annFile = "{}/instances_minival2014.json".format(annDir)
annURL = "https://dl.dropboxusercontent.com/s/o43o90bna78omob/instances_minival2014.json.zip?dl=0"
unZipDir = annDir
elif dataType == "valminusminival":
annZipFile = "{}/instances_valminusminival2014.json.zip".format(dataDir)
annFile = "{}/instances_valminusminival2014.json".format(annDir)
annURL = "https://dl.dropboxusercontent.com/s/s3tw5zcg7395368/instances_valminusminival2014.json.zip?dl=0"
unZipDir = annDir
else:
annZipFile = "{}/annotations_trainval{}.zip".format(dataDir, dataYear)
annFile = "{}/instances_{}{}.json".format(annDir, dataType, dataYear)
annURL = "http://images.cocodataset.org/annotations/annotations_trainval{}.zip".format(dataYear)
unZipDir = dataDir
# print("Annotations paths:"); print(annDir); print(annFile); print(annZipFile); print(annURL)
# Download annotations if not available locally
if not os.path.exists(annDir):
os.makedirs(annDir)
if not os.path.exists(annFile):
if not os.path.exists(annZipFile):
print("Downloading zipped annotations to " + annZipFile + " ...")
with urllib.request.urlopen(annURL) as resp, open(annZipFile, 'wb') as out:
shutil.copyfileobj(resp, out)
print("... done downloading.")
print("Unzipping " + annZipFile)
with zipfile.ZipFile(annZipFile, "r") as zip_ref:
zip_ref.extractall(unZipDir)
print("... done unzipping")
print("Will use annotations in " + annFile)
def load_mask(self, image_id):
| """Load instance masks for the given image.
Different datasets use different ways to store masks. This
function converts the different mask format to one format
in the form of a bitmap [height, width, instances].
Returns:
masks: A bool array of shape [height, width, instance count] with
one mask per instance.
class_ids: a 1D array of class IDs of the instance masks.
"""
# If not a COCO image, delegate to parent class.
image_info = self.image_info[image_id]
if image_info["source"] != "coco":
return super(ExtendedCocoDataset, self).load_mask(image_id, common.COCO_NUM_CLASSES) # NOTE: this calls ActivityDataset.load_mask()
instance_masks = []
class_ids = []
annotations = self.image_info[image_id]["annotations"]
# Build mask of shape [height, width, instance_count] and list | identifier_body |
|
activity.py | ("activityobj", idx+1, c)
with open(dataset_json_path) as dataset_json_file:
self.json_data = json.load(dataset_json_file)
print("Elements in the json file:", str(len(self.json_data)))
for image_path, masks in self.json_data.items():
image = skimage.io.imread(image_path)
height, width = image.shape[:2]
self.add_image("activityobj",
image_id=image_path, # use file path as a unique image id
path=image_path,
width=width, height=height)
def load_mask(self, image_id, coco_offset=0):
"""Generate instance masks for an image.
Returns:
masks: A bool array of shape [height, width, instance count] with
one mask per instance.
class_ids: a 1D array of class IDs of the instance masks.
"""
info = self.image_info[image_id]
mask = np.zeros([info["height"], info["width"], len(self.json_data[info["id"]])], dtype=np.uint8)
lbls = np.zeros(len(self.json_data[info["id"]]), dtype=np.int32)
for idx, (mask_path, mask_info) in enumerate(self.json_data[info["id"]].items()):
mask_class = mask_info["class"]
mask[:,:,idx] = np.array(PIL.Image.open(mask_path), dtype=np.uint8)
lbls[idx] = common.activity_classes_names.index(mask_class) + 1 + coco_offset
# Return mask, and array of class IDs of each instance. Since we have
# one class ID only, we return an array of 1s
return mask.astype(np.bool), lbls
class ExtendedCocoDataset(ActivityDataset):
def load_coco(self, dataset_dir, subset, year=DEFAULT_DATASET_YEAR, class_ids=None, class_names=None,
class_map=None, return_coco=False, auto_download=False):
"""Load a subset of the COCO dataset.
dataset_dir: The root directory of the COCO dataset.
subset: What to load (train, val, minival, valminusminival)
year: What dataset year to load (2014, 2017) as a string, not an integer
class_ids: If provided, only loads images that have the given classes.
class_map: TODO: Not implemented yet. Supports maping classes from
different datasets to the same class ID.
return_coco: If True, returns the COCO object.
auto_download: Automatically download and unzip MS-COCO images and annotations
"""
if auto_download is True:
self.auto_download(dataset_dir, subset, year)
coco = COCO("{}/annotations/instances_{}{}.json".format(dataset_dir, subset, year))
if subset == "minival" or subset == "valminusminival":
subset = "val"
image_dir = "{}/{}{}".format(dataset_dir, subset, year)
# Select class_ids from class_names:
if class_names:
class_ids = sorted(coco.getCatIds(catNms=class_names))
# Load all classes or a subset?
if not class_ids:
# All classes
class_ids = sorted(coco.getCatIds())
# All images or a subset?
if class_ids:
image_ids = []
for id in class_ids:
imgs = [] # list of images to add to image_ids
# Select at most COCO_IMAGES_PER_OBJECT and select only the images
# that have at most COCO_MAX_NUM_MASK_PER_IMAGE masks inside them:
for imgid in list(coco.getImgIds(catIds=[id])):
if len(imgs) >= COCO_IMAGES_PER_OBJECT:
break
if len(coco.loadAnns(coco.getAnnIds(imgIds=[imgid], catIds=class_ids, iscrowd=None))) <= COCO_MAX_NUM_MASK_PER_IMAGE:
imgs.append(imgid)
image_ids.extend(imgs)
#image_ids.extend(list(coco.getImgIds(catIds=[id]))[:COCO_IMAGES_PER_OBJECT])
# Remove duplicates
image_ids = list(set(image_ids))
else:
# All images
image_ids = list(coco.imgs.keys())
# Add classes
for i in class_ids:
self.add_class("coco", i, coco.loadCats(i)[0]["name"])
# Add images
for i in image_ids:
#print(len(coco.loadAnns(coco.getAnnIds(imgIds=[i], catIds=class_ids, iscrowd=None))))
self.add_image(
"coco", image_id=i,
path=os.path.join(image_dir, coco.imgs[i]['file_name']),
width=coco.imgs[i]["width"],
height=coco.imgs[i]["height"],
annotations=coco.loadAnns(coco.getAnnIds(imgIds=[i], catIds=class_ids, iscrowd=None)))
if return_coco:
return coco
def | (self, dataDir, dataType, dataYear):
"""Download the COCO dataset/annotations if requested.
dataDir: The root directory of the COCO dataset.
dataType: What to load (train, val, minival, valminusminival)
dataYear: What dataset year to load (2014, 2017) as a string, not an integer
Note:
For 2014, use "train", "val", "minival", or "valminusminival"
For 2017, only "train" and "val" annotations are available
"""
# Setup paths and file names
if dataType == "minival" or dataType == "valminusminival":
imgDir = "{}/{}{}".format(dataDir, "val", dataYear)
imgZipFile = "{}/{}{}.zip".format(dataDir, "val", dataYear)
imgURL = "http://images.cocodataset.org/zips/{}{}.zip".format("val", dataYear)
else:
imgDir = "{}/{}{}".format(dataDir, dataType, dataYear)
imgZipFile = "{}/{}{}.zip".format(dataDir, dataType, dataYear)
imgURL = "http://images.cocodataset.org/zips/{}{}.zip".format(dataType, dataYear)
# print("Image paths:"); print(imgDir); print(imgZipFile); print(imgURL)
# Create main folder if it doesn't exist yet
if not os.path.exists(dataDir):
os.makedirs(dataDir)
# Download images if not available locally
if not os.path.exists(imgDir):
os.makedirs(imgDir)
print("Downloading images to " + imgZipFile + " ...")
with urllib.request.urlopen(imgURL) as resp, open(imgZipFile, 'wb') as out:
shutil.copyfileobj(resp, out)
print("... done downloading.")
print("Unzipping " + imgZipFile)
with zipfile.ZipFile(imgZipFile, "r") as zip_ref:
zip_ref.extractall(dataDir)
print("... done unzipping")
print("Will use images in " + imgDir)
# Setup annotations data paths
annDir = "{}/annotations".format(dataDir)
if dataType == "minival":
annZipFile = "{}/instances_minival2014.json.zip".format(dataDir)
annFile = "{}/instances_minival2014.json".format(annDir)
annURL = "https://dl.dropboxusercontent.com/s/o43o90bna78omob/instances_minival2014.json.zip?dl=0"
unZipDir = annDir
elif dataType == "valminusminival":
annZipFile = "{}/instances_valminusminival2014.json.zip".format(dataDir)
annFile = "{}/instances_valminusminival2014.json".format(annDir)
annURL = "https://dl.dropboxusercontent.com/s/s3tw5zcg7395368/instances_valminusminival2014.json.zip?dl=0"
unZipDir = annDir
else:
annZipFile = "{}/annotations_trainval{}.zip".format(dataDir, dataYear)
annFile = "{}/instances_{}{}.json".format(annDir, dataType, dataYear)
annURL = "http://images.cocodataset.org/annotations/annotations_trainval{}.zip".format(dataYear)
unZipDir = dataDir
# print("Annotations paths:"); print(annDir); print(annFile); print(annZipFile); print(annURL)
# Download annotations if not available locally
if not os.path.exists(annDir):
os.makedirs(annDir)
if not os.path.exists(annFile):
if not os.path.exists(annZipFile):
print("Downloading zipped annotations to " + annZipFile + " ...")
with urllib.request.urlopen(annURL) as resp, open(annZipFile, 'wb') as out:
shutil.copyfileobj(resp, out)
print("... done downloading.")
print("Unzipping " + annZipFile)
with zipfile.ZipFile(annZipFile, "r") as zip_ref:
zip_ref.extractall(unZipDir)
print("... done unzipping")
print("Will use annotations in " + annFile)
| auto_download | identifier_name |
net.rs | /// session: Session::load_or_create("hello-world.session")?,
/// api_id: API_ID,
/// api_hash: API_HASH.to_string(),
/// params: Default::default(),
/// }).await?;
/// # Ok(())
/// # }
/// ```
pub async fn connect(mut config: Config) -> Result<Self, AuthorizationError> {
let sender = connect_sender(config.session.user_dc.unwrap_or(0), &mut config).await?;
// TODO Sender doesn't have a way to handle backpressure yet
let (handle_tx, handle_rx) = mpsc::unbounded_channel();
Ok(Self {
sender,
config,
handle_tx,
handle_rx,
})
}
/// Invoke a raw API call without the need to use a [`Client::handle`] or having to repeatedly
/// call [`Client::step`]. This directly sends the request to Telegram's servers.
///
/// Using function definitions corresponding to a different layer is likely to cause the
/// responses to the request to not be understood.
///
/// <div class="stab unstable">
///
/// **Warning**: this method is **not** part of the stability guarantees of semantic
/// versioning. It **may** break during *minor* version changes (but not on patch version
/// changes). Use with care.
///
/// </div>
///
/// # Examples
///
/// ```
/// # async fn f(mut client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// use grammers_tl_types as tl;
///
/// dbg!(client.invoke(&tl::functions::Ping { ping_id: 0 }).await?);
/// # Ok(())
/// # }
/// ```
pub async fn invoke<R: tl::RemoteCall>(
&mut self,
request: &R,
) -> Result<R::Return, InvocationError> {
self.sender.invoke(request).await
}
/// Return a new [`ClientHandle`] that can be used to invoke remote procedure calls.
///
/// # Examples
///
/// ```
/// use tokio::task;
///
/// # async fn f(mut client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// // Obtain a handle. After this you can obtain more by using `client_handle.clone()`.
/// let mut client_handle = client.handle();
///
/// // Run the network loop. This is necessary, or no network events will be processed!
/// let network_handle = task::spawn(async move { client.run_until_disconnected().await });
///
/// // Use the `client_handle` to your heart's content, maybe you just want to disconnect:
/// client_handle.disconnect().await;
///
/// // Joining on the spawned task lets us access the result from `run_until_disconnected`,
/// // so we can verify everything went fine. You could also just drop this though.
/// network_handle.await?;
/// # Ok(())
/// # }
///
pub fn handle(&self) -> ClientHandle {
ClientHandle {
tx: self.handle_tx.clone(),
}
}
/// Perform a single network step or processing of incoming requests via handles.
///
/// If a server message is received, requests enqueued via the [`ClientHandle`]s may have
/// their result delivered via a channel, and a (possibly empty) list of updates will be
/// returned.
///
/// The other return values are graceful disconnection, or a read error.
///
/// Most commonly, you will want to use the higher-level abstraction [`Client::next_updates`]
/// instead.
///
/// # Examples
///
/// ```
/// # async fn f(mut client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// use grammers_client::NetworkStep;
///
/// loop {
/// // Process network events forever until we gracefully disconnect or get an error.
/// match client.step().await? {
/// NetworkStep::Connected { .. } => continue,
/// NetworkStep::Disconnected => break,
/// }
/// }
/// # Ok(())
/// # }
/// ```
pub async fn step(&mut self) -> Result<Step, sender::ReadError> {
let (network, request) = {
let network = self.sender.step();
let request = self.handle_rx.recv();
pin_mut!(network);
pin_mut!(request);
match future::select(network, request).await {
future::Either::Left((network, request)) => {
let request = request.now_or_never();
(Some(network), request)
}
future::Either::Right((request, network)) => {
let network = network.now_or_never();
(network, Some(request))
}
}
};
if let Some(request) = request {
let request = request.expect("mpsc returned None");
match request {
Request::Rpc { request, response } => {
// Channel will return `Err` if the `ClientHandle` lost interest, just drop the error.
drop(response.send(self.sender.enqueue_body(request)));
}
Request::Disconnect { response } => {
// Channel will return `Err` if the `ClientHandle` lost interest, just drop the error.
drop(response.send(()));
return Ok(Step::Disconnected);
}
}
}
// TODO request cancellation if this is Err
// (perhaps a method on the sender to cancel_all)
Ok(Step::Connected {
updates: if let Some(updates) = network {
updates?
} else {
Vec::new()
},
})
}
/// Run the client by repeatedly calling [`Client::step`] until a graceful disconnection
/// occurs, or a network error occurs. Incoming updates are ignored and simply dropped.
/// instead.
///
/// # Examples
///
/// ```
/// # async fn f(mut client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// client.run_until_disconnected().await?;
/// # Ok(())
/// # }
/// ```
pub async fn run_until_disconnected(mut self) -> Result<(), sender::ReadError> {
loop {
match self.step().await? {
Step::Connected { .. } => continue,
Step::Disconnected => break Ok(()),
}
}
}
}
/// Method implementations directly related with network connectivity.
impl ClientHandle {
/// Invoke a raw API call.
///
/// Using function definitions corresponding to a different layer is likely to cause the
/// responses to the request to not be understood.
///
/// <div class="stab unstable">
///
/// **Warning**: this method is **not** part of the stability guarantees of semantic
/// versioning. It **may** break during *minor* version changes (but not on patch version
/// changes). Use with care.
///
/// </div>
///
/// # Examples
///
/// ```
/// # async fn f(mut client: grammers_client::ClientHandle) -> Result<(), Box<dyn std::error::Error>> {
/// use grammers_tl_types as tl;
///
/// dbg!(client.invoke(&tl::functions::Ping { ping_id: 0 }).await?);
/// # Ok(())
/// # }
/// ```
pub async fn invoke<R: tl::RemoteCall>(
&mut self,
request: &R,
) -> Result<R::Return, InvocationError> {
let (response, rx) = oneshot::channel();
// TODO add a test this (using handle with client dropped)
if let Err(_) = self.tx.send(Request::Rpc {
request: request.to_bytes(),
response,
}) {
// `Client` was dropped, can no longer send requests
return Err(InvocationError::Dropped);
}
// First receive the `oneshot::Receiver` with from the `Client`,
// then `await` on that to receive the response body for the request.
if let Ok(response) = rx.await {
if let Ok(result) = response.await {
match result {
Ok(body) => R::Return::from_bytes(&body).map_err(|e| e.into()),
Err(e) => Err(e),
}
} else {
// `Sender` dropped, won't be receiving a response for this
Err(InvocationError::Dropped)
}
} else {
// `Client` dropped, won't be receiving a response for this
Err(InvocationError::Dropped)
}
}
/// Gracefully tell the [`Client`] that created this handle to disconnect and stop receiving
/// things from the network.
///
/// If the client has already been dropped (and thus disconnected), this method does nothing.
///
/// # Examples
///
/// ```
/// # async fn f(mut client: grammers_client::ClientHandle) {
/// client.disconnect().await;
/// # }
/// ```
pub async fn disconnect(&mut self) {
let (response, rx) = oneshot::channel();
if let Ok(_) = self.tx.send(Request::Disconnect { response }) {
// It's fine to drop errors here, it means the channel was dropped by the `Client`.
drop(rx.await);
} else | {
// `Client` is already dropped, no need to disconnect again.
} | conditional_block |
|
net.rs | longer knows about it)
// TODO all up-to-date server addresses should be stored in the session for future initial connections
let _remote_config = sender
.invoke(&tl::functions::InvokeWithLayer {
layer: tl::LAYER,
query: tl::functions::InitConnection {
api_id: config.api_id,
device_model: config.params.device_model.clone(),
system_version: config.params.system_version.clone(),
app_version: config.params.app_version.clone(),
system_lang_code: config.params.system_lang_code.clone(),
lang_pack: "".into(),
lang_code: config.params.lang_code.clone(),
proxy: None,
params: None,
query: tl::functions::help::GetConfig {},
},
})
.await?;
// TODO use the dc id from the config as "this dc", not the input dc id
config.session.user_dc = Some(dc_id);
config.session.save()?;
Ok(sender)
}
/// Method implementations directly related with network connectivity.
impl Client {
/// Creates and returns a new client instance upon successful connection to Telegram.
///
/// If the session in the configuration did not have an authorization key, a new one
/// will be created and the session will be saved with it.
///
/// The connection will be initialized with the data from the input configuration.
///
/// # Examples
///
/// ```
/// use grammers_client::{Client, Config};
/// use grammers_session::Session;
///
/// // Note: these are example values and are not actually valid.
/// // Obtain your own with the developer's phone at https://my.telegram.org.
/// const API_ID: i32 = 932939;
/// const API_HASH: &str = "514727c32270b9eb8cc16daf17e21e57";
///
/// # async fn f(mut client: Client) -> Result<(), Box<dyn std::error::Error>> {
/// let client = Client::connect(Config {
/// session: Session::load_or_create("hello-world.session")?,
/// api_id: API_ID,
/// api_hash: API_HASH.to_string(),
/// params: Default::default(),
/// }).await?;
/// # Ok(())
/// # }
/// ```
pub async fn connect(mut config: Config) -> Result<Self, AuthorizationError> {
let sender = connect_sender(config.session.user_dc.unwrap_or(0), &mut config).await?;
// TODO Sender doesn't have a way to handle backpressure yet
let (handle_tx, handle_rx) = mpsc::unbounded_channel();
Ok(Self {
sender,
config,
handle_tx,
handle_rx,
})
}
/// Invoke a raw API call without the need to use a [`Client::handle`] or having to repeatedly
/// call [`Client::step`]. This directly sends the request to Telegram's servers.
///
/// Using function definitions corresponding to a different layer is likely to cause the
/// responses to the request to not be understood.
///
/// <div class="stab unstable">
///
/// **Warning**: this method is **not** part of the stability guarantees of semantic
/// versioning. It **may** break during *minor* version changes (but not on patch version
/// changes). Use with care.
///
/// </div>
///
/// # Examples
///
/// ```
/// # async fn f(mut client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// use grammers_tl_types as tl;
///
/// dbg!(client.invoke(&tl::functions::Ping { ping_id: 0 }).await?);
/// # Ok(())
/// # }
/// ```
pub async fn invoke<R: tl::RemoteCall>(
&mut self,
request: &R,
) -> Result<R::Return, InvocationError> {
self.sender.invoke(request).await
}
/// Return a new [`ClientHandle`] that can be used to invoke remote procedure calls.
///
/// # Examples
///
/// ```
/// use tokio::task;
///
/// # async fn f(mut client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// // Obtain a handle. After this you can obtain more by using `client_handle.clone()`.
/// let mut client_handle = client.handle();
///
/// // Run the network loop. This is necessary, or no network events will be processed!
/// let network_handle = task::spawn(async move { client.run_until_disconnected().await });
///
/// // Use the `client_handle` to your heart's content, maybe you just want to disconnect:
/// client_handle.disconnect().await;
///
/// // Joining on the spawned task lets us access the result from `run_until_disconnected`,
/// // so we can verify everything went fine. You could also just drop this though.
/// network_handle.await?;
/// # Ok(())
/// # }
///
pub fn handle(&self) -> ClientHandle {
ClientHandle {
tx: self.handle_tx.clone(),
}
}
/// Perform a single network step or processing of incoming requests via handles.
///
/// If a server message is received, requests enqueued via the [`ClientHandle`]s may have
/// their result delivered via a channel, and a (possibly empty) list of updates will be
/// returned.
///
/// The other return values are graceful disconnection, or a read error.
///
/// Most commonly, you will want to use the higher-level abstraction [`Client::next_updates`]
/// instead.
///
/// # Examples
///
/// ```
/// # async fn f(mut client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// use grammers_client::NetworkStep;
///
/// loop {
/// // Process network events forever until we gracefully disconnect or get an error.
/// match client.step().await? {
/// NetworkStep::Connected { .. } => continue,
/// NetworkStep::Disconnected => break,
/// }
/// }
/// # Ok(())
/// # }
/// ```
pub async fn step(&mut self) -> Result<Step, sender::ReadError> {
let (network, request) = {
let network = self.sender.step();
let request = self.handle_rx.recv();
pin_mut!(network);
pin_mut!(request);
match future::select(network, request).await {
future::Either::Left((network, request)) => {
let request = request.now_or_never();
(Some(network), request)
}
future::Either::Right((request, network)) => {
let network = network.now_or_never();
(network, Some(request))
}
}
};
if let Some(request) = request {
let request = request.expect("mpsc returned None");
match request {
Request::Rpc { request, response } => {
// Channel will return `Err` if the `ClientHandle` lost interest, just drop the error.
drop(response.send(self.sender.enqueue_body(request)));
}
Request::Disconnect { response } => {
// Channel will return `Err` if the `ClientHandle` lost interest, just drop the error.
drop(response.send(()));
return Ok(Step::Disconnected);
}
}
}
// TODO request cancellation if this is Err
// (perhaps a method on the sender to cancel_all)
Ok(Step::Connected {
updates: if let Some(updates) = network {
updates?
} else {
Vec::new()
},
})
}
/// Run the client by repeatedly calling [`Client::step`] until a graceful disconnection
/// occurs, or a network error occurs. Incoming updates are ignored and simply dropped.
/// instead.
///
/// # Examples
///
/// ```
/// # async fn f(mut client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// client.run_until_disconnected().await?;
/// # Ok(())
/// # }
/// ```
pub async fn run_until_disconnected(mut self) -> Result<(), sender::ReadError> {
loop {
match self.step().await? {
Step::Connected { .. } => continue,
Step::Disconnected => break Ok(()),
}
}
}
}
/// Method implementations directly related with network connectivity.
impl ClientHandle {
/// Invoke a raw API call.
///
/// Using function definitions corresponding to a different layer is likely to cause the
/// responses to the request to not be understood.
///
/// <div class="stab unstable">
///
/// **Warning**: this method is **not** part of the stability guarantees of semantic
/// versioning. It **may** break during *minor* version changes (but not on patch version
/// changes). Use with care.
///
/// </div>
///
/// # Examples
///
/// ```
/// # async fn f(mut client: grammers_client::ClientHandle) -> Result<(), Box<dyn std::error::Error>> {
/// use grammers_tl_types as tl;
///
/// dbg!(client.invoke(&tl::functions::Ping { ping_id: 0 }).await?);
/// # Ok(())
/// # }
/// ```
pub async fn | invoke | identifier_name |
|
net.rs | {
/// session: Session::load_or_create("hello-world.session")?,
/// api_id: API_ID,
/// api_hash: API_HASH.to_string(),
/// params: Default::default(),
/// }).await?;
/// # Ok(())
/// # }
/// ```
pub async fn connect(mut config: Config) -> Result<Self, AuthorizationError> {
let sender = connect_sender(config.session.user_dc.unwrap_or(0), &mut config).await?;
// TODO Sender doesn't have a way to handle backpressure yet
let (handle_tx, handle_rx) = mpsc::unbounded_channel();
Ok(Self {
sender,
config,
handle_tx,
handle_rx,
})
}
/// Invoke a raw API call without the need to use a [`Client::handle`] or having to repeatedly
/// call [`Client::step`]. This directly sends the request to Telegram's servers.
///
/// Using function definitions corresponding to a different layer is likely to cause the
/// responses to the request to not be understood.
///
/// <div class="stab unstable">
///
/// **Warning**: this method is **not** part of the stability guarantees of semantic
/// versioning. It **may** break during *minor* version changes (but not on patch version
/// changes). Use with care.
///
/// </div>
///
/// # Examples
///
/// ```
/// # async fn f(mut client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// use grammers_tl_types as tl;
///
/// dbg!(client.invoke(&tl::functions::Ping { ping_id: 0 }).await?);
/// # Ok(())
/// # }
/// ```
pub async fn invoke<R: tl::RemoteCall>(
&mut self,
request: &R,
) -> Result<R::Return, InvocationError> {
self.sender.invoke(request).await
}
/// Return a new [`ClientHandle`] that can be used to invoke remote procedure calls.
///
/// # Examples
///
/// ```
/// use tokio::task;
///
/// # async fn f(mut client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// // Obtain a handle. After this you can obtain more by using `client_handle.clone()`.
/// let mut client_handle = client.handle();
///
/// // Run the network loop. This is necessary, or no network events will be processed!
/// let network_handle = task::spawn(async move { client.run_until_disconnected().await });
///
/// // Use the `client_handle` to your heart's content, maybe you just want to disconnect:
/// client_handle.disconnect().await;
///
/// // Joining on the spawned task lets us access the result from `run_until_disconnected`,
/// // so we can verify everything went fine. You could also just drop this though.
/// network_handle.await?;
/// # Ok(())
/// # }
///
pub fn handle(&self) -> ClientHandle {
ClientHandle {
tx: self.handle_tx.clone(),
}
}
/// Perform a single network step or processing of incoming requests via handles.
///
/// If a server message is received, requests enqueued via the [`ClientHandle`]s may have
/// their result delivered via a channel, and a (possibly empty) list of updates will be
/// returned.
///
/// The other return values are graceful disconnection, or a read error.
///
/// Most commonly, you will want to use the higher-level abstraction [`Client::next_updates`]
/// instead.
///
/// # Examples
///
/// ```
/// # async fn f(mut client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// use grammers_client::NetworkStep;
///
/// loop {
/// // Process network events forever until we gracefully disconnect or get an error.
/// match client.step().await? {
/// NetworkStep::Connected { .. } => continue,
/// NetworkStep::Disconnected => break,
/// }
/// }
/// # Ok(())
/// # }
/// ```
pub async fn step(&mut self) -> Result<Step, sender::ReadError> {
let (network, request) = {
let network = self.sender.step();
let request = self.handle_rx.recv();
pin_mut!(network);
pin_mut!(request);
match future::select(network, request).await {
future::Either::Left((network, request)) => {
let request = request.now_or_never();
(Some(network), request)
}
future::Either::Right((request, network)) => {
let network = network.now_or_never();
(network, Some(request))
}
}
};
if let Some(request) = request {
let request = request.expect("mpsc returned None");
match request {
Request::Rpc { request, response } => {
// Channel will return `Err` if the `ClientHandle` lost interest, just drop the error.
drop(response.send(self.sender.enqueue_body(request)));
}
Request::Disconnect { response } => {
// Channel will return `Err` if the `ClientHandle` lost interest, just drop the error.
drop(response.send(()));
return Ok(Step::Disconnected);
}
}
}
// TODO request cancellation if this is Err
// (perhaps a method on the sender to cancel_all)
Ok(Step::Connected {
updates: if let Some(updates) = network {
updates?
} else {
Vec::new()
},
})
}
/// Run the client by repeatedly calling [`Client::step`] until a graceful disconnection
/// occurs, or a network error occurs. Incoming updates are ignored and simply dropped.
/// instead.
///
/// # Examples
///
/// ```
/// # async fn f(mut client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// client.run_until_disconnected().await?;
/// # Ok(())
/// # }
/// ```
pub async fn run_until_disconnected(mut self) -> Result<(), sender::ReadError> {
loop {
match self.step().await? {
Step::Connected { .. } => continue,
Step::Disconnected => break Ok(()),
}
}
}
}
/// Method implementations directly related with network connectivity.
impl ClientHandle {
/// Invoke a raw API call.
///
/// Using function definitions corresponding to a different layer is likely to cause the
/// responses to the request to not be understood.
///
/// <div class="stab unstable">
///
/// **Warning**: this method is **not** part of the stability guarantees of semantic
/// versioning. It **may** break during *minor* version changes (but not on patch version
/// changes). Use with care.
///
/// </div>
///
/// # Examples
///
/// ```
/// # async fn f(mut client: grammers_client::ClientHandle) -> Result<(), Box<dyn std::error::Error>> {
/// use grammers_tl_types as tl;
///
/// dbg!(client.invoke(&tl::functions::Ping { ping_id: 0 }).await?);
/// # Ok(())
/// # }
/// ```
pub async fn invoke<R: tl::RemoteCall>(
&mut self,
request: &R,
) -> Result<R::Return, InvocationError> {
let (response, rx) = oneshot::channel();
// TODO add a test this (using handle with client dropped)
if let Err(_) = self.tx.send(Request::Rpc {
request: request.to_bytes(),
response,
}) {
// `Client` was dropped, can no longer send requests
return Err(InvocationError::Dropped);
}
// First receive the `oneshot::Receiver` with from the `Client`,
// then `await` on that to receive the response body for the request.
if let Ok(response) = rx.await {
if let Ok(result) = response.await {
match result {
Ok(body) => R::Return::from_bytes(&body).map_err(|e| e.into()),
Err(e) => Err(e),
}
} else {
// `Sender` dropped, won't be receiving a response for this
Err(InvocationError::Dropped)
}
} else {
// `Client` dropped, won't be receiving a response for this
Err(InvocationError::Dropped)
}
}
/// Gracefully tell the [`Client`] that created this handle to disconnect and stop receiving
/// things from the network.
///
/// If the client has already been dropped (and thus disconnected), this method does nothing.
///
/// # Examples
///
/// ```
/// # async fn f(mut client: grammers_client::ClientHandle) {
/// client.disconnect().await;
/// # }
/// ```
pub async fn disconnect(&mut self) {
let (response, rx) = oneshot::channel();
if let Ok(_) = self.tx.send(Request::Disconnect { response }) {
// It's fine to drop errors here, it means the channel was dropped by the `Client`.
drop(rx.await);
} else {
// `Client` is already dropped, no need to disconnect again. | } | random_line_split |
|
net.rs | 3),
(Ipv4Addr::new(149, 154, 167, 51), 443),
(Ipv4Addr::new(149, 154, 175, 100), 443),
(Ipv4Addr::new(149, 154, 167, 92), 443),
(Ipv4Addr::new(91, 108, 56, 190), 443),
];
pub(crate) async fn connect_sender(
dc_id: i32,
config: &mut Config,
) -> Result<Sender<transport::Full, mtp::Encrypted>, AuthorizationError> | sender
};
// TODO handle -404 (we had a previously-valid authkey, but server no longer knows about it)
// TODO all up-to-date server addresses should be stored in the session for future initial connections
let _remote_config = sender
.invoke(&tl::functions::InvokeWithLayer {
layer: tl::LAYER,
query: tl::functions::InitConnection {
api_id: config.api_id,
device_model: config.params.device_model.clone(),
system_version: config.params.system_version.clone(),
app_version: config.params.app_version.clone(),
system_lang_code: config.params.system_lang_code.clone(),
lang_pack: "".into(),
lang_code: config.params.lang_code.clone(),
proxy: None,
params: None,
query: tl::functions::help::GetConfig {},
},
})
.await?;
// TODO use the dc id from the config as "this dc", not the input dc id
config.session.user_dc = Some(dc_id);
config.session.save()?;
Ok(sender)
}
/// Method implementations directly related with network connectivity.
impl Client {
/// Creates and returns a new client instance upon successful connection to Telegram.
///
/// If the session in the configuration did not have an authorization key, a new one
/// will be created and the session will be saved with it.
///
/// The connection will be initialized with the data from the input configuration.
///
/// # Examples
///
/// ```
/// use grammers_client::{Client, Config};
/// use grammers_session::Session;
///
/// // Note: these are example values and are not actually valid.
/// // Obtain your own with the developer's phone at https://my.telegram.org.
/// const API_ID: i32 = 932939;
/// const API_HASH: &str = "514727c32270b9eb8cc16daf17e21e57";
///
/// # async fn f(mut client: Client) -> Result<(), Box<dyn std::error::Error>> {
/// let client = Client::connect(Config {
/// session: Session::load_or_create("hello-world.session")?,
/// api_id: API_ID,
/// api_hash: API_HASH.to_string(),
/// params: Default::default(),
/// }).await?;
/// # Ok(())
/// # }
/// ```
pub async fn connect(mut config: Config) -> Result<Self, AuthorizationError> {
let sender = connect_sender(config.session.user_dc.unwrap_or(0), &mut config).await?;
// TODO Sender doesn't have a way to handle backpressure yet
let (handle_tx, handle_rx) = mpsc::unbounded_channel();
Ok(Self {
sender,
config,
handle_tx,
handle_rx,
})
}
/// Invoke a raw API call without the need to use a [`Client::handle`] or having to repeatedly
/// call [`Client::step`]. This directly sends the request to Telegram's servers.
///
/// Using function definitions corresponding to a different layer is likely to cause the
/// responses to the request to not be understood.
///
/// <div class="stab unstable">
///
/// **Warning**: this method is **not** part of the stability guarantees of semantic
/// versioning. It **may** break during *minor* version changes (but not on patch version
/// changes). Use with care.
///
/// </div>
///
/// # Examples
///
/// ```
/// # async fn f(mut client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// use grammers_tl_types as tl;
///
/// dbg!(client.invoke(&tl::functions::Ping { ping_id: 0 }).await?);
/// # Ok(())
/// # }
/// ```
pub async fn invoke<R: tl::RemoteCall>(
&mut self,
request: &R,
) -> Result<R::Return, InvocationError> {
self.sender.invoke(request).await
}
/// Return a new [`ClientHandle`] that can be used to invoke remote procedure calls.
///
/// # Examples
///
/// ```
/// use tokio::task;
///
/// # async fn f(mut client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// // Obtain a handle. After this you can obtain more by using `client_handle.clone()`.
/// let mut client_handle = client.handle();
///
/// // Run the network loop. This is necessary, or no network events will be processed!
/// let network_handle = task::spawn(async move { client.run_until_disconnected().await });
///
/// // Use the `client_handle` to your heart's content, maybe you just want to disconnect:
/// client_handle.disconnect().await;
///
/// // Joining on the spawned task lets us access the result from `run_until_disconnected`,
/// // so we can verify everything went fine. You could also just drop this though.
/// network_handle.await?;
/// # Ok(())
/// # }
///
pub fn handle(&self) -> ClientHandle {
ClientHandle {
tx: self.handle_tx.clone(),
}
}
/// Perform a single network step or processing of incoming requests via handles.
///
/// If a server message is received, requests enqueued via the [`ClientHandle`]s may have
/// their result delivered via a channel, and a (possibly empty) list of updates will be
/// returned.
///
/// The other return values are graceful disconnection, or a read error.
///
/// Most commonly, you will want to use the higher-level abstraction [`Client::next_updates`]
/// instead.
///
/// # Examples
///
/// ```
/// # async fn f(mut client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// use grammers_client::NetworkStep;
///
/// loop {
/// // Process network events forever until we gracefully disconnect or get an error.
/// match client.step().await? {
/// NetworkStep::Connected { .. } => continue,
/// NetworkStep::Disconnected => break,
/// }
/// }
/// # Ok(())
/// # }
/// ```
pub async fn step(&mut self) -> Result<Step, sender::ReadError> {
let (network, request) = {
let network = self.sender.step();
let request = self.handle_rx.recv();
pin_mut!(network);
pin_mut!(request);
match future::select(network, request).await {
future::Either::Left((network, request)) => {
let request = request.now_or_never();
(Some(network), request)
}
future::Either::Right((request, network)) => {
let network = network.now_or_never();
(network, Some(request))
}
}
};
if let Some(request) = request {
let request = request.expect("mpsc returned None");
match request {
Request::Rpc { request, response } => {
// Channel will return `Err` if the `ClientHandle` lost interest, just drop the error.
drop(response.send(self.sender.enqueue_body(request)));
}
Request::Disconnect { response } => {
// Channel will return `Err` if the `ClientHandle` lost interest, just drop the error.
drop(response.send(()));
return Ok(Step::Disconnected);
}
}
}
// TODO request cancellation if this is Err
// (perhaps a method on the sender to cancel_all)
Ok(Step::Connected {
updates: if let Some(updates) = network {
updates?
} else {
Vec::new()
},
})
}
/// Run the client by repeatedly calling [`Client::step`] until a graceful disconnection
/// occurs, or | {
let transport = transport::Full::new();
let addr = DC_ADDRESSES[dc_id as usize];
let mut sender = if let Some(auth_key) = config.session.auth_key.as_ref() {
info!(
"creating a new sender with existing auth key to dc {} {:?}",
dc_id, addr
);
sender::connect_with_auth(transport, addr, auth_key.clone()).await?
} else {
info!(
"creating a new sender and auth key in dc {} {:?}",
dc_id, addr
);
let sender = sender::connect(transport, addr).await?;
config.session.auth_key = Some(sender.auth_key().clone());
config.session.save()?; | identifier_body |
Props.ts | cn ms, 两次提交间隔时长（防止重复提交）
* @default 1000
*/
throttle?: number
/**
* @en bind form ref, Can call some form methods
* @cn 绑定 form 的引用, 可以调用某些 form 的方法
* @override
*/
formRef?: ((form: FormRef<Value>) => void) | { current?: FormRef<Value> }
/**
* @inner 内部属性
*/
error?: ObjectType<string | Error>
}
/** ----------------formItem-----------------------* */
export interface ItemProps extends StandardProps {
/**
* @inner 待废弃
*/
grid?: number | { width: number; offset: number; response: 'sm' | 'md' | 'lg' | 'xl' }
/**
* @en Single-line error prompt will not stretch the page height
* @cn 单行错误提示不撑开页面高度
* @default false
*/
keepErrorHeight?: boolean
/**
* @en When it is undefined, the tag does not be rendered or occupy space. If there is no content, but it needs to be occupied, you can use an empty string ''.
* @cn 未定义时，标签不会 render，也不会占位。如果无内容需要占位，使用空字符串 ''。
*/
label?: React.ReactNode
/**
* @en The default is empty, follow the theme style.
* @cn 默认为空，跟随主题样式。
*/
labelAlign?: 'top' | 'left' | 'right'
/**
* @en The width of label. It is invalid when labelAlign is 'top'.
* @cn 标签宽度，labelAlign 为 'top' 时无效。
* @default 140px
*/
labelWidth?: string | number
/**
* @en Required tags for pure display. Do not trigger validation
* @cn 必填标记，纯展示用，不会触发校验
* @default false
*/
required?: boolean
/**
* @en Prompting information
* @cn 提示文案
*/
tip?: React.ReactNode
formDatum?: FormDatum<any>
/**
* @en label vertical align
* @cn 标签垂直方向对齐方式
* @default "top"
*/
labelVerticalAlign?: 'top' | 'middle' | 'bottom'
/**
* @en form element
* @cn 表单元素
*/
children?: React.ReactNode
}
/** ----------------formButton-----------------------* */
export interface FormButtonProps extends Omit<ButtonProps, 'htmlType' | 'onRef'> {
onClick?: () => void
type?: RegularAttributes.Type
}
/** ----------------Field-----------------------* */
export interface FieldChildrenFunc<Value = any> {
(params: { value: Value; error?: Error; onChange: (value: Value) => void; disabled?: boolean }): React.ReactNode
}
export interface FieldProps<Value> {
/**
* @inner 内部属性
*/
cache?: boolean
/**
* @inner 内部属性
*/
onChange: (value: Value) => void
/**
* @inner 内部属性
*/
value: Value
/**
* @inner 内部属性
*/
error?: Error
/**
* @inner 内部属性
*/
disabled?: boolean
/**
* @en React components that support value and onChange or function. The function object attribute is as follows:
* value: The value obtained from the parent Form or Form.Block by name.
* error: the error information of data validation. type is Error.
* onChange: The callback when the value is changing.
* disabled: inherit the disabled attribute of Form.
*
* @cn 支持 value 和 onChange 的 React 组件，或者函数，函数object属性如下
* value: 根据 name 从上级 Form 或 Form.Block 获取的值
* error：数据校验错误信息，类型为 Error
* onChange: 值改变回调函数
* disabled: 继承 Form 的 disabled 属性
*
* @override ((opts: object) => ReactNode) | ReactNode
*/
children: React.ReactNode | FieldChildrenFunc<Value>
}
/** ----------------FieldError-----------------------* */
export interface FieldErrorProps {
error?: Error | Error[]
}
/** ----------------Flow-----------------------* */
export interface FlowProps {
/**
* @en datum is the object of Datum.Form.
* @cn datum 为 Datum.Form 对象
* @override (datum: FormDatum) => ReactNode
*/
children: (datum: FormDatum<ObjectType>) => ReactNode
formDatum: FormDatum<ObjectType>
/**
* @en Specifying which fields to change trigger the Flow update.
* @cn names 为空时，Form 内任意值变化会触发 Flow 更新；不为空时，只监听指定字段变化
*/
names?: string[]
}
/** ----------------index-----------------------* */
// Form
export type FormCardConsumerKey = 'setFormStatus'
export type FormDatumKey = 'removeUndefined' | 'error'
export type FormPropsWithCardConsumer<Value> = CardConsumerType<SimpleFormProps<Value>, FormCardConsumerKey>
export type FormPropsWithProvider<Value> = GetFormProviderProps<FormPropsWithCardConsumer<Value>, Value>
/**
* @title Form
*/
export type FormProps<Value> = GetDatumFormProps<FormPropsWithProvider<Value>, Value, FormDatumKey>
export declare class Form<Value> extends React.Component<FormProps<Value>, any> {
static Item: typeof FormItem
static Field: typeof FormField
static Flow: typeof FormFlow
static FieldSet: typeof FormFieldSet
static Submit: React.ComponentType<FormButtonProps>
static Reset: React.ComponentType<FormButtonProps>
static Button: React.ComponentType<FormButtonProps>
static formConsumer: any
static useMode: (...args: string[]) => React.ComponentType<FormModeProps>[]
render: () => JSX.Element
}
export type FormCompType = typeof Form
// FormItem
export type FormItemWithFormConsumerKeys =
| 'formDatum'
| 'labelWidth'
| 'labelAlign'
| 'labelVerticalAlign'
| 'keepErrorHeight'
/**
* @title Form.Item
* @cn 表单项，主要用来布局，显示标签，提示文案信息等
* @en Used to layout, display labels, tips, errors, etc
*/
export type FormItemProps = GetFormConsumerProps<ItemProps, FormItemWithFormConsumerKeys>
export declare class FormItem extends React.Component<FormItemProps, any> {
render: () => JSX.Element
}
/**
* @title Form.Field
* @en Used to handle custom form components, enabling custom form components to get/store/validate value from formdata by name.
* @cn 用于处理自定义表单组件，使自定义表单组件实现通过rules校验，存储数据功能
*/
export type FormFieldProps<Value> = GetInputableProps<FieldProps<Value>, Value>
export declare class FormField<Value> extends React.Component<FormFieldProps<Value>, any> {
render: () => JSX.Element
}
export type FormFlowWithFormConsumerKeys = 'formDatum'
export type FormFieldSetWithFormConsumerKeys = 'formDatum'
/**
* @title Form.FieldSet
* @en Handle a set(group) data from form by name
* @cn 用来处理 object 类型 字段和数组。
*/
export type FormFieldSetProps<Value> = GetFormConsumerProps<FieldSetProps<Value>, FormFlowWithFormConsumerKeys>
export declare class FormFieldSet<Value> extends React.Component<FormFieldSetProps<Value>, any> {
render: () => JSX.Element
}
/**
* @title Form.Flow
*/
export type FormFlowProps = GetFormConsumerProps<FlowProps, FormFlowWithFormConsumerKeys>
export declare class FormFlow extends React.Component<FormFlowProps, any> {
render: () => JSX.Element
}
/**
* @title FormRef
* @en Form instance method
* @cn Form 实例的一些方法
* @isDetail true
*/
export interface FormRef<Value> {
/**
* @en return form value
* @cn 返回表单的值
*/
getValue: () => Value
/**
* @en Validate form
* @cn 校验表单
*/
validate: () => Promise<any>
/**
* @en Validation form fields
* @cn 校验表单指定字段
*/
validateFields: (fields: string | string[]) => Promise<any>
/**
* @en The verification can get the error message through Promise.catch
* @cn 校验可以通过 catch 获取报错信息
*/
validateFieldsWithError: (fields: string | string[]) => Promise<any>
/**
* @en Clear check
* @cn 清除校验
*/
clearValidate: () => void
/**
* @en Submit Form, withValidate: Whether to verify
* @cn 提交表单, withValidate: 是否校验
*/
submit: (withValidate?: boolean) => void
/**
* @en reset form
* @cn 重置表单
*/
reset: () => void
}
| identifier_name |
||
Props.ts | import { CardConsumerType } from '../Card/Props'
import { GetDatumFormProps } from '../Datum/Props'
export interface RuleObject {
[name: string]: FormItemRule<any> | RuleObject
}
/** ----------------fieldSet-----------------------* */
export interface FieldSetChildrenFunc<Value = any> {
(
params: {
list: any
value: Value
onChange: (value: Value[]) => void
onRemove: () => void
index: number
onInsert: (value: Value) => void
onAppend: (value: Value) => void
error: Error[]
datum: FormDatum<ObjectType>
}
): React.ReactNode
}
export interface FieldSetProviderValueType {
path?: string
val?: () => Promise<FormError | true>
}
export interface FieldSetProps<Value = any> {
/**
* @en default Value
* @cn 默认值
*/
defaultValue?: Value[]
/**
* @en Show content when data is empty. (only valid when children is function)
* @cn 数据为空时展示内容。（仅在children为function时有效）
*/
empty?: (onInsert: (value: Value) => void) => React.ReactNode
formDatum: FormDatum<ObjectType>
/**
* @en The name that accesses data from from
* @cn 从 Form 中存取数据的名称
*/
name: string
/**
* @inner 内部属性
*/
onError?: (error?: Error) => void
/**
* @en Validation rules
* @cn 校验规则
* @override RuleItem[]
*/
rules?: FormItemRule<any>
/**
* @en When children type is not function, handle a set data type of object
* When children type is function, handle a group of data type of array. options property:
* list: all data of name.
* value: a single piece of data for the value obtained by name.
* onChange: a callback when the value is changing.
* onRemove: a callback when a child component is removed.
* index: the current index.
* onInsert: Insert a piece of data before the current item.
* onAppend: Insert a piece of data after the current item.
*
* @cn children 不为 function，用来处理 object 类型数据，children 内的 name 会拼接 FieldSet name，如 FieldSet name 为 'a', children 元素name 为 b，children 实际处理的数据为 a.b;
* children 为 function 时，用来处理数组数据。options 属性为
* list: name 下的全部数据。
* value: 根据name获取的值的单条数据。
* onChange: 子组件数据改变回调。
* onRemove: 子组件删除回调。
* index: 当前项索引。
* onInsert: 在当前项之前插入一条数据。
* onAppend: 在当前项之后附加一条数据。
*
* @override ((opts: object) => ReactNode) |ReactNode
*/
children: FieldSetChildrenFunc<Value> | React.ReactNode
}
export type GetFieldSetConsumerProps<U> = Omit<U, 'innerFormNamePath' | 'fieldSetValidate'>
/** ----------------formContext-----------------------* */
export interface FormContextValue {
formDatum: FormDatum<ObjectType>
formMode?: string
disabled?: any
labelAlign?: 'top' | 'left' | 'right'
labelVerticalAlign?: 'top' | 'middle' | 'bottom'
size?: RegularAttributes.Size
labelWidth?: string | number
combineRules: <U>(name: string, rule: FormItemRule<U>) => FormItemRule<U>
keepErrorHeight?: boolean
}
export interface FormProviderProps<V extends ObjectType> {
datum: FormDatum<V>
disabled?: boolean
/**
* @en The default is empty, follow the theme style.
* @cn 默认为空，跟随主题样式。
*/
labelAlign?: 'top' | 'left' | 'right'
/**
* @en the default value is top.
* @cn 默认顶部对齐
* @default 'top'
*/
labelVerticalAlign?: 'top' | 'middle' | 'bottom'
/**
* @en Form element size
* @cn 表单元素的尺寸
* @default 'default'
* @override union
*/
size?: RegularAttributes.Size
/**
* @en The width of label. It is invalid when labelAlign is 'top'.
* @cn 标签宽度，labelAlign 为 'top' 时无效。
* @default 140px
*/
labelWidth?: number | string
/**
* @en mode, with useMode
* @cn 模式，和 useMode 配合使用
*/
mode?: string
pending?: boolean
rules?: RuleObject
/**
* @en Single-line error prompt will not stretch the page height
* @cn 单行错误提示不撑开页面高度
* @default false
*/
keepErrorHeight?: boolean
}
export type FormContextKey = keyof FormContextValue
export type GetFormConsumerProps<U, Keys extends FormContextKey> = Omit<
PartialKeys<U, Keys>,
'formDatum' | 'combineRules'
>
export type GetFormProviderProps<U, Value> = ForceAdd<U, FormProviderProps<Value>>
/** ----------------formItemContext-----------------------* */
export interface FormItemContextValue {
onItemError?: (id: string, error?: Error) => void
bindInputToItem?: (name: string) => void
unbindInputFromItem?: (name: string) => void
}
export type GetFormItemConsumerProps<U> = Omit<U, keyof FormItemContextValue>
/** ----------------inputable-----------------------* */
export interface BaseInputProps {
value?: any
onChange?: any
}
export interface InputableProps<Value> {
/**
* @en The callback before the value is changed, when the return value is not empty, it will be used as the new value of the component
* @cn 值改变前的回调，当返回值不为空时将作为组件的新值
* @override (value: any , datum?: FormDatum) => any
*/
beforeChange?: (value: Value | undefined, datum?: FormDatum<ObjectType>) => Value | undefined | void
onChange?: (value: Value | undefined, ...rest: any) => void
/**
* @en rules validation callback
* @cn rules 校验回调
*/
onError?: (e?: Error) => void
/**
* @inner 内部属性
*/
popover?: string
/**
* @en value
* @cn 值
*/
value?: Value
/**
* @inner 内部属性
*/
error?: Error
// readOnly?: boolean
disabled?: boolean
/**
* @en onChange is not triggered when two selected values are the same
* @cn 当两次选择的值相同时不触发 onChange
* @default false
*/
filterSameChange?: boolean
combineRules?: (name: string, rules?: FormItemRule<Value>) => FormItemRule<Value>
required?: boolean
/**
* @en When the value changes, it will link to verify the fields in the bind, which needs to be used with Form
* @cn 当值改变是会联动校验 bind 中的字段, 需要配合 Form 使用
*/
bind?: string[]
onItemError?: (id: string, error?: Error) => void
bindInputToItem?: (name: string) => void
unbindInputFromItem?: (name: string) => void
/**
* @inner 内部属性
*/
scuSkip?: string[]
/**
* @en defaultValue 和 value 类型相同
* @cn 默认值 和 value 类型相同
*/
defaultValue?: Value
/**
* @en If set to true, the form will not automatically delete the data after the component is uninstalled
* @cn 设置为 true 组件卸载后表单不自动删除数据
*/
reserveAble?: boolean
/**
* @en Validation rules, see [Rule](/components/rule) usage for details
* @cn 校验规则 详见 [Rule](/components/rule)
* @override RuleItem[]
*/
rules?: FormItemRule<Value>
/**
* @inner 内部属性
*/
formDatum?: FormDatum<ObjectType>
fieldSetValidate?: (validator: boolean) => void
/**
* @en Form field, used with Form
* @cn 表单字段, 配合 Form 使用
*/
name?: string | string[]
/**
* @inner 内部属性
*/
forceChangeOn | import { FormError } from '../utils/errors'
import FormDatum from '../Datum/Form'
import { ForceAdd, ObjectType, StandardProps, RegularAttributes, PartialKeys } from '../@types/common'
import { FormItemRule } from '../Rule/Props'
import { ButtonProps } from '../Button/Props' | random_line_split |
|
views.py | products = Product.objects.values('title', 'balance', 'price')
result['Список товаров с остатками и ценами'] = list(products)
# Суммарная стоимость всех товаров на складе
total_cost = Product.objects.aggregate(summary_cost=Sum(F('balance')*F('price')))
result['Суммарная стоимость всех товаров на складе'] = total_cost['summary_cost']
# Количество заказов
orders_count = Order.objects.count()
result['Общее количество заказов в базе'] = orders_count
# Список заказов с суммой каждого заказа (можно ли дать имя вычисляемому полю? спросить у Жени)
orders_list = Order.objects.values_list(
'client__title',
'product__title',
'dt_create',
'count',
F('count')*F('product__price')
)
orders_list = list(orders_list)
orders_list.sort(reverse=True, key=lambda e: e[4])
result['Список заказов с суммой каждого заказа'] = orders_list
# Среднее количество товаров в заказе
avg_count_in_order = Order.objects.aggregate(Avg('count'))['count__avg']
result['Среднее количество товаров в заказе'] = avg_count_in_order
# Получаем список клиентов и для каждого подсчитываем сумму сделанных им заказов
# Клиенты, не сделавшие ни одного заказа - отсекаются (filter(sum_counts__isnull=False))
# Результаты сортируются по возрастанию суммы заказа
clients_order_cost = Client.objects.annotate(
sum_counts=Sum(
F('order__count')*F('order__product__price')
)
).filter(sum_counts__isnull=False).order_by('sum_counts')
result['Список клиентов и сумма их заказов'] = [
{client.title: client.sum_counts} for client in clients_order_cost
]
# Получаем список клиентов, превысивших свой кредитный лимит
clients_over_limit = Client.objects.annotate(
sum_counts=Sum(
F('order__count')*F('order__product__price')
)
).filter(sum_counts__isnull=False, sum_counts__gt=F('credit_limit'))
result['Список клиентов, превысивших свой кредитный лимит'] = [
{
'Клиент': client.title,
'Превышение лимина': (client.sum_counts-client.credit_limit)
} for client in clients_over_limit
]
# Получаем товары, которых заказано больше их наличия на складе
products_over_balance = Product.objects.annotate(
sum_counts=Sum('order__count')
).filter(sum_counts__isnull=False, sum_counts__gt=F('balance'))
result['Список товаров, которых заказано больше их количества на складе'] = [
{
'Товар': product.title,
'Превышение количества': (product.sum_counts - product.balance)
} for product in products_over_balance
]
# Пример использования класса Prefetch: выбор всех клиентов, которые заказывали видеокарты
video_pr = Prefetch(
'order_set',
queryset=Order.objects.filter(product__title__istartswith='Видеокарта'),
to_attr='video_orders'
)
clients_videocard = Client.objects.prefetch_related(video_pr).all()
result['Клиенты, заказавшие видеокарты'] = [
{
'Клиент': client.title,
'Заказы': [
order.__str__() for order in client.video_orders
]
} for client in clients_videocard if client.video_orders
]
return JsonResponse(result)
@require_GET
def spec_stat(request, stat_type):
# Получаем сумму всех кретидных лимитов клиентов
if stat_type == 'sum_limits':
sum_limits = Client.objects.aggregate(sum=Sum('credit_limit'))['sum']
result = {'Сумма кредитных лимитов клиентов': sum_limits}
# Получаем сумму кредитных лимитов всех клиентов
if stat_type == 'sum_limits_vip':
sum_limits_vip = Client.objects.aggregate(
sum=Sum('credit_limit', filter=Q(vip=True))
)['sum']
result = {'Сумма кредитных лимитов VIP-клиентов': sum_limits_vip}
# Получаем всех клиентов, у которых кредитный лимит выше среднего
if stat_type == 'limit_over_avg':
avg_limit = Client.objects.aggregate(avg=Avg('credit_limit'))['avg']
clients = Client.objects.filter(
credit_limit__gt=avg_limit
).values_list(
'title', flat=True
)
result = {'Клиенты, у которых кредитный лимит выше среднего': list(clients)}
# Клиенты и список их заказов
if stat_type == 'clients_and_orders':
clients = Client.objects.prefetch_related('order_set').all()
result = {}
for client in clients:
result[client.title] = list(client.order_set.all().values('product__title', 'count'))
# vip-клиенты и список их заказов, включающих видеокарты
if stat_type == 'vip_clients_and_orders_video':
pr = Prefetch('order_set', queryset=Order.objects.filter(product__title__contains='Видеокарта'))
clients = Client.objects.prefetch_related(pr).filter(vip=True)
result = {}
for client in clients:
order_list = list(client.order_set.values_list('product__title', 'count'))
if order_list:
result[client.title] = order_list
# Полная стоимость каждого товара на складе
if stat_type == 'products_cost':
products_with_coast = Product.objects.annotate(coast=F('price')*F('balance'))
result = {'Список товаров': [
{
'Товар': p.title,
'Полная строимость (цена*остаток)': p.coast
} for p in products_with_coast
]}
print(result)
return JsonResponse(result)
@api_view(['GET'])
def get_clients(request):
clients = Client.objects.all()
serializer = SimpleClientSerializer(clients, many=True)
return Response(serializer.data)
@api_view(['POST'])
def create_client(request):
serializer = SimpleClientSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response('Запрос принят и успешно обработан')
else:
return Response(serializer.errors)
@api_view(['GET'])
def get_detailed_clients(request):
clients = Client.objects.all()
serializer = ClientSerializer(clients, many=True)
return Response(serializer.data)
@api_view(['GET', 'POST'])
def person_demo(request):
if request.method == 'GET':
person = Person('Сергей Лебидко', 'm', 35, '[email protected]')
serializer = PersonSerializer(person)
return Response([serializer.data])
if request.method == 'POST':
person_for_update = Person(name='Вася Пупкин', gender='m', age=15, email='[email protected]')
original_data = str(person_for_update)
serializer = PersonSerializer(data=request.data, instance=person_for_update)
if serializer.is_valid():
return Response({
'Данные до обновления экземпляра': original_data,
'Валидированные данные': serializer.validated_data,
'Данные после обновления экземпляра': str(serializer.save())
})
else:
return Response(serializer.errors)
@api_view(['GET'])
def get_urls_list(request):
from .urls import urlpatterns
return Response([str(url) for url in urlpatterns])
class ProductViewSet(ModelViewSet):
queryset = Product.objects.all()
serializer_class = ProductSerializer
class ClientViewSet(GenericViewSet, ListModelMixin, RetrieveModelMixin, CreateModelMixin, DestroyModelMixin):
queryset = Client.objects.all()
serializer_class = SimpleClientSerializer
class OrderViewSet(ModelViewSet):
queryset = Order.objects.all()
serializer_class = OrderSerializer
# Класс-контроллер входа на сайт
class Login(LoginView):
template_name = 'main/login.html'
# Контроллер отображает страницу текущего пользователя
@require_GET
def show_current_user(request):
return render(request, 'main/current_user.html', {})
# Класс-контроллер выхода с сайта
class Logout(LogoutView):
next_page = reverse_lazy('show_current_user')
@api_view(['GET'])
@permission_classes([MyPermission])
def test_permission(request):
return Response('Тест разрешений выполнен успешно')
@api_view(['GET'])
def clear_orders(request):
count = Order.objects.all().delete()[0]
return Response(f'Удалено заказов: {count}')
# Контроллер для быстрого тестирования различных фишек django / drf
# @api_view(['GET'])
def test(request):
from django.http import HttpResponse
return HttpR | esponse(request.GET['dt'])
| conditional_block |
|
views.py | список товаров
products = Product.objects.values('title', 'balance', 'price')
result['Список товаров с остатками и ценами'] = list(products)
# Суммарная стоимость всех товаров на складе
total_cost = Product.objects.aggregate(summary_cost=Sum(F('balance')*F('price')))
result['Суммарная стоимость всех товаров на складе'] = total_cost['summary_cost']
# Количество заказов
orders_count = Order.objects.count()
result['Общее количество заказов в базе'] = orders_count
# Список заказов с суммой каждого заказа (можно ли дать имя вычисляемому полю? спросить у Жени)
orders_list = Order.objects.values_list(
'client__title',
'product__title',
'dt_create',
'count',
F('count')*F('product__price')
)
orders_list = list(orders_list)
orders_list.sort(reverse=True, key=lambda e: e[4])
result['Список заказов с суммой каждого заказа'] = orders_list
# Среднее количество товаров в заказе
avg_count_in_order = Order.objects.aggregate(Avg('count'))['count__avg']
result['Среднее количество товаров в заказе'] = avg_count_in_order
# Получаем список клиентов и для каждого подсчитываем сумму сделанных им заказов
# Клиенты, не сделавшие ни одного заказа - отсекаются (filter(sum_counts__isnull=False))
# Результаты сортируются по возрастанию суммы заказа
clients_order_cost = Client.objects.annotate(
sum_counts=Sum(
F('order__count')*F('order__product__price')
)
).filter(sum_counts__isnull=False).order_by('sum_counts')
result['Список клиентов и сумма их заказов'] = [
{client.title: client.sum_counts} for client in clients_order_cost
]
# Получаем список клиентов, превысивших свой кредитный лимит
clients_over_limit = Client.objects.annotate(
sum_counts=Sum(
F('order__count')*F('order__product__price')
)
).filter(sum_counts__isnull=False, sum_counts__gt=F('credit_limit'))
result['Список клиентов, превысивших свой кредитный лимит'] = [
{
'Клиент': client.title,
'Превышение лимина': (client.sum_counts-client.credit_limit)
} for client in clients_over_limit
]
# Получаем товары, которых заказано больше их наличия на складе
products_over_balance = Product.objects.annotate(
sum_counts=Sum('order__count')
).filter(sum_counts__isnull=False, sum_counts__gt=F('balance'))
result['Список товаров, которых заказано больше их количества на складе'] = [
{
'Товар': product.title,
'Превышение количества': (product.sum_counts - product.balance)
} for product in products_over_balance
]
# Пример использования класса Prefetch: выбор всех клиентов, которые заказывали видеокарты
video_pr = Prefetch(
'order_set',
queryset=Order.objects.filter(product__title__istartswith='Видеокарта'),
to_attr='video_orders'
)
clients_videocard = Client.objects.prefetch_related(video_pr).all()
result['Клиенты, заказавшие видеокарты'] = [
{
'Клиент': client.title,
'Заказы': [
order.__str__() for order in client.video_orders
]
} for client in clients_videocard if client.video_orders
]
return JsonResponse(result)
@require_GET
def spec_stat(request, stat_type):
# Получаем сумму всех кретидных лимитов клиентов
if stat_type == 'sum_limits':
sum_limits = Client.objects.aggregate(sum=Sum('credit_limit'))['sum']
result = {'Сумма кредитных лимитов клиентов': sum_limits}
# Получаем сумму кредитных лимитов всех клиентов
if stat_type == 'sum_limits_vip':
sum_limits_vip = Client.objects.aggregate(
sum=Sum('credit_limit', filter=Q(vip=True))
)['sum']
result = {'Сумма кредитных лимитов VIP-клиентов': sum_limits_vip}
# Получаем всех клиентов, у которых кредитный лимит выше среднего
if stat_type == 'limit_over_avg':
avg_limit = Client.objects.aggregate(avg=Avg('credit_limit'))['avg']
clients = Client.objects.filter(
credit_limit__gt=avg_limit
).values_list(
'title', flat=True
)
result = {'Клиенты, у которых кредитный лимит выше среднего': list(clients)}
# Клиенты и список их заказов
if stat_type == 'clients_and_orders':
clients = Client.objects.prefetch_related('order_set').all()
result = {}
for client in clients:
result[client.title] = list(client.order_set.all().values('product__title', 'count'))
# vip-клиенты и список их заказов, включающих видеокарты
if stat_type == 'vip_clients_and_orders_video':
pr = Prefetch('order_set', queryset=Order.objects.filter(product__title__contains='Видеокарта'))
clients = Client.objects.prefetch_related(pr).filter(vip=True)
result = {}
for client in clients:
order_list = list(client.order_set.values_list('product__title', 'count'))
if order_list:
result[client.title] = order_list
# Полная стоимость каждого товара на складе
if stat_type == 'products_cost':
products_with_coast = Product.objects.annotate(coast=F('price')*F('balance'))
result = {'Список товаров': [
{
'Товар': p.title,
'Полная строимость (цена*остаток)': p.coast
} for p in products_with_coast
]}
print(result)
return JsonResponse(result)
@api_view(['GET'])
def get_clients(request):
clients = Client.objects.all()
serializer = SimpleClientSerializer(clients, many=True)
return Response(serializer.data)
@api_view(['POST'])
def create_client(request):
serializer = SimpleClientSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response('Запрос принят и успешно обработан')
else:
return Response(serializer.errors)
@api_view(['GET'])
def get_detailed_clients(request):
clients = Client.objects.all()
serializer = ClientSerializer(clients, many=True)
return Response(serializer.data)
@api_view(['GET', 'POST'])
def person_demo(request):
if request.method == 'GET':
person = Person('Сергей Лебидко', 'm', 35, '[email protected]')
serializer = PersonSerializer(person)
return Response([serializer.data])
if request.method == 'POST':
person_for_update = Person(name='Вася Пупкин', gender='m', age=15, email='[email protected]')
original_data = str(person_for_update)
serializer = PersonSerializer(data=request.data, instance=person_for_update)
if serializer.is_valid():
return Response({
'Данные до обновления экземпляра': original_data,
'Валидированные данные': serializer.validated_data,
'Данные после обновления экземпляра': str(serializer.save())
})
else:
return Response(serializer.errors)
@api_view(['GET'])
def get_urls_list(request):
from .urls import urlpatterns
return Response([str(url) for url in urlpatterns])
class ProductViewSet(ModelViewSet):
queryset = Product.objects.all()
serializer_class = ProductSerializer
class ClientViewSet(GenericViewSet, ListModelMixin, RetrieveModelMixin, CreateModelMixin, DestroyModelMixin):
queryset = Client.objects.all()
serializer_class = SimpleClientSerializer
class OrderViewSet(ModelViewSet):
queryset = Order.objects.all()
serializer_class = OrderSerializer
# Класс-контроллер входа на сайт
class Login(LoginView):
template_name = 'main/login.html'
# Контроллер отображает страницу текущего пользователя
@require_GET
def show_current_user(request):
return render(request, 'main/current_user.html', {})
# Класс-контроллер выхода с сайта
class Logout(LogoutView):
next_page = reverse_lazy('show_current_user')
@api_view(['GET'])
@permission_classes([MyPermission])
def test_permission(request):
return Response('Тест разрешений выполнен успешно')
@api_view(['GET'])
def clear_orders(request):
count = Order.objects.all().delete()[0]
return Response(f'Удалено заказов: {count}')
# Контроллер для быстрого тестирования различных фишек django / drf
# @api_view(['GET'])
def test(request):
from django.http import HttpResponse
return HttpResponse(request.GET['dt'])
| identifier_name |
||
views.py | их заказов'],
['GET /spec_stat/vip_clients_and_orders_video/', 'vip-клиенты и список их заказов, включающих видеокарты'],
['GET /spec_stat/products_cost/', 'Список товаров с их полной стоимостью (цена*количество)'],
['GET /get_clients/', 'Список клиентов (формируется с помощью DRF)'],
['GET /create_client/', 'Создать клиента (формируется с помощью DRF)'],
['GET /test/', 'Хук для тестовых запросов'],
['GET или POST /person_demo/', 'Хук для тестирования работы с сериализатором обычного объекта'],
['GET /get_detailed_clients/', 'Выводит список клиентов, свомещенный со списками id их заказов'],
['GET /get_url_list/', 'Выводит список всех элементов списка urlpatterns'],
]
}
return render(request, 'main/hooks.html', context)
@require_GET
def create_orders(request):
# Получаем количество заказаов, которые будем формировать
orders_count = request.GET.get('orders_count')
if not orders_count:
orders_count = request.default_orders_count
orders_count = int(orders_count)
# Предварительно очищаем БД от старых заказов
Order.objects.all().delete() | clients = Client.objects.all()
products = Product.objects.all()
# Добавляем новые заказы
today = date.today()
for i in range(0, orders_count):
client = random.choice(clients)
product = random.choice(products)
t_delta = timedelta(days=random.randint(0, 10))
dt_create = today - t_delta
count = random.randint(1, 10)
Order.objects.create(
client=client,
product=product,
dt_create=dt_create,
count=count
)
result = {'Создано заказов': str(orders_count)}
return JsonResponse(result)
@require_GET
def statistic(request):
result = {}
# values возвращает queryset, содержащий словари
# clients = Client.objects.values('title')
# result['Список клиентов (получен с помощью values)'] = list(clients)
# values_list возвращает queryset, содержащий кортежи
# clients = Client.objects.values_list('title')
# result['Список клиентов (получен с помощью values_list (flat=False))'] = list(clients)
# values_list с пареметром flat=True возвращает queryset, содержащий значения поля
clients = Client.objects.values_list('title', flat=True)
result['Список клиентов (получен с помощью values_list (flat=True))'] = list(clients)
# Пример использования функции aggregate для получения сводной информации по всей таблице клиентов сразу
agr_values = Client.objects.aggregate(
count_clients=Count('title'),
credit_limit_max=Max('credit_limit'),
credit_limit_min=Min('credit_limit'),
credit_limit_avg=Avg('credit_limit'),
credit_limit_sum=Sum('credit_limit')
)
result['Сводные данные по всем клиентам'] = agr_values
# Получаем информацию о количестве заказов, сделанных каждым клиентом
clients_with_order_counts = Client.objects.annotate(Count('order')).order_by('-order__count')
result['Количество заказов, сделанных клиентами'] = {
client.title: client.order__count for client in clients_with_order_counts
}
# По примеру формирования списка клиентов формируем и список товаров
products = Product.objects.values('title', 'balance', 'price')
result['Список товаров с остатками и ценами'] = list(products)
# Суммарная стоимость всех товаров на складе
total_cost = Product.objects.aggregate(summary_cost=Sum(F('balance')*F('price')))
result['Суммарная стоимость всех товаров на складе'] = total_cost['summary_cost']
# Количество заказов
orders_count = Order.objects.count()
result['Общее количество заказов в базе'] = orders_count
# Список заказов с суммой каждого заказа (можно ли дать имя вычисляемому полю? спросить у Жени)
orders_list = Order.objects.values_list(
'client__title',
'product__title',
'dt_create',
'count',
F('count')*F('product__price')
)
orders_list = list(orders_list)
orders_list.sort(reverse=True, key=lambda e: e[4])
result['Список заказов с суммой каждого заказа'] = orders_list
# Среднее количество товаров в заказе
avg_count_in_order = Order.objects.aggregate(Avg('count'))['count__avg']
result['Среднее количество товаров в заказе'] = avg_count_in_order
# Получаем список клиентов и для каждого подсчитываем сумму сделанных им заказов
# Клиенты, не сделавшие ни одного заказа - отсекаются (filter(sum_counts__isnull=False))
# Результаты сортируются по возрастанию суммы заказа
clients_order_cost = Client.objects.annotate(
sum_counts=Sum(
F('order__count')*F('order__product__price')
)
).filter(sum_counts__isnull=False).order_by('sum_counts')
result['Список клиентов и сумма их заказов'] = [
{client.title: client.sum_counts} for client in clients_order_cost
]
# Получаем список клиентов, превысивших свой кредитный лимит
clients_over_limit = Client.objects.annotate(
sum_counts=Sum(
F('order__count')*F('order__product__price')
)
).filter(sum_counts__isnull=False, sum_counts__gt=F('credit_limit'))
result['Список клиентов, превысивших свой кредитный лимит'] = [
{
'Клиент': client.title,
'Превышение лимина': (client.sum_counts-client.credit_limit)
} for client in clients_over_limit
]
# Получаем товары, которых заказано больше их наличия на складе
products_over_balance = Product.objects.annotate(
sum_counts=Sum('order__count')
).filter(sum_counts__isnull=False, sum_counts__gt=F('balance'))
result['Список товаров, которых заказано больше их количества на складе'] = [
{
'Товар': product.title,
'Превышение количества': (product.sum_counts - product.balance)
} for product in products_over_balance
]
# Пример использования класса Prefetch: выбор всех клиентов, которые заказывали видеокарты
video_pr = Prefetch(
'order_set',
queryset=Order.objects.filter(product__title__istartswith='Видеокарта'),
to_attr='video_orders'
)
clients_videocard = Client.objects.prefetch_related(video_pr).all()
result['Клиенты, заказавшие видеокарты'] = [
{
'Клиент': client.title,
'Заказы': [
order.__str__() for order in client.video_orders
]
} for client in clients_videocard if client.video_orders
]
return JsonResponse(result)
@require_GET
def spec_stat(request, stat_type):
# Получаем сумму всех кретидных лимитов клиентов
if stat_type == 'sum_limits':
sum_limits = Client.objects.aggregate(sum=Sum('credit_limit'))['sum']
result = {'Сумма кредитных лимитов клиентов': sum_limits}
# Получаем сумму кредитных лимитов всех клиентов
if stat_type == 'sum_limits_vip':
sum_limits_vip = Client.objects.aggregate(
sum=Sum('credit_limit', filter=Q(vip=True))
)['sum']
result = {'Сумма кредитных лимитов VIP-клиентов': sum_limits_vip}
# Получаем всех клиентов, у которых кредитный лимит выше среднего
if stat_type == 'limit_over_avg':
avg_limit = Client.objects.aggregate(avg=Avg('credit_limit'))['avg']
clients = Client.objects.filter(
credit_limit__gt=avg_limit
).values_list(
'title', flat=True
)
result = {'Клиенты, у которых кредитный лимит выше среднего': list(clients)}
# Клиенты и список их заказов
if stat_type == 'clients_and_orders':
clients = Client.objects.prefetch_related('order_set').all()
result = {}
for client in clients:
result[client.title] = list(client.order_set.all().values('product__title', 'count'))
# vip-клиенты и список их заказов, включающих видеокарты
if stat_type == 'vip_clients_and_orders_video':
pr = Prefetch('order_set', queryset=Order.objects.filter(product__title__contains='Видеокарта'))
clients = Client.objects.pref |
# Получаем списки клиентов и товаров | random_line_split |
views.py | ым клиентом
clients_with_order_counts = Client.objects.annotate(Count('order')).order_by('-order__count')
result['Количество заказов, сделанных клиентами'] = {
client.title: client.order__count for client in clients_with_order_counts
}
# По примеру формирования списка клиентов формируем и список товаров
products = Product.objects.values('title', 'balance', 'price')
result['Список товаров с остатками и ценами'] = list(products)
# Суммарная стоимость всех товаров на складе
total_cost = Product.objects.aggregate(summary_cost=Sum(F('balance')*F('price')))
result['Суммарная стоимость всех товаров на складе'] = total_cost['summary_cost']
# Количество заказов
orders_count = Order.objects.count()
result['Общее количество заказов в базе'] = orders_count
# Список заказов с суммой каждого заказа (можно ли дать имя вычисляемому полю? спросить у Жени)
orders_list = Order.objects.values_list(
'client__title',
'product__title',
'dt_create',
'count',
F('count')*F('product__price')
)
orders_list = list(orders_list)
orders_list.sort(reverse=True, key=lambda e: e[4])
result['Список заказов с суммой каждого заказа'] = orders_list
# Среднее количество товаров в заказе
avg_count_in_order = Order.objects.aggregate(Avg('count'))['count__avg']
result['Среднее количество товаров в заказе'] = avg_count_in_order
# Получаем список клиентов и для каждого подсчитываем сумму сделанных им заказов
# Клиенты, не сделавшие ни одного заказа - отсекаются (filter(sum_counts__isnull=False))
# Результаты сортируются по возрастанию суммы заказа
clients_order_cost = Client.objects.annotate(
sum_counts=Sum(
F('order__count')*F('order__product__price')
)
).filter(sum_counts__isnull=False).order_by('sum_counts')
result['Список клиентов и сумма их заказов'] = [
{client.title: client.sum_counts} for client in clients_order_cost
]
# Получаем список клиентов, превысивших свой кредитный лимит
clients_over_limit = Client.objects.annotate(
sum_counts=Sum(
F('order__count')*F('order__product__price')
)
).filter(sum_counts__isnull=False, sum_counts__gt=F('credit_limit'))
result['Список клиентов, превысивших свой кредитный лимит'] = [
{
'Клиент': client.title,
'Превышение лимина': (client.sum_counts-client.credit_limit)
} for client in clients_over_limit
]
# Получаем товары, которых заказано больше их наличия на складе
products_over_balance = Product.objects.annotate(
sum_counts=Sum('order__count')
).filter(sum_counts__isnull=False, sum_counts__gt=F('balance'))
result['Список товаров, которых заказано больше их количества на складе'] = [
{
'Товар': product.title,
'Превышение количества': (product.sum_counts - product.balance)
} for product in products_over_balance
]
# Пример использования класса Prefetch: выбор всех клиентов, которые заказывали видеокарты
video_pr = Prefetch(
'order_set',
queryset=Order.objects.filter(product__title__istartswith='Видеокарта'),
to_attr='video_orders'
)
clients_videocard = Client.objects.prefetch_related(video_pr).all()
result['Клиенты, заказавшие видеокарты'] = [
{
'Клиент': client.title,
'Заказы': [
order.__str__() for order in client.video_orders
]
} for client in clients_videocard if client.video_orders
]
return JsonResponse(result)
@require_GET
def spec_stat(request, stat_type):
# Получаем сумму всех кретидных лимитов клиентов
if stat_type == 'sum_limits':
sum_limits = Client.objects.aggregate(sum=Sum('credit_limit'))['sum']
result = {'Сумма кредитных лимитов клиентов': sum_limits}
# Получаем сумму кредитных лимитов всех клиентов
if stat_type == 'sum_limits_vip':
sum_limits_vip = Client.objects.aggregate(
sum=Sum('credit_limit', filter=Q(vip=True))
)['sum']
result = {'Сумма кредитных лимитов VIP-клиентов': sum_limits_vip}
# Получаем всех клиентов, у которых кредитный лимит выше среднего
if stat_type == 'limit_over_avg':
avg_limit = Client.objects.aggregate(avg=Avg('credit_limit'))['avg']
clients = Client.objects.filter(
credit_limit__gt=avg_limit
).values_list(
'title', flat=True
)
result = {'Клиенты, у которых кредитный лимит выше среднего': list(clients)}
# Клиенты и список их заказов
if stat_type == 'clients_and_orders':
clients = Client.objects.prefetch_related('order_set').all()
result = {}
for client in clients:
result[client.title] = list(client.order_set.all().values('product__title', 'count'))
# vip-клиенты и список их заказов, включающих видеокарты
if stat_type == 'vip_clients_and_orders_video':
pr = Prefetch('order_set', queryset=Order.objects.filter(product__title__contains='Видеокарта'))
clients = Client.objects.prefetch_related(pr).filter(vip=True)
result = {}
for client in clients:
order_list = list(client.order_set.values_list('product__title', 'count'))
if order_list:
result[client.title] = order_list
# Полная стоимость каждого товара на складе
if stat_type == 'products_cost':
products_with_coast = Product.objects.annotate(coast=F('price')*F('balance'))
result = {'Список товаров': [
{
'Товар': p.title,
'Полная строимость (цена*остаток)': p.coast
} for p in products_with_coast
]}
print(result)
return JsonResponse(result)
@api_view(['GET'])
def get_clients(request):
clients = Client.objects.all()
serializer = SimpleClientSerializer(clients, many=True)
return Response(serializer.data)
@api_view(['POST'])
def create_client(request):
serializer = SimpleClientSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response('Запрос принят и успешно обработан')
else:
return Response(serializer.errors)
@api_view(['GET'])
def get_detailed_clients(request):
clients = Client.objects.all()
serializer = ClientSerializer(clients, many=True)
return Response(serializer.data)
@api_view(['GET', 'POST'])
def person_demo(request):
if request.method == 'GET':
person = Person('Сергей Лебидко', 'm', 35, '[email protected]')
serializer = PersonSerializer(person)
return Response([serializer.data])
if request.method == 'POST':
person_for_update = Person(name='Вася Пупкин', gender='m', age=15, email='[email protected]')
original_data = str(person_for_update)
serializer = PersonSerializer(data=request.data, instance=person_for_update)
if serializer.is_valid():
return Response({
'Данные до обновления экземпляра': original_data,
'Валидированные данные': serializer.validated_data,
'Данные после обновления экземпляра': str(serializer.save())
})
else:
return Response(serializer.errors)
@api_view(['GET'])
def get_urls_list(request):
from .urls import urlpatterns
return Response([str(url) for url in urlpatterns])
class ProductViewSet(ModelViewSet):
queryset = Product.objects.all()
serializer_class = ProductSerializer
class ClientViewSet(GenericViewSet, ListModelMixin, RetrieveModelMixin, CreateModelMixin, DestroyModelMixin):
queryset = Client.objects.all()
serializer_class = SimpleClientSerializer
class OrderViewSet(ModelViewSet):
queryset = Order.objects.all()
serializer_class = OrderSerializer
# Класс-контроллер входа на сайт
class Login(LoginView):
template_name = 'main/login.html'
# Контроллер отображает страницу текущего пользователя
@require_GET
def show_current_user(request):
return render(request, 'main/current_user.html', {})
# Класс-контроллер выхода с сайта
class Logout(LogoutView):
next_page = reverse_lazy('show_current_user')
@api_view(['GET'])
@permission_classes([MyPermis | sion])
def test_permission(request):
return Response('Тест разрешений выполнен успешно')
@api_view(['GET'])
def clear_ord | identifier_body |
|
main.rs | (?P<ref>\w+))?:(?P<script>.+)$").unwrap();
static ref GIT_SOURCE_REGEX: Regex =
Regex::new(r"^(?P<repo>((git|ssh|http(s)?)|(git@[\w\.]+))(:(//)?)([\w\./\-~]+)(\.git)?(/)?)(@(?P<ref>\w+))?:(?P<script>.+)$")
.unwrap();
}
#[derive(Clap, Debug)]
#[clap(author, about, version)]
#[clap(global_setting = AppSettings::ColoredHelp)]
#[clap(setting = AppSettings::DeriveDisplayOrder)]
#[clap(setting = AppSettings::SubcommandRequiredElseHelp)]
struct Opts {
#[clap(subcommand)]
command: Command,
}
const SCRIPT_HELP: &'static str = r"Script identifier for a script from a repository
For saved repos: `<repo>[@ref]:<script_path>`
Example: `myscripts:hello.bash`
Example (w/ ref): `[email protected]:hello.bash`
For git repos: `git@<repo_url>[@ref]:<script_path>`
Example: `[email protected]:user/myscripts:hello.bash`
Example (w/ ref): `[email protected]:user/myscripts@main:hello.bash`
";
#[derive(Clap, Debug)]
enum Command {
/// Read and modify locally saved repositories
Repo {
#[clap(subcommand)]
command: RepoCommand,
},
/// Run a script using the locally installed bash shell
Run {
/// Force a fresh download of the script (only for raw git repositories)
#[clap(short, long)]
fresh: bool,
#[clap(about = "Script to run", long_about = SCRIPT_HELP)]
script: String,
/// Args to be passed to the script
#[clap(about = "Args to be passed to the script")]
args: Vec<String>,
},
/// Import a script and print it to stdout
Import {
#[clap(short, long)]
fresh: bool,
#[clap(about = "Script to import", long_about = SCRIPT_HELP)]
script: String,
},
}
#[derive(Clap, Debug)]
enum RepoCommand {
/// List all locally saved repositories
#[clap(alias = "ls")]
List,
/// Add a repository to the local repository list
Add {
/// Local alias for the repository to add
name: String,
/// URI of the repository to add
uri: String,
/// Username for the repository (if required)
#[clap(long, short)]
username: Option<String>,
/// Password or token for the repository (if required)
#[clap(long, short)]
password: Option<String>,
/// Reads the password from the given environment variable when the repo is used
#[clap(long)]
password_env: Option<String>,
/// Reads the password or token from stdin
#[clap(long)]
password_stdin: bool,
},
/// Remove a repository from the local repository list
#[clap(alias = "rm")]
Remove {
/// Local alias for the repository to remove
name: String,
},
}
#[derive(PartialEq)]
pub enum Password {
Saved(String),
FromEnv(String, String),
None,
}
#[tokio::main]
async fn main() -> Result<()> {
openssl_probe::init_ssl_cert_env_vars();
let mut config = config::load_config().await?;
match Opts::parse().command {
Command::Repo { command } => match command {
RepoCommand::List => {
if config.repo.is_empty() {
println!("No Saved repositories.");
return Ok(());
}
println!("Saved repositories:");
for (k, v) in config.repo {
println!(" {} ({} | {})", k, v.provider(), v.readable());
}
}
RepoCommand::Add {
name,
uri,
username,
password,
password_env,
password_stdin,
} => {
if config.repo.contains_key(&name) {
bail!("A repository with the name `{}` already exists", &name);
}
let password_for_parse = match (password, password_env, password_stdin) {
(Some(pass), _, _) => Password::Saved(pass),
(_, Some(var), _) => Password::FromEnv(var.clone(), env::var(var)?),
(_, _, true) => {
let mut buf = String::new();
io::stdin().read_to_string(&mut buf)?;
Password::Saved(buf)
}
_ => Password::None,
};
let repo = validate_api_repo(&uri, username, password_for_parse).await?;
config.repo.insert(name.clone(), repo);
save_config(&config)
.await
.context("Failed to save updated config")?;
println!("Repo `{}` was successfully added", &name);
}
RepoCommand::Remove { name } => {
if !config.repo.contains_key(&name) {
bail!("Repo `{}` was not found", &name);
}
config.repo.remove(&name);
save_config(&config)
.await
.context("Failed to save updated config")?;
println!("Repo `{}` was removed", &name);
}
},
Command::Run {
script,
args,
fresh,
} => {
let src = ScriptSource::parse(&script, ScriptAction::Run)?;
src.validate_script_name(&config)?;
let contents = src.fetch_script_contents(&config, fresh).await?;
let args = args.iter().map(|s| &**s).collect();
// TODO(happens): Find a way to propagate the actual exit code
// instead of simply returning 0/1 depending on the script.
// This should cover most use cases if you just want to know
// if the script failed, but until `std::process::Termination`
// is stabilized, it seems unsafe to use `std::process::exit`
// since we're using a tokio main.
let exit = repo::run_script(&contents, args).await?;
if !exit.success() {
bail!("");
}
}
Command::Import { script, fresh } => {
let src = ScriptSource::parse(&script, ScriptAction::Import)?;
src.validate_script_name(&config)?;
let contents = src.fetch_script_contents(&config, fresh).await?;
repo::import_script(&contents).await?;
}
};
Ok(())
}
enum ScriptAction {
Run,
Import,
}
pub struct ScriptSource {
repo: String,
source_type: SourceType,
script_name: String,
rref: Option<String>,
action: ScriptAction,
}
enum | {
Git,
Saved,
}
impl ScriptSource {
fn parse(script: &str, action: ScriptAction) -> Result<ScriptSource> {
if let Some(matches) = API_SOURCE_REGEX.captures(script) {
let repo = matches
.name("alias")
.expect("No alias matched")
.as_str()
.to_owned();
let script_name = matches
.name("script")
.expect("No script name matched")
.as_str()
.to_owned();
let rref = matches.name("ref").map(|rref| rref.as_str().to_owned());
return Ok(Self {
source_type: SourceType::Saved,
repo,
script_name,
rref,
action,
});
}
if let Some(matches) = GIT_SOURCE_REGEX.captures(script) {
let repo = matches
.name("repo")
.expect("No repo matched")
.as_str()
.to_owned();
let script_name = matches
.name("script")
.expect("No script name matched")
.as_str()
.to_owned();
let rref = matches.name("ref").map(|rref| rref.as_str().to_owned());
return Ok(Self {
source_type: SourceType::Git,
repo,
script_name,
rref,
action,
});
}
bail!("Script source could not be parsed")
}
fn validate_script_name(&self, config: &Config) -> Result<()> {
if config.require_bash_extension.is_none() && config.require_lib_extension.is_none() {
return Ok(());
}
let expected = match (
&config.require_bash_extension,
&config.require_lib_extension,
&self.action,
) {
(Some(ref ext), _, &ScriptAction::Run) => ext,
(_, Some(ext), &ScriptAction::Import) => ext,
_ => unreachable!(),
};
if !self.script_name.ends_with(expected) {
bail!("Expected script name to end with `{}`", expected);
}
Ok(())
}
async fn fetch_script_contents(&self, config: &config::Config, fresh: bool) -> Result<String> {
let repo = match self.source_type {
SourceType::Saved => config
.repo
.get(&self.repo)
.ok_or(anyhow!("Repo `{}` was not found", &self.repo))?
.box_clone(),
SourceType::Git => git::GitRepo::from_src(&self),
};
let rref = self.rref.clone().unwrap_or("HEAD".to_owned());
Ok(repo.fetch_script(&self.script_name, &rref, fresh).await | SourceType | identifier_name |
main.rs | (?P<ref>\w+))?:(?P<script>.+)$").unwrap();
static ref GIT_SOURCE_REGEX: Regex =
Regex::new(r"^(?P<repo>((git|ssh|http(s)?)|(git@[\w\.]+))(:(//)?)([\w\./\-~]+)(\.git)?(/)?)(@(?P<ref>\w+))?:(?P<script>.+)$")
.unwrap();
}
#[derive(Clap, Debug)]
#[clap(author, about, version)]
#[clap(global_setting = AppSettings::ColoredHelp)]
#[clap(setting = AppSettings::DeriveDisplayOrder)]
#[clap(setting = AppSettings::SubcommandRequiredElseHelp)]
struct Opts {
#[clap(subcommand)]
command: Command,
}
const SCRIPT_HELP: &'static str = r"Script identifier for a script from a repository
For saved repos: `<repo>[@ref]:<script_path>`
Example: `myscripts:hello.bash`
Example (w/ ref): `[email protected]:hello.bash`
For git repos: `git@<repo_url>[@ref]:<script_path>`
Example: `[email protected]:user/myscripts:hello.bash`
Example (w/ ref): `[email protected]:user/myscripts@main:hello.bash`
";
#[derive(Clap, Debug)]
enum Command {
/// Read and modify locally saved repositories
Repo {
#[clap(subcommand)]
command: RepoCommand,
},
/// Run a script using the locally installed bash shell
Run {
/// Force a fresh download of the script (only for raw git repositories)
#[clap(short, long)]
fresh: bool,
#[clap(about = "Script to run", long_about = SCRIPT_HELP)]
script: String,
/// Args to be passed to the script
#[clap(about = "Args to be passed to the script")]
args: Vec<String>,
},
/// Import a script and print it to stdout
Import {
#[clap(short, long)]
fresh: bool,
#[clap(about = "Script to import", long_about = SCRIPT_HELP)]
script: String,
},
}
#[derive(Clap, Debug)]
enum RepoCommand {
/// List all locally saved repositories
#[clap(alias = "ls")]
List,
/// Add a repository to the local repository list
Add {
/// Local alias for the repository to add
name: String,
/// URI of the repository to add
uri: String,
/// Username for the repository (if required)
#[clap(long, short)]
username: Option<String>,
/// Password or token for the repository (if required)
#[clap(long, short)]
password: Option<String>,
/// Reads the password from the given environment variable when the repo is used
#[clap(long)]
password_env: Option<String>,
/// Reads the password or token from stdin
#[clap(long)]
password_stdin: bool,
},
/// Remove a repository from the local repository list
#[clap(alias = "rm")]
Remove {
/// Local alias for the repository to remove
name: String,
},
}
#[derive(PartialEq)]
pub enum Password {
Saved(String),
FromEnv(String, String),
None,
}
#[tokio::main]
async fn main() -> Result<()> {
openssl_probe::init_ssl_cert_env_vars();
let mut config = config::load_config().await?;
match Opts::parse().command {
Command::Repo { command } => match command {
RepoCommand::List => {
if config.repo.is_empty() {
println!("No Saved repositories.");
return Ok(());
}
println!("Saved repositories:");
for (k, v) in config.repo {
println!(" {} ({} | {})", k, v.provider(), v.readable());
}
}
RepoCommand::Add {
name,
uri,
username,
password,
password_env,
password_stdin,
} => {
if config.repo.contains_key(&name) {
bail!("A repository with the name `{}` already exists", &name);
}
let password_for_parse = match (password, password_env, password_stdin) {
(Some(pass), _, _) => Password::Saved(pass),
(_, Some(var), _) => Password::FromEnv(var.clone(), env::var(var)?),
(_, _, true) => {
let mut buf = String::new();
io::stdin().read_to_string(&mut buf)?;
Password::Saved(buf)
}
_ => Password::None,
};
let repo = validate_api_repo(&uri, username, password_for_parse).await?;
config.repo.insert(name.clone(), repo);
save_config(&config)
.await
.context("Failed to save updated config")?;
println!("Repo `{}` was successfully added", &name);
}
RepoCommand::Remove { name } => {
if !config.repo.contains_key(&name) {
bail!("Repo `{}` was not found", &name);
}
config.repo.remove(&name);
save_config(&config)
.await
.context("Failed to save updated config")?;
println!("Repo `{}` was removed", &name);
}
},
Command::Run {
script,
args,
fresh,
} => {
let src = ScriptSource::parse(&script, ScriptAction::Run)?;
src.validate_script_name(&config)?;
let contents = src.fetch_script_contents(&config, fresh).await?;
let args = args.iter().map(|s| &**s).collect();
// TODO(happens): Find a way to propagate the actual exit code
// instead of simply returning 0/1 depending on the script.
// This should cover most use cases if you just want to know
// if the script failed, but until `std::process::Termination`
// is stabilized, it seems unsafe to use `std::process::exit`
// since we're using a tokio main.
let exit = repo::run_script(&contents, args).await?;
if !exit.success() {
bail!("");
}
}
Command::Import { script, fresh } => {
let src = ScriptSource::parse(&script, ScriptAction::Import)?;
src.validate_script_name(&config)?;
let contents = src.fetch_script_contents(&config, fresh).await?;
repo::import_script(&contents).await?;
}
};
Ok(())
}
enum ScriptAction {
Run,
Import,
}
pub struct ScriptSource {
repo: String,
source_type: SourceType,
script_name: String,
rref: Option<String>,
action: ScriptAction,
}
enum SourceType {
Git,
Saved,
}
impl ScriptSource {
fn parse(script: &str, action: ScriptAction) -> Result<ScriptSource> {
if let Some(matches) = API_SOURCE_REGEX.captures(script) {
let repo = matches
.name("alias")
.expect("No alias matched")
.as_str()
.to_owned();
let script_name = matches
.name("script")
.expect("No script name matched")
.as_str()
.to_owned();
let rref = matches.name("ref").map(|rref| rref.as_str().to_owned());
return Ok(Self {
source_type: SourceType::Saved,
repo,
script_name,
rref,
action,
});
}
if let Some(matches) = GIT_SOURCE_REGEX.captures(script) {
let repo = matches
.name("repo")
.expect("No repo matched")
.as_str()
.to_owned();
let script_name = matches
.name("script")
.expect("No script name matched")
.as_str()
.to_owned();
let rref = matches.name("ref").map(|rref| rref.as_str().to_owned());
return Ok(Self {
source_type: SourceType::Git,
repo,
script_name,
rref,
action,
});
}
bail!("Script source could not be parsed")
}
fn validate_script_name(&self, config: &Config) -> Result<()> {
if config.require_bash_extension.is_none() && config.require_lib_extension.is_none() {
return Ok(());
}
let expected = match (
&config.require_bash_extension,
&config.require_lib_extension,
&self.action,
) {
(Some(ref ext), _, &ScriptAction::Run) => ext,
(_, Some(ext), &ScriptAction::Import) => ext,
_ => unreachable!(),
};
if !self.script_name.ends_with(expected) {
bail!("Expected script name to end with `{}`", expected);
}
Ok(())
}
async fn fetch_script_contents(&self, config: &config::Config, fresh: bool) -> Result<String> {
let repo = match self.source_type {
SourceType::Saved => config
.repo | SourceType::Git => git::GitRepo::from_src(&self),
};
let rref = self.rref.clone().unwrap_or("HEAD".to_owned());
Ok(repo.fetch_script(&self.script_name, &rref, fresh).await?)
| .get(&self.repo)
.ok_or(anyhow!("Repo `{}` was not found", &self.repo))?
.box_clone(), | random_line_split |
main.rs | (?P<ref>\w+))?:(?P<script>.+)$").unwrap();
static ref GIT_SOURCE_REGEX: Regex =
Regex::new(r"^(?P<repo>((git|ssh|http(s)?)|(git@[\w\.]+))(:(//)?)([\w\./\-~]+)(\.git)?(/)?)(@(?P<ref>\w+))?:(?P<script>.+)$")
.unwrap();
}
#[derive(Clap, Debug)]
#[clap(author, about, version)]
#[clap(global_setting = AppSettings::ColoredHelp)]
#[clap(setting = AppSettings::DeriveDisplayOrder)]
#[clap(setting = AppSettings::SubcommandRequiredElseHelp)]
struct Opts {
#[clap(subcommand)]
command: Command,
}
const SCRIPT_HELP: &'static str = r"Script identifier for a script from a repository
For saved repos: `<repo>[@ref]:<script_path>`
Example: `myscripts:hello.bash`
Example (w/ ref): `[email protected]:hello.bash`
For git repos: `git@<repo_url>[@ref]:<script_path>`
Example: `[email protected]:user/myscripts:hello.bash`
Example (w/ ref): `[email protected]:user/myscripts@main:hello.bash`
";
#[derive(Clap, Debug)]
enum Command {
/// Read and modify locally saved repositories
Repo {
#[clap(subcommand)]
command: RepoCommand,
},
/// Run a script using the locally installed bash shell
Run {
/// Force a fresh download of the script (only for raw git repositories)
#[clap(short, long)]
fresh: bool,
#[clap(about = "Script to run", long_about = SCRIPT_HELP)]
script: String,
/// Args to be passed to the script
#[clap(about = "Args to be passed to the script")]
args: Vec<String>,
},
/// Import a script and print it to stdout
Import {
#[clap(short, long)]
fresh: bool,
#[clap(about = "Script to import", long_about = SCRIPT_HELP)]
script: String,
},
}
#[derive(Clap, Debug)]
enum RepoCommand {
/// List all locally saved repositories
#[clap(alias = "ls")]
List,
/// Add a repository to the local repository list
Add {
/// Local alias for the repository to add
name: String,
/// URI of the repository to add
uri: String,
/// Username for the repository (if required)
#[clap(long, short)]
username: Option<String>,
/// Password or token for the repository (if required)
#[clap(long, short)]
password: Option<String>,
/// Reads the password from the given environment variable when the repo is used
#[clap(long)]
password_env: Option<String>,
/// Reads the password or token from stdin
#[clap(long)]
password_stdin: bool,
},
/// Remove a repository from the local repository list
#[clap(alias = "rm")]
Remove {
/// Local alias for the repository to remove
name: String,
},
}
#[derive(PartialEq)]
pub enum Password {
Saved(String),
FromEnv(String, String),
None,
}
#[tokio::main]
async fn main() -> Result<()> {
openssl_probe::init_ssl_cert_env_vars();
let mut config = config::load_config().await?;
match Opts::parse().command {
Command::Repo { command } => match command {
RepoCommand::List => {
if config.repo.is_empty() {
println!("No Saved repositories.");
return Ok(());
}
println!("Saved repositories:");
for (k, v) in config.repo {
println!(" {} ({} | {})", k, v.provider(), v.readable());
}
}
RepoCommand::Add {
name,
uri,
username,
password,
password_env,
password_stdin,
} => | .context("Failed to save updated config")?;
println!("Repo `{}` was successfully added", &name);
}
RepoCommand::Remove { name } => {
if !config.repo.contains_key(&name) {
bail!("Repo `{}` was not found", &name);
}
config.repo.remove(&name);
save_config(&config)
.await
.context("Failed to save updated config")?;
println!("Repo `{}` was removed", &name);
}
},
Command::Run {
script,
args,
fresh,
} => {
let src = ScriptSource::parse(&script, ScriptAction::Run)?;
src.validate_script_name(&config)?;
let contents = src.fetch_script_contents(&config, fresh).await?;
let args = args.iter().map(|s| &**s).collect();
// TODO(happens): Find a way to propagate the actual exit code
// instead of simply returning 0/1 depending on the script.
// This should cover most use cases if you just want to know
// if the script failed, but until `std::process::Termination`
// is stabilized, it seems unsafe to use `std::process::exit`
// since we're using a tokio main.
let exit = repo::run_script(&contents, args).await?;
if !exit.success() {
bail!("");
}
}
Command::Import { script, fresh } => {
let src = ScriptSource::parse(&script, ScriptAction::Import)?;
src.validate_script_name(&config)?;
let contents = src.fetch_script_contents(&config, fresh).await?;
repo::import_script(&contents).await?;
}
};
Ok(())
}
enum ScriptAction {
Run,
Import,
}
pub struct ScriptSource {
repo: String,
source_type: SourceType,
script_name: String,
rref: Option<String>,
action: ScriptAction,
}
enum SourceType {
Git,
Saved,
}
impl ScriptSource {
fn parse(script: &str, action: ScriptAction) -> Result<ScriptSource> {
if let Some(matches) = API_SOURCE_REGEX.captures(script) {
let repo = matches
.name("alias")
.expect("No alias matched")
.as_str()
.to_owned();
let script_name = matches
.name("script")
.expect("No script name matched")
.as_str()
.to_owned();
let rref = matches.name("ref").map(|rref| rref.as_str().to_owned());
return Ok(Self {
source_type: SourceType::Saved,
repo,
script_name,
rref,
action,
});
}
if let Some(matches) = GIT_SOURCE_REGEX.captures(script) {
let repo = matches
.name("repo")
.expect("No repo matched")
.as_str()
.to_owned();
let script_name = matches
.name("script")
.expect("No script name matched")
.as_str()
.to_owned();
let rref = matches.name("ref").map(|rref| rref.as_str().to_owned());
return Ok(Self {
source_type: SourceType::Git,
repo,
script_name,
rref,
action,
});
}
bail!("Script source could not be parsed")
}
fn validate_script_name(&self, config: &Config) -> Result<()> {
if config.require_bash_extension.is_none() && config.require_lib_extension.is_none() {
return Ok(());
}
let expected = match (
&config.require_bash_extension,
&config.require_lib_extension,
&self.action,
) {
(Some(ref ext), _, &ScriptAction::Run) => ext,
(_, Some(ext), &ScriptAction::Import) => ext,
_ => unreachable!(),
};
if !self.script_name.ends_with(expected) {
bail!("Expected script name to end with `{}`", expected);
}
Ok(())
}
async fn fetch_script_contents(&self, config: &config::Config, fresh: bool) -> Result<String> {
let repo = match self.source_type {
SourceType::Saved => config
.repo
.get(&self.repo)
.ok_or(anyhow!("Repo `{}` was not found", &self.repo))?
.box_clone(),
SourceType::Git => git::GitRepo::from_src(&self),
};
let rref = self.rref.clone().unwrap_or("HEAD".to_owned());
Ok(repo.fetch_script(&self.script_name, &rref, fresh).await | {
if config.repo.contains_key(&name) {
bail!("A repository with the name `{}` already exists", &name);
}
let password_for_parse = match (password, password_env, password_stdin) {
(Some(pass), _, _) => Password::Saved(pass),
(_, Some(var), _) => Password::FromEnv(var.clone(), env::var(var)?),
(_, _, true) => {
let mut buf = String::new();
io::stdin().read_to_string(&mut buf)?;
Password::Saved(buf)
}
_ => Password::None,
};
let repo = validate_api_repo(&uri, username, password_for_parse).await?;
config.repo.insert(name.clone(), repo);
save_config(&config)
.await | conditional_block |
ledger_manager.rs | 256>,
pub tx_confirmed: HashSet<H256>,
pub tx_count: usize,
}
//ledger-manager will periodically loop and confirm the transactions
pub struct LedgerManager {
pub ledger_manager_state: LedgerManagerState,
pub blockchain: Arc<Mutex<Blockchain>>,
pub utxo_state: Arc<Mutex<UtxoState>>,
pub voter_depth_k: u32,
}
impl LedgerManager {
pub fn new(blockchain: &Arc<Mutex<Blockchain>>, utxo_state: &Arc<Mutex<UtxoState>>, k: u32) -> Self {
let ledger_manager_state = LedgerManagerState{
last_level_processed: 1,
proposer_blocks_processed: HashSet::new(),
leader_sequence: Vec::new(),
tx_confirmed: HashSet::new(),
tx_count: 0,
};
LedgerManager {
ledger_manager_state: ledger_manager_state,
blockchain: Arc::clone(blockchain),
utxo_state: Arc::clone(utxo_state),
voter_depth_k: k,
}
}
pub fn start(mut self) {
thread::Builder::new()
.name("ledger_manager".to_string())
.spawn(move || {
self.ledger_manager_loop();
})
.unwrap();
}
//Three Steps
//1. Get the leader sequence
//2. Get Transaction sequence
//3. Sanitize Tx and update UTXO state
//All 3 steps are done in the loop
//
fn ledger_manager_loop(&mut self) {
loop{
//Step 1
//let leader_sequence = self.get_leader_sequence();
//This one uses the algorithm described in Prism Paper
let leader_sequence = self.get_confirmed_leader_sequence();
//Step 2
let tx_sequence = self.get_transaction_sequence(&leader_sequence);
//Step 3
self.confirm_transactions(&tx_sequence);
thread::sleep(Duration::from_secs(1));
}
}
fn get_leader_sequence(&mut self) -> Vec<H256> {
let locked_blockchain = self.blockchain.lock().unwrap();
let mut leader_sequence: Vec<H256> = vec![];
//TODO: This is a workaround for now till we have some DS which asserts that
//all voter chains at a particular level has voted
// level2votes: how many votes have been casted at level i
let level_start = self.ledger_manager_state.last_level_processed + 1;
let level_end = locked_blockchain.proposer_depth + 1;
for level in level_start..level_end {
let proposers = &locked_blockchain.level2allproposers[&level];
let mut max_vote_count = 0;
let mut leader: H256 = [0; 32].into();
//Assumption: if a vote for proposer not present, assumed to be 0
//When above TODO is done, then this will not be needed or modified accordingly
for proposer in proposers {
if locked_blockchain.proposer2votecount.contains_key(proposer) {
let vote_count = locked_blockchain.proposer2votecount[proposer];
if vote_count > max_vote_count {
max_vote_count = vote_count;
leader = *proposer;
}
}
}
//break out as there is no point going forward as no leader found at this level
if max_vote_count == 0 {
break;
}
println!("Adding leader at level {}, leader hash: {:?}, max votes: {}", level, leader, max_vote_count);
leader_sequence.push(leader);
self.ledger_manager_state.leader_sequence.push(leader);
println!("Leader sequence: {:?}", self.ledger_manager_state.leader_sequence);
self.ledger_manager_state.last_level_processed = level;
}
leader_sequence
}
fn get_confirmed_leader_sequence(&mut self) -> Vec<H256> {
let mut leader_sequence: Vec<H256> = vec![];
//Locking Blockchain to get proposer_depth currently. Then dropping the lock
//Will be holding locj for each level processing inside the subroutine
let locked_blockchain = self.blockchain.lock().unwrap();
let level_start = self.ledger_manager_state.last_level_processed + 1;
let level_end = locked_blockchain.proposer_depth + 1;
drop(locked_blockchain);
for level in level_start..level_end {
let leader: Option<H256> = self.confirm_leader(level);
match leader {
Some(leader_hash) => {
println!("Adding leader at level {}, leader hash: {:?}", level, leader_hash);
leader_sequence.push(leader_hash);
// self.ledger_manager_state.leader_sequence.push(leader_hash);
// println!("Leader sequence: {:?}", self.ledger_manager_state.leader_sequence);
self.ledger_manager_state.last_level_processed = level;
}
None => {
println!("Unable to confirm leader at level {}", level);
println!("Returning from get_confirmed_leader_sequence func");
break; // TODO: Will this break out of loop??
}
}
}
leader_sequence
}
//we use the confirmation policy from https://arxiv.org/abs/1810.08092
//This function is heavily borrowed from implementation provided in the actual Prism codebase
//https://github.com/yangl1996/prism-rust/
fn confirm_leader(&mut self, level: u32) -> Option<H256> {
let locked_blockchain = self.blockchain.lock().unwrap();
let proposer_blocks = &locked_blockchain.level2allproposers[&level];
let mut new_leader: Option<H256> = None;
let num_voter_chains: u32 = locked_blockchain.num_voter_chains;
// for each proposer count the number of confirmed votes i.e. votes that are k-deep (2-deep).
let mut num_confirmed_votes: HashMap<H256, u32> = HashMap::new();
for block in proposer_blocks {
if locked_blockchain.proposer2voterinfo.contains_key(block) | }
num_confirmed_votes.insert(*block, total_k_deep_votes);
}
}
for (proposer, votes) in num_confirmed_votes.iter() {
println!("proposer {:?} votes {}", proposer, *votes);
if *votes > (num_voter_chains / 2) {
new_leader = Some(*proposer);
break;
}
}
new_leader
}
// needs to process parent as well
fn get_transaction_sequence(&mut self, leader_sequence: &Vec<H256>) -> Vec<SignedTransaction> {
let locked_blockchain = self.blockchain.lock().unwrap();
let mut tx_sequence: Vec<SignedTransaction> = Vec::new();
//TODO: Should we do it recusrively? Like should we also see references to
//proposer references of leader?
//TODO: Also we should refactor it later
for leader in leader_sequence {
let leader_block = &locked_blockchain.proposer_chain[leader].block;
//processing parent and proposer refs
let mut proposer_refs_to_process: Vec<H256> = Vec::new();
let mut leader_txs: Vec<SignedTransaction> = Vec::new();
match &leader_block.content {
Content::Proposer(content) => {
// parent and proposer_refs of leader
let parent = &content.parent_hash;
let proposer_refs = &content.proposer_refs;
if !self.ledger_manager_state.proposer_blocks_processed.contains(parent) {
proposer_refs_to_process.push(*parent);
}
for proposer_ref in proposer_refs {
if !self.ledger_manager_state.proposer_blocks_processed.contains(proposer_ref) {
proposer_refs_to_process.push(*proposer_ref);
}
}
//txs of leader
leader_txs = content.transactions.clone();
}
_ => {
}
}
//TODO: Do we have to do match in this and previous loop as we know it will always
//match to Proposer(content). Can we unwrap??
for proposer_ref in &proposer_refs_to_process {
let proposer_block = &locked_blockchain.prop | {
//TODO: We might also need number of voter blocks at a particular level of a voter chain
//This is not urgent as we can **assume**, there is one block at each level
let voters_info = &locked_blockchain.proposer2voterinfo[block];
if voters_info.len() < (num_voter_chains as usize / 2) {
println!("number of votes for {:?} is {}", block, voters_info.len());
continue;
}
let mut total_k_deep_votes: u32 = 0;
for (voter_chain, voter_block) in voters_info {
let voter_block_level = locked_blockchain.voter_chains[(*voter_chain-1) as usize][voter_block].level;
let voter_chain_level = locked_blockchain.voter_depths[(*voter_chain-1) as usize];
let this_vote_depth = voter_chain_level - voter_block_level;
if this_vote_depth >= self.voter_depth_k {
total_k_deep_votes += 1;
} | conditional_block |
ledger_manager.rs | {
pub last_level_processed: u32,
pub leader_sequence: Vec<H256>,
pub proposer_blocks_processed: HashSet<H256>,
pub tx_confirmed: HashSet<H256>,
pub tx_count: usize,
}
//ledger-manager will periodically loop and confirm the transactions
pub struct LedgerManager {
pub ledger_manager_state: LedgerManagerState,
pub blockchain: Arc<Mutex<Blockchain>>,
pub utxo_state: Arc<Mutex<UtxoState>>,
pub voter_depth_k: u32,
}
impl LedgerManager {
pub fn new(blockchain: &Arc<Mutex<Blockchain>>, utxo_state: &Arc<Mutex<UtxoState>>, k: u32) -> Self {
let ledger_manager_state = LedgerManagerState{
last_level_processed: 1,
proposer_blocks_processed: HashSet::new(),
leader_sequence: Vec::new(),
tx_confirmed: HashSet::new(),
tx_count: 0,
};
LedgerManager {
ledger_manager_state: ledger_manager_state,
blockchain: Arc::clone(blockchain),
utxo_state: Arc::clone(utxo_state),
voter_depth_k: k,
}
}
pub fn start(mut self) {
thread::Builder::new()
.name("ledger_manager".to_string())
.spawn(move || {
self.ledger_manager_loop();
})
.unwrap();
}
//Three Steps
//1. Get the leader sequence
//2. Get Transaction sequence
//3. Sanitize Tx and update UTXO state
//All 3 steps are done in the loop
//
fn ledger_manager_loop(&mut self) {
loop{
//Step 1
//let leader_sequence = self.get_leader_sequence();
//This one uses the algorithm described in Prism Paper
let leader_sequence = self.get_confirmed_leader_sequence();
//Step 2
let tx_sequence = self.get_transaction_sequence(&leader_sequence);
//Step 3
self.confirm_transactions(&tx_sequence);
thread::sleep(Duration::from_secs(1));
}
}
fn get_leader_sequence(&mut self) -> Vec<H256> {
let locked_blockchain = self.blockchain.lock().unwrap();
let mut leader_sequence: Vec<H256> = vec![];
//TODO: This is a workaround for now till we have some DS which asserts that
//all voter chains at a particular level has voted
// level2votes: how many votes have been casted at level i
let level_start = self.ledger_manager_state.last_level_processed + 1;
let level_end = locked_blockchain.proposer_depth + 1;
for level in level_start..level_end {
let proposers = &locked_blockchain.level2allproposers[&level];
let mut max_vote_count = 0;
let mut leader: H256 = [0; 32].into();
//Assumption: if a vote for proposer not present, assumed to be 0
//When above TODO is done, then this will not be needed or modified accordingly
for proposer in proposers {
if locked_blockchain.proposer2votecount.contains_key(proposer) {
let vote_count = locked_blockchain.proposer2votecount[proposer];
if vote_count > max_vote_count {
max_vote_count = vote_count;
leader = *proposer;
}
}
}
//break out as there is no point going forward as no leader found at this level
if max_vote_count == 0 {
break;
}
println!("Adding leader at level {}, leader hash: {:?}, max votes: {}", level, leader, max_vote_count);
leader_sequence.push(leader);
self.ledger_manager_state.leader_sequence.push(leader);
println!("Leader sequence: {:?}", self.ledger_manager_state.leader_sequence);
self.ledger_manager_state.last_level_processed = level;
}
leader_sequence
}
fn get_confirmed_leader_sequence(&mut self) -> Vec<H256> {
let mut leader_sequence: Vec<H256> = vec![];
//Locking Blockchain to get proposer_depth currently. Then dropping the lock
//Will be holding locj for each level processing inside the subroutine
let locked_blockchain = self.blockchain.lock().unwrap();
let level_start = self.ledger_manager_state.last_level_processed + 1;
let level_end = locked_blockchain.proposer_depth + 1;
drop(locked_blockchain);
for level in level_start..level_end {
let leader: Option<H256> = self.confirm_leader(level);
match leader {
Some(leader_hash) => {
println!("Adding leader at level {}, leader hash: {:?}", level, leader_hash);
leader_sequence.push(leader_hash);
// self.ledger_manager_state.leader_sequence.push(leader_hash);
// println!("Leader sequence: {:?}", self.ledger_manager_state.leader_sequence);
self.ledger_manager_state.last_level_processed = level;
}
None => {
println!("Unable to confirm leader at level {}", level);
println!("Returning from get_confirmed_leader_sequence func");
break; // TODO: Will this break out of loop??
}
}
}
leader_sequence
}
//we use the confirmation policy from https://arxiv.org/abs/1810.08092
//This function is heavily borrowed from implementation provided in the actual Prism codebase
//https://github.com/yangl1996/prism-rust/
fn confirm_leader(&mut self, level: u32) -> Option<H256> {
let locked_blockchain = self.blockchain.lock().unwrap();
let proposer_blocks = &locked_blockchain.level2allproposers[&level];
let mut new_leader: Option<H256> = None;
let num_voter_chains: u32 = locked_blockchain.num_voter_chains;
// for each proposer count the number of confirmed votes i.e. votes that are k-deep (2-deep).
let mut num_confirmed_votes: HashMap<H256, u32> = HashMap::new();
for block in proposer_blocks {
if locked_blockchain.proposer2voterinfo.contains_key(block) {
//TODO: We might also need number of voter blocks at a particular level of a voter chain
//This is not urgent as we can **assume**, there is one block at each level
let voters_info = &locked_blockchain.proposer2voterinfo[block];
if voters_info.len() < (num_voter_chains as usize / 2) {
println!("number of votes for {:?} is {}", block, voters_info.len());
continue;
}
let mut total_k_deep_votes: u32 = 0;
for (voter_chain, voter_block) in voters_info {
let voter_block_level = locked_blockchain.voter_chains[(*voter_chain-1) as usize][voter_block].level;
let voter_chain_level = locked_blockchain.voter_depths[(*voter_chain-1) as usize];
let this_vote_depth = voter_chain_level - voter_block_level;
if this_vote_depth >= self.voter_depth_k {
total_k_deep_votes += 1;
}
}
num_confirmed_votes.insert(*block, total_k_deep_votes);
}
}
for (proposer, votes) in num_confirmed_votes.iter() {
println!("proposer {:?} votes {}", proposer, *votes);
if *votes > (num_voter_chains / 2) {
new_leader = Some(*proposer);
break;
}
}
new_leader
}
// needs to process parent as well
fn get_transaction_sequence(&mut self, leader_sequence: &Vec<H256>) -> Vec<SignedTransaction> {
let locked_blockchain = self.blockchain.lock().unwrap();
let mut tx_sequence: Vec<SignedTransaction> = Vec::new();
//TODO: Should we do it recusrively? Like should we also see references to
//proposer references of leader?
//TODO: Also we should refactor it later
for leader in leader_sequence {
let leader_block = &locked_blockchain.proposer_chain[leader].block;
//processing parent and proposer refs
let mut proposer_refs_to_process: Vec<H256> = Vec::new();
let mut leader_txs: Vec<SignedTransaction> = Vec::new();
match &leader_block.content {
Content::Proposer(content) => {
// parent and proposer_refs of leader
let parent = &content.parent_hash;
let proposer_refs = &content.proposer_refs;
if !self.ledger_manager_state.proposer_blocks_processed.contains(parent) {
proposer_refs_to_process.push(*parent);
}
for proposer_ref in proposer_refs {
if !self.ledger_manager_state.proposer_blocks_processed.contains(proposer_ref) {
proposer_refs_to_process.push(*proposer_ref);
}
}
//txs of leader
leader_txs = content.transactions.clone();
}
_ => {
}
}
//TODO: Do we have to do match in this and previous loop as we know it will always
//match | LedgerManagerState | identifier_name |
|
ledger_manager.rs | 256>,
pub tx_confirmed: HashSet<H256>,
pub tx_count: usize,
}
//ledger-manager will periodically loop and confirm the transactions
pub struct LedgerManager {
pub ledger_manager_state: LedgerManagerState,
pub blockchain: Arc<Mutex<Blockchain>>,
pub utxo_state: Arc<Mutex<UtxoState>>,
pub voter_depth_k: u32,
}
impl LedgerManager {
pub fn new(blockchain: &Arc<Mutex<Blockchain>>, utxo_state: &Arc<Mutex<UtxoState>>, k: u32) -> Self {
let ledger_manager_state = LedgerManagerState{
last_level_processed: 1,
proposer_blocks_processed: HashSet::new(),
leader_sequence: Vec::new(),
tx_confirmed: HashSet::new(),
tx_count: 0,
};
LedgerManager {
ledger_manager_state: ledger_manager_state,
blockchain: Arc::clone(blockchain),
utxo_state: Arc::clone(utxo_state),
voter_depth_k: k,
}
}
pub fn start(mut self) {
thread::Builder::new()
.name("ledger_manager".to_string())
.spawn(move || {
self.ledger_manager_loop();
})
.unwrap();
}
//Three Steps
//1. Get the leader sequence
//2. Get Transaction sequence
//3. Sanitize Tx and update UTXO state
//All 3 steps are done in the loop
//
fn ledger_manager_loop(&mut self) |
fn get_leader_sequence(&mut self) -> Vec<H256> {
let locked_blockchain = self.blockchain.lock().unwrap();
let mut leader_sequence: Vec<H256> = vec![];
//TODO: This is a workaround for now till we have some DS which asserts that
//all voter chains at a particular level has voted
// level2votes: how many votes have been casted at level i
let level_start = self.ledger_manager_state.last_level_processed + 1;
let level_end = locked_blockchain.proposer_depth + 1;
for level in level_start..level_end {
let proposers = &locked_blockchain.level2allproposers[&level];
let mut max_vote_count = 0;
let mut leader: H256 = [0; 32].into();
//Assumption: if a vote for proposer not present, assumed to be 0
//When above TODO is done, then this will not be needed or modified accordingly
for proposer in proposers {
if locked_blockchain.proposer2votecount.contains_key(proposer) {
let vote_count = locked_blockchain.proposer2votecount[proposer];
if vote_count > max_vote_count {
max_vote_count = vote_count;
leader = *proposer;
}
}
}
//break out as there is no point going forward as no leader found at this level
if max_vote_count == 0 {
break;
}
println!("Adding leader at level {}, leader hash: {:?}, max votes: {}", level, leader, max_vote_count);
leader_sequence.push(leader);
self.ledger_manager_state.leader_sequence.push(leader);
println!("Leader sequence: {:?}", self.ledger_manager_state.leader_sequence);
self.ledger_manager_state.last_level_processed = level;
}
leader_sequence
}
fn get_confirmed_leader_sequence(&mut self) -> Vec<H256> {
let mut leader_sequence: Vec<H256> = vec![];
//Locking Blockchain to get proposer_depth currently. Then dropping the lock
//Will be holding locj for each level processing inside the subroutine
let locked_blockchain = self.blockchain.lock().unwrap();
let level_start = self.ledger_manager_state.last_level_processed + 1;
let level_end = locked_blockchain.proposer_depth + 1;
drop(locked_blockchain);
for level in level_start..level_end {
let leader: Option<H256> = self.confirm_leader(level);
match leader {
Some(leader_hash) => {
println!("Adding leader at level {}, leader hash: {:?}", level, leader_hash);
leader_sequence.push(leader_hash);
// self.ledger_manager_state.leader_sequence.push(leader_hash);
// println!("Leader sequence: {:?}", self.ledger_manager_state.leader_sequence);
self.ledger_manager_state.last_level_processed = level;
}
None => {
println!("Unable to confirm leader at level {}", level);
println!("Returning from get_confirmed_leader_sequence func");
break; // TODO: Will this break out of loop??
}
}
}
leader_sequence
}
//we use the confirmation policy from https://arxiv.org/abs/1810.08092
//This function is heavily borrowed from implementation provided in the actual Prism codebase
//https://github.com/yangl1996/prism-rust/
fn confirm_leader(&mut self, level: u32) -> Option<H256> {
let locked_blockchain = self.blockchain.lock().unwrap();
let proposer_blocks = &locked_blockchain.level2allproposers[&level];
let mut new_leader: Option<H256> = None;
let num_voter_chains: u32 = locked_blockchain.num_voter_chains;
// for each proposer count the number of confirmed votes i.e. votes that are k-deep (2-deep).
let mut num_confirmed_votes: HashMap<H256, u32> = HashMap::new();
for block in proposer_blocks {
if locked_blockchain.proposer2voterinfo.contains_key(block) {
//TODO: We might also need number of voter blocks at a particular level of a voter chain
//This is not urgent as we can **assume**, there is one block at each level
let voters_info = &locked_blockchain.proposer2voterinfo[block];
if voters_info.len() < (num_voter_chains as usize / 2) {
println!("number of votes for {:?} is {}", block, voters_info.len());
continue;
}
let mut total_k_deep_votes: u32 = 0;
for (voter_chain, voter_block) in voters_info {
let voter_block_level = locked_blockchain.voter_chains[(*voter_chain-1) as usize][voter_block].level;
let voter_chain_level = locked_blockchain.voter_depths[(*voter_chain-1) as usize];
let this_vote_depth = voter_chain_level - voter_block_level;
if this_vote_depth >= self.voter_depth_k {
total_k_deep_votes += 1;
}
}
num_confirmed_votes.insert(*block, total_k_deep_votes);
}
}
for (proposer, votes) in num_confirmed_votes.iter() {
println!("proposer {:?} votes {}", proposer, *votes);
if *votes > (num_voter_chains / 2) {
new_leader = Some(*proposer);
break;
}
}
new_leader
}
// needs to process parent as well
fn get_transaction_sequence(&mut self, leader_sequence: &Vec<H256>) -> Vec<SignedTransaction> {
let locked_blockchain = self.blockchain.lock().unwrap();
let mut tx_sequence: Vec<SignedTransaction> = Vec::new();
//TODO: Should we do it recusrively? Like should we also see references to
//proposer references of leader?
//TODO: Also we should refactor it later
for leader in leader_sequence {
let leader_block = &locked_blockchain.proposer_chain[leader].block;
//processing parent and proposer refs
let mut proposer_refs_to_process: Vec<H256> = Vec::new();
let mut leader_txs: Vec<SignedTransaction> = Vec::new();
match &leader_block.content {
Content::Proposer(content) => {
// parent and proposer_refs of leader
let parent = &content.parent_hash;
let proposer_refs = &content.proposer_refs;
if !self.ledger_manager_state.proposer_blocks_processed.contains(parent) {
proposer_refs_to_process.push(*parent);
}
for proposer_ref in proposer_refs {
if !self.ledger_manager_state.proposer_blocks_processed.contains(proposer_ref) {
proposer_refs_to_process.push(*proposer_ref);
}
}
//txs of leader
leader_txs = content.transactions.clone();
}
_ => {
}
}
//TODO: Do we have to do match in this and previous loop as we know it will always
//match to Proposer(content). Can we unwrap??
for proposer_ref in &proposer_refs_to_process {
let proposer_block = &locked_blockchain | {
loop{
//Step 1
//let leader_sequence = self.get_leader_sequence();
//This one uses the algorithm described in Prism Paper
let leader_sequence = self.get_confirmed_leader_sequence();
//Step 2
let tx_sequence = self.get_transaction_sequence(&leader_sequence);
//Step 3
self.confirm_transactions(&tx_sequence);
thread::sleep(Duration::from_secs(1));
}
} | identifier_body |
ledger_manager.rs | State>>, k: u32) -> Self {
let ledger_manager_state = LedgerManagerState{
last_level_processed: 1,
proposer_blocks_processed: HashSet::new(),
leader_sequence: Vec::new(),
tx_confirmed: HashSet::new(),
tx_count: 0,
};
LedgerManager {
ledger_manager_state: ledger_manager_state,
blockchain: Arc::clone(blockchain),
utxo_state: Arc::clone(utxo_state),
voter_depth_k: k,
}
}
pub fn start(mut self) {
thread::Builder::new()
.name("ledger_manager".to_string())
.spawn(move || {
self.ledger_manager_loop();
})
.unwrap();
}
//Three Steps
//1. Get the leader sequence
//2. Get Transaction sequence
//3. Sanitize Tx and update UTXO state
//All 3 steps are done in the loop
//
fn ledger_manager_loop(&mut self) {
loop{
//Step 1
//let leader_sequence = self.get_leader_sequence();
//This one uses the algorithm described in Prism Paper
let leader_sequence = self.get_confirmed_leader_sequence();
//Step 2
let tx_sequence = self.get_transaction_sequence(&leader_sequence);
//Step 3
self.confirm_transactions(&tx_sequence);
thread::sleep(Duration::from_secs(1));
}
}
fn get_leader_sequence(&mut self) -> Vec<H256> {
let locked_blockchain = self.blockchain.lock().unwrap();
let mut leader_sequence: Vec<H256> = vec![];
//TODO: This is a workaround for now till we have some DS which asserts that
//all voter chains at a particular level has voted
// level2votes: how many votes have been casted at level i
let level_start = self.ledger_manager_state.last_level_processed + 1;
let level_end = locked_blockchain.proposer_depth + 1;
for level in level_start..level_end {
let proposers = &locked_blockchain.level2allproposers[&level];
let mut max_vote_count = 0;
let mut leader: H256 = [0; 32].into();
//Assumption: if a vote for proposer not present, assumed to be 0
//When above TODO is done, then this will not be needed or modified accordingly
for proposer in proposers {
if locked_blockchain.proposer2votecount.contains_key(proposer) {
let vote_count = locked_blockchain.proposer2votecount[proposer];
if vote_count > max_vote_count {
max_vote_count = vote_count;
leader = *proposer;
}
}
}
//break out as there is no point going forward as no leader found at this level
if max_vote_count == 0 {
break;
}
println!("Adding leader at level {}, leader hash: {:?}, max votes: {}", level, leader, max_vote_count);
leader_sequence.push(leader);
self.ledger_manager_state.leader_sequence.push(leader);
println!("Leader sequence: {:?}", self.ledger_manager_state.leader_sequence);
self.ledger_manager_state.last_level_processed = level;
}
leader_sequence
}
fn get_confirmed_leader_sequence(&mut self) -> Vec<H256> {
let mut leader_sequence: Vec<H256> = vec![];
//Locking Blockchain to get proposer_depth currently. Then dropping the lock
//Will be holding locj for each level processing inside the subroutine
let locked_blockchain = self.blockchain.lock().unwrap();
let level_start = self.ledger_manager_state.last_level_processed + 1;
let level_end = locked_blockchain.proposer_depth + 1;
drop(locked_blockchain);
for level in level_start..level_end {
let leader: Option<H256> = self.confirm_leader(level);
match leader {
Some(leader_hash) => {
println!("Adding leader at level {}, leader hash: {:?}", level, leader_hash);
leader_sequence.push(leader_hash);
// self.ledger_manager_state.leader_sequence.push(leader_hash);
// println!("Leader sequence: {:?}", self.ledger_manager_state.leader_sequence);
self.ledger_manager_state.last_level_processed = level;
}
None => {
println!("Unable to confirm leader at level {}", level);
println!("Returning from get_confirmed_leader_sequence func");
break; // TODO: Will this break out of loop??
}
}
}
leader_sequence
}
//we use the confirmation policy from https://arxiv.org/abs/1810.08092
//This function is heavily borrowed from implementation provided in the actual Prism codebase
//https://github.com/yangl1996/prism-rust/
fn confirm_leader(&mut self, level: u32) -> Option<H256> {
let locked_blockchain = self.blockchain.lock().unwrap();
let proposer_blocks = &locked_blockchain.level2allproposers[&level];
let mut new_leader: Option<H256> = None;
let num_voter_chains: u32 = locked_blockchain.num_voter_chains;
// for each proposer count the number of confirmed votes i.e. votes that are k-deep (2-deep).
let mut num_confirmed_votes: HashMap<H256, u32> = HashMap::new();
for block in proposer_blocks {
if locked_blockchain.proposer2voterinfo.contains_key(block) {
//TODO: We might also need number of voter blocks at a particular level of a voter chain
//This is not urgent as we can **assume**, there is one block at each level
let voters_info = &locked_blockchain.proposer2voterinfo[block];
if voters_info.len() < (num_voter_chains as usize / 2) {
println!("number of votes for {:?} is {}", block, voters_info.len());
continue;
}
let mut total_k_deep_votes: u32 = 0;
for (voter_chain, voter_block) in voters_info {
let voter_block_level = locked_blockchain.voter_chains[(*voter_chain-1) as usize][voter_block].level;
let voter_chain_level = locked_blockchain.voter_depths[(*voter_chain-1) as usize];
let this_vote_depth = voter_chain_level - voter_block_level;
if this_vote_depth >= self.voter_depth_k {
total_k_deep_votes += 1;
}
}
num_confirmed_votes.insert(*block, total_k_deep_votes);
}
}
for (proposer, votes) in num_confirmed_votes.iter() {
println!("proposer {:?} votes {}", proposer, *votes);
if *votes > (num_voter_chains / 2) {
new_leader = Some(*proposer);
break;
}
}
new_leader
}
// needs to process parent as well
fn get_transaction_sequence(&mut self, leader_sequence: &Vec<H256>) -> Vec<SignedTransaction> {
let locked_blockchain = self.blockchain.lock().unwrap();
let mut tx_sequence: Vec<SignedTransaction> = Vec::new();
//TODO: Should we do it recusrively? Like should we also see references to
//proposer references of leader?
//TODO: Also we should refactor it later
for leader in leader_sequence {
let leader_block = &locked_blockchain.proposer_chain[leader].block;
//processing parent and proposer refs
let mut proposer_refs_to_process: Vec<H256> = Vec::new();
let mut leader_txs: Vec<SignedTransaction> = Vec::new();
match &leader_block.content {
Content::Proposer(content) => {
// parent and proposer_refs of leader
let parent = &content.parent_hash;
let proposer_refs = &content.proposer_refs;
if !self.ledger_manager_state.proposer_blocks_processed.contains(parent) {
proposer_refs_to_process.push(*parent);
}
for proposer_ref in proposer_refs {
if !self.ledger_manager_state.proposer_blocks_processed.contains(proposer_ref) {
proposer_refs_to_process.push(*proposer_ref);
}
}
//txs of leader
leader_txs = content.transactions.clone();
}
_ => {
}
}
//TODO: Do we have to do match in this and previous loop as we know it will always
//match to Proposer(content). Can we unwrap??
for proposer_ref in &proposer_refs_to_process {
let proposer_block = &locked_blockchain.proposer_chain[proposer_ref].block;
match &proposer_block.content {
Content::Proposer(content) => {
tx_sequence.append(&mut content.transactions.clone());
}
_ => {
}
}
self.ledger_manager_state.proposer_blocks_processed.insert(*proposer_ref);
}
//appending leader txs finally
//adding leader to proposer_blocks_processed
tx_sequence.append(&mut leader_txs); | self.ledger_manager_state.proposer_blocks_processed.insert(*leader);
}
tx_sequence | random_line_split |
|
PredictionRuntimeInspector.py | brk; brk(port=9011)
exp.pause = True
self.pause = True
self.pauseAtPhaseSetup = False
else:
self.pauseAtPhaseSetup = True
def onPhaseTeardown(self, exp):
title()
index = exp.position.phase
# Last phase
if index == len(exp.workflow) - 1:
self.done = True
def onIter(self, exp, i):
""" """
title(additional='(), self.pause = ' + str(self.pause))
self.iteration += 1
# check if the pause button was clicked
if self.pause:
exp.pause = True
elif self.runCount is not None:
self.runCount -= 1
if self.runCount == 0:
exp.pause = True
runtimelistener.listenersEnabled = exp.pause
def _setProgress(self):
"""Set the progress trait from the iteration."""
self.progress = (self.iteration, self.iterationCount)
def _disableRegions(self):
"""
Disable any regions that can't be run.
Currently only looks for VectorFileEffectors whose outputFile parameter
is equal to 'No output file specified'.
"""
effectors = [e for e in _getElements(self.network) if _isEffector(e)]
for e in effectors:
if e.getParameter('outputFile') == 'No outputFile specified':
_disable(self.network, e.getName())
def _createView(self):
"""Set up a view for the traits."""
items = []
if self.showProgressBar:
items.append(Item('progress', show_label=False,
editor=ProgressEditor(callback=self._seek)))
# Controls
items.append(
alignCenter(
Item('backwardButton', style='custom',
enabled_when='not object.running and object.mainloopRunning '
+'and object.sensors and object.iteration > 1'),
Item('runButton', style='custom',
enabled_when='object.pause and not object.done'),
Item('pauseButton', style='custom',
enabled_when='not (object.pause or object.done)'),
Item('stepButton', style='custom',
enabled_when='object.pause and not object.done'),
show_labels=False,
orientation='horizontal'
))
# Repeat button and pause target buttons
items.append(
alignCenter(
Item('repeatButton', show_label=False,
enabled_when='not object.running and object.mainloopRunning '
'and object.iteration > 0'),
Item('nextTargetButton', show_label=False,
editor=ButtonEditor(label_value='targetButtonLabel'),
enabled_when='not object.running and object.mainloopRunning '
'and object.pauseTarget'),
Item('customTargetButton', show_label=False,
enabled_when='not object.running and object.mainloopRunning')
))
# Speed control
items.append(Item('speed', style='custom', show_label=False,
editor=EnumEditor(cols=1, values={
1 : '1: Slow (update on every iteration)',
10 : '2: Medium (update every 10 iterations)',
100 : '3: Fast (update every 100 iterations)'
})
))
items.extend([
Group(
Item('pauseAtNextStep'),
show_left=False
),
alignLeft(
Item('stopButton', show_label=False, enabled_when='object.iteration')
)
])
self.traits_view = View(*items)
def close(self):
"""Called by MultiInspector upon closing."""
#title()
self.experiment.pause = True
if self.running:
self.running = False
self._unregisterCallbacks()
def start(self, numIterations=0, target=None, tier=0, stop=False,
callback=None):
"""
Start running the network, and start the mainloop if necessary.
numIterations -- Number of iterations to run for (optional).
target -- Run until this condition is met (used by the Vision Framework).
This is distinct from the user-specified target in the GUI, which simply
tells the network when to pause.
tier -- Tier being trained. Used to check the target on it.
stop -- Whether to stop immediately (used when training a tier for 0
iterations).
callback -- Called right after initialization (optional).
"""
#title()
self._registerCallbacks()
self.iterationCount = numIterations
self.iteration = 0
self.stopTarget = target
self.tier = tier
self.pauseAtPhaseSetup = False
if callback:
callback()
self._disableRegions() # Disable regions which can't be run (e.g. effectors)
# Re-enable this window (use this hack to get a reference to it), because
# it may have been disabled at the end of the previous tier/dataset when
# running from the Vision Framework
wx.GetApp().GetTopWindow().Enable()
# Insert a call into the event loop to run (or stop)
#if stop: # Immediately stop - used by training GUI with 0 iterations
# wx.CallLater(self.runInterval, self.stop)
#elif self.running:
# wx.CallLater(self.runInterval, self._run)
self.mainloopRunning = True
if not wx.GetApp().IsMainLoopRunning():
wx.GetApp().MainLoop()
self.close()
def stop(self):
"""Stop running."""
# Stop the experiment
self.experiment.pause = True
# Any extra calls to _run that are in the event loop should return
self.stopping = True
#if self.pauseAtNextTier and self.pauseAtNextDataset:
if self.pauseAtNextStep:
# Pausing, so set running to False -- otherwise we will continue running
# again
self.running = False
# Disable the window to prevent user input until start is called again
# E.g. control will go back to the Vision Framework
wx.GetApp().GetTopWindow().Disable()
self.mainloopRunning = False
wx.GetApp().ExitMainLoop()
def _seek(self, iteration):
"""Seek to the specified iteration."""
# Validate it
if iteration < 1:
iteration = 1
# Seek to one iteration before the specified iteration, then run the
# network for one iteration, so the inspectors will show the right data
self.iteration = iteration - 1
self.experiment.position.iter = iteration - 1
for sensor in self.sensors:
assert sensor.type == 'VectorFileSensor'
sensor.setParameter('position', self.iteration)
self._step()
def _pause(self):
#title(additional='(), self.pause = ' + str(self.pause))
self.pause = True
def _runExperiment(self):
#title(additional='(), self.pause = ' + str(self.pause))
self.experiment.run()
return self.experiment.done
def _run(self):
"""Run the experiment."""
#title(additional='(), self.pause = ' + str(self.pause))
#if self.experiment.done or self.pause:
# return
# self.speed can be either 1, 10, or 100
if not self.iterationCount:
iterations = self.speed
else:
iterations = \
min(self.speed - self.iteration % self.speed, self.iterationCount - self.iteration)
self.runCount = iterations
self.experiment.pause = False
self.done = self._runExperiment()
# If the experiment is done or paused or stepping
if self.done or self.pause:
return
# Schedule another run
wx.CallLater(self.runInterval, self._run)
def update(self, methodName=None, elementName=None, args=None, kwargs=None):
"""
Called automatically in response to runtime engine activity.
Extra arguments (optional) are passed by the wrapped methods,
and they can be used to avoid unnecessary updating.
@param methodName -- RuntimeElement class method that was called.
@param elementName -- RuntimeElement name.
@param args -- Positional arguments passed to the method.
@param kwargs -- Keyword arguments passed to the method.
"""
#if methodName != 'run':
# return
##print methodName
##from dbgp.client import brk; brk(port=9011)
#self.iteration = self.experiment.position.iter
#exp = self.experiment
## check if the pause button was clicked
#if self.pause:
# exp.pause = True
#elif self.runCount is not None:
# self.runCount -= 1
# if self.runCount == 0:
# exp.pause = True
#
#runtimelistener.listenersEnabled = exp.pause
def _step(self):
"""Run the network for one iteration."""
title()
self.runCount = 1
self.experiment.pause = False
self._runExperiment()
self.pause = True
def _iteration_changed(self):
"""
Called automatically by Traits when the iteration updates.
Update the progress bar and check the conditions to see whether to stop or
pause.
"""
if self.showProgressBar:
| try:
self._setProgress()
except:
# may fail when switching from training to inference
from dbgp.client import brk; brk(port=9011)
pass | conditional_block |
|
PredictionRuntimeInspector.py | ("Repeat")
# The "Next Error" button becomes "Next Target" when user sets a custom one
nextTargetButton = Event # Button with dynamic label
targetButtonLabels = ('Next error', 'Next target') | pauseTarget = Str
backwardButton = Button('Back',
image=ImageResource(getNTAImage('backward_36_26')))
runButton = Button('Run',
image=ImageResource(getNTAImage('play_36_26')))
pauseButton = Button('Pause',
image=ImageResource(getNTAImage('pause_36_26')))
stepButton = Button('Step',
image=ImageResource(getNTAImage('forward_36_26')))
# Internal traits
tier = Int
tierCount = Int
running = Bool
iteration = Int
numIterations = Int
mainloopRunning = Bool
spacer = Str
pause = Bool
done = Bool
@staticmethod
def getNames():
"""
Return the short and long names for this inspector. The short name appears
in the dropdown menu, and the long name is used as the window title.
"""
return ('run', 'Run Network')
def __init__(self, parent, experiment, tierCount=0, showProgressBar=False,
multipleDatasets=False, startImmediately=True):
"""
"""
#title()
self.experiment = experiment
self.pause = True
self.experiment.pause = True
self.runCount = None
network = experiment.network
NetworkInspector.__init__(self, parent, network)
self.tierCount = tierCount
self.showProgressBar = showProgressBar
self.multipleDatasets = multipleDatasets
self.stopTarget = None
self.iteration = 0
self.iterationCount = 0
self.usingPauseTarget = False
self.stepping = False
# Look for all sensors (regions without inputs)
# If all sensors are of a supported type, seeking backward is supported
# Otherwise, seeking backward is not supported, because not all sensors
# can be run in reverse
self.sensors = []
for element in _getElements(self.network):
if _isSensor(element):
if element.type == 'VectorFileSensor':
self.sensors.append(element)
else:
# Unsupported sensor type
self.sensors = []
break
# Set the stop button label differently for training and testing
# The stop button isn't shown at all if neither training nor testing, so
# don't worry about that case
if not self.tierCount and self.multipleDatasets:
self.add_trait('stopButton', Button(label='Skip to next dataset'))
else:
self.add_trait('stopButton', Button(label='Stop training this tier'))
# Set up the default pause target (next error), which the user will be
# able to change later
#self._createDefaultPauseTarget()
#self.pauseTarget = self.defaultPauseTarget
# Set up the Traits view
self._createView()
if startImmediately:
self.start() # Start running the network
#RuntimeInspectorBase.__init__(self, parent, network, tierCount, showProgressBar,
# multipleDatasets, startImmediately)
def _registerCallbacks(self):
d = self.experiment.description
for name in 'spTrain', 'tpTrain', 'classifierTrain', 'infer':
if not name in d:
continue
phase = d[name]
if len(phase) > 0:
assert self.onPhaseSetup not in phase[0]['setup']
phase[0]['setup'].append(self.onPhaseSetup)
phase[-1]['finish'].append(self.onPhaseTeardown)
for step in phase:
# Make sure to be the first callback
step['iter'].insert(0, self.onIter)
def _unregisterCallbacks(self):
d = self.experiment.description
for name in 'spTrain', 'tpTrain', 'classifierTrain', 'infer':
if not name in d:
continue
phase = d[name]
if len(phase) > 0:
assert self.onPhaseSetup in phase[0]['setup']
phase[0]['setup'].remove(self.onPhaseSetup)
phase[-1]['finish'].remove(self.onPhaseTeardown)
for step in phase:
# Make sure to be the first callback
step['iter'].remove(self.onIter)
def _getTierName(self, tier):
raise NotImplementedError
def detectNetworkType(self):
self.isFrameworkNetwork = 'sensor' in self.network.regions and \
self.network.regions['sensor'].type == 'RecordSensor'
def _getPhase(self, e):
index = e.position.phase
name = e.workflow[index][0]
return (name, e.description[name])
def onPhaseSetup(self, exp):
title()
self.iteration = 0
self.phase = self._getPhase(exp)
phase = self.phase[1]
self.iterationCount = phase[0]['iterationCount'] if len(phase) > 0 else 0
if self.pauseAtNextStep and self.pauseAtPhaseSetup:
#if self.pauseAtNextStep:
#from dbgp.client import brk; brk(port=9011)
exp.pause = True
self.pause = True
self.pauseAtPhaseSetup = False
else:
self.pauseAtPhaseSetup = True
def onPhaseTeardown(self, exp):
title()
index = exp.position.phase
# Last phase
if index == len(exp.workflow) - 1:
self.done = True
def onIter(self, exp, i):
""" """
title(additional='(), self.pause = ' + str(self.pause))
self.iteration += 1
# check if the pause button was clicked
if self.pause:
exp.pause = True
elif self.runCount is not None:
self.runCount -= 1
if self.runCount == 0:
exp.pause = True
runtimelistener.listenersEnabled = exp.pause
def _setProgress(self):
"""Set the progress trait from the iteration."""
self.progress = (self.iteration, self.iterationCount)
def _disableRegions(self):
"""
Disable any regions that can't be run.
Currently only looks for VectorFileEffectors whose outputFile parameter
is equal to 'No output file specified'.
"""
effectors = [e for e in _getElements(self.network) if _isEffector(e)]
for e in effectors:
if e.getParameter('outputFile') == 'No outputFile specified':
_disable(self.network, e.getName())
def _createView(self):
"""Set up a view for the traits."""
items = []
if self.showProgressBar:
items.append(Item('progress', show_label=False,
editor=ProgressEditor(callback=self._seek)))
# Controls
items.append(
alignCenter(
Item('backwardButton', style='custom',
enabled_when='not object.running and object.mainloopRunning '
+'and object.sensors and object.iteration > 1'),
Item('runButton', style='custom',
enabled_when='object.pause and not object.done'),
Item('pauseButton', style='custom',
enabled_when='not (object.pause or object.done)'),
Item('stepButton', style='custom',
enabled_when='object.pause and not object.done'),
show_labels=False,
orientation='horizontal'
))
# Repeat button and pause target buttons
items.append(
alignCenter(
Item('repeatButton', show_label=False,
enabled_when='not object.running and object.mainloopRunning '
'and object.iteration > 0'),
Item('nextTargetButton', show_label=False,
editor=ButtonEditor(label_value='targetButtonLabel'),
enabled_when='not object.running and object.mainloopRunning '
'and object.pauseTarget'),
Item('customTargetButton', show_label=False,
enabled_when='not object.running and object.mainloopRunning')
))
# Speed control
items.append(Item('speed', style='custom', show_label=False,
editor=EnumEditor(cols=1, values={
1 : '1: Slow (update on every iteration)',
10 : '2: Medium (update every 10 iterations)',
100 : '3: Fast (update every 100 iterations)'
})
))
items.extend([
Group(
Item('pauseAtNextStep'),
show_left=False
),
alignLeft(
Item('stopButton', show_label=False, enabled_when='object.iteration')
)
])
self.traits_view = View(*items)
def close(self):
"""Called by MultiInspector upon closing."""
#title()
self.experiment.pause = True
if self.running:
self.running = False
self._unregisterCallbacks()
def start(self, numIterations=0, target=None, tier=0, stop=False,
callback=None):
"""
Start running the network, and start the mainloop if necessary.
numIterations -- Number of iterations to run for (optional).
target -- Run until this condition is met (used by the Vision Framework).
This is distinct from the user-s | targetButtonLabel = Str(targetButtonLabels[0])
customTargetButton = Button('Custom...') | random_line_split |
PredictionRuntimeInspector.py | i):
""" """
title(additional='(), self.pause = ' + str(self.pause))
self.iteration += 1
# check if the pause button was clicked
if self.pause:
exp.pause = True
elif self.runCount is not None:
self.runCount -= 1
if self.runCount == 0:
exp.pause = True
runtimelistener.listenersEnabled = exp.pause
def _setProgress(self):
"""Set the progress trait from the iteration."""
self.progress = (self.iteration, self.iterationCount)
def _disableRegions(self):
"""
Disable any regions that can't be run.
Currently only looks for VectorFileEffectors whose outputFile parameter
is equal to 'No output file specified'.
"""
effectors = [e for e in _getElements(self.network) if _isEffector(e)]
for e in effectors:
if e.getParameter('outputFile') == 'No outputFile specified':
_disable(self.network, e.getName())
def _createView(self):
"""Set up a view for the traits."""
items = []
if self.showProgressBar:
items.append(Item('progress', show_label=False,
editor=ProgressEditor(callback=self._seek)))
# Controls
items.append(
alignCenter(
Item('backwardButton', style='custom',
enabled_when='not object.running and object.mainloopRunning '
+'and object.sensors and object.iteration > 1'),
Item('runButton', style='custom',
enabled_when='object.pause and not object.done'),
Item('pauseButton', style='custom',
enabled_when='not (object.pause or object.done)'),
Item('stepButton', style='custom',
enabled_when='object.pause and not object.done'),
show_labels=False,
orientation='horizontal'
))
# Repeat button and pause target buttons
items.append(
alignCenter(
Item('repeatButton', show_label=False,
enabled_when='not object.running and object.mainloopRunning '
'and object.iteration > 0'),
Item('nextTargetButton', show_label=False,
editor=ButtonEditor(label_value='targetButtonLabel'),
enabled_when='not object.running and object.mainloopRunning '
'and object.pauseTarget'),
Item('customTargetButton', show_label=False,
enabled_when='not object.running and object.mainloopRunning')
))
# Speed control
items.append(Item('speed', style='custom', show_label=False,
editor=EnumEditor(cols=1, values={
1 : '1: Slow (update on every iteration)',
10 : '2: Medium (update every 10 iterations)',
100 : '3: Fast (update every 100 iterations)'
})
))
items.extend([
Group(
Item('pauseAtNextStep'),
show_left=False
),
alignLeft(
Item('stopButton', show_label=False, enabled_when='object.iteration')
)
])
self.traits_view = View(*items)
def close(self):
"""Called by MultiInspector upon closing."""
#title()
self.experiment.pause = True
if self.running:
self.running = False
self._unregisterCallbacks()
def start(self, numIterations=0, target=None, tier=0, stop=False,
callback=None):
"""
Start running the network, and start the mainloop if necessary.
numIterations -- Number of iterations to run for (optional).
target -- Run until this condition is met (used by the Vision Framework).
This is distinct from the user-specified target in the GUI, which simply
tells the network when to pause.
tier -- Tier being trained. Used to check the target on it.
stop -- Whether to stop immediately (used when training a tier for 0
iterations).
callback -- Called right after initialization (optional).
"""
#title()
self._registerCallbacks()
self.iterationCount = numIterations
self.iteration = 0
self.stopTarget = target
self.tier = tier
self.pauseAtPhaseSetup = False
if callback:
callback()
self._disableRegions() # Disable regions which can't be run (e.g. effectors)
# Re-enable this window (use this hack to get a reference to it), because
# it may have been disabled at the end of the previous tier/dataset when
# running from the Vision Framework
wx.GetApp().GetTopWindow().Enable()
# Insert a call into the event loop to run (or stop)
#if stop: # Immediately stop - used by training GUI with 0 iterations
# wx.CallLater(self.runInterval, self.stop)
#elif self.running:
# wx.CallLater(self.runInterval, self._run)
self.mainloopRunning = True
if not wx.GetApp().IsMainLoopRunning():
wx.GetApp().MainLoop()
self.close()
def stop(self):
"""Stop running."""
# Stop the experiment
self.experiment.pause = True
# Any extra calls to _run that are in the event loop should return
self.stopping = True
#if self.pauseAtNextTier and self.pauseAtNextDataset:
if self.pauseAtNextStep:
# Pausing, so set running to False -- otherwise we will continue running
# again
self.running = False
# Disable the window to prevent user input until start is called again
# E.g. control will go back to the Vision Framework
wx.GetApp().GetTopWindow().Disable()
self.mainloopRunning = False
wx.GetApp().ExitMainLoop()
def _seek(self, iteration):
"""Seek to the specified iteration."""
# Validate it
if iteration < 1:
iteration = 1
# Seek to one iteration before the specified iteration, then run the
# network for one iteration, so the inspectors will show the right data
self.iteration = iteration - 1
self.experiment.position.iter = iteration - 1
for sensor in self.sensors:
assert sensor.type == 'VectorFileSensor'
sensor.setParameter('position', self.iteration)
self._step()
def _pause(self):
#title(additional='(), self.pause = ' + str(self.pause))
self.pause = True
def _runExperiment(self):
#title(additional='(), self.pause = ' + str(self.pause))
self.experiment.run()
return self.experiment.done
def _run(self):
"""Run the experiment."""
#title(additional='(), self.pause = ' + str(self.pause))
#if self.experiment.done or self.pause:
# return
# self.speed can be either 1, 10, or 100
if not self.iterationCount:
iterations = self.speed
else:
iterations = \
min(self.speed - self.iteration % self.speed, self.iterationCount - self.iteration)
self.runCount = iterations
self.experiment.pause = False
self.done = self._runExperiment()
# If the experiment is done or paused or stepping
if self.done or self.pause:
return
# Schedule another run
wx.CallLater(self.runInterval, self._run)
def update(self, methodName=None, elementName=None, args=None, kwargs=None):
"""
Called automatically in response to runtime engine activity.
Extra arguments (optional) are passed by the wrapped methods,
and they can be used to avoid unnecessary updating.
@param methodName -- RuntimeElement class method that was called.
@param elementName -- RuntimeElement name.
@param args -- Positional arguments passed to the method.
@param kwargs -- Keyword arguments passed to the method.
"""
#if methodName != 'run':
# return
##print methodName
##from dbgp.client import brk; brk(port=9011)
#self.iteration = self.experiment.position.iter
#exp = self.experiment
## check if the pause button was clicked
#if self.pause:
# exp.pause = True
#elif self.runCount is not None:
# self.runCount -= 1
# if self.runCount == 0:
# exp.pause = True
#
#runtimelistener.listenersEnabled = exp.pause
def _step(self):
"""Run the network for one iteration."""
title()
self.runCount = 1
self.experiment.pause = False
self._runExperiment()
self.pause = True
def _iteration_changed(self):
"""
Called automatically by Traits when the iteration updates.
Update the progress bar and check the conditions to see whether to stop or
pause.
"""
if self.showProgressBar:
try:
self._setProgress()
except:
# may fail when switching from training to inference
from dbgp.client import brk; brk(port=9011)
pass
def _runButton_fired(self):
self.pause = False
wx.CallLater(self.runInterval, self._run)
def _pauseButton_fired(self):
#from dbgp.client import brk; brk(port=9011)
self.pause = True
#wx.CallLater(self.runInterval, self._pause)
def _stepButton_fired(self):
| wx.CallLater(self.runInterval, self._step) | identifier_body |
|
PredictionRuntimeInspector.py | ("Repeat")
# The "Next Error" button becomes "Next Target" when user sets a custom one
nextTargetButton = Event # Button with dynamic label
targetButtonLabels = ('Next error', 'Next target')
targetButtonLabel = Str(targetButtonLabels[0])
customTargetButton = Button('Custom...')
pauseTarget = Str
backwardButton = Button('Back',
image=ImageResource(getNTAImage('backward_36_26')))
runButton = Button('Run',
image=ImageResource(getNTAImage('play_36_26')))
pauseButton = Button('Pause',
image=ImageResource(getNTAImage('pause_36_26')))
stepButton = Button('Step',
image=ImageResource(getNTAImage('forward_36_26')))
# Internal traits
tier = Int
tierCount = Int
running = Bool
iteration = Int
numIterations = Int
mainloopRunning = Bool
spacer = Str
pause = Bool
done = Bool
@staticmethod
def getNames():
"""
Return the short and long names for this inspector. The short name appears
in the dropdown menu, and the long name is used as the window title.
"""
return ('run', 'Run Network')
def __init__(self, parent, experiment, tierCount=0, showProgressBar=False,
multipleDatasets=False, startImmediately=True):
"""
"""
#title()
self.experiment = experiment
self.pause = True
self.experiment.pause = True
self.runCount = None
network = experiment.network
NetworkInspector.__init__(self, parent, network)
self.tierCount = tierCount
self.showProgressBar = showProgressBar
self.multipleDatasets = multipleDatasets
self.stopTarget = None
self.iteration = 0
self.iterationCount = 0
self.usingPauseTarget = False
self.stepping = False
# Look for all sensors (regions without inputs)
# If all sensors are of a supported type, seeking backward is supported
# Otherwise, seeking backward is not supported, because not all sensors
# can be run in reverse
self.sensors = []
for element in _getElements(self.network):
if _isSensor(element):
if element.type == 'VectorFileSensor':
self.sensors.append(element)
else:
# Unsupported sensor type
self.sensors = []
break
# Set the stop button label differently for training and testing
# The stop button isn't shown at all if neither training nor testing, so
# don't worry about that case
if not self.tierCount and self.multipleDatasets:
self.add_trait('stopButton', Button(label='Skip to next dataset'))
else:
self.add_trait('stopButton', Button(label='Stop training this tier'))
# Set up the default pause target (next error), which the user will be
# able to change later
#self._createDefaultPauseTarget()
#self.pauseTarget = self.defaultPauseTarget
# Set up the Traits view
self._createView()
if startImmediately:
self.start() # Start running the network
#RuntimeInspectorBase.__init__(self, parent, network, tierCount, showProgressBar,
# multipleDatasets, startImmediately)
def | (self):
d = self.experiment.description
for name in 'spTrain', 'tpTrain', 'classifierTrain', 'infer':
if not name in d:
continue
phase = d[name]
if len(phase) > 0:
assert self.onPhaseSetup not in phase[0]['setup']
phase[0]['setup'].append(self.onPhaseSetup)
phase[-1]['finish'].append(self.onPhaseTeardown)
for step in phase:
# Make sure to be the first callback
step['iter'].insert(0, self.onIter)
def _unregisterCallbacks(self):
d = self.experiment.description
for name in 'spTrain', 'tpTrain', 'classifierTrain', 'infer':
if not name in d:
continue
phase = d[name]
if len(phase) > 0:
assert self.onPhaseSetup in phase[0]['setup']
phase[0]['setup'].remove(self.onPhaseSetup)
phase[-1]['finish'].remove(self.onPhaseTeardown)
for step in phase:
# Make sure to be the first callback
step['iter'].remove(self.onIter)
def _getTierName(self, tier):
raise NotImplementedError
def detectNetworkType(self):
self.isFrameworkNetwork = 'sensor' in self.network.regions and \
self.network.regions['sensor'].type == 'RecordSensor'
def _getPhase(self, e):
index = e.position.phase
name = e.workflow[index][0]
return (name, e.description[name])
def onPhaseSetup(self, exp):
title()
self.iteration = 0
self.phase = self._getPhase(exp)
phase = self.phase[1]
self.iterationCount = phase[0]['iterationCount'] if len(phase) > 0 else 0
if self.pauseAtNextStep and self.pauseAtPhaseSetup:
#if self.pauseAtNextStep:
#from dbgp.client import brk; brk(port=9011)
exp.pause = True
self.pause = True
self.pauseAtPhaseSetup = False
else:
self.pauseAtPhaseSetup = True
def onPhaseTeardown(self, exp):
title()
index = exp.position.phase
# Last phase
if index == len(exp.workflow) - 1:
self.done = True
def onIter(self, exp, i):
""" """
title(additional='(), self.pause = ' + str(self.pause))
self.iteration += 1
# check if the pause button was clicked
if self.pause:
exp.pause = True
elif self.runCount is not None:
self.runCount -= 1
if self.runCount == 0:
exp.pause = True
runtimelistener.listenersEnabled = exp.pause
def _setProgress(self):
"""Set the progress trait from the iteration."""
self.progress = (self.iteration, self.iterationCount)
def _disableRegions(self):
"""
Disable any regions that can't be run.
Currently only looks for VectorFileEffectors whose outputFile parameter
is equal to 'No output file specified'.
"""
effectors = [e for e in _getElements(self.network) if _isEffector(e)]
for e in effectors:
if e.getParameter('outputFile') == 'No outputFile specified':
_disable(self.network, e.getName())
def _createView(self):
"""Set up a view for the traits."""
items = []
if self.showProgressBar:
items.append(Item('progress', show_label=False,
editor=ProgressEditor(callback=self._seek)))
# Controls
items.append(
alignCenter(
Item('backwardButton', style='custom',
enabled_when='not object.running and object.mainloopRunning '
+'and object.sensors and object.iteration > 1'),
Item('runButton', style='custom',
enabled_when='object.pause and not object.done'),
Item('pauseButton', style='custom',
enabled_when='not (object.pause or object.done)'),
Item('stepButton', style='custom',
enabled_when='object.pause and not object.done'),
show_labels=False,
orientation='horizontal'
))
# Repeat button and pause target buttons
items.append(
alignCenter(
Item('repeatButton', show_label=False,
enabled_when='not object.running and object.mainloopRunning '
'and object.iteration > 0'),
Item('nextTargetButton', show_label=False,
editor=ButtonEditor(label_value='targetButtonLabel'),
enabled_when='not object.running and object.mainloopRunning '
'and object.pauseTarget'),
Item('customTargetButton', show_label=False,
enabled_when='not object.running and object.mainloopRunning')
))
# Speed control
items.append(Item('speed', style='custom', show_label=False,
editor=EnumEditor(cols=1, values={
1 : '1: Slow (update on every iteration)',
10 : '2: Medium (update every 10 iterations)',
100 : '3: Fast (update every 100 iterations)'
})
))
items.extend([
Group(
Item('pauseAtNextStep'),
show_left=False
),
alignLeft(
Item('stopButton', show_label=False, enabled_when='object.iteration')
)
])
self.traits_view = View(*items)
def close(self):
"""Called by MultiInspector upon closing."""
#title()
self.experiment.pause = True
if self.running:
self.running = False
self._unregisterCallbacks()
def start(self, numIterations=0, target=None, tier=0, stop=False,
callback=None):
"""
Start running the network, and start the mainloop if necessary.
numIterations -- Number of iterations to run for (optional).
target -- Run until this condition is met (used by the Vision Framework).
This is distinct from the user-specified | _registerCallbacks | identifier_name |
04-aruco_calibration.py | uco_type = list(df[(df["place"]=="floor") & (df["aruco_type"]==aruco_type)]["id"])
if len(corners) > 0: # verify *at least* one ArUco marker was detected
for i, markerID in enumerate(list(ids.flatten())): # loop over the detected ArUCo corners
if markerID in ids_on_floor_with_current_aruco_type:
corners_all.append(corners[i])
ids_all.append(markerID)
markerSize = float(df[(df["place"]=="floor") & (df["aruco_type"]==aruco_type) & (df["id"]==markerID)]["size_mm"])
sizes_all.append(markerSize)
# print(corners_all)
# print(ids_all)
# print(sizes_all)
print("[INFO] Num of detected Tags: ",len(corners_all))
corners_all = np.array(corners_all)
ids_all = np.array(ids_all)
sizes_all = np.array(sizes_all)
# verify *at least* one ArUco marker was detected on floor
if len(corners_all) > 0:
rvecs = []
tvecs = []
# loop over the detected ArUCo corners and draw ids and bounding boxes around the detected markers
for (markerCorner, markerID, markerSize) in zip(corners_all, ids_all, sizes_all):
# extract the marker corners (which are always returned in
# top-left, top-right, bottom-right, and bottom-left order)
corners = markerCorner.reshape((4, 2))
(topLeft, topRight, bottomRight, bottomLeft) = corners
# convert each of the (x, y)-coordinate pairs to integers
topRight = (int(topRight[0]), int(topRight[1]))
bottomRight = (int(bottomRight[0]), int(bottomRight[1]))
bottomLeft = (int(bottomLeft[0]), int(bottomLeft[1]))
topLeft = (int(topLeft[0]), int(topLeft[1]))
# draw the bounding box of the ArUCo detection
cv2.line(frame, topLeft, topRight, (0, 255, 0), 1)
cv2.line(frame, topRight, bottomRight, (0, 255, 0), 1)
cv2.line(frame, bottomRight, bottomLeft, (0, 255, 0), 1)
cv2.line(frame, bottomLeft, topLeft, (0, 255, 0), 1)
# compute and draw the center (x, y)-coordinates of the ArUco
# marker
cX = int((topLeft[0] + bottomRight[0]) / 2.0)
cY = int((topLeft[1] + bottomRight[1]) / 2.0)
cv2.circle(frame, (cX, cY), 4, (0, 0, 255), -1)
# draw the ArUco marker ID on the image
cv2.putText(frame, str(markerID),
(topLeft[0], topLeft[1] - 15), cv2.FONT_HERSHEY_SIMPLEX,
0.5, (0, 255, 0), 2)
# Estimate the pose of the detected marker in camera frame
rvec, tvec, markerPoints = cv2.aruco.estimatePoseSingleMarkers(markerCorner, markerSize, mtx_new, dist_new)
cv2.aruco.drawAxis(frame, mtx_new, dist_new, rvec, tvec, markerSize*0.75) # Draw Axis
# print("[INFO] ArUco marker ID: {}".format(markerID))
# print(tvec[0].flatten()) # in camera's frame)
# print(rvec[0].flatten()) # in camera's frame)
rvecs.append(rvec[0])
tvecs.append(tvec[0])
rvecs = np.array(rvecs)
tvecs = np.array(tvecs)
# # Estimate the pose of the detected marker in camera frame at once
# rvecs, tvecs, markerPoints = cv2.aruco.estimatePoseSingleMarkers(corners_all, 190, mtx_new, dist_new)
# cv2.aruco.drawDetectedMarkers(frame, corners_all, ids_all) # Draw Bounding boxes
# for (rvec, tvec) in zip(rvecs, tvecs):
# cv2.aruco.drawAxis(frame, mtx_new, dist_new, rvec, tvec, 190*0.75) # Draw Axis
# show the output image
cv2.imshow("Image", frame)
cv2.waitKey(0)
# print(tvecs)
# print(type(tvec))
# print(type(tvecs))
# Transform detected locations from camera frame to World frame
tvecs = np.squeeze(tvecs).T # (3,N)
tvecs = R_oc @ tvecs # (3,N)
tvecs = T_oc + tvecs # (3,N)
# print(np.shape(tvecs))
# Calculate the best fitting plane
origin = np.mean(tvecs,axis=1).reshape(3,1)
tvecs2 = np.squeeze(tvecs - origin) # (3, N)
(U,S,Vt) = np.linalg.svd(tvecs2)
normal_vec = U[:,-1].reshape(3,1)
# Calculate residuals of the plane fitting
distances = normal_vec.T @ tvecs2
RMSE = math.sqrt(np.mean(np.square(distances)))
# print("RMSE: ", RMSE, " (mm)")
# Plot the data and fitting plane
# plot data
plt.figure()
ax = plt.subplot(111, projection='3d')
ax.scatter(tvecs[0,:], tvecs[1,:], tvecs[2,:], color='b')
# plot plane
xlim = ax.get_xlim()
ylim = ax.get_ylim()
X,Y = np.meshgrid(np.arange(xlim[0], xlim[1], step=500),
np.arange(ylim[0], ylim[1], step=500))
Z = -(normal_vec[0]/normal_vec[2])*(X-origin[0]) - (normal_vec[1]/normal_vec[2])*(Y-origin[1]) + origin[2]
ax.plot_wireframe(X,Y,Z, color='k')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
plt.show()
## Calculate the frame on the best fit plane based on world origin
# Project the world origin onto the best fit plane
origin_new = (normal_vec.T @ origin) * normal_vec
# Projecy world frame x axis onto the origin
x = np.array([[1],[0],[0]])
x_p = x - (normal_vec.T @ (x - origin) ) * normal_vec
# calculate the corresponding x axis on the plane
x_new = (x_p - origin_new) / np.sqrt(np.sum((x_p - origin_new)**2))
# calculate the corresponding y axis on the plane
y_new = np.cross(np.squeeze(normal_vec), np.squeeze(x_new)).reshape(3,1)
# y_new = y_new / np.sqrt(np.sum(y_new**2)) # Normalization is not necessary since x_new and normal_vec are perpendicular
# Define the rotation matrix from world frame to new plane frame
R_op = np.concatenate((x_new, y_new,normal_vec), axis=1)
R_po = R_op.T
# Define the translation between world frame to plane frame
T_op = origin_new
T_po = -R_po @ T_op
# As an example project all data points to the plane
tvecs3 = R_po @ tvecs # (3,N)
tvecs3 = T_po + tvecs3 # (3,N)
tvecs3 = tvecs3[0:2,:]
plt.figure()
plt.title("2D Data")
plt.xlabel("X")
plt.ylabel("Y")
plt.scatter(tvecs3[0,:], tvecs3[1,:], marker='x')
plt.axis('equal')
plt.grid()
plt.show()
return R_op, R_po, T_op, T_po, RMSE
def load_coefficients(path):
| """ Loads camera matrix and distortion coefficients. """
# FILE_STORAGE_READ
cv_file = cv2.FileStorage(path, cv2.FILE_STORAGE_READ)
# note we also have to specify the type to retrieve other wise we only get a
# FileNode object back instead of a matrix
camera_matrix = cv_file.getNode("K").mat()
dist_matrix = cv_file.getNode("D").mat()
try:
R_co = cv_file.getNode("R_co").mat()
R_oc = cv_file.getNode("R_oc").mat()
T_co = cv_file.getNode("T_co").mat()
T_oc = cv_file.getNode("T_oc").mat()
except:
print("[INFO]: could not read R_co, R_oc, T_co, T_oc from: {}".format(path))
print(str(R_co), str(R_oc), str(T_co), str(T_oc))
cv_file.release()
return [camera_matrix, dist_matrix]
| identifier_body |
|
04-aruco_calibration.py | # verify *at least* one ArUco marker was detected on floor
if len(corners_all) > 0:
rvecs = []
tvecs = []
# loop over the detected ArUCo corners and draw ids and bounding boxes around the detected markers
for (markerCorner, markerID, markerSize) in zip(corners_all, ids_all, sizes_all):
# extract the marker corners (which are always returned in
# top-left, top-right, bottom-right, and bottom-left order)
corners = markerCorner.reshape((4, 2))
(topLeft, topRight, bottomRight, bottomLeft) = corners
# convert each of the (x, y)-coordinate pairs to integers
topRight = (int(topRight[0]), int(topRight[1]))
bottomRight = (int(bottomRight[0]), int(bottomRight[1]))
bottomLeft = (int(bottomLeft[0]), int(bottomLeft[1]))
topLeft = (int(topLeft[0]), int(topLeft[1]))
# draw the bounding box of the ArUCo detection
cv2.line(frame, topLeft, topRight, (0, 255, 0), 1)
cv2.line(frame, topRight, bottomRight, (0, 255, 0), 1)
cv2.line(frame, bottomRight, bottomLeft, (0, 255, 0), 1)
cv2.line(frame, bottomLeft, topLeft, (0, 255, 0), 1)
# compute and draw the center (x, y)-coordinates of the ArUco
# marker
cX = int((topLeft[0] + bottomRight[0]) / 2.0)
cY = int((topLeft[1] + bottomRight[1]) / 2.0)
cv2.circle(frame, (cX, cY), 4, (0, 0, 255), -1)
# draw the ArUco marker ID on the image
cv2.putText(frame, str(markerID),
(topLeft[0], topLeft[1] - 15), cv2.FONT_HERSHEY_SIMPLEX,
0.5, (0, 255, 0), 2)
# Estimate the pose of the detected marker in camera frame
rvec, tvec, markerPoints = cv2.aruco.estimatePoseSingleMarkers(markerCorner, markerSize, mtx_new, dist_new)
cv2.aruco.drawAxis(frame, mtx_new, dist_new, rvec, tvec, markerSize*0.75) # Draw Axis
# print("[INFO] ArUco marker ID: {}".format(markerID))
# print(tvec[0].flatten()) # in camera's frame)
# print(rvec[0].flatten()) # in camera's frame)
rvecs.append(rvec[0])
tvecs.append(tvec[0])
rvecs = np.array(rvecs)
tvecs = np.array(tvecs)
# # Estimate the pose of the detected marker in camera frame at once
# rvecs, tvecs, markerPoints = cv2.aruco.estimatePoseSingleMarkers(corners_all, 190, mtx_new, dist_new)
# cv2.aruco.drawDetectedMarkers(frame, corners_all, ids_all) # Draw Bounding boxes
# for (rvec, tvec) in zip(rvecs, tvecs):
# cv2.aruco.drawAxis(frame, mtx_new, dist_new, rvec, tvec, 190*0.75) # Draw Axis
# show the output image
cv2.imshow("Image", frame)
cv2.waitKey(0)
# print(tvecs)
# print(type(tvec))
# print(type(tvecs))
# Transform detected locations from camera frame to World frame
tvecs = np.squeeze(tvecs).T # (3,N)
tvecs = R_oc @ tvecs # (3,N)
tvecs = T_oc + tvecs # (3,N)
# print(np.shape(tvecs))
# Calculate the best fitting plane
origin = np.mean(tvecs,axis=1).reshape(3,1)
tvecs2 = np.squeeze(tvecs - origin) # (3, N)
(U,S,Vt) = np.linalg.svd(tvecs2)
normal_vec = U[:,-1].reshape(3,1)
# Calculate residuals of the plane fitting
distances = normal_vec.T @ tvecs2
RMSE = math.sqrt(np.mean(np.square(distances)))
# print("RMSE: ", RMSE, " (mm)")
# Plot the data and fitting plane
# plot data
plt.figure()
ax = plt.subplot(111, projection='3d')
ax.scatter(tvecs[0,:], tvecs[1,:], tvecs[2,:], color='b')
# plot plane
xlim = ax.get_xlim()
ylim = ax.get_ylim()
X,Y = np.meshgrid(np.arange(xlim[0], xlim[1], step=500),
np.arange(ylim[0], ylim[1], step=500))
Z = -(normal_vec[0]/normal_vec[2])*(X-origin[0]) - (normal_vec[1]/normal_vec[2])*(Y-origin[1]) + origin[2]
ax.plot_wireframe(X,Y,Z, color='k')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
plt.show()
## Calculate the frame on the best fit plane based on world origin
# Project the world origin onto the best fit plane
origin_new = (normal_vec.T @ origin) * normal_vec
# Projecy world frame x axis onto the origin
x = np.array([[1],[0],[0]])
x_p = x - (normal_vec.T @ (x - origin) ) * normal_vec
# calculate the corresponding x axis on the plane
x_new = (x_p - origin_new) / np.sqrt(np.sum((x_p - origin_new)**2))
# calculate the corresponding y axis on the plane
y_new = np.cross(np.squeeze(normal_vec), np.squeeze(x_new)).reshape(3,1)
# y_new = y_new / np.sqrt(np.sum(y_new**2)) # Normalization is not necessary since x_new and normal_vec are perpendicular
# Define the rotation matrix from world frame to new plane frame
R_op = np.concatenate((x_new, y_new,normal_vec), axis=1)
R_po = R_op.T
# Define the translation between world frame to plane frame
T_op = origin_new
T_po = -R_po @ T_op
# As an example project all data points to the plane
tvecs3 = R_po @ tvecs # (3,N)
tvecs3 = T_po + tvecs3 # (3,N)
tvecs3 = tvecs3[0:2,:]
plt.figure()
plt.title("2D Data")
plt.xlabel("X")
plt.ylabel("Y")
plt.scatter(tvecs3[0,:], tvecs3[1,:], marker='x')
plt.axis('equal')
plt.grid()
plt.show()
return R_op, R_po, T_op, T_po, RMSE
def load_coefficients(path):
""" Loads camera matrix and distortion coefficients. """
# FILE_STORAGE_READ
cv_file = cv2.FileStorage(path, cv2.FILE_STORAGE_READ)
# note we also have to specify the type to retrieve other wise we only get a
# FileNode object back instead of a matrix
camera_matrix = cv_file.getNode("K").mat()
dist_matrix = cv_file.getNode("D").mat()
try:
R_co = cv_file.getNode("R_co").mat()
R_oc = cv_file.getNode("R_oc").mat()
T_co = cv_file.getNode("T_co").mat()
T_oc = cv_file.getNode("T_oc").mat()
except:
print("[INFO]: could not read R_co, R_oc, T_co, T_oc from: {}".format(path))
print(str(R_co), str(R_oc), str(T_co), str(T_oc))
cv_file.release()
return [camera_matrix, dist_matrix]
cv_file.release()
return [camera_matrix, dist_matrix, R_co, R_oc, T_co, T_oc]
def capture_img(image_dir, image_name, image_format):
cam = cv2.VideoCapture(1)
cam.set(3,3840)
cam.set(4,2160)
# cam.set(3,640)
# cam.set(4,480)
print("Hit SPACE key to capture, Hit ESC key to continue")
img_name = image_dir + "/" + image_name + "." + image_format
cv2.namedWindow("test")
while True:
ret, frame = cam.read()
if not ret:
print("failed to grab frame")
break
cv2.imshow("test", frame)
k = cv2.waitKey(1)
if k%256 == 27:
# ESC pressed
| print("Escape hit, closing...")
img = cv2.imread(img_name)
break | conditional_block |
|
04-aruco_calibration.py | boxes around the detected markers
for (markerCorner, markerID, markerSize) in zip(corners_all, ids_all, sizes_all):
# extract the marker corners (which are always returned in
# top-left, top-right, bottom-right, and bottom-left order)
corners = markerCorner.reshape((4, 2))
(topLeft, topRight, bottomRight, bottomLeft) = corners
# convert each of the (x, y)-coordinate pairs to integers
topRight = (int(topRight[0]), int(topRight[1]))
bottomRight = (int(bottomRight[0]), int(bottomRight[1]))
bottomLeft = (int(bottomLeft[0]), int(bottomLeft[1]))
topLeft = (int(topLeft[0]), int(topLeft[1]))
# draw the bounding box of the ArUCo detection
cv2.line(frame, topLeft, topRight, (0, 255, 0), 1)
cv2.line(frame, topRight, bottomRight, (0, 255, 0), 1)
cv2.line(frame, bottomRight, bottomLeft, (0, 255, 0), 1)
cv2.line(frame, bottomLeft, topLeft, (0, 255, 0), 1)
# compute and draw the center (x, y)-coordinates of the ArUco
# marker
cX = int((topLeft[0] + bottomRight[0]) / 2.0)
cY = int((topLeft[1] + bottomRight[1]) / 2.0)
cv2.circle(frame, (cX, cY), 4, (0, 0, 255), -1)
# draw the ArUco marker ID on the image
cv2.putText(frame, str(markerID),
(topLeft[0], topLeft[1] - 15), cv2.FONT_HERSHEY_SIMPLEX,
0.5, (0, 255, 0), 2)
# Estimate the pose of the detected marker in camera frame
rvec, tvec, markerPoints = cv2.aruco.estimatePoseSingleMarkers(markerCorner, markerSize, mtx_new, dist_new)
cv2.aruco.drawAxis(frame, mtx_new, dist_new, rvec, tvec, markerSize*0.75) # Draw Axis
# print("[INFO] ArUco marker ID: {}".format(markerID))
# print(tvec[0].flatten()) # in camera's frame)
# print(rvec[0].flatten()) # in camera's frame)
rvecs.append(rvec[0])
tvecs.append(tvec[0])
rvecs = np.array(rvecs)
tvecs = np.array(tvecs)
# # Estimate the pose of the detected marker in camera frame at once
# rvecs, tvecs, markerPoints = cv2.aruco.estimatePoseSingleMarkers(corners_all, 190, mtx_new, dist_new)
# cv2.aruco.drawDetectedMarkers(frame, corners_all, ids_all) # Draw Bounding boxes
# for (rvec, tvec) in zip(rvecs, tvecs):
# cv2.aruco.drawAxis(frame, mtx_new, dist_new, rvec, tvec, 190*0.75) # Draw Axis
# show the output image
cv2.imshow("Image", frame)
cv2.waitKey(0)
# print(tvecs)
# print(type(tvec))
# print(type(tvecs))
# Transform detected locations from camera frame to World frame
tvecs = np.squeeze(tvecs).T # (3,N)
tvecs = R_oc @ tvecs # (3,N)
tvecs = T_oc + tvecs # (3,N)
# print(np.shape(tvecs))
# Calculate the best fitting plane
origin = np.mean(tvecs,axis=1).reshape(3,1)
tvecs2 = np.squeeze(tvecs - origin) # (3, N)
(U,S,Vt) = np.linalg.svd(tvecs2)
normal_vec = U[:,-1].reshape(3,1)
# Calculate residuals of the plane fitting
distances = normal_vec.T @ tvecs2
RMSE = math.sqrt(np.mean(np.square(distances)))
# print("RMSE: ", RMSE, " (mm)")
# Plot the data and fitting plane
# plot data
plt.figure()
ax = plt.subplot(111, projection='3d')
ax.scatter(tvecs[0,:], tvecs[1,:], tvecs[2,:], color='b')
# plot plane
xlim = ax.get_xlim()
ylim = ax.get_ylim()
X,Y = np.meshgrid(np.arange(xlim[0], xlim[1], step=500),
np.arange(ylim[0], ylim[1], step=500))
Z = -(normal_vec[0]/normal_vec[2])*(X-origin[0]) - (normal_vec[1]/normal_vec[2])*(Y-origin[1]) + origin[2]
ax.plot_wireframe(X,Y,Z, color='k')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
plt.show()
## Calculate the frame on the best fit plane based on world origin
# Project the world origin onto the best fit plane
origin_new = (normal_vec.T @ origin) * normal_vec
# Projecy world frame x axis onto the origin
x = np.array([[1],[0],[0]])
x_p = x - (normal_vec.T @ (x - origin) ) * normal_vec
# calculate the corresponding x axis on the plane
x_new = (x_p - origin_new) / np.sqrt(np.sum((x_p - origin_new)**2))
# calculate the corresponding y axis on the plane
y_new = np.cross(np.squeeze(normal_vec), np.squeeze(x_new)).reshape(3,1)
# y_new = y_new / np.sqrt(np.sum(y_new**2)) # Normalization is not necessary since x_new and normal_vec are perpendicular
# Define the rotation matrix from world frame to new plane frame
R_op = np.concatenate((x_new, y_new,normal_vec), axis=1)
R_po = R_op.T
# Define the translation between world frame to plane frame
T_op = origin_new
T_po = -R_po @ T_op
# As an example project all data points to the plane
tvecs3 = R_po @ tvecs # (3,N)
tvecs3 = T_po + tvecs3 # (3,N)
tvecs3 = tvecs3[0:2,:]
plt.figure()
plt.title("2D Data")
plt.xlabel("X")
plt.ylabel("Y")
plt.scatter(tvecs3[0,:], tvecs3[1,:], marker='x')
plt.axis('equal')
plt.grid()
plt.show()
return R_op, R_po, T_op, T_po, RMSE
def load_coefficients(path):
""" Loads camera matrix and distortion coefficients. """
# FILE_STORAGE_READ
cv_file = cv2.FileStorage(path, cv2.FILE_STORAGE_READ)
# note we also have to specify the type to retrieve other wise we only get a
# FileNode object back instead of a matrix
camera_matrix = cv_file.getNode("K").mat()
dist_matrix = cv_file.getNode("D").mat()
try:
R_co = cv_file.getNode("R_co").mat()
R_oc = cv_file.getNode("R_oc").mat()
T_co = cv_file.getNode("T_co").mat()
T_oc = cv_file.getNode("T_oc").mat()
except:
print("[INFO]: could not read R_co, R_oc, T_co, T_oc from: {}".format(path))
print(str(R_co), str(R_oc), str(T_co), str(T_oc))
cv_file.release()
return [camera_matrix, dist_matrix]
cv_file.release()
return [camera_matrix, dist_matrix, R_co, R_oc, T_co, T_oc]
def capture_img(image_dir, image_name, image_format):
cam = cv2.VideoCapture(1)
cam.set(3,3840)
cam.set(4,2160)
# cam.set(3,640)
# cam.set(4,480)
print("Hit SPACE key to capture, Hit ESC key to continue")
img_name = image_dir + "/" + image_name + "." + image_format
cv2.namedWindow("test")
while True:
ret, frame = cam.read()
if not ret:
print("failed to grab frame")
break
cv2.imshow("test", frame)
k = cv2.waitKey(1)
if k%256 == 27:
# ESC pressed
print("Escape hit, closing...")
img = cv2.imread(img_name)
break
elif k%256 == 32:
# SPACE pressed
cv2.imwrite(img_name, frame)
print("{} written!".format(img_name))
cam.release()
cv2.destroyAllWindows()
return img
def | save_coefficients | identifier_name |
|
04-aruco_calibration.py | uco.DICT_APRILTAG_36h10,
"DICT_APRILTAG_36h11": cv2.aruco.DICT_APRILTAG_36h11
}
def calibrate_aruco(intrinsic_calib_path, intrinsic_calib_path_undistorted, image_dir, image_name, image_format, aruco_tags_info_path):
[mtx, dist, R_co, R_oc, T_co, T_oc] = load_coefficients(intrinsic_calib_path)
[mtx_new, dist_new, R_co, R_oc, T_co, T_oc] = load_coefficients(intrinsic_calib_path_undistorted) |
frame = capture_img(image_dir, image_name, image_format)
# try undistorted image
# h, w = frame.shape[:2]
# newcameramtx, roi = cv2.getOptimalNewCameraMatrix(mtx, dist, (w,h), 1, (w,h))
# undistort
# # frame = cv2.undistort(frame, mtx, dist, None, newcameramtx)
frame = cv2.undistort(frame, mtx, dist, None, mtx)
# # # crop the image
# # x, y, w, h = roi
# # frame = frame[y:y+h, x:x+w]
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# read csv file that includes places of the aruco tags, their aruco type, ids, sizes and locations wrt their places
df = pd.read_csv(aruco_tags_info_path)
# get aruco dictionary types on the floor as a list
aruco_types = list(df[df["place"]=="floor"]["aruco_type"].unique())
corners_all = []
ids_all = []
sizes_all = []
for aruco_type in aruco_types:
arucoType = ARUCO_DICT[aruco_type]
# verify that the supplied ArUCo tag exists and is supported by OpenCV
if ARUCO_DICT.get(aruco_type, None) is None:
print("[ERROR] ArUCo tag of '{}' is not supported".format(aruco_type))
sys.exit(0)
# load the ArUCo dictionary, grab the ArUCo parameters, and detect the markers
print("[INFO] detecting '{}' tags...".format(aruco_type))
arucoDict = cv2.aruco.Dictionary_get(ARUCO_DICT[aruco_type])
arucoParams = cv2.aruco.DetectorParameters_create()
(corners, ids, rejected) = cv2.aruco.detectMarkers(frame, arucoDict, parameters=arucoParams)
# only keep the detections that are on the floor by looking at the IDs
ids_on_floor_with_current_aruco_type = list(df[(df["place"]=="floor") & (df["aruco_type"]==aruco_type)]["id"])
if len(corners) > 0: # verify *at least* one ArUco marker was detected
for i, markerID in enumerate(list(ids.flatten())): # loop over the detected ArUCo corners
if markerID in ids_on_floor_with_current_aruco_type:
corners_all.append(corners[i])
ids_all.append(markerID)
markerSize = float(df[(df["place"]=="floor") & (df["aruco_type"]==aruco_type) & (df["id"]==markerID)]["size_mm"])
sizes_all.append(markerSize)
# print(corners_all)
# print(ids_all)
# print(sizes_all)
print("[INFO] Num of detected Tags: ",len(corners_all))
corners_all = np.array(corners_all)
ids_all = np.array(ids_all)
sizes_all = np.array(sizes_all)
# verify *at least* one ArUco marker was detected on floor
if len(corners_all) > 0:
rvecs = []
tvecs = []
# loop over the detected ArUCo corners and draw ids and bounding boxes around the detected markers
for (markerCorner, markerID, markerSize) in zip(corners_all, ids_all, sizes_all):
# extract the marker corners (which are always returned in
# top-left, top-right, bottom-right, and bottom-left order)
corners = markerCorner.reshape((4, 2))
(topLeft, topRight, bottomRight, bottomLeft) = corners
# convert each of the (x, y)-coordinate pairs to integers
topRight = (int(topRight[0]), int(topRight[1]))
bottomRight = (int(bottomRight[0]), int(bottomRight[1]))
bottomLeft = (int(bottomLeft[0]), int(bottomLeft[1]))
topLeft = (int(topLeft[0]), int(topLeft[1]))
# draw the bounding box of the ArUCo detection
cv2.line(frame, topLeft, topRight, (0, 255, 0), 1)
cv2.line(frame, topRight, bottomRight, (0, 255, 0), 1)
cv2.line(frame, bottomRight, bottomLeft, (0, 255, 0), 1)
cv2.line(frame, bottomLeft, topLeft, (0, 255, 0), 1)
# compute and draw the center (x, y)-coordinates of the ArUco
# marker
cX = int((topLeft[0] + bottomRight[0]) / 2.0)
cY = int((topLeft[1] + bottomRight[1]) / 2.0)
cv2.circle(frame, (cX, cY), 4, (0, 0, 255), -1)
# draw the ArUco marker ID on the image
cv2.putText(frame, str(markerID),
(topLeft[0], topLeft[1] - 15), cv2.FONT_HERSHEY_SIMPLEX,
0.5, (0, 255, 0), 2)
# Estimate the pose of the detected marker in camera frame
rvec, tvec, markerPoints = cv2.aruco.estimatePoseSingleMarkers(markerCorner, markerSize, mtx_new, dist_new)
cv2.aruco.drawAxis(frame, mtx_new, dist_new, rvec, tvec, markerSize*0.75) # Draw Axis
# print("[INFO] ArUco marker ID: {}".format(markerID))
# print(tvec[0].flatten()) # in camera's frame)
# print(rvec[0].flatten()) # in camera's frame)
rvecs.append(rvec[0])
tvecs.append(tvec[0])
rvecs = np.array(rvecs)
tvecs = np.array(tvecs)
# # Estimate the pose of the detected marker in camera frame at once
# rvecs, tvecs, markerPoints = cv2.aruco.estimatePoseSingleMarkers(corners_all, 190, mtx_new, dist_new)
# cv2.aruco.drawDetectedMarkers(frame, corners_all, ids_all) # Draw Bounding boxes
# for (rvec, tvec) in zip(rvecs, tvecs):
# cv2.aruco.drawAxis(frame, mtx_new, dist_new, rvec, tvec, 190*0.75) # Draw Axis
# show the output image
cv2.imshow("Image", frame)
cv2.waitKey(0)
# print(tvecs)
# print(type(tvec))
# print(type(tvecs))
# Transform detected locations from camera frame to World frame
tvecs = np.squeeze(tvecs).T # (3,N)
tvecs = R_oc @ tvecs # (3,N)
tvecs = T_oc + tvecs # (3,N)
# print(np.shape(tvecs))
# Calculate the best fitting plane
origin = np.mean(tvecs,axis=1).reshape(3,1)
tvecs2 = np.squeeze(tvecs - origin) # (3, N)
(U,S,Vt) = np.linalg.svd(tvecs2)
normal_vec = U[:,-1].reshape(3,1)
# Calculate residuals of the plane fitting
distances = normal_vec.T @ tvecs2
RMSE = math.sqrt(np.mean(np.square(distances)))
# print("RMSE: ", RMSE, " (mm)")
# Plot the data and fitting plane
# plot data
plt.figure()
ax = plt.subplot(111, projection='3d')
ax.scatter(tvecs[0,:], tvecs[1,:], tvecs[2,:], color='b')
# plot plane
xlim = ax.get_xlim()
ylim = ax.get_ylim()
X,Y = np.meshgrid(np.arange(xlim[0], xlim[1], step=500),
np.arange(ylim[0], ylim[1], step=500))
Z = -(normal_vec[0]/normal_vec[2])*(X-origin[0]) - (normal_vec[1]/normal_vec[2])*(Y-origin[1]) + origin[2]
ax.plot_wireframe(X,Y,Z, color='k')
ax.set_xlabel('x')
ax.set_ylabel('y | random_line_split |
|
huff_algorithm.py | (self):
if (self.lvl ==None):
return "\t%.3d=%c id:%0.3d : %.3f\r\n" % (self.symbol, self.symbol,\
self.id,self.prob)
else :
return "\t%.3d=%c id:%0.3d : %.3f (%d)\r\n" % (self.symbol,self.symbol,\
self.id,self.prob, self.lvl)
# @brief Binary tree leaf constructor specific class prototype contains symbol_val field and does
# not need any fields for descending nodes (dead end, None on default)
# @param Symbol value -> character which is represented by this node
# @param Symbol probability -> how many times the specific symbol occured in the sourcedata.
# @param Node level -> designated during BT generation (None on default).
class TBinTree_NodeGenerator:
# @brief
# @param Symbol value -> character which is represented by this node
def __init__(self, filedata): #constructor which accepts string as arg and uses it to generate dictionary to store input source data (arg -> filedata string
self.S_LOW_VALUE=32 #space
self.S_HIGH_VALUE=125 # }- character
self.pPopulation = 0 #total character count
#create empty list as property pBTLeafList -> for fresh data
self.pBTLeafList = list()
#create empty list as property pSymbolsList_sorted -> for sorted fresh data
self.pSymbolsList_sorted = list()
#create empty dictionary as property pSymbolsDict
self.pSymbolsDict = dict()
#fill list with symbol data (character with their probability)
for ascii_code in range(self.S_LOW_VALUE, self.S_HIGH_VALUE+1): # for every ASCII code from LOW_VALUE to HIGH_VALUE
x = filedata.count(chr(ascii_code)) # count number of characters in string
if (x>0) : # if character appears in string at least once
self.pSymbolsDict.update({ascii_code:x}) # put it into dictionary with ASCII code as key and no. of appearences as value
self.pPopulation +=x # all counted symbols are added to total source data population
self.pListString = str()
def SortData(self): # creates list by sorting symbols along probability
for key, value in sorted(self.pSymbolsDict.iteritems(), key=lambda (k,v): (v,k),reverse=False):
self.pSymbolsList_sorted.append((key,value))
def Pop2Prob(self): # takes total population into consideration and tranlates it into probability
for x in range(0,len(self.pSymbolsList_sorted)):
tempItem = list(self.pSymbolsList_sorted.pop(x))
tempItem[1]=float(tempItem[1])/self.pPopulation
print tempItem
self.pSymbolsList_sorted.insert(x,tempItem)
#self.pSymbolsList_sorted[x]=self.pSymbolsList_sorted[x]/self.pPopulation
print self.pSymbolsList_sorted
def setNewSymbolsDict(self, newDict):
self.pSymbolsDict = newDict
def SortedLeafGen(self):
for leaf_no in range(0, len(self.pSymbolsList_sorted)):
self.pBTLeafList.append(TBinTree_Leaf(self.pSymbolsList_sorted[leaf_no][0],self.pSymbolsList_sorted[leaf_no][1]))
self.LeafPopulation = len(self.pBTLeafList)
def DictPrint(self):
print ("\r\nIn total = %d" % self.pPopulation)
for key in range(self.S_LOW_VALUE, self.S_HIGH_VALUE+1):
if (self.pSymbolsDict.has_key(key)):
print "%.3d='%c' -> %.3f " % (key, key, self.pSymbolsDict[key], \
float(self.pSymbolsDict[key])/self.pPopulation )
def ListPrint(self):
print ("\r\nIn total = %d" % self.pPopulation)
for i in range(0,len(self.pSymbolsList_sorted)):
print("%.3d=%c : %.3f" % (self.pSymbolsList_sorted[i][0],self.pSymbolsList_sorted[i][0], \
self.pSymbolsList_sorted[i][1]))
self.pListString = self.pListString + ("%.3d='%c' : %.3f\n" % (self.pSymbolsList_sorted[i][0],self.pSymbolsList_sorted[i][0], \
self.pSymbolsList_sorted[i][1]))
def GetPopulation(self):
return self.pPopulation
def GetSortedList(self):
return self.pSymbolsList_sorted
def GetNodeList(self):
return self.pBTLeafList
def GetSourceEntropy(self):
Entropy = 0
temp = 0
for x in range(0,len(self.pSymbolsList_sorted)):
temp = self.pSymbolsList_sorted[x][1]
Entropy+= temp*np.log2(1.0/temp)
print temp
print "Source entropy:\t%f" % (Entropy)
return Entropy
class TBinTree_Tree:
def __init__(self, Leaves):
self.pPopulation = Leaves.GetPopulation()
self.LeavesList = Leaves.GetNodeList()
self.All_leaves = list()
self.All_edges = list()
self.CodeList = dict()
def __call__(self,option=None): #by default top-down method of defininf binary tree, if parameters is present- bottom-up
if (option==None):
self.root = fBinaryTreeBuilder(self.LeavesList, 0)
else :
self.root = fBinaryTreeBuilderBU(self.LeavesList, 0)
self.AvgCL = fMECalc(self.root)
def ShowBT(self):
fBinaryTreeNodeFinder(self.root)
def GraphGen(self):
#global graphen
print "Starting Source tree graph generation..."
fBinaryTreeNodeCartograph(self.root)
BTGraph.write_png('SourceTree.png')
print "Graph complete."
def CodingListGenerator(self):
global gCodingDict
print "Generating symbol coding list..."
fBinaryTreeNodeFinder(self.root,Action=1)
# print dictionary with symbol coding
dictKeys = gCodingDict.keys()
for x in range(0,len(gCodingDict)):
print "%02d)\'%c\' -> %s"% (x,dictKeys[x],gCodingDict[dictKeys[x]])
def CodeMessage(self,MessageContent, Action=None):
global gCodingDict
if (Action==None):
codedMsg = ""
print len(MessageContent)
for x in range(0,len(MessageContent)): #TODO try KeyError -> dictionary unspecified key handling - done
if (gCodingDict.has_key(ord(MessageContent[x]))==False):
return None
codedMsg = codedMsg + gCodingDict[ord(MessageContent[x])] + "|"
return codedMsg
elif (Action==1):
codedMsg = list()
for x in range(0,len(MessageContent)):
if (gCodingDict.has_key(ord(MessageContent[x]))==False):
return None
codedMsg.append(gCodingDict[ord(MessageContent[x])])
return codedMsg
def GetAvgCL(self):
return self.AvgCL
# @brief Decoding function as a method of Binary tree class which cooperates with indepednent
# fDecodeBit function which is repeteadly called until the end of coded message.
# Global variable which temporarly stores string is used.
# @param Encoded as a string.
def DecodeMessage(self,MessageContent):
print "Commencing message decoding..."
global gTempCodedMsg
gTempCodedMsg = "".join(MessageContent) #copy coded message string into global variable string for further manipulations
gTempCodedMsg = gTempCodedMsg.replace("|","")
#print gTempCodedMsg
tempString = ""
while (len(gTempCodedMsg)): #while there are bits of the coded message available run decoding of consecutive symbols in loop
symbol = fDecodeBit(self.root, gTempCodedMsg)
print symbol
tempString = tempString + chr(symbol) # concatanate character symbol to string
return tempString
print
global gTempCodedMsg
gTempCodedMsg = str()
# @brief Indepednent function which recursively calls itself to explore binary tree until Leaf is reached
# and proper symbol retrieved
# @param Current - strarting point for exploring.
# @param Piece of encoded message - the compass to navigate between branches.
def fDecodeBit(CurrentNode,CodedMsg):
global gTempCodedMsg
gTempCodedMsg = CodedMsg
if (CurrentNode.__class__.__name__ == 'TBinTree_Leaf'):
return CurrentNode.symbol
elif (CurrentNode.__class__.__name__ == 'TBinTree_Node'):
#if (len(CodedMsg)):
#print CodedMsg[0]
if (CodedMsg[0]=='0') :
return fDecodeBit(CurrentNode.b_zero, CodedMsg[1:])
elif (CodedMsg[0]=='1') :
return fDecodeBit(CurrentNode.b_one, CodedMsg[1:])
else :
print "DecodeError 2 Message!"
else:
print "DecodeError 1 Message!"
# @brief Indepednent function with implementation of suboptimal top-down method of source tree generation
# algorithm
# @param List of BTLeaves representing symbols sorted along probability
# @param Current level - codelength
def fBinaryTreeBuilder(LeavesList,Level) : # top-down method | __repr__ | identifier_name |
|
huff_algorithm.py | Dict = newDict
def SortedLeafGen(self):
for leaf_no in range(0, len(self.pSymbolsList_sorted)):
self.pBTLeafList.append(TBinTree_Leaf(self.pSymbolsList_sorted[leaf_no][0],self.pSymbolsList_sorted[leaf_no][1]))
self.LeafPopulation = len(self.pBTLeafList)
def DictPrint(self):
print ("\r\nIn total = %d" % self.pPopulation)
for key in range(self.S_LOW_VALUE, self.S_HIGH_VALUE+1):
if (self.pSymbolsDict.has_key(key)):
print "%.3d='%c' -> %.3f " % (key, key, self.pSymbolsDict[key], \
float(self.pSymbolsDict[key])/self.pPopulation )
def ListPrint(self):
print ("\r\nIn total = %d" % self.pPopulation)
for i in range(0,len(self.pSymbolsList_sorted)):
print("%.3d=%c : %.3f" % (self.pSymbolsList_sorted[i][0],self.pSymbolsList_sorted[i][0], \
self.pSymbolsList_sorted[i][1]))
self.pListString = self.pListString + ("%.3d='%c' : %.3f\n" % (self.pSymbolsList_sorted[i][0],self.pSymbolsList_sorted[i][0], \
self.pSymbolsList_sorted[i][1]))
def GetPopulation(self):
return self.pPopulation
def GetSortedList(self):
return self.pSymbolsList_sorted
def GetNodeList(self):
return self.pBTLeafList
def GetSourceEntropy(self):
Entropy = 0
temp = 0
for x in range(0,len(self.pSymbolsList_sorted)):
temp = self.pSymbolsList_sorted[x][1]
Entropy+= temp*np.log2(1.0/temp)
print temp
print "Source entropy:\t%f" % (Entropy)
return Entropy
class TBinTree_Tree:
def __init__(self, Leaves):
self.pPopulation = Leaves.GetPopulation()
self.LeavesList = Leaves.GetNodeList()
self.All_leaves = list()
self.All_edges = list()
self.CodeList = dict()
def __call__(self,option=None): #by default top-down method of defininf binary tree, if parameters is present- bottom-up
if (option==None):
self.root = fBinaryTreeBuilder(self.LeavesList, 0)
else :
self.root = fBinaryTreeBuilderBU(self.LeavesList, 0)
self.AvgCL = fMECalc(self.root)
def ShowBT(self):
fBinaryTreeNodeFinder(self.root)
def GraphGen(self):
#global graphen
print "Starting Source tree graph generation..."
fBinaryTreeNodeCartograph(self.root)
BTGraph.write_png('SourceTree.png')
print "Graph complete."
def CodingListGenerator(self):
global gCodingDict
print "Generating symbol coding list..."
fBinaryTreeNodeFinder(self.root,Action=1)
# print dictionary with symbol coding
dictKeys = gCodingDict.keys()
for x in range(0,len(gCodingDict)):
print "%02d)\'%c\' -> %s"% (x,dictKeys[x],gCodingDict[dictKeys[x]])
def CodeMessage(self,MessageContent, Action=None):
global gCodingDict
if (Action==None):
codedMsg = ""
print len(MessageContent)
for x in range(0,len(MessageContent)): #TODO try KeyError -> dictionary unspecified key handling - done
if (gCodingDict.has_key(ord(MessageContent[x]))==False):
return None
codedMsg = codedMsg + gCodingDict[ord(MessageContent[x])] + "|"
return codedMsg
elif (Action==1):
codedMsg = list()
for x in range(0,len(MessageContent)):
if (gCodingDict.has_key(ord(MessageContent[x]))==False):
return None
codedMsg.append(gCodingDict[ord(MessageContent[x])])
return codedMsg
def GetAvgCL(self):
return self.AvgCL
# @brief Decoding function as a method of Binary tree class which cooperates with indepednent
# fDecodeBit function which is repeteadly called until the end of coded message.
# Global variable which temporarly stores string is used.
# @param Encoded as a string.
def DecodeMessage(self,MessageContent):
print "Commencing message decoding..."
global gTempCodedMsg
gTempCodedMsg = "".join(MessageContent) #copy coded message string into global variable string for further manipulations
gTempCodedMsg = gTempCodedMsg.replace("|","")
#print gTempCodedMsg
tempString = ""
while (len(gTempCodedMsg)): #while there are bits of the coded message available run decoding of consecutive symbols in loop
symbol = fDecodeBit(self.root, gTempCodedMsg)
print symbol
tempString = tempString + chr(symbol) # concatanate character symbol to string
return tempString
print
global gTempCodedMsg
gTempCodedMsg = str()
# @brief Indepednent function which recursively calls itself to explore binary tree until Leaf is reached
# and proper symbol retrieved
# @param Current - strarting point for exploring.
# @param Piece of encoded message - the compass to navigate between branches.
def fDecodeBit(CurrentNode,CodedMsg):
global gTempCodedMsg
gTempCodedMsg = CodedMsg
if (CurrentNode.__class__.__name__ == 'TBinTree_Leaf'):
return CurrentNode.symbol
elif (CurrentNode.__class__.__name__ == 'TBinTree_Node'):
#if (len(CodedMsg)):
#print CodedMsg[0]
if (CodedMsg[0]=='0') :
return fDecodeBit(CurrentNode.b_zero, CodedMsg[1:])
elif (CodedMsg[0]=='1') :
return fDecodeBit(CurrentNode.b_one, CodedMsg[1:])
else :
print "DecodeError 2 Message!"
else:
print "DecodeError 1 Message!"
# @brief Indepednent function with implementation of suboptimal top-down method of source tree generation
# algorithm
# @param List of BTLeaves representing symbols sorted along probability
# @param Current level - codelength
def fBinaryTreeBuilder(LeavesList,Level) : # top-down method
print "Generating Soure tree implementing top-down algorithm."
leaves_in_list = len(LeavesList)
Population=0
print LeavesList
for i in LeavesList[:] :
Population+=i.prob
print("\tcounted pop=%d,nodes=%d\n" % (Population, leaves_in_list))
if ( leaves_in_list < 3 ) :
if (leaves_in_list == 0) :
print "ERROR!->leaf node empty"
return None
elif (leaves_in_list == 1) :
total_leaf_prob = LeavesList[0].prob
LeavesList[0].UpdateLvl(Level)
return LeavesList[0]
elif (leaves_in_list == 2) :
total_leaf_prob = LeavesList[0].prob + LeavesList[1].prob
LeavesList[0].UpdateLvl(Level+1)
LeavesList[1].UpdateLvl(Level+1)
NewBTNode = TBinTree_Node(total_leaf_prob,LeavesList[0], LeavesList[1], Level)
return NewBTNode
else :
tempPopulation = float(1.0)#Population
index = 0
prob_sum = 0
while ( 1 ) :
prob_sum = prob_sum + LeavesList[index].prob
if ( (prob_sum<(0.5*Population)) and (index<(leaves_in_list)-1) ) :
index = index + 1
else :
break
BinaryNodeZero = fBinaryTreeBuilder(LeavesList[:index], Level+1)
BinaryNodeOne = fBinaryTreeBuilder(LeavesList[index:], Level+1)
return TBinTree_Node( Population, BinaryNodeZero, BinaryNodeOne, Level)
# @brief Indepednent function with more efficient implementation of bottom-up method of source tree generation
# algorithm.
# @param List of BTLeaves representing symbols sorted along probability
# @param Current level - codelength
def fBinaryTreeBuilderBU(LeavesList,Level) : # bottom-up method
| print "Generating Soure tree implementing bottom-up algorithm."
print LeavesList.__class__.__name__
print LeavesList
while (len(LeavesList)>1):
for leafIndex in range(0,len(LeavesList)-1) :
if (LeavesList[leafIndex].prob>LeavesList[leafIndex+1].prob):
temp = LeavesList.pop(leafIndex)
LeavesList.insert(leafIndex+1, temp)
newNode = TBinTree_Node(LeavesList[0].prob+LeavesList[1].prob, LeavesList[0], LeavesList[1], 0)
LeavesList.insert(0, newNode)
LeavesList.pop(1)
LeavesList.pop(1)
fLvlUpdate(LeavesList[0],0)
return LeavesList[0] | identifier_body |
|
huff_algorithm.py | )\r\n" % (self.symbol,self.symbol,\
self.id,self.prob, self.lvl)
# @brief Binary tree leaf constructor specific class prototype contains symbol_val field and does
# not need any fields for descending nodes (dead end, None on default)
# @param Symbol value -> character which is represented by this node
# @param Symbol probability -> how many times the specific symbol occured in the sourcedata.
# @param Node level -> designated during BT generation (None on default).
class TBinTree_NodeGenerator:
# @brief
# @param Symbol value -> character which is represented by this node
def __init__(self, filedata): #constructor which accepts string as arg and uses it to generate dictionary to store input source data (arg -> filedata string
self.S_LOW_VALUE=32 #space
self.S_HIGH_VALUE=125 # }- character
self.pPopulation = 0 #total character count
#create empty list as property pBTLeafList -> for fresh data
self.pBTLeafList = list()
#create empty list as property pSymbolsList_sorted -> for sorted fresh data
self.pSymbolsList_sorted = list()
#create empty dictionary as property pSymbolsDict
self.pSymbolsDict = dict()
#fill list with symbol data (character with their probability)
for ascii_code in range(self.S_LOW_VALUE, self.S_HIGH_VALUE+1): # for every ASCII code from LOW_VALUE to HIGH_VALUE
x = filedata.count(chr(ascii_code)) # count number of characters in string
if (x>0) : # if character appears in string at least once
self.pSymbolsDict.update({ascii_code:x}) # put it into dictionary with ASCII code as key and no. of appearences as value
self.pPopulation +=x # all counted symbols are added to total source data population
self.pListString = str()
def SortData(self): # creates list by sorting symbols along probability |
def Pop2Prob(self): # takes total population into consideration and tranlates it into probability
for x in range(0,len(self.pSymbolsList_sorted)):
tempItem = list(self.pSymbolsList_sorted.pop(x))
tempItem[1]=float(tempItem[1])/self.pPopulation
print tempItem
self.pSymbolsList_sorted.insert(x,tempItem)
#self.pSymbolsList_sorted[x]=self.pSymbolsList_sorted[x]/self.pPopulation
print self.pSymbolsList_sorted
def setNewSymbolsDict(self, newDict):
self.pSymbolsDict = newDict
def SortedLeafGen(self):
for leaf_no in range(0, len(self.pSymbolsList_sorted)):
self.pBTLeafList.append(TBinTree_Leaf(self.pSymbolsList_sorted[leaf_no][0],self.pSymbolsList_sorted[leaf_no][1]))
self.LeafPopulation = len(self.pBTLeafList)
def DictPrint(self):
print ("\r\nIn total = %d" % self.pPopulation)
for key in range(self.S_LOW_VALUE, self.S_HIGH_VALUE+1):
if (self.pSymbolsDict.has_key(key)):
print "%.3d='%c' -> %.3f " % (key, key, self.pSymbolsDict[key], \
float(self.pSymbolsDict[key])/self.pPopulation )
def ListPrint(self):
print ("\r\nIn total = %d" % self.pPopulation)
for i in range(0,len(self.pSymbolsList_sorted)):
print("%.3d=%c : %.3f" % (self.pSymbolsList_sorted[i][0],self.pSymbolsList_sorted[i][0], \
self.pSymbolsList_sorted[i][1]))
self.pListString = self.pListString + ("%.3d='%c' : %.3f\n" % (self.pSymbolsList_sorted[i][0],self.pSymbolsList_sorted[i][0], \
self.pSymbolsList_sorted[i][1]))
def GetPopulation(self):
return self.pPopulation
def GetSortedList(self):
return self.pSymbolsList_sorted
def GetNodeList(self):
return self.pBTLeafList
def GetSourceEntropy(self):
Entropy = 0
temp = 0
for x in range(0,len(self.pSymbolsList_sorted)):
temp = self.pSymbolsList_sorted[x][1]
Entropy+= temp*np.log2(1.0/temp)
print temp
print "Source entropy:\t%f" % (Entropy)
return Entropy
class TBinTree_Tree:
def __init__(self, Leaves):
self.pPopulation = Leaves.GetPopulation()
self.LeavesList = Leaves.GetNodeList()
self.All_leaves = list()
self.All_edges = list()
self.CodeList = dict()
def __call__(self,option=None): #by default top-down method of defininf binary tree, if parameters is present- bottom-up
if (option==None):
self.root = fBinaryTreeBuilder(self.LeavesList, 0)
else :
self.root = fBinaryTreeBuilderBU(self.LeavesList, 0)
self.AvgCL = fMECalc(self.root)
def ShowBT(self):
fBinaryTreeNodeFinder(self.root)
def GraphGen(self):
#global graphen
print "Starting Source tree graph generation..."
fBinaryTreeNodeCartograph(self.root)
BTGraph.write_png('SourceTree.png')
print "Graph complete."
def CodingListGenerator(self):
global gCodingDict
print "Generating symbol coding list..."
fBinaryTreeNodeFinder(self.root,Action=1)
# print dictionary with symbol coding
dictKeys = gCodingDict.keys()
for x in range(0,len(gCodingDict)):
print "%02d)\'%c\' -> %s"% (x,dictKeys[x],gCodingDict[dictKeys[x]])
def CodeMessage(self,MessageContent, Action=None):
global gCodingDict
if (Action==None):
codedMsg = ""
print len(MessageContent)
for x in range(0,len(MessageContent)): #TODO try KeyError -> dictionary unspecified key handling - done
if (gCodingDict.has_key(ord(MessageContent[x]))==False):
return None
codedMsg = codedMsg + gCodingDict[ord(MessageContent[x])] + "|"
return codedMsg
elif (Action==1):
codedMsg = list()
for x in range(0,len(MessageContent)):
if (gCodingDict.has_key(ord(MessageContent[x]))==False):
return None
codedMsg.append(gCodingDict[ord(MessageContent[x])])
return codedMsg
def GetAvgCL(self):
return self.AvgCL
# @brief Decoding function as a method of Binary tree class which cooperates with indepednent
# fDecodeBit function which is repeteadly called until the end of coded message.
# Global variable which temporarly stores string is used.
# @param Encoded as a string.
def DecodeMessage(self,MessageContent):
print "Commencing message decoding..."
global gTempCodedMsg
gTempCodedMsg = "".join(MessageContent) #copy coded message string into global variable string for further manipulations
gTempCodedMsg = gTempCodedMsg.replace("|","")
#print gTempCodedMsg
tempString = ""
while (len(gTempCodedMsg)): #while there are bits of the coded message available run decoding of consecutive symbols in loop
symbol = fDecodeBit(self.root, gTempCodedMsg)
print symbol
tempString = tempString + chr(symbol) # concatanate character symbol to string
return tempString
print
global gTempCodedMsg
gTempCodedMsg = str()
# @brief Indepednent function which recursively calls itself to explore binary tree until Leaf is reached
# and proper symbol retrieved
# @param Current - strarting point for exploring.
# @param Piece of encoded message - the compass to navigate between branches.
def fDecodeBit(CurrentNode,CodedMsg):
global gTempCodedMsg
gTempCodedMsg = CodedMsg
if (CurrentNode.__class__.__name__ == 'TBinTree_Leaf'):
return CurrentNode.symbol
elif (CurrentNode.__class__.__name__ == 'TBinTree_Node'):
#if (len(CodedMsg)):
#print CodedMsg[0]
if (CodedMsg[0]=='0') :
return fDecodeBit(CurrentNode.b_zero, CodedMsg[1:])
elif (CodedMsg[0]=='1') :
return fDecodeBit(CurrentNode.b_one, CodedMsg[1:])
else :
print "DecodeError 2 Message!"
else:
print "DecodeError 1 Message!"
# @brief Indepednent function with implementation of suboptimal top-down method of source tree generation
# algorithm
# @param List of BTLeaves representing symbols sorted along probability
# @param Current level - codelength
def fBinaryTreeBuilder(LeavesList,Level) : # top-down method
print "Generating Soure tree implementing top-down algorithm."
leaves_in_list = len(LeavesList)
Population=0
print LeavesList
for i in LeavesList[:] :
Population+=i.prob
print("\tcounted pop=%d,nodes=%d\n" % (Population, leaves_in_list))
if ( | for key, value in sorted(self.pSymbolsDict.iteritems(), key=lambda (k,v): (v,k),reverse=False):
self.pSymbolsList_sorted.append((key,value)) | random_line_split |
huff_algorithm.py | r\n" % (self.symbol,self.symbol,\
self.id,self.prob, self.lvl)
# @brief Binary tree leaf constructor specific class prototype contains symbol_val field and does
# not need any fields for descending nodes (dead end, None on default)
# @param Symbol value -> character which is represented by this node
# @param Symbol probability -> how many times the specific symbol occured in the sourcedata.
# @param Node level -> designated during BT generation (None on default).
class TBinTree_NodeGenerator:
# @brief
# @param Symbol value -> character which is represented by this node
def __init__(self, filedata): #constructor which accepts string as arg and uses it to generate dictionary to store input source data (arg -> filedata string
self.S_LOW_VALUE=32 #space
self.S_HIGH_VALUE=125 # }- character
self.pPopulation = 0 #total character count
#create empty list as property pBTLeafList -> for fresh data
self.pBTLeafList = list()
#create empty list as property pSymbolsList_sorted -> for sorted fresh data
self.pSymbolsList_sorted = list()
#create empty dictionary as property pSymbolsDict
self.pSymbolsDict = dict()
#fill list with symbol data (character with their probability)
for ascii_code in range(self.S_LOW_VALUE, self.S_HIGH_VALUE+1): # for every ASCII code from LOW_VALUE to HIGH_VALUE
x = filedata.count(chr(ascii_code)) # count number of characters in string
if (x>0) : # if character appears in string at least once
self.pSymbolsDict.update({ascii_code:x}) # put it into dictionary with ASCII code as key and no. of appearences as value
self.pPopulation +=x # all counted symbols are added to total source data population
self.pListString = str()
def SortData(self): # creates list by sorting symbols along probability
for key, value in sorted(self.pSymbolsDict.iteritems(), key=lambda (k,v): (v,k),reverse=False):
self.pSymbolsList_sorted.append((key,value))
def Pop2Prob(self): # takes total population into consideration and tranlates it into probability
for x in range(0,len(self.pSymbolsList_sorted)):
tempItem = list(self.pSymbolsList_sorted.pop(x))
tempItem[1]=float(tempItem[1])/self.pPopulation
print tempItem
self.pSymbolsList_sorted.insert(x,tempItem)
#self.pSymbolsList_sorted[x]=self.pSymbolsList_sorted[x]/self.pPopulation
print self.pSymbolsList_sorted
def setNewSymbolsDict(self, newDict):
self.pSymbolsDict = newDict
def SortedLeafGen(self):
for leaf_no in range(0, len(self.pSymbolsList_sorted)):
self.pBTLeafList.append(TBinTree_Leaf(self.pSymbolsList_sorted[leaf_no][0],self.pSymbolsList_sorted[leaf_no][1]))
self.LeafPopulation = len(self.pBTLeafList)
def DictPrint(self):
print ("\r\nIn total = %d" % self.pPopulation)
for key in range(self.S_LOW_VALUE, self.S_HIGH_VALUE+1):
if (self.pSymbolsDict.has_key(key)):
print "%.3d='%c' -> %.3f " % (key, key, self.pSymbolsDict[key], \
float(self.pSymbolsDict[key])/self.pPopulation )
def ListPrint(self):
print ("\r\nIn total = %d" % self.pPopulation)
for i in range(0,len(self.pSymbolsList_sorted)):
print("%.3d=%c : %.3f" % (self.pSymbolsList_sorted[i][0],self.pSymbolsList_sorted[i][0], \
self.pSymbolsList_sorted[i][1]))
self.pListString = self.pListString + ("%.3d='%c' : %.3f\n" % (self.pSymbolsList_sorted[i][0],self.pSymbolsList_sorted[i][0], \
self.pSymbolsList_sorted[i][1]))
def GetPopulation(self):
return self.pPopulation
def GetSortedList(self):
return self.pSymbolsList_sorted
def GetNodeList(self):
return self.pBTLeafList
def GetSourceEntropy(self):
Entropy = 0
temp = 0
for x in range(0,len(self.pSymbolsList_sorted)):
temp = self.pSymbolsList_sorted[x][1]
Entropy+= temp*np.log2(1.0/temp)
print temp
print "Source entropy:\t%f" % (Entropy)
return Entropy
class TBinTree_Tree:
def __init__(self, Leaves):
self.pPopulation = Leaves.GetPopulation()
self.LeavesList = Leaves.GetNodeList()
self.All_leaves = list()
self.All_edges = list()
self.CodeList = dict()
def __call__(self,option=None): #by default top-down method of defininf binary tree, if parameters is present- bottom-up
if (option==None):
self.root = fBinaryTreeBuilder(self.LeavesList, 0)
else :
self.root = fBinaryTreeBuilderBU(self.LeavesList, 0)
self.AvgCL = fMECalc(self.root)
def ShowBT(self):
fBinaryTreeNodeFinder(self.root)
def GraphGen(self):
#global graphen
print "Starting Source tree graph generation..."
fBinaryTreeNodeCartograph(self.root)
BTGraph.write_png('SourceTree.png')
print "Graph complete."
def CodingListGenerator(self):
global gCodingDict
print "Generating symbol coding list..."
fBinaryTreeNodeFinder(self.root,Action=1)
# print dictionary with symbol coding
dictKeys = gCodingDict.keys()
for x in range(0,len(gCodingDict)):
print "%02d)\'%c\' -> %s"% (x,dictKeys[x],gCodingDict[dictKeys[x]])
def CodeMessage(self,MessageContent, Action=None):
global gCodingDict
if (Action==None):
codedMsg = ""
print len(MessageContent)
for x in range(0,len(MessageContent)): #TODO try KeyError -> dictionary unspecified key handling - done
if (gCodingDict.has_key(ord(MessageContent[x]))==False):
return None
codedMsg = codedMsg + gCodingDict[ord(MessageContent[x])] + "|"
return codedMsg
elif (Action==1):
codedMsg = list()
for x in range(0,len(MessageContent)):
if (gCodingDict.has_key(ord(MessageContent[x]))==False):
return None
codedMsg.append(gCodingDict[ord(MessageContent[x])])
return codedMsg
def GetAvgCL(self):
return self.AvgCL
# @brief Decoding function as a method of Binary tree class which cooperates with indepednent
# fDecodeBit function which is repeteadly called until the end of coded message.
# Global variable which temporarly stores string is used.
# @param Encoded as a string.
def DecodeMessage(self,MessageContent):
print "Commencing message decoding..."
global gTempCodedMsg
gTempCodedMsg = "".join(MessageContent) #copy coded message string into global variable string for further manipulations
gTempCodedMsg = gTempCodedMsg.replace("|","")
#print gTempCodedMsg
tempString = ""
while (len(gTempCodedMsg)): #while there are bits of the coded message available run decoding of consecutive symbols in loop
symbol = fDecodeBit(self.root, gTempCodedMsg)
print symbol
tempString = tempString + chr(symbol) # concatanate character symbol to string
return tempString
print
global gTempCodedMsg
gTempCodedMsg = str()
# @brief Indepednent function which recursively calls itself to explore binary tree until Leaf is reached
# and proper symbol retrieved
# @param Current - strarting point for exploring.
# @param Piece of encoded message - the compass to navigate between branches.
def fDecodeBit(CurrentNode,CodedMsg):
global gTempCodedMsg
gTempCodedMsg = CodedMsg
if (CurrentNode.__class__.__name__ == 'TBinTree_Leaf'):
return CurrentNode.symbol
elif (CurrentNode.__class__.__name__ == 'TBinTree_Node'):
#if (len(CodedMsg)):
#print CodedMsg[0]
if (CodedMsg[0]=='0') :
|
elif (CodedMsg[0]=='1') :
return fDecodeBit(CurrentNode.b_one, CodedMsg[1:])
else :
print "DecodeError 2 Message!"
else:
print "DecodeError 1 Message!"
# @brief Indepednent function with implementation of suboptimal top-down method of source tree generation
# algorithm
# @param List of BTLeaves representing symbols sorted along probability
# @param Current level - codelength
def fBinaryTreeBuilder(LeavesList,Level) : # top-down method
print "Generating Soure tree implementing top-down algorithm."
leaves_in_list = len(LeavesList)
Population=0
print LeavesList
for i in LeavesList[:] :
Population+=i.prob
print("\tcounted pop=%d,nodes=%d\n" % (Population, leaves_in_list))
if | return fDecodeBit(CurrentNode.b_zero, CodedMsg[1:]) | conditional_block |
rtc_api.rs | const COUNTA_HAPPENED = 0b0100_0000;
const WATCHA_HAPPENED = 0b1000_0000;
}
}
pub const ABRTCMC_CONTROL3: u8 = 0x02;
bitflags! {
pub struct Control3: u8 {
const BATTLOW_INT = 0b0000_0001;
const BATTSWITCH_INT = 0b0000_0010;
const BATTLOW_STAT = 0b0000_0100;
const BATTSW_HAPPENED = 0b0000_1000;
const BATT_STD_BL_EN = 0b0000_0000;
const BATT_DIR_BL_EN = 0b0010_0000;
const BATT_DIS_BL_EN = 0b0100_0000;
const BATT_STD_BL_DIS = 0b1000_0000;
const BATT_DIR_BL_DIS = 0b1010_0000;
const BATT_DI_BL_DIS = 0b1110_0000;
}
}
pub const ABRTCMC_SECONDS: u8 = 0x3;
bitflags! {
pub struct Seconds: u8 {
const SECONDS_BCD = 0b0111_1111;
const CORRUPTED = 0b1000_0000;
}
}
pub const ABRTCMC_MINUTES: u8 = 0x4;
// no bitflags, minutes are BCD whole register
pub const ABRTCMC_HOURS: u8 = 0x5;
bitflags! {
pub struct Hours: u8 {
const HR12_HOURS_BCD = 0b0001_1111;
const HR12_PM_FLAG = 0b0010_0000;
const HR24_HOURS_BCD = 0b0011_1111;
}
}
pub const ABRTCMC_DAYS: u8 = 0x6;
// no bitflags, days are BCD whole register
pub const ABRTCMC_WEEKDAYS: u8 = 0x7;
bitflags! {
pub struct Weekdays: u8 {
const SUNDAY = 0b000;
const MONDAY = 0b001;
const TUESDAY = 0b010;
const WEDNESDAY= 0b011;
const THURSDAY = 0b100;
const FRIDAY = 0b101;
const SATURDAY = 0b110;
}
}
pub const ABRTCMC_MONTHS: u8 = 0x8;
bitflags! {
pub struct Months: u8 { // BCD "months"
const JANUARY = 0b0_0001;
const FEBRUARY = 0b0_0010;
const MARCH = 0b0_0011;
const APRIL = 0b0_0100;
const MAY = 0b0_0101;
const JUNE = 0b0_0110;
const JULY = 0b0_0111;
const AUGUST = 0b0_1000;
const SEPTEMBER = 0b0_1001;
const OCTOBER = 0b1_0000;
const NOVEMBER = 0b1_0001;
const DECEMBER = 0b1_0010;
}
}
pub const ABRTCMC_YEARS: u8 = 0x9;
// no bitflags, years are 00-99 in BCD format
pub const ABRTCMC_MINUTE_ALARM: u8 = 0xA;
pub const ABRTCMC_HOUR_ALARM: u8 = 0xB;
pub const ABRTCMC_DAY_ALARM: u8 = 0xC;
pub const ABRTCMC_WEEKDAY_ALARM: u8 = 0xD;
bitflags! {
pub struct Alarm: u8 {
const ENABLE = 0b1000_0000;
// all others code minute/hour/day/weekday in BCD LSBs
const HR12_PM_FLAG = 0b0010_0000; // only used in hours alarm, 12-hour mode
}
}
pub const ABRTCMC_CONFIG: u8 = 0xF;
bitflags! {
pub struct Config: u8 {
const TIMER_B_ENABLE = 0b0000_0001;
const TIMER_A_WATCHDOG = 0b0000_0100;
const TIMER_A_COUNTDWN = 0b0000_0010;
const TIMER_A_DISABLE = 0b0000_0000;
const TIMER_A_DISABLE2 = 0b0000_0110;
const CLKOUT_32768_HZ = 0b0000_0000;
const CLKOUT_16384_HZ = 0b0000_1000;
const CLKOUT_8192_HZ = 0b0001_0000;
const CLKOUT_4096_HZ = 0b0001_1000;
const CLKOUT_1024_HZ = 0b0010_0000;
const CLKOUT_32_HZ = 0b0010_1000;
const CLKOUT_1_HZ = 0b0011_0000;
const CLKOUT_DISABLE = 0b0011_1000;
const TIMERB_INT_PULSED = 0b0100_0000;
const TIMERA_SECONDS_INT_PULSED = 0b1000_0000;
}
}
pub const ABRTCMC_TIMERA_CLK: u8 = 0x10;
pub const ABRTCMC_TIMERB_CLK: u8 = 0x12;
bitflags! {
pub struct TimerClk: u8 {
const CLK_3600_S = 0b0000_0100;
const CLK_60_S = 0b0000_0011;
const CLK_1_S = 0b0000_0010;
const CLK_64_HZ = 0b0000_0001; // 15.625ms
const CLK_4096_HZ = 0b0000_0000; // 0.2441ms
const PULSE_46_MS = 0b0000_0000;
const PULSE_62_MS = 0b0001_0000;
const PULSE_78_MS = 0b0010_0000;
const PULSE_93_MS = 0b0011_0000;
const PULSE_125_MS = 0b0100_0000;
const PULSE_156_MS = 0b0101_0000;
const PULSE_187_MS = 0b0110_0000;
const PULSE_218_MS = 0b0111_0000;
}
}
pub const ABRTCMC_TIMERA: u8 = 0x11;
// no bitflags, register is timer period in seconds, and the period is N / (source clock frequency)
pub const ABRTCMC_TIMERB: u8 = 0x13;
// no bitflags, register is timer period in seconds, and the period is N / (source clock frequency)
/// This function takes the raw &[u8] as returned by the RTC I2C low level read function
/// and converts it to a number of seconds. All hardware RTC readings are based off of the
/// BCD equivalent of Jan 1 2000, 00:00:00, but keep in mind this is just an internal representation.
/// We turn this into a u64 number of seconds because what we really want out of the hardware RTC
/// is _just_ a count of seconds from some arbitrary but fixed start point, that we anchor through other
/// algorithms to UTC.
pub fn | rtc_to_seconds | identifier_name |
|
rtc_api.rs | 000_0001;
const TIMER_A_WATCHDOG = 0b0000_0100;
const TIMER_A_COUNTDWN = 0b0000_0010;
const TIMER_A_DISABLE = 0b0000_0000;
const TIMER_A_DISABLE2 = 0b0000_0110;
const CLKOUT_32768_HZ = 0b0000_0000;
const CLKOUT_16384_HZ = 0b0000_1000;
const CLKOUT_8192_HZ = 0b0001_0000;
const CLKOUT_4096_HZ = 0b0001_1000;
const CLKOUT_1024_HZ = 0b0010_0000;
const CLKOUT_32_HZ = 0b0010_1000;
const CLKOUT_1_HZ = 0b0011_0000;
const CLKOUT_DISABLE = 0b0011_1000;
const TIMERB_INT_PULSED = 0b0100_0000;
const TIMERA_SECONDS_INT_PULSED = 0b1000_0000;
}
}
pub const ABRTCMC_TIMERA_CLK: u8 = 0x10;
pub const ABRTCMC_TIMERB_CLK: u8 = 0x12;
bitflags! {
pub struct TimerClk: u8 {
const CLK_3600_S = 0b0000_0100;
const CLK_60_S = 0b0000_0011;
const CLK_1_S = 0b0000_0010;
const CLK_64_HZ = 0b0000_0001; // 15.625ms
const CLK_4096_HZ = 0b0000_0000; // 0.2441ms
const PULSE_46_MS = 0b0000_0000;
const PULSE_62_MS = 0b0001_0000;
const PULSE_78_MS = 0b0010_0000;
const PULSE_93_MS = 0b0011_0000;
const PULSE_125_MS = 0b0100_0000;
const PULSE_156_MS = 0b0101_0000;
const PULSE_187_MS = 0b0110_0000;
const PULSE_218_MS = 0b0111_0000;
}
}
pub const ABRTCMC_TIMERA: u8 = 0x11;
// no bitflags, register is timer period in seconds, and the period is N / (source clock frequency)
pub const ABRTCMC_TIMERB: u8 = 0x13;
// no bitflags, register is timer period in seconds, and the period is N / (source clock frequency)
/// This function takes the raw &[u8] as returned by the RTC I2C low level read function
/// and converts it to a number of seconds. All hardware RTC readings are based off of the
/// BCD equivalent of Jan 1 2000, 00:00:00, but keep in mind this is just an internal representation.
/// We turn this into a u64 number of seconds because what we really want out of the hardware RTC
/// is _just_ a count of seconds from some arbitrary but fixed start point, that we anchor through other
/// algorithms to UTC.
pub fn rtc_to_seconds(settings: &[u8]) -> Option<u64> {
const CTL3: usize = 0;
const SECS: usize = 1;
const MINS: usize = 2;
const HOURS: usize = 3;
const DAYS: usize = 4;
// note 5 is skipped - this is weekdays, and is unused
const MONTHS: usize = 6;
const YEARS: usize = 7;
if ((settings[CTL3] & 0xE0) != crate::RTC_PWR_MODE) // power switchover setting should be initialized
|| (settings[SECS] & 0x80 != 0) { // clock integrity should be guaranteed
log::error!("RTC is in an uninitialized state!, {:x?}", settings);
return None;
}
// this is a secondary check -- I have seen RTC return nonsense time results before
// so this is an extra check above and beyond what's in the datasheet
if (to_binary(settings[SECS]) > 59)
|| (to_binary(settings[MINS]) > 59)
|| (to_binary(settings[HOURS]) > 23) // 24 hour mode is default and assumed
|| (to_binary(settings[DAYS]) > 31) || (to_binary(settings[DAYS]) == 0)
|| (to_binary(settings[MONTHS]) > 12) || (to_binary(settings[MONTHS]) == 0)
|| (to_binary(settings[YEARS]) > 99) {
log::error!("RTC has invalid digits!: {:?}", settings);
return None;
}
let mut total_secs: u64 = 0;
total_secs += to_binary(settings[SECS]) as u64;
total_secs += to_binary(settings[MINS]) as u64 * 60;
total_secs += to_binary(settings[HOURS]) as u64 * 3600;
const SECS_PER_DAY: u64 = 86400;
// DAYS is checked to be 1-31, so, it's safe to subtract 1 here
total_secs += (to_binary(settings[DAYS]) as u64 - 1) * SECS_PER_DAY;
// this will iterate from 0 through 11; december never has an offset added, because its contribution is directly measured in DAYS
for month in 0..to_binary(settings[MONTHS]) {
match month {
0 => total_secs += 0u64,
1 => total_secs += 31u64 * SECS_PER_DAY,
2 => {
// per spec sheet: 1) If the year counter contains a value which is exactly divisible by 4 (including the year 00),
// the AB-RTCMC-32.768kHz-B5ZE-S3 compensates for leap years by adding a 29th day to February.
if (to_binary(settings[YEARS]) % 4) == 0 {
total_secs += 29u64 * SECS_PER_DAY;
} else {
total_secs += 28u64 * SECS_PER_DAY;
};
},
3 => total_secs += 31u64 * SECS_PER_DAY,
4 => total_secs += 30u64 * SECS_PER_DAY,
5 => total_secs += 31u64 * SECS_PER_DAY,
6 => total_secs += 30u64 * SECS_PER_DAY,
7 => total_secs += 31u64 * SECS_PER_DAY,
8 => total_secs += 31u64 * SECS_PER_DAY,
9 => total_secs += 30u64 * SECS_PER_DAY,
10 => total_secs += 31u64 * SECS_PER_DAY,
11 => total_secs += 30u64 * SECS_PER_DAY,
// December shoud never be encountered in this loop since it's right-exclusive
_ => panic!("RTC code has an internal error, months encountered an 'impossible' value"),
}
}
// figure out what the last round multiple of leap years was before the current time
let last_leap = (to_binary(settings[YEARS]) - to_binary(settings[YEARS]) % 4) as u64;
// now add the contributions of all these prior years
total_secs += (last_leap / 4) * (365 * 3 + 366) * SECS_PER_DAY;
// now add the contributions of any years since the last round multiple of leap years
if to_binary(settings[YEARS]) % 4 != 0 {
// account for the leap year
total_secs += 366 * SECS_PER_DAY;
// now account for successive years
total_secs += 365 * (((to_binary(settings[YEARS]) % 4) - 1) as u64) * SECS_PER_DAY;
}
Some(total_secs) | } | random_line_split |
|
mod.rs | //! methods!
//!
//! Aside from the cognitive complexity of having so many methods on a single
//! trait, this approach had numerous other drawbacks as well:
//!
//! - Implementations that did not implement all available protocol extensions
//! still had to "pay" for the unused packet parsing/handler code, resulting
//! in substantial code bloat, even on `no_std` platforms.
//! - `GdbStub`'s internal implementation needed to include _runtime_ checks to
//! deal with incorrectly implemented `Target`s.
//! - No way to enforce "mutually-dependent" trait methods at compile-time.
//! - e.g: When implementing hardware breakpoint extensions, targets
//! _must_ implement both the `add_breakpoint` and
//! `remove_breakpoints` methods.
//! - No way to enforce "mutually-exclusive" trait methods at compile-time.
//! - e.g: The `resume` method for single-threaded targets has a much
//! simpler API than for multi-threaded targets, but it would be
//! incorrect for a target to implement both.
//!
//! At first blush, it seems the the solution to all these issues is obvious:
//! simply tie each protocol extension to a `cargo` feature! And yes, while
//! would would indeed work, there would be several serious ergonomic drawbacks:
//!
//! - There would be _hundreds_ of individual feature flags that would need to
//! be toggled by end users.
//! - It would be functionally impossible to _test_ all permutations of
//! enabled/disabled cargo features.
//! - A single binary would need to rely on some [non-trivial `cargo`-fu](https://github.com/rust-lang/cargo/issues/674)
//! in order to have multiple `Target` implementations in a single binary.
//!
//! After much experimentation and iteration, `gdbstub` ended up taking a
//! radically different approach to implementing and enumerating available
//! features, using a technique called **Inlineable Dyn Extension Traits**.
//!
//! > _Author's note:_ As far as I can tell, this isn't a very well-known trick,
//! or at the very least, I've personally never encountered any library that
//! uses this sort of API. As such, I've decided to be a bit cheeky and give it
//! a name! At some point, I'm hoping to write a standalone blog post which
//! further explores this technique, comparing it to other/existing approaches,
//! and diving into details of the how the compiler optimizes this sort of code.
//! In fact, I've already got a [very rough github repo](https://github.com/daniel5151/optional-trait-methods) with some of my
//! findings.
//!
//! So, what are "Inlineable Dyn Extension Traits"? Well, let's break it down:
//!
//! - **Extension Traits** - A common [Rust convention](https://rust-lang.github.io/rfcs/0445-extension-trait-conventions.html#what-is-an-extension-trait)
//! to extend the functionality of a Trait, _without_ modifying the original
//! trait.
//! - **Dyn** - Alludes to the use of Dynamic Dispatch via [Trait Objects](https://doc.rust-lang.org/book/ch17-02-trait-objects.html).
//! - **Inlineable** - Alludes to the fact that this approach can be easily
//! inlined, making it a truly zero-cost abstraction.
//!
//! In a nutshell, Inlineable Dyn Extension Traits (or IDETs) are an abuse of
//! the Rust trait system + modern compiler optimizations to emulate zero-cost,
//! runtime-enumerable optional trait methods!
//!
//! #### Technical overview
//!
//! The basic principles behind Inlineable Dyn Extension Traits are best
//! explained though example:
//!
//! Lets say we want to add an optional protocol extension described by an
//! `ProtocolExt` trait to a base `Protocol` trait. How would we do that using
//! IDETs?
//!
//! - (library) Define a `trait ProtocolExt: Protocol { ... }` which includes
//! all the methods required by the protocol extension:
//! - _Note:_ Making `ProtocolExt` a subtrait of `Protocol` is not strictly
//! required, but it does enable transparently using `Protocol`'s
//! associated types as part of `ProtocolExt`'s method definitions.
//!
//! ```rust,ignore
//! /// `foo` and `bar` are mutually-dependent methods.
//! trait ProtocolExt: Protocol {
//! fn foo(&self);
//! // can use associated types in method signature!
//! fn bar(&mut self) -> Result<(), Self::Error>;
//! }
//! ```
//!
//! - (library) "Associate" the `ProtocolExt` extension trait to the original
//! `Protocol` trait by adding a new `Protocol` method that "downcasts" `self`
//! into a `&mut dyn ProtocolExt`.
//!
//! ```rust,ignore
//! trait Protocol {
//! // ... other methods ...
//!
//! // Optional extension
//! #[inline(always)]
//! fn get_protocol_ext(&mut self) -> Option<ProtocolExtOps<Self>> {
//! // disabled by default
//! None
//! }
//!
//! // Mutually-exclusive extensions
//! fn get_ext_a_or_b(&mut self) -> EitherOrExt<Self::Arch, Self::Error>;
//! }
//!
//! // Using a typedef for readability
//! type ProtocolExtOps<T> =
//! &'a mut dyn ProtocolExt<Arch = <T as Protocol>::Arch, Error = <T as Protocol>::Error>;
//!
//! enum EitherOrExt<A, E> {
//! ProtocolExtA(&'a mut dyn ProtocolExtA<Arch = A, Error = E>),
//! ProtocolExtB(&'a mut dyn ProtocolExtB<Arch = A, Error = E>),
//! }
//! ```
//!
//! - (user) Implements the `ProtocolExt` extension for their target (just like
//! a normal trait).
//!
//! ```rust,ignore
//! impl ProtocolExt for MyTarget {
//! fn foo(&self) { ... }
//! fn bar(&mut self) -> Result<(), Self::Error> { ... }
//! }
//! ```
//!
//! - (user) Implements the base `Protocol` trait, overriding the
//! `get_protocol_ext` method to return `Some(self)`, which will effectively
//! "enable" the extension.
//!
//! ```rust,ignore
//! impl Protocol for MyTarget {
//! // Optional extension
//! #[inline(always)]
//! fn get_protocol_ext(&mut self) -> Option<ProtocolExtOps<Self>> {
//! Some(self) // will not compile unless `MyTarget` also implements `ProtocolExt`
//! }
//!
//! // Mutually-exclusive extensions
//! #[inline(always)]
//! fn get_ext_a_or_b(&mut self) -> EitherOrExt<Self::Arch, Self::Error> {
//! EitherOrExt::ProtocolExtA(self)
//! }
//! }
//! ```
//!
//! > Please note the use of `#[inline(always)]` when enabling IDET methods.
//! While LLVM is usually smart enough to inline single-level IDETs (such as in
//! the example above), nested IDETs will often require a bit of "help" from the
//! `inline` directive to be correctly optimized.
//!
//! Now, here's where IDETs really shine: If the user didn't implement
//! `ProtocolExt`, but _did_ try to enable the feature by overriding
//! `get_protocol_ext` to return `Some(self)`, they'll get a compile-time error
//! that looks something like this:
//!
//! ```text
//! error[E0277]: the trait bound `MyTarget: ProtocolExt` is not satisfied
//! --> path/to/implementation.rs:44:14
//! |
//! 44 | Some(self)
//! | ^^^^ the trait `ProtocolExt` is not implemented for `MyTarget`
//! |
//! = note: required for the cast to the object type `dyn ProtocolExt<Arch = ..., Error = ...>`
//! ```
//!
//! The Rust compiler is preventing you from enabling a feature you haven't
//! implemented _at compile time!_
//!
//! - (library) Is able to _query_ whether or not an extension is available,
//! _without_ having to actually invoke any method on the target!
//!
//! ```rust,ignore
//! fn execute_protocol(mut target: impl Target) {
//! match target.get_protocol_ext() {
//! Some(ops) => ops.foo(),
//! None => { /* fallback when not enabled */ }
//! }
//! }
//! ```
//!
//! This is already pretty cool, but what's _even cooler_ is that if you take a
//! look at the generated assembly of a monomorphized `execute_protocol` method
//! (e.g: using godbolt.org), you'll find that the compiler is able to
//! efficiently inline and devirtualize _all_ the calls to `get_protocol_ext`
//! method, which in-turn allows the dead-code-eliminator to work its magic, and
//! remove the unused branches from the generated code! i.e: If a target
//! implemention didn't implement the `ProtocolExt` extension, then that `match`
//! statement in `execute_protocol` would simply turn into a noop!
//!
//! If IDETs are something you're interested in, consider checking out
//! [daniel5151/optional-trait-methods](https | //! to the extreme, would have resulted in literally _hundreds_ of associated | random_line_split |
|
main.rs | gl_Position = scale * vec4(0.5 * a_Pos, 0.0, 1.0);
}
";
const FS_SHADER: &'static str = "
#version 150 core
in vec4 v_Color;
out vec4 Target0;
void main() {
Target0 = v_Color;
}
";
const VERTICES: &'static [[f32;2];3] = &[
[-1.0, -0.57],
[ 1.0, -0.57],
[ 0.0, 1.15]
];
const COLORS: &'static [[f32;3];3] = &[
[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 1.0]
];
fn add_shader(program: gl::GLuint, src: &str, ty: gl::GLenum) {
let id = unsafe { gl::CreateShader(ty) };
if id == (0 as gl::GLuint) {
panic!("Failed to create shader type: {:?}", ty);
}
let mut source = Vec::new();
source.extend_from_slice(src.as_bytes());
gl::shader_source(id, &[&source[..]]);
gl::compile_shader(id);
let log = gl::get_shader_info_log(id);
if gl::get_shader_iv(id, gl::COMPILE_STATUS) == (0 as gl::GLint) {
panic!("Failed to compile shader:\n{}", log);
} else {
if !log.is_empty() {
println!("Warnings detected on shader:\n{}", log);
}
gl::attach_shader(program, id);
}
}
fn compile_shaders(handles: &GlHandles) {
handles.program.set(gl::create_program());
if handles.program.get() == (0 as gl::GLuint) {
panic!("Failed to create shader program");
}
add_shader(handles.program.get(), VS_SHADER, gl::VERTEX_SHADER);
add_shader(handles.program.get(), FS_SHADER, gl::FRAGMENT_SHADER);
gl::link_program(handles.program.get());
if gl::get_program_iv(handles.program.get(), gl::LINK_STATUS) == (0 as gl::GLint) {
let error_log = gl::get_program_info_log(handles.program.get());
panic!("Failed to link shader program: \n{}", error_log);
}
gl::validate_program(handles.program.get());
if gl::get_program_iv(handles.program.get(), gl::VALIDATE_STATUS) == (0 as gl::GLint) {
let error_log = gl::get_program_info_log(handles.program.get());
panic!("Failed to validate shader program: \n{}", error_log);
}
gl::use_program(handles.program.get());
}
fn gl_draw(handles: &GlHandles) {
gl::clear_color(CLEAR_COLOR.0, CLEAR_COLOR.1, CLEAR_COLOR.2, CLEAR_COLOR.3);
gl::clear(gl::COLOR_BUFFER_BIT);
gl::bind_buffer(gl::ARRAY_BUFFER, handles.vbos.get()[0]);
gl::buffer_data(gl::ARRAY_BUFFER, VERTICES, gl::STATIC_DRAW);
gl::vertex_attrib_pointer(0 as gl::GLuint,
2,
gl::FLOAT,
false,
0 as gl::GLint,
0);
gl::enable_vertex_attrib_array(0 as gl::GLuint);
gl::bind_buffer(gl::ARRAY_BUFFER, handles.vbos.get()[1]);
gl::buffer_data(gl::ARRAY_BUFFER, COLORS, gl::STATIC_DRAW);
gl::vertex_attrib_pointer(1 as gl::GLuint,
3,
gl::FLOAT,
false,
0 as gl::GLint,
0);
gl::enable_vertex_attrib_array(1 as gl::GLuint);
handles.scale.set(handles.scale.get() + 0.01);
let scale = handles.scale.get();
let rot_matrix = [
scale.cos(), -1.0 * scale.sin(), 0.0, 0.0,
scale.sin(), scale.cos(), 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0
];
let scale_pos = gl::get_uniform_location(handles.program.get(), "scale");
gl::uniform_matrix_4fv(scale_pos, false, &rot_matrix);
gl::draw_arrays(gl::TRIANGLES, 0, 3);
}
pub fn main() {
gl::load_with(|s| GLContext::<NativeGLContext>::get_proc_address(s) as *const _);
let offscreen_ctx = GLContext::<NativeGLContext>::new(Size2D::new(256, 256),
GLContextAttributes::default(),
ColorAttachmentType::Renderbuffer,
None).unwrap();
offscreen_ctx.make_current().unwrap();
let handles: GlHandles = GlHandles::new();
// Create VAO and VBOs
handles.vao.set(gl::gen_vertex_arrays(1)[0]);
gl::bind_vertex_array(handles.vao.get());
let buffer_ids = gl::gen_buffers(2);
handles.vbos.set([buffer_ids[0], buffer_ids[1]]);
compile_shaders(&handles);
// Create FBO and bind it
let fbo = gl::gen_framebuffers(1)[0];
gl::bind_framebuffer(gl::FRAMEBUFFER, fbo);
let extensions = vulkano_win::required_extensions();
let instance = vulkano::instance::Instance::new(None, &extensions, &[]).expect("failed to create instance");
let physical = vulkano::instance::PhysicalDevice::enumerate(&instance)
.next().expect("no device available");
println!("Using device: {} (type: {:?})", physical.name(), physical.ty());
let window = winit::WindowBuilder::new().build_vk_surface(&instance).unwrap();
let queue = physical.queue_families().find(|q| q.supports_graphics() &&
window.surface().is_supported(q).unwrap_or(false))
.expect("couldn't find a graphical queue family");
let device_ext = vulkano::device::DeviceExtensions {
khr_swapchain: true,
.. vulkano::device::DeviceExtensions::none()
};
let (device, mut queues) = vulkano::device::Device::new(&physical, physical.supported_features(),
&device_ext, [(queue, 0.5)].iter().cloned())
.expect("failed to create device");
let queue = queues.next().unwrap();
let (swapchain, images) = {
let caps = window.surface().get_capabilities(&physical).expect("failed to get surface capabilities");
let dimensions = caps.current_extent.unwrap_or([WIN_WIDTH as u32, WIN_HEIGTH as u32]);
let present = caps.present_modes.iter().next().unwrap();
let usage = caps.supported_usage_flags;
vulkano::swapchain::Swapchain::new(&device, &window.surface(), caps.min_image_count,
vulkano::format::B8G8R8A8Srgb, dimensions, 1,
&usage, &queue, vulkano::swapchain::SurfaceTransform::Identity,
vulkano::swapchain::CompositeAlpha::Opaque,
present, true, None).expect("failed to create swapchain")
};
#[derive(Debug, Clone)]
struct Vertex { position: [f32; 2] }
impl_vertex!(Vertex, position);
let vertex_buffer = vulkano::buffer::cpu_access::CpuAccessibleBuffer::<[Vertex]>
::from_iter(&device, &vulkano::buffer::BufferUsage::all(),
Some(queue.family()), [
Vertex { position: [-0.5, -0.5 ] },
Vertex { position: [-0.5, 0.5 ] },
Vertex { position: [ 0.5, -0.5 ] },
Vertex { position: [ 0.5, 0.5 ] },
].iter().cloned()).expect("failed to create buffer");
mod vs { include!{concat!(env!("OUT_DIR"), "/shaders/src/shader/image_vs.glsl")} }
let vs = vs::Shader::load(&device).expect("failed to create shader module");
mod fs { include!{concat!(env!("OUT_DIR"), "/shaders/src/shader/image_fs.glsl")} }
let fs = fs::Shader::load(&device).expect("failed to create shader module");
mod renderpass {
single_pass_renderpass!{
attachments: {
color: {
load: Clear,
store: Store,
format: ::vulkano::format::B8G8R8A8Srgb,
}
},
pass: {
color: [color],
depth_stencil: {}
}
}
}
let renderpass = renderpass::CustomRenderPass::new(&device, &renderpass::Formats {
color: (vulkano::format::B8G8R8A8Srgb, 1)
}).unwrap();
let texture = vulkano::image::immutable::ImmutableImage::new(&device, vulkano::image:: | v_Color = vec4(a_Color, 1.0); | random_line_split |
|
main.rs | () -> GlHandles {
GlHandles {
vao: Cell::new(0 as gl::GLuint),
vbos: Cell::new([0,0]),
program: Cell::new(0 as gl::GLuint),
scale: Cell::new(0.0),
}
}
}
const CLEAR_COLOR: (f32, f32, f32, f32) = (0.0, 0.2, 0.3, 1.0);
const WIN_WIDTH: i32 = 256;
const WIN_HEIGTH: i32 = 256;
const VS_SHADER: &'static str = "
#version 150 core
in vec2 a_Pos;
in vec3 a_Color;
uniform mat4 scale;
out vec4 v_Color;
void main() {
v_Color = vec4(a_Color, 1.0);
gl_Position = scale * vec4(0.5 * a_Pos, 0.0, 1.0);
}
";
const FS_SHADER: &'static str = "
#version 150 core
in vec4 v_Color;
out vec4 Target0;
void main() {
Target0 = v_Color;
}
";
const VERTICES: &'static [[f32;2];3] = &[
[-1.0, -0.57],
[ 1.0, -0.57],
[ 0.0, 1.15]
];
const COLORS: &'static [[f32;3];3] = &[
[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 1.0]
];
fn add_shader(program: gl::GLuint, src: &str, ty: gl::GLenum) {
let id = unsafe { gl::CreateShader(ty) };
if id == (0 as gl::GLuint) {
panic!("Failed to create shader type: {:?}", ty);
}
let mut source = Vec::new();
source.extend_from_slice(src.as_bytes());
gl::shader_source(id, &[&source[..]]);
gl::compile_shader(id);
let log = gl::get_shader_info_log(id);
if gl::get_shader_iv(id, gl::COMPILE_STATUS) == (0 as gl::GLint) {
panic!("Failed to compile shader:\n{}", log);
} else {
if !log.is_empty() {
println!("Warnings detected on shader:\n{}", log);
}
gl::attach_shader(program, id);
}
}
fn compile_shaders(handles: &GlHandles) {
handles.program.set(gl::create_program());
if handles.program.get() == (0 as gl::GLuint) {
panic!("Failed to create shader program");
}
add_shader(handles.program.get(), VS_SHADER, gl::VERTEX_SHADER);
add_shader(handles.program.get(), FS_SHADER, gl::FRAGMENT_SHADER);
gl::link_program(handles.program.get());
if gl::get_program_iv(handles.program.get(), gl::LINK_STATUS) == (0 as gl::GLint) {
let error_log = gl::get_program_info_log(handles.program.get());
panic!("Failed to link shader program: \n{}", error_log);
}
gl::validate_program(handles.program.get());
if gl::get_program_iv(handles.program.get(), gl::VALIDATE_STATUS) == (0 as gl::GLint) {
let error_log = gl::get_program_info_log(handles.program.get());
panic!("Failed to validate shader program: \n{}", error_log);
}
gl::use_program(handles.program.get());
}
fn gl_draw(handles: &GlHandles) {
gl::clear_color(CLEAR_COLOR.0, CLEAR_COLOR.1, CLEAR_COLOR.2, CLEAR_COLOR.3);
gl::clear(gl::COLOR_BUFFER_BIT);
gl::bind_buffer(gl::ARRAY_BUFFER, handles.vbos.get()[0]);
gl::buffer_data(gl::ARRAY_BUFFER, VERTICES, gl::STATIC_DRAW);
gl::vertex_attrib_pointer(0 as gl::GLuint,
2,
gl::FLOAT,
false,
0 as gl::GLint,
0);
gl::enable_vertex_attrib_array(0 as gl::GLuint);
gl::bind_buffer(gl::ARRAY_BUFFER, handles.vbos.get()[1]);
gl::buffer_data(gl::ARRAY_BUFFER, COLORS, gl::STATIC_DRAW);
gl::vertex_attrib_pointer(1 as gl::GLuint,
3,
gl::FLOAT,
false,
0 as gl::GLint,
0);
gl::enable_vertex_attrib_array(1 as gl::GLuint);
handles.scale.set(handles.scale.get() + 0.01);
let scale = handles.scale.get();
let rot_matrix = [
scale.cos(), -1.0 * scale.sin(), 0.0, 0.0,
scale.sin(), scale.cos(), 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0
];
let scale_pos = gl::get_uniform_location(handles.program.get(), "scale");
gl::uniform_matrix_4fv(scale_pos, false, &rot_matrix);
gl::draw_arrays(gl::TRIANGLES, 0, 3);
}
pub fn main() {
gl::load_with(|s| GLContext::<NativeGLContext>::get_proc_address(s) as *const _);
let offscreen_ctx = GLContext::<NativeGLContext>::new(Size2D::new(256, 256),
GLContextAttributes::default(),
ColorAttachmentType::Renderbuffer,
None).unwrap();
offscreen_ctx.make_current().unwrap();
let handles: GlHandles = GlHandles::new();
// Create VAO and VBOs
handles.vao.set(gl::gen_vertex_arrays(1)[0]);
gl::bind_vertex_array(handles.vao.get());
let buffer_ids = gl::gen_buffers(2);
handles.vbos.set([buffer_ids[0], buffer_ids[1]]);
compile_shaders(&handles);
// Create FBO and bind it
let fbo = gl::gen_framebuffers(1)[0];
gl::bind_framebuffer(gl::FRAMEBUFFER, fbo);
let extensions = vulkano_win::required_extensions();
let instance = vulkano::instance::Instance::new(None, &extensions, &[]).expect("failed to create instance");
let physical = vulkano::instance::PhysicalDevice::enumerate(&instance)
.next().expect("no device available");
println!("Using device: {} (type: {:?})", physical.name(), physical.ty());
let window = winit::WindowBuilder::new().build_vk_surface(&instance).unwrap();
let queue = physical.queue_families().find(|q| q.supports_graphics() &&
window.surface().is_supported(q).unwrap_or(false))
.expect("couldn't find a graphical queue family");
let device_ext = vulkano::device::DeviceExtensions {
khr_swapchain: true,
.. vulkano::device::DeviceExtensions::none()
};
let (device, mut queues) = vulkano::device::Device::new(&physical, physical.supported_features(),
&device_ext, [(queue, 0.5)].iter().cloned())
.expect("failed to create device");
let queue = queues.next().unwrap();
let (swapchain, images) = {
let caps = window.surface().get_capabilities(&physical).expect("failed to get surface capabilities");
let dimensions = caps.current_extent.unwrap_or([WIN_WIDTH as u32, WIN_HEIGTH as u32]);
let present = caps.present_modes.iter().next().unwrap();
let usage = caps.supported_usage_flags;
vulkano::swapchain::Swapchain::new(&device, &window.surface(), caps.min_image_count,
vulkano::format::B8G8R8A8Srgb, dimensions, 1,
&usage, &queue, vulkano::swapchain::SurfaceTransform::Identity,
vulkano::swapchain::CompositeAlpha::Opaque,
present, true, None).expect("failed to create swapchain")
};
#[derive(Debug, Clone)]
struct Vertex { position: [f32; 2] }
impl_vertex!(Vertex, position);
let vertex_buffer = vulkano::buffer::cpu_access::CpuAccessibleBuffer::<[Vertex]>
::from_iter(&device, &vulkano::buffer::BufferUsage::all(),
Some(queue.family()), [
Vertex { position: [-0.5, -0.5 ] },
Vertex { position: [-0.5, 0.5 ] },
Vertex { position: [ 0.5, -0.5 ] },
Vertex { position: [ 0.5, 0.5 ] },
].iter().cloned()).expect("failed to create buffer");
mod vs { include!{concat!(env!("OUT_DIR"), "/shaders/src/shader/image_vs.glsl")} }
let vs = vs::Shader::load(&device).expect("failed to create shader module");
mod fs { include!{concat!(env!("OUT_DIR | new | identifier_name |
|
main.rs | = &[
[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 1.0]
];
fn add_shader(program: gl::GLuint, src: &str, ty: gl::GLenum) {
let id = unsafe { gl::CreateShader(ty) };
if id == (0 as gl::GLuint) {
panic!("Failed to create shader type: {:?}", ty);
}
let mut source = Vec::new();
source.extend_from_slice(src.as_bytes());
gl::shader_source(id, &[&source[..]]);
gl::compile_shader(id);
let log = gl::get_shader_info_log(id);
if gl::get_shader_iv(id, gl::COMPILE_STATUS) == (0 as gl::GLint) {
panic!("Failed to compile shader:\n{}", log);
} else |
}
fn compile_shaders(handles: &GlHandles) {
handles.program.set(gl::create_program());
if handles.program.get() == (0 as gl::GLuint) {
panic!("Failed to create shader program");
}
add_shader(handles.program.get(), VS_SHADER, gl::VERTEX_SHADER);
add_shader(handles.program.get(), FS_SHADER, gl::FRAGMENT_SHADER);
gl::link_program(handles.program.get());
if gl::get_program_iv(handles.program.get(), gl::LINK_STATUS) == (0 as gl::GLint) {
let error_log = gl::get_program_info_log(handles.program.get());
panic!("Failed to link shader program: \n{}", error_log);
}
gl::validate_program(handles.program.get());
if gl::get_program_iv(handles.program.get(), gl::VALIDATE_STATUS) == (0 as gl::GLint) {
let error_log = gl::get_program_info_log(handles.program.get());
panic!("Failed to validate shader program: \n{}", error_log);
}
gl::use_program(handles.program.get());
}
fn gl_draw(handles: &GlHandles) {
gl::clear_color(CLEAR_COLOR.0, CLEAR_COLOR.1, CLEAR_COLOR.2, CLEAR_COLOR.3);
gl::clear(gl::COLOR_BUFFER_BIT);
gl::bind_buffer(gl::ARRAY_BUFFER, handles.vbos.get()[0]);
gl::buffer_data(gl::ARRAY_BUFFER, VERTICES, gl::STATIC_DRAW);
gl::vertex_attrib_pointer(0 as gl::GLuint,
2,
gl::FLOAT,
false,
0 as gl::GLint,
0);
gl::enable_vertex_attrib_array(0 as gl::GLuint);
gl::bind_buffer(gl::ARRAY_BUFFER, handles.vbos.get()[1]);
gl::buffer_data(gl::ARRAY_BUFFER, COLORS, gl::STATIC_DRAW);
gl::vertex_attrib_pointer(1 as gl::GLuint,
3,
gl::FLOAT,
false,
0 as gl::GLint,
0);
gl::enable_vertex_attrib_array(1 as gl::GLuint);
handles.scale.set(handles.scale.get() + 0.01);
let scale = handles.scale.get();
let rot_matrix = [
scale.cos(), -1.0 * scale.sin(), 0.0, 0.0,
scale.sin(), scale.cos(), 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0
];
let scale_pos = gl::get_uniform_location(handles.program.get(), "scale");
gl::uniform_matrix_4fv(scale_pos, false, &rot_matrix);
gl::draw_arrays(gl::TRIANGLES, 0, 3);
}
pub fn main() {
gl::load_with(|s| GLContext::<NativeGLContext>::get_proc_address(s) as *const _);
let offscreen_ctx = GLContext::<NativeGLContext>::new(Size2D::new(256, 256),
GLContextAttributes::default(),
ColorAttachmentType::Renderbuffer,
None).unwrap();
offscreen_ctx.make_current().unwrap();
let handles: GlHandles = GlHandles::new();
// Create VAO and VBOs
handles.vao.set(gl::gen_vertex_arrays(1)[0]);
gl::bind_vertex_array(handles.vao.get());
let buffer_ids = gl::gen_buffers(2);
handles.vbos.set([buffer_ids[0], buffer_ids[1]]);
compile_shaders(&handles);
// Create FBO and bind it
let fbo = gl::gen_framebuffers(1)[0];
gl::bind_framebuffer(gl::FRAMEBUFFER, fbo);
let extensions = vulkano_win::required_extensions();
let instance = vulkano::instance::Instance::new(None, &extensions, &[]).expect("failed to create instance");
let physical = vulkano::instance::PhysicalDevice::enumerate(&instance)
.next().expect("no device available");
println!("Using device: {} (type: {:?})", physical.name(), physical.ty());
let window = winit::WindowBuilder::new().build_vk_surface(&instance).unwrap();
let queue = physical.queue_families().find(|q| q.supports_graphics() &&
window.surface().is_supported(q).unwrap_or(false))
.expect("couldn't find a graphical queue family");
let device_ext = vulkano::device::DeviceExtensions {
khr_swapchain: true,
.. vulkano::device::DeviceExtensions::none()
};
let (device, mut queues) = vulkano::device::Device::new(&physical, physical.supported_features(),
&device_ext, [(queue, 0.5)].iter().cloned())
.expect("failed to create device");
let queue = queues.next().unwrap();
let (swapchain, images) = {
let caps = window.surface().get_capabilities(&physical).expect("failed to get surface capabilities");
let dimensions = caps.current_extent.unwrap_or([WIN_WIDTH as u32, WIN_HEIGTH as u32]);
let present = caps.present_modes.iter().next().unwrap();
let usage = caps.supported_usage_flags;
vulkano::swapchain::Swapchain::new(&device, &window.surface(), caps.min_image_count,
vulkano::format::B8G8R8A8Srgb, dimensions, 1,
&usage, &queue, vulkano::swapchain::SurfaceTransform::Identity,
vulkano::swapchain::CompositeAlpha::Opaque,
present, true, None).expect("failed to create swapchain")
};
#[derive(Debug, Clone)]
struct Vertex { position: [f32; 2] }
impl_vertex!(Vertex, position);
let vertex_buffer = vulkano::buffer::cpu_access::CpuAccessibleBuffer::<[Vertex]>
::from_iter(&device, &vulkano::buffer::BufferUsage::all(),
Some(queue.family()), [
Vertex { position: [-0.5, -0.5 ] },
Vertex { position: [-0.5, 0.5 ] },
Vertex { position: [ 0.5, -0.5 ] },
Vertex { position: [ 0.5, 0.5 ] },
].iter().cloned()).expect("failed to create buffer");
mod vs { include!{concat!(env!("OUT_DIR"), "/shaders/src/shader/image_vs.glsl")} }
let vs = vs::Shader::load(&device).expect("failed to create shader module");
mod fs { include!{concat!(env!("OUT_DIR"), "/shaders/src/shader/image_fs.glsl")} }
let fs = fs::Shader::load(&device).expect("failed to create shader module");
mod renderpass {
single_pass_renderpass!{
attachments: {
color: {
load: Clear,
store: Store,
format: ::vulkano::format::B8G8R8A8Srgb,
}
},
pass: {
color: [color],
depth_stencil: {}
}
}
}
let renderpass = renderpass::CustomRenderPass::new(&device, &renderpass::Formats {
color: (vulkano::format::B8G8R8A8Srgb, 1)
}).unwrap();
let texture = vulkano::image::immutable::ImmutableImage::new(&device, vulkano::image::Dimensions::Dim2d { width: WIN_WIDTH as u32, height: WIN_HEIGTH as u32 },
vulkano::format::R8G8B8A8Unorm, Some(queue.family())).unwrap();
let sampler = vulkano::sampler::Sampler::new(&device, vulkano::sampler::Filter::Linear,
vulkano::sampler::Filter::Linear, vulkano::sampler::MipmapMode::Nearest,
vulkano::sampler::SamplerAddressMode::Repeat,
vulkano::sampler::SamplerAddressMode::Repeat,
vulkano::sampler::SamplerAddressMode::Repeat,
0.0, 1.0, 0.0, | {
if !log.is_empty() {
println!("Warnings detected on shader:\n{}", log);
}
gl::attach_shader(program, id);
} | conditional_block |
main.go | : in6dest,
In6Plen: uint(64), Rt6Dest: rt6dest, Rt6Plen: uint(64)}
event(logdebug, li, "Session [%v] deactivation parameters: [Interface "+
"name: %v, Tunnel source: %v, Tunnel destination: %v, Server "+
"inet6 address: %v/64, Client inet6 address: %v/64, Routed "+
"prefix: %v/64]", e.Id, ifname, app.SvInfo.TunSrc, e.Opt,
in6addr, in6dest, rt6dest)
var si []Id
if err = deactivateSession(s); err != nil {
si = []Id{Id{ErrNo: EINVAL}}
event(logwarn, li, err.Error())
} else {
si = []Id{Id{}}
}
var buf, _ = json.Marshal(&IdList{Entry: si})
sendResponse(w, &Msg{Data: string(buf)})
return nil
}
func check(w http.ResponseWriter, d *RequestMsg) (err error) {
stat.ReqCheck++
var m *IdList
if m, err = getIdList(d.Data, d.Command); err != nil {
stat.ReqErrCheck++
return
}
var e = m.Entry[0]
if e.Id == 0 {
stat.ReqErrCheck++
return
}
var ipf int
if ipf, err = checkIPFamily(e.Opt); ipf != 4 {
stat.ReqErrCheck++
return
}
var pp = strings.Split(app.SvInfo.PpPrefix, "::/")
//var ip6s = fmt.Sprintf("%v:%v::1", pp[0], e.Id)
var ip6c = fmt.Sprintf("%v:%v::2", pp[0], e.Id)
var si = make([]Id, 2)
for i := range si {
var dst = e.Opt
var udp = "udp4"
if i == 1 {
udp = "udp6"
dst = ip6c
}
if rtt, tgt, err := pingSession(dst, udp); err != nil {
si[i] = Id{ErrNo: EINVAL, Opt: tgt}
event(logwarn, li, err.Error())
} else {
si[i] = Id{Id: int64(rtt), Opt: tgt}
}
}
var buf, _ = json.Marshal(&IdList{Entry: si})
sendResponse(w, &Msg{Data: string(buf)})
return nil
}
func status(w http.ResponseWriter, d *RequestMsg) (err error) {
stat.ReqStatus++
var buf, _ = json.Marshal(&stat)
sendResponse(w, &Msg{Data: string(buf)})
return
}
func serverInfo() (err error) {
var data = &RebanaRequestMsg{UserId: 102, Command: "server-info",
Data: app.HostName}
var buf, _ = json.Marshal(data)
var url = app.RebanaUrl + "/v/info"
var rd = bytes.NewReader(buf)
var req *http.Request
if req, err = http.NewRequest("POST", url, rd); err != nil {
return
}
var loc = &time.Location{}
if loc, err = time.LoadLocation("Etc/GMT"); err != nil {
return
}
req.Header.Add("Date", time.Now().In(loc).Format(time.RFC1123))
req.Header.Add("Accept", "application/json")
req.Header.Add("Content-Type", "application/json")
req.Header.Add("X-N3-Service-Name", "rebana")
req.Header.Add("X-N3-Tunnel-Server", app.HostName)
req.Header.Add("X-N3-Signature", signRequest(buf, 0))
var c = &http.Client{}
c.Transport = &http.Transport{TLSClientConfig: tlsc}
var res *http.Response
if res, err = c.Do(req); err != nil {
return
}
defer res.Body.Close()
var t time.Time
if t, err = checkResponseHeader(res); err != nil {
return
}
var msg = &RebanaMsg{}
if err = json.NewDecoder(res.Body).Decode(msg); err != nil {
return
}
var sig = res.Header.Get("X-N3-Signature")
buf, _ = json.Marshal(msg)
if err = checkSignature(sig, buf); err != nil {
stat.ReqErrSignature++
return
}
if msg.ErrNo != EOK {
return errors.New(msg.Data)
}
var sv = &ServerInfo{}
if err = json.Unmarshal([]byte(msg.Data), sv); err != nil {
return
}
var ipf int
if ipf, err = checkIPFamily(sv.TunSrc); ipf != 4 {
return
}
if !strings.Contains(sv.PpPrefix, "::/48") ||
!strings.Contains(sv.RtPrefix, "::/48") {
return
}
app.SvInfo = &ServerInfo{}
app.SvInfo.Id = sv.Id
app.SvInfo.TunSrc = sv.TunSrc
app.SvInfo.PpPrefix = sv.PpPrefix
app.SvInfo.RtPrefix = sv.RtPrefix
app.SvInfo.Session = sv.Session
var sl = "Active tunnel session(s): "
for i := range sv.Session {
var e = sv.Session[i]
var sa = fmt.Sprintf("%v[%v]", e.Id, e.Dst)
sl += sa
if i < (len(sv.Session) - 1) {
sl += ", "
}
}
var ts = t.In(time.Local).Format(time.RFC1123)
event(logdebug, li, "Server information retrieved: "+
"[Timestamp: %v, Server name: %v[%v], "+
"Tunnel source address: %v, "+
"Tunnel point-to-point prefix: %v, "+
"Tunnel routed prefix: %v, Active tunnel sessions: %v]",
ts, app.HostName, sv.Id, sv.TunSrc, sv.PpPrefix, sv.RtPrefix,
len(sv.Session))
return
}
func defaultHandler(w http.ResponseWriter, r *http.Request) {
stat.ReqAll++
var err error
var str = "Invalid request"
if err = checkUrl(r); err != nil {
stat.ReqErrHeader++
sendError(w, EINVAL, str, err)
return
}
if err = checkHeader(r); err != nil {
stat.ReqErrHeader++
sendError(w, EINVAL, str, err)
return
}
var d *RequestMsg
if d, err = checkData(r); err != nil {
stat.ReqErrPayload++
sendError(w, EINVAL, str, err)
return
}
event(logdebug, li, "Processing request [%v:%v]", d.Command, d.MsgId)
switch d.Command {
case "activate":
err = activate(w, d)
case "deactivate":
err = deactivate(w, d)
case "check":
err = check(w, d)
case "status":
err = status(w, d)
}
if err != nil {
str += ": " + d.Command
sendError(w, EINVAL, str, err)
return
}
event(logdebug, li, "Request [%v:%v] completed", d.Command, d.MsgId)
}
func main() {
var help, debug bool
var conf string
flag.BoolVar(&debug, "d", false, "Debug mode")
flag.BoolVar(&help, "h", false, "Display usage")
flag.StringVar(&conf, "c", CONFFILE, "Configuration file")
flag.Parse()
if help {
usage()
}
app = &AppConfig{ProgName: APPNAME, Version: APPVER, Pid: os.Getpid()}
stat = &AppStat{HostName: app.HostName}
var err error
if err = parseConfig(conf); err != nil {
fatal(err.Error())
}
if err = setupLog(debug); err != nil {
fatal(err.Error())
}
go sigHandler()
event(loginfo, li, "%v-%v server started: %v", app.ProgName, app.Version,
app.HostName)
if err = setupServer(); err != nil {
fatal(err.Error())
}
if err = serverInfo(); err != nil {
fatal(err.Error())
}
var pid = fmt.Sprintf("%v", app.Pid)
if err = ioutil.WriteFile(PIDFILE, []byte(pid), 0644); err != nil {
fatal(err.Error())
}
select {}
}
func sigHandler() {
var quit bool
var c = make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)
var signal = <-c
event(lognotice, li, "Signal received: "+signal.String())
switch signal {
case syscall.SIGINT, syscall.SIGTERM:
quit = true
}
if quit {
event(lognotice, li, "Terminating..")
os.Remove(PIDFILE)
os.Exit(0)
}
}
func usage() | {
var str = fmt.Sprintf("%v-%v\nusage: %v [-d] [-h] [-c config file]\n",
APPNAME, APPVER, APPNAME)
fmt.Fprintf(os.Stderr, str)
os.Exit(1)
} | identifier_body |
|
main.go | 64
ReqError int64
ReqErrUrl int64
ReqErrHeader int64
ReqErrPayload int64
ReqErrSignature int64
ReqErrServerId int64
ReqErrUserId int64
ReqErrMsgId int64
ReqErrCommand int64
ReqErrData int64
ReqErrActivate int64
ReqErrDeactivate int64
ReqErrCheck int64
ReqErrStatus int64
}
const (
APPNAME = "rebanats"
APPVER = "1.0.0"
PIDFILE = "/var/run/rebanats.pid"
CONFFILE = "/usr/local/etc/rebanats.json"
// error codes
EOK = 0
EINVAL = 1
EAGAIN = 2
ENOENT = 3
)
var (
app *AppConfig
stat *AppStat
tlsc *tls.Config
)
func activate(w http.ResponseWriter, d *RequestMsg) (err error) {
stat.ReqActivate++
var m *IdList
if m, err = getIdList(d.Data, d.Command); err != nil {
stat.ReqErrActivate++
return
}
var e = m.Entry[0]
if e.Id == 0 {
stat.ReqErrActivate++
return
}
var ipf int
if ipf, err = checkIPFamily(e.Opt); ipf != 4 {
stat.ReqErrActivate++
return
}
var pp = strings.Split(app.SvInfo.PpPrefix, "::/")
var rt = strings.Split(app.SvInfo.RtPrefix, "::/")
var ifname = fmt.Sprintf("gif%v", e.Id)
var in6addr = fmt.Sprintf("%v:%v::1", pp[0], e.Id)
var in6dest = fmt.Sprintf("%v:%v::2", pp[0], e.Id)
var rt6dest = fmt.Sprintf("%v:%v::", rt[0], e.Id)
var s = &CSession{Ifname: ifname, TunAddr: app.SvInfo.TunSrc,
TunDest: e.Opt, In6Addr: in6addr, In6Dest: in6dest,
In6Plen: uint(64), Rt6Dest: rt6dest, Rt6Plen: uint(64)}
event(logdebug, li, "Session [%v] activation parameters: [Interface "+
"name: %v, Tunnel source: %v, Tunnel destination: %v, Server "+
"inet6 address: %v/64, Client inet6 address: %v/64, Routed "+
"prefix: %v/64]", e.Id, ifname, app.SvInfo.TunSrc, e.Opt,
in6addr, in6dest, rt6dest)
var si []Id
if err = activateSession(s); err != nil {
si = []Id{Id{ErrNo: EINVAL}}
event(logwarn, li, err.Error())
} else {
si = []Id{Id{}}
}
var buf, _ = json.Marshal(&IdList{Entry: si})
sendResponse(w, &Msg{Data: string(buf)})
return nil
}
func deactivate(w http.ResponseWriter, d *RequestMsg) (err error) {
stat.ReqDeactivate++
var m *IdList
if m, err = getIdList(d.Data, d.Command); err != nil {
stat.ReqErrDeactivate++
return
}
var e = m.Entry[0]
if e.Id == 0 {
stat.ReqErrDeactivate++
return
}
var ipf int
if ipf, err = checkIPFamily(e.Opt); ipf != 4 {
stat.ReqErrDeactivate++
return
}
var pp = strings.Split(app.SvInfo.PpPrefix, "::/")
var rt = strings.Split(app.SvInfo.RtPrefix, "::/")
var ifname = fmt.Sprintf("gif%v", e.Id)
var in6addr = fmt.Sprintf("%v:%v::1", pp[0], e.Id)
var in6dest = fmt.Sprintf("%v:%v::2", pp[0], e.Id)
var rt6dest = fmt.Sprintf("%v:%v::", rt[0], e.Id)
var s = &CSession{Ifname: ifname, TunAddr: app.SvInfo.TunSrc,
TunDest: e.Opt, In6Addr: in6addr, In6Dest: in6dest,
In6Plen: uint(64), Rt6Dest: rt6dest, Rt6Plen: uint(64)}
event(logdebug, li, "Session [%v] deactivation parameters: [Interface "+
"name: %v, Tunnel source: %v, Tunnel destination: %v, Server "+
"inet6 address: %v/64, Client inet6 address: %v/64, Routed "+
"prefix: %v/64]", e.Id, ifname, app.SvInfo.TunSrc, e.Opt,
in6addr, in6dest, rt6dest)
var si []Id
if err = deactivateSession(s); err != nil {
si = []Id{Id{ErrNo: EINVAL}}
event(logwarn, li, err.Error())
} else {
si = []Id{Id{}}
}
var buf, _ = json.Marshal(&IdList{Entry: si})
sendResponse(w, &Msg{Data: string(buf)})
return nil
}
func check(w http.ResponseWriter, d *RequestMsg) (err error) {
stat.ReqCheck++
var m *IdList
if m, err = getIdList(d.Data, d.Command); err != nil {
stat.ReqErrCheck++
return
}
var e = m.Entry[0]
if e.Id == 0 {
stat.ReqErrCheck++
return
}
var ipf int
if ipf, err = checkIPFamily(e.Opt); ipf != 4 {
stat.ReqErrCheck++
return
}
var pp = strings.Split(app.SvInfo.PpPrefix, "::/")
//var ip6s = fmt.Sprintf("%v:%v::1", pp[0], e.Id)
var ip6c = fmt.Sprintf("%v:%v::2", pp[0], e.Id)
var si = make([]Id, 2)
for i := range si {
var dst = e.Opt
var udp = "udp4"
if i == 1 {
udp = "udp6"
dst = ip6c
}
if rtt, tgt, err := pingSession(dst, udp); err != nil {
si[i] = Id{ErrNo: EINVAL, Opt: tgt}
event(logwarn, li, err.Error())
} else {
si[i] = Id{Id: int64(rtt), Opt: tgt}
}
}
var buf, _ = json.Marshal(&IdList{Entry: si})
sendResponse(w, &Msg{Data: string(buf)})
return nil
}
func status(w http.ResponseWriter, d *RequestMsg) (err error) {
stat.ReqStatus++
var buf, _ = json.Marshal(&stat)
sendResponse(w, &Msg{Data: string(buf)})
return
}
func | () (err error) {
var data = &RebanaRequestMsg{UserId: 102, Command: "server-info",
Data: app.HostName}
var buf, _ = json.Marshal(data)
var url = app.RebanaUrl + "/v/info"
var rd = bytes.NewReader(buf)
var req *http.Request
if req, err = http.NewRequest("POST", url, rd); err != nil {
return
}
var loc = &time.Location{}
if loc, err = time.LoadLocation("Etc/GMT"); err != nil {
return
}
req.Header.Add("Date", time.Now().In(loc).Format(time.RFC1123))
req.Header.Add("Accept", "application/json")
req.Header.Add("Content-Type", "application/json")
req.Header.Add("X-N3-Service-Name", "rebana")
req.Header.Add("X-N3-Tunnel-Server", app.HostName)
req.Header.Add("X-N3-Signature", signRequest(buf, 0))
var c = &http.Client{}
c.Transport = &http.Transport{TLSClientConfig: tlsc}
var res *http.Response
if res, err = c.Do(req); err != nil {
return
}
defer res.Body.Close()
var t time.Time
if t, err = checkResponseHeader(res); err != nil {
return
}
var msg = &RebanaMsg{}
if err = json.NewDecoder(res.Body).Decode(msg); err != nil {
return
}
var sig = res.Header.Get("X-N3-Signature")
buf, _ = json.Marshal(msg)
if err = checkSignature(sig, buf); err != nil {
stat.ReqErrSignature++
return
}
if msg.ErrNo != EOK {
return errors.New(msg.Data)
}
var sv = &ServerInfo{}
if err = json.Unmarshal([]byte(msg.Data), sv); err != nil {
return
}
var ipf int
if ipf, | serverInfo | identifier_name |
main.go | Opt string
}
type IdList struct {
Id int64
Entry []Id
}
type ServerInfo struct {
Id int64
TunSrc string
PpPrefix string
RtPrefix string
Session []Session
}
type Session struct {
Id int64
Dst string
Idx int64
}
type BindInfo struct {
Host string
Port string
}
type AppConfig struct {
HostName string `json:"ServerName"`
ProgName string
Version string
Pid int
Bind []BindInfo
RebanaUrl string
LogUrl string
Secret string
TLSCACert []string `json:"TLSCACert"`
SvInfo *ServerInfo
}
type AppStat struct {
HostName string
ReqAll int64
ReqActivate int64
ReqDeactivate int64
ReqCheck int64
ReqStatus int64
ReqError int64
ReqErrUrl int64
ReqErrHeader int64
ReqErrPayload int64
ReqErrSignature int64
ReqErrServerId int64
ReqErrUserId int64
ReqErrMsgId int64
ReqErrCommand int64
ReqErrData int64
ReqErrActivate int64
ReqErrDeactivate int64
ReqErrCheck int64
ReqErrStatus int64
}
const (
APPNAME = "rebanats"
APPVER = "1.0.0"
PIDFILE = "/var/run/rebanats.pid"
CONFFILE = "/usr/local/etc/rebanats.json"
// error codes
EOK = 0
EINVAL = 1
EAGAIN = 2
ENOENT = 3
)
var (
app *AppConfig
stat *AppStat
tlsc *tls.Config
)
func activate(w http.ResponseWriter, d *RequestMsg) (err error) {
stat.ReqActivate++
var m *IdList
if m, err = getIdList(d.Data, d.Command); err != nil {
stat.ReqErrActivate++
return
}
var e = m.Entry[0]
if e.Id == 0 {
stat.ReqErrActivate++
return
}
var ipf int
if ipf, err = checkIPFamily(e.Opt); ipf != 4 {
stat.ReqErrActivate++
return
}
var pp = strings.Split(app.SvInfo.PpPrefix, "::/")
var rt = strings.Split(app.SvInfo.RtPrefix, "::/")
var ifname = fmt.Sprintf("gif%v", e.Id)
var in6addr = fmt.Sprintf("%v:%v::1", pp[0], e.Id)
var in6dest = fmt.Sprintf("%v:%v::2", pp[0], e.Id)
var rt6dest = fmt.Sprintf("%v:%v::", rt[0], e.Id)
var s = &CSession{Ifname: ifname, TunAddr: app.SvInfo.TunSrc,
TunDest: e.Opt, In6Addr: in6addr, In6Dest: in6dest,
In6Plen: uint(64), Rt6Dest: rt6dest, Rt6Plen: uint(64)}
event(logdebug, li, "Session [%v] activation parameters: [Interface "+
"name: %v, Tunnel source: %v, Tunnel destination: %v, Server "+
"inet6 address: %v/64, Client inet6 address: %v/64, Routed "+
"prefix: %v/64]", e.Id, ifname, app.SvInfo.TunSrc, e.Opt,
in6addr, in6dest, rt6dest)
var si []Id
if err = activateSession(s); err != nil {
si = []Id{Id{ErrNo: EINVAL}}
event(logwarn, li, err.Error())
} else {
si = []Id{Id{}}
}
var buf, _ = json.Marshal(&IdList{Entry: si})
sendResponse(w, &Msg{Data: string(buf)})
return nil
}
func deactivate(w http.ResponseWriter, d *RequestMsg) (err error) {
stat.ReqDeactivate++
var m *IdList
if m, err = getIdList(d.Data, d.Command); err != nil {
stat.ReqErrDeactivate++
return
}
var e = m.Entry[0]
if e.Id == 0 {
stat.ReqErrDeactivate++
return
}
var ipf int
if ipf, err = checkIPFamily(e.Opt); ipf != 4 {
stat.ReqErrDeactivate++
return
}
var pp = strings.Split(app.SvInfo.PpPrefix, "::/")
var rt = strings.Split(app.SvInfo.RtPrefix, "::/")
var ifname = fmt.Sprintf("gif%v", e.Id)
var in6addr = fmt.Sprintf("%v:%v::1", pp[0], e.Id)
var in6dest = fmt.Sprintf("%v:%v::2", pp[0], e.Id)
var rt6dest = fmt.Sprintf("%v:%v::", rt[0], e.Id)
var s = &CSession{Ifname: ifname, TunAddr: app.SvInfo.TunSrc,
TunDest: e.Opt, In6Addr: in6addr, In6Dest: in6dest,
In6Plen: uint(64), Rt6Dest: rt6dest, Rt6Plen: uint(64)}
event(logdebug, li, "Session [%v] deactivation parameters: [Interface "+
"name: %v, Tunnel source: %v, Tunnel destination: %v, Server "+
"inet6 address: %v/64, Client inet6 address: %v/64, Routed "+
"prefix: %v/64]", e.Id, ifname, app.SvInfo.TunSrc, e.Opt,
in6addr, in6dest, rt6dest)
var si []Id
if err = deactivateSession(s); err != nil {
si = []Id{Id{ErrNo: EINVAL}}
event(logwarn, li, err.Error())
} else {
si = []Id{Id{}}
}
var buf, _ = json.Marshal(&IdList{Entry: si})
sendResponse(w, &Msg{Data: string(buf)})
return nil
}
func check(w http.ResponseWriter, d *RequestMsg) (err error) {
stat.ReqCheck++
var m *IdList
if m, err = getIdList(d.Data, d.Command); err != nil {
stat.ReqErrCheck++
return
}
var e = m.Entry[0]
if e.Id == 0 {
stat.ReqErrCheck++
return
}
var ipf int
if ipf, err = checkIPFamily(e.Opt); ipf != 4 {
stat.ReqErrCheck++
return
}
var pp = strings.Split(app.SvInfo.PpPrefix, "::/")
//var ip6s = fmt.Sprintf("%v:%v::1", pp[0], e.Id)
var ip6c = fmt.Sprintf("%v:%v::2", pp[0], e.Id)
var si = make([]Id, 2)
for i := range si {
var dst = e.Opt
var udp = "udp4"
if i == 1 {
udp = "udp6"
dst = ip6c
}
if rtt, tgt, err := pingSession(dst, udp); err != nil {
si[i] = Id{ErrNo: EINVAL, Opt: tgt}
event(logwarn, li, err.Error())
} else {
si[i] = Id{Id: int64(rtt), Opt: tgt}
}
}
var buf, _ = json.Marshal(&IdList{Entry: si})
sendResponse(w, &Msg{Data: string(buf)})
return nil
}
func status(w http.ResponseWriter, d *RequestMsg) (err error) {
stat.ReqStatus++
var buf, _ = json.Marshal(&stat)
sendResponse(w, &Msg{Data: string(buf)})
return
}
func serverInfo() (err error) {
var data = &RebanaRequestMsg{UserId: 102, Command: "server-info",
Data: app.HostName}
var buf, _ = json.Marshal(data)
var url = app.RebanaUrl + "/v/info"
var rd = bytes.NewReader(buf)
var req *http.Request
if req, err = http.NewRequest("POST", url, rd); err != nil {
return
}
var loc = &time.Location{}
if loc, err = time.LoadLocation("Etc/GMT"); err != nil {
return
}
req.Header.Add("Date", time.Now().In(loc).Format(time.RFC1123))
req.Header.Add("Accept", "application/json")
req.Header.Add("Content-Type", "application/json")
req.Header.Add("X-N3-Service-Name", "rebana")
req.Header.Add("X-N3-Tunnel-Server", app.HostName)
req.Header | Id int64
ErrNo int | random_line_split |
|
main.go | v:%v::", rt[0], e.Id)
var s = &CSession{Ifname: ifname, TunAddr: app.SvInfo.TunSrc,
TunDest: e.Opt, In6Addr: in6addr, In6Dest: in6dest,
In6Plen: uint(64), Rt6Dest: rt6dest, Rt6Plen: uint(64)}
event(logdebug, li, "Session [%v] deactivation parameters: [Interface "+
"name: %v, Tunnel source: %v, Tunnel destination: %v, Server "+
"inet6 address: %v/64, Client inet6 address: %v/64, Routed "+
"prefix: %v/64]", e.Id, ifname, app.SvInfo.TunSrc, e.Opt,
in6addr, in6dest, rt6dest)
var si []Id
if err = deactivateSession(s); err != nil {
si = []Id{Id{ErrNo: EINVAL}}
event(logwarn, li, err.Error())
} else {
si = []Id{Id{}}
}
var buf, _ = json.Marshal(&IdList{Entry: si})
sendResponse(w, &Msg{Data: string(buf)})
return nil
}
func check(w http.ResponseWriter, d *RequestMsg) (err error) {
stat.ReqCheck++
var m *IdList
if m, err = getIdList(d.Data, d.Command); err != nil {
stat.ReqErrCheck++
return
}
var e = m.Entry[0]
if e.Id == 0 {
stat.ReqErrCheck++
return
}
var ipf int
if ipf, err = checkIPFamily(e.Opt); ipf != 4 {
stat.ReqErrCheck++
return
}
var pp = strings.Split(app.SvInfo.PpPrefix, "::/")
//var ip6s = fmt.Sprintf("%v:%v::1", pp[0], e.Id)
var ip6c = fmt.Sprintf("%v:%v::2", pp[0], e.Id)
var si = make([]Id, 2)
for i := range si {
var dst = e.Opt
var udp = "udp4"
if i == 1 {
udp = "udp6"
dst = ip6c
}
if rtt, tgt, err := pingSession(dst, udp); err != nil {
si[i] = Id{ErrNo: EINVAL, Opt: tgt}
event(logwarn, li, err.Error())
} else {
si[i] = Id{Id: int64(rtt), Opt: tgt}
}
}
var buf, _ = json.Marshal(&IdList{Entry: si})
sendResponse(w, &Msg{Data: string(buf)})
return nil
}
func status(w http.ResponseWriter, d *RequestMsg) (err error) {
stat.ReqStatus++
var buf, _ = json.Marshal(&stat)
sendResponse(w, &Msg{Data: string(buf)})
return
}
func serverInfo() (err error) {
var data = &RebanaRequestMsg{UserId: 102, Command: "server-info",
Data: app.HostName}
var buf, _ = json.Marshal(data)
var url = app.RebanaUrl + "/v/info"
var rd = bytes.NewReader(buf)
var req *http.Request
if req, err = http.NewRequest("POST", url, rd); err != nil {
return
}
var loc = &time.Location{}
if loc, err = time.LoadLocation("Etc/GMT"); err != nil {
return
}
req.Header.Add("Date", time.Now().In(loc).Format(time.RFC1123))
req.Header.Add("Accept", "application/json")
req.Header.Add("Content-Type", "application/json")
req.Header.Add("X-N3-Service-Name", "rebana")
req.Header.Add("X-N3-Tunnel-Server", app.HostName)
req.Header.Add("X-N3-Signature", signRequest(buf, 0))
var c = &http.Client{}
c.Transport = &http.Transport{TLSClientConfig: tlsc}
var res *http.Response
if res, err = c.Do(req); err != nil {
return
}
defer res.Body.Close()
var t time.Time
if t, err = checkResponseHeader(res); err != nil {
return
}
var msg = &RebanaMsg{}
if err = json.NewDecoder(res.Body).Decode(msg); err != nil {
return
}
var sig = res.Header.Get("X-N3-Signature")
buf, _ = json.Marshal(msg)
if err = checkSignature(sig, buf); err != nil {
stat.ReqErrSignature++
return
}
if msg.ErrNo != EOK {
return errors.New(msg.Data)
}
var sv = &ServerInfo{}
if err = json.Unmarshal([]byte(msg.Data), sv); err != nil {
return
}
var ipf int
if ipf, err = checkIPFamily(sv.TunSrc); ipf != 4 {
return
}
if !strings.Contains(sv.PpPrefix, "::/48") ||
!strings.Contains(sv.RtPrefix, "::/48") {
return
}
app.SvInfo = &ServerInfo{}
app.SvInfo.Id = sv.Id
app.SvInfo.TunSrc = sv.TunSrc
app.SvInfo.PpPrefix = sv.PpPrefix
app.SvInfo.RtPrefix = sv.RtPrefix
app.SvInfo.Session = sv.Session
var sl = "Active tunnel session(s): "
for i := range sv.Session {
var e = sv.Session[i]
var sa = fmt.Sprintf("%v[%v]", e.Id, e.Dst)
sl += sa
if i < (len(sv.Session) - 1) {
sl += ", "
}
}
var ts = t.In(time.Local).Format(time.RFC1123)
event(logdebug, li, "Server information retrieved: "+
"[Timestamp: %v, Server name: %v[%v], "+
"Tunnel source address: %v, "+
"Tunnel point-to-point prefix: %v, "+
"Tunnel routed prefix: %v, Active tunnel sessions: %v]",
ts, app.HostName, sv.Id, sv.TunSrc, sv.PpPrefix, sv.RtPrefix,
len(sv.Session))
return
}
func defaultHandler(w http.ResponseWriter, r *http.Request) {
stat.ReqAll++
var err error
var str = "Invalid request"
if err = checkUrl(r); err != nil {
stat.ReqErrHeader++
sendError(w, EINVAL, str, err)
return
}
if err = checkHeader(r); err != nil {
stat.ReqErrHeader++
sendError(w, EINVAL, str, err)
return
}
var d *RequestMsg
if d, err = checkData(r); err != nil {
stat.ReqErrPayload++
sendError(w, EINVAL, str, err)
return
}
event(logdebug, li, "Processing request [%v:%v]", d.Command, d.MsgId)
switch d.Command {
case "activate":
err = activate(w, d)
case "deactivate":
err = deactivate(w, d)
case "check":
err = check(w, d)
case "status":
err = status(w, d)
}
if err != nil {
str += ": " + d.Command
sendError(w, EINVAL, str, err)
return
}
event(logdebug, li, "Request [%v:%v] completed", d.Command, d.MsgId)
}
func main() {
var help, debug bool
var conf string
flag.BoolVar(&debug, "d", false, "Debug mode")
flag.BoolVar(&help, "h", false, "Display usage")
flag.StringVar(&conf, "c", CONFFILE, "Configuration file")
flag.Parse()
if help {
usage()
}
app = &AppConfig{ProgName: APPNAME, Version: APPVER, Pid: os.Getpid()}
stat = &AppStat{HostName: app.HostName}
var err error
if err = parseConfig(conf); err != nil {
fatal(err.Error())
}
if err = setupLog(debug); err != nil {
fatal(err.Error())
}
go sigHandler()
event(loginfo, li, "%v-%v server started: %v", app.ProgName, app.Version,
app.HostName)
if err = setupServer(); err != nil {
fatal(err.Error())
}
if err = serverInfo(); err != nil {
fatal(err.Error())
}
var pid = fmt.Sprintf("%v", app.Pid)
if err = ioutil.WriteFile(PIDFILE, []byte(pid), 0644); err != nil {
fatal(err.Error())
}
select {}
}
func sigHandler() {
var quit bool
var c = make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)
var signal = <-c
event(lognotice, li, "Signal received: "+signal.String())
switch signal {
case syscall.SIGINT, syscall.SIGTERM:
quit = true
}
if quit | {
event(lognotice, li, "Terminating..")
os.Remove(PIDFILE)
os.Exit(0)
} | conditional_block |
|
digits_DG_Gphi_projection.py | d(c_in, c_out, 3, stride=1, padding=1)
self.relu = nn.ReLU(True)
def forward(self, x):
return self.relu(self.conv(x))
class ConvNet(Backbone):
def __init__(self, c_hidden=64):
super().__init__()
self.conv1 = Convolution(3, c_hidden)
self.conv2 = Convolution(c_hidden, c_hidden)
self.conv3 = Convolution(c_hidden, c_hidden)
self.conv4 = Convolution(c_hidden, c_hidden)
self._out_features = 2**2 * c_hidden
def _check_input(self, x):
H, W = x.shape[2:]
assert H == 32 and W == 32, 'Input to network must be 32x32, ' 'but got {}x{}'.format(H, W)
def forward(self, x):
self._check_input(x)
x = self.conv1(x)
x = F.max_pool2d(x, 2)
x = self.conv2(x)
x = F.max_pool2d(x, 2)
x = self.conv3(x)
x = F.max_pool2d(x, 2)
x = self.conv4(x)
x = F.max_pool2d(x, 2)
return x.view(x.size(0), -1)
class DGdata(Dataset):
def __init__(self, root_dir, image_size, domains=None, transform = None):
self.root_dir = root_dir
if root_dir[-1] != "/":
self.root_dir = self.root_dir + "/"
self.categories = ['0', '1', '2', '3', '4', '5', '6','7', '8', '9']
if domains is None:
self.domains = ["mnist", "mnist_m", "svhn", "syn"]
else:
self.domains = domains
if transform is None:
self.transform = transforms.ToTensor()
else:
self.transform = transform
# make a list of all the files in the root_dir
# and read the labels
self.img_files = []
self.labels = []
self.domain_labels = []
for domain in self.domains:
for category in self.categories:
for image in os.listdir(self.root_dir+domain+'/'+category):
self.img_files.append(image)
self.labels.append(self.categories.index(category))
self.domain_labels.append(self.domains.index(domain))
def __len__(self):
return len(self.img_files)
def __getitem__(self, idx):
if torch.is_tensor(idx):
idx = idx.tolist()
img_path = self.root_dir + self.domains[self.domain_labels[idx]] + "/" + self.categories[self.labels[idx]] + "/" + self.img_files[idx]
image = PIL.Image.open(img_path)
label = self.labels[idx]
return self.transform(image), label
class Flatten(nn.Module):
def forward(self, input):
return input.view(input.size(0), -1)
class UnFlatten(nn.Module):
def forward(self, input, size=64):
return input.view(input.size(0), size, 1, 1)
class VAE_Digits(nn.Module):
def __init__(self, image_channels=1, h_dim=64, z_dim=32):
super(VAE_Digits, self).__init__()
self.encoder = nn.Sequential(
nn.Conv2d(image_channels, 4, kernel_size=3, stride=2,padding=1),
nn.ReLU(),
nn.Conv2d(4, 8, kernel_size=3, stride=2,padding=1),
nn.ReLU(),
nn.Conv2d(8, 16, kernel_size=3, stride=2,padding=1),
nn.ReLU(),
Flatten()
)
self.fc1 = nn.Linear(h_dim, z_dim)
self.fc2 = nn.Linear(h_dim, z_dim)
self.fc3 = nn.Linear(z_dim, h_dim)
self.decoder = nn.Sequential(
UnFlatten(),
nn.ConvTranspose2d(h_dim, 16, kernel_size=2, stride=1),
nn.ReLU(),
nn.ConvTranspose2d(16, 8, kernel_size=2, stride=2),
nn.ReLU(),
nn.ConvTranspose2d(8, 4, kernel_size=2, stride=2),
nn.Sigmoid(),
)
def reparameterize(self, mu, logvar):
std = torch.exp(0.5*logvar)
eps = torch.randn_like(std)
z = mu + eps*std
return z
def bottleneck(self, h):
mu, logvar = self.fc1(h), self.fc2(h)
z = self.reparameterize(mu, logvar)
return z, mu, logvar
def encode(self, x):
x = x.view(-1, 1, 16,16)
h = self.encoder(x)
z, mu, logvar = self.bottleneck(h)
return z, mu, logvar
def decode(self, z):
z = self.fc3(z)
z = self.decoder(z)
return z.view(-1, 1, 16,16)
def forward(self, x):
z, mu, logvar = self.encode(x)
z = self.decode(z)
return z, mu, logvar
digits_fnet = ConvNet(c_hidden=64)
checkpoint = torch.load('../Models/digits_fnet.pt')
digits_fnet.load_state_dict(checkpoint['model_state_dict'])
digits_fnet = digits_fnet.to(dev)
layers = []
layers.append(nn.Linear(FEATURE_DIM, CLASSES))
classifier = torch.nn.Sequential(*layers).to(dev)
CELoss = nn.CrossEntropyLoss()
classifier = classifier.to(dev)
data_transforms = transforms.Compose([transforms.RandomResizedCrop(size=IMAGE_SIZE), transforms.ToTensor()] )
ds = DGdata(".", IMAGE_SIZE, [src_path], transform=data_transforms)
dataloader = DataLoader(ds, batch_size=64, shuffle=True, num_workers = 4)
digits_fnet.eval()
opt = torch.optim.Adam(classifier.parameters(), lr=0.003)
for epoch in range(15):
step_wise_loss = []
step_wise_accuracy = []
for image_batch, labels in (dataloader):
image_batch = image_batch.float()
if dev is not None:
image_batch, labels = image_batch.to(dev), labels.to(dev)
# zero the parameter gradients
opt.zero_grad()
z = digits_fnet(image_batch).to(dev)
pred = classifier(z)
loss = CELoss(pred, labels)
accuracy = (pred.argmax(dim=1) == labels).float().sum()/pred.shape[0]
loss.backward()
opt.step()
step_wise_loss.append(loss.detach().cpu().numpy())
step_wise_accuracy.append(accuracy.detach().cpu().numpy())
print("Epoch " + str(epoch) + " Loss " + str(np.mean(step_wise_loss)) + " Accuracy " + str(np.mean(step_wise_accuracy)))
vae = VAE_Digits().to(dev)
VAEoptim = LARS(torch.optim.SGD(vae.parameters(), lr=0.005))
dataloader_vae = DataLoader(ds, batch_size=64, shuffle=True, num_workers = 4)
#modified loss
def loss_function(recon_x, x, mu, logvar):
l2 = F.mse_loss(recon_x, x.view(-1, 1, 16, 16), reduction='mean')
KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
l1 = F.l1_loss(recon_x, x.view(-1, 1, 16, 16), reduction='mean')
return l1 + l2 + KLD
def trainVAE(epoch):
vae.train()
train_loss = 0
print(epoch)
for batch_idx, (image_batch, _) in enumerate(dataloader_vae):
image_batch = image_batch.float()
image_batch = image_batch.to(dev) | #print(h.shape)
h = h.view(-1, 1, 16,16)
#print(h.shape)
h=h.detach()
recon_batch, mu, logvar = vae(h)
loss = loss_function(recon_batch, h, mu, logvar)
loss.backward()
train_loss += loss.item()
VAEoptim.step()
print('====> Epoch: {} Average loss: {:.4f}'.format(
epoch, train_loss / len(dataloader_vae.dataset)))
for epoch in range(1, 150):
trainVAE(epoch)
if (epoch)%10 == 0:
torch.save({'epoch' : epoch,
'model_state_dict': vae.state_dict(),
'optimizer_state_dict': VAEoptim.state_dict()
}, CHECKPOINT_DIR+"VAEepoch_digits_"+str(epoch)+".pt")
############################################ inference - target projection ##############################################################
vae.eval()
data_transforms = transforms.Compose([transforms.RandomResizedCrop(size=IMAGE_SIZE), transforms.ToTensor()] )
test_data = DGdata(".", IMAGE_SIZE, [target_path | VAEoptim.zero_grad()
h = digits_fnet(image_batch).to(dev) | random_line_split |
digits_DG_Gphi_projection.py | d(c_in, c_out, 3, stride=1, padding=1)
self.relu = nn.ReLU(True)
def forward(self, x):
return self.relu(self.conv(x))
class ConvNet(Backbone):
def __init__(self, c_hidden=64):
super().__init__()
self.conv1 = Convolution(3, c_hidden)
self.conv2 = Convolution(c_hidden, c_hidden)
self.conv3 = Convolution(c_hidden, c_hidden)
self.conv4 = Convolution(c_hidden, c_hidden)
self._out_features = 2**2 * c_hidden
def _check_input(self, x):
H, W = x.shape[2:]
assert H == 32 and W == 32, 'Input to network must be 32x32, ' 'but got {}x{}'.format(H, W)
def forward(self, x):
self._check_input(x)
x = self.conv1(x)
x = F.max_pool2d(x, 2)
x = self.conv2(x)
x = F.max_pool2d(x, 2)
x = self.conv3(x)
x = F.max_pool2d(x, 2)
x = self.conv4(x)
x = F.max_pool2d(x, 2)
return x.view(x.size(0), -1)
class DGdata(Dataset):
def __init__(self, root_dir, image_size, domains=None, transform = None):
self.root_dir = root_dir
if root_dir[-1] != "/":
self.root_dir = self.root_dir + "/"
self.categories = ['0', '1', '2', '3', '4', '5', '6','7', '8', '9']
if domains is None:
self.domains = ["mnist", "mnist_m", "svhn", "syn"]
else:
self.domains = domains
if transform is None:
self.transform = transforms.ToTensor()
else:
self.transform = transform
# make a list of all the files in the root_dir
# and read the labels
self.img_files = []
self.labels = []
self.domain_labels = []
for domain in self.domains:
for category in self.categories:
for image in os.listdir(self.root_dir+domain+'/'+category):
self.img_files.append(image)
self.labels.append(self.categories.index(category))
self.domain_labels.append(self.domains.index(domain))
def __len__(self):
return len(self.img_files)
def __getitem__(self, idx):
if torch.is_tensor(idx):
idx = idx.tolist()
img_path = self.root_dir + self.domains[self.domain_labels[idx]] + "/" + self.categories[self.labels[idx]] + "/" + self.img_files[idx]
image = PIL.Image.open(img_path)
label = self.labels[idx]
return self.transform(image), label
class | (nn.Module):
def forward(self, input):
return input.view(input.size(0), -1)
class UnFlatten(nn.Module):
def forward(self, input, size=64):
return input.view(input.size(0), size, 1, 1)
class VAE_Digits(nn.Module):
def __init__(self, image_channels=1, h_dim=64, z_dim=32):
super(VAE_Digits, self).__init__()
self.encoder = nn.Sequential(
nn.Conv2d(image_channels, 4, kernel_size=3, stride=2,padding=1),
nn.ReLU(),
nn.Conv2d(4, 8, kernel_size=3, stride=2,padding=1),
nn.ReLU(),
nn.Conv2d(8, 16, kernel_size=3, stride=2,padding=1),
nn.ReLU(),
Flatten()
)
self.fc1 = nn.Linear(h_dim, z_dim)
self.fc2 = nn.Linear(h_dim, z_dim)
self.fc3 = nn.Linear(z_dim, h_dim)
self.decoder = nn.Sequential(
UnFlatten(),
nn.ConvTranspose2d(h_dim, 16, kernel_size=2, stride=1),
nn.ReLU(),
nn.ConvTranspose2d(16, 8, kernel_size=2, stride=2),
nn.ReLU(),
nn.ConvTranspose2d(8, 4, kernel_size=2, stride=2),
nn.Sigmoid(),
)
def reparameterize(self, mu, logvar):
std = torch.exp(0.5*logvar)
eps = torch.randn_like(std)
z = mu + eps*std
return z
def bottleneck(self, h):
mu, logvar = self.fc1(h), self.fc2(h)
z = self.reparameterize(mu, logvar)
return z, mu, logvar
def encode(self, x):
x = x.view(-1, 1, 16,16)
h = self.encoder(x)
z, mu, logvar = self.bottleneck(h)
return z, mu, logvar
def decode(self, z):
z = self.fc3(z)
z = self.decoder(z)
return z.view(-1, 1, 16,16)
def forward(self, x):
z, mu, logvar = self.encode(x)
z = self.decode(z)
return z, mu, logvar
digits_fnet = ConvNet(c_hidden=64)
checkpoint = torch.load('../Models/digits_fnet.pt')
digits_fnet.load_state_dict(checkpoint['model_state_dict'])
digits_fnet = digits_fnet.to(dev)
layers = []
layers.append(nn.Linear(FEATURE_DIM, CLASSES))
classifier = torch.nn.Sequential(*layers).to(dev)
CELoss = nn.CrossEntropyLoss()
classifier = classifier.to(dev)
data_transforms = transforms.Compose([transforms.RandomResizedCrop(size=IMAGE_SIZE), transforms.ToTensor()] )
ds = DGdata(".", IMAGE_SIZE, [src_path], transform=data_transforms)
dataloader = DataLoader(ds, batch_size=64, shuffle=True, num_workers = 4)
digits_fnet.eval()
opt = torch.optim.Adam(classifier.parameters(), lr=0.003)
for epoch in range(15):
step_wise_loss = []
step_wise_accuracy = []
for image_batch, labels in (dataloader):
image_batch = image_batch.float()
if dev is not None:
image_batch, labels = image_batch.to(dev), labels.to(dev)
# zero the parameter gradients
opt.zero_grad()
z = digits_fnet(image_batch).to(dev)
pred = classifier(z)
loss = CELoss(pred, labels)
accuracy = (pred.argmax(dim=1) == labels).float().sum()/pred.shape[0]
loss.backward()
opt.step()
step_wise_loss.append(loss.detach().cpu().numpy())
step_wise_accuracy.append(accuracy.detach().cpu().numpy())
print("Epoch " + str(epoch) + " Loss " + str(np.mean(step_wise_loss)) + " Accuracy " + str(np.mean(step_wise_accuracy)))
vae = VAE_Digits().to(dev)
VAEoptim = LARS(torch.optim.SGD(vae.parameters(), lr=0.005))
dataloader_vae = DataLoader(ds, batch_size=64, shuffle=True, num_workers = 4)
#modified loss
def loss_function(recon_x, x, mu, logvar):
l2 = F.mse_loss(recon_x, x.view(-1, 1, 16, 16), reduction='mean')
KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
l1 = F.l1_loss(recon_x, x.view(-1, 1, 16, 16), reduction='mean')
return l1 + l2 + KLD
def trainVAE(epoch):
vae.train()
train_loss = 0
print(epoch)
for batch_idx, (image_batch, _) in enumerate(dataloader_vae):
image_batch = image_batch.float()
image_batch = image_batch.to(dev)
VAEoptim.zero_grad()
h = digits_fnet(image_batch).to(dev)
#print(h.shape)
h = h.view(-1, 1, 16,16)
#print(h.shape)
h=h.detach()
recon_batch, mu, logvar = vae(h)
loss = loss_function(recon_batch, h, mu, logvar)
loss.backward()
train_loss += loss.item()
VAEoptim.step()
print('====> Epoch: {} Average loss: {:.4f}'.format(
epoch, train_loss / len(dataloader_vae.dataset)))
for epoch in range(1, 150):
trainVAE(epoch)
if (epoch)%10 == 0:
torch.save({'epoch' : epoch,
'model_state_dict': vae.state_dict(),
'optimizer_state_dict': VAEoptim.state_dict()
}, CHECKPOINT_DIR+"VAEepoch_digits_"+str(epoch)+".pt")
############################################ inference - target projection ##############################################################
vae.eval()
data_transforms = transforms.Compose([transforms.RandomResizedCrop(size=IMAGE_SIZE), transforms.ToTensor()] )
test_data = DGdata(".", IMAGE_SIZE, [ | Flatten | identifier_name |
digits_DG_Gphi_projection.py | d(c_in, c_out, 3, stride=1, padding=1)
self.relu = nn.ReLU(True)
def forward(self, x):
return self.relu(self.conv(x))
class ConvNet(Backbone):
def __init__(self, c_hidden=64):
super().__init__()
self.conv1 = Convolution(3, c_hidden)
self.conv2 = Convolution(c_hidden, c_hidden)
self.conv3 = Convolution(c_hidden, c_hidden)
self.conv4 = Convolution(c_hidden, c_hidden)
self._out_features = 2**2 * c_hidden
def _check_input(self, x):
H, W = x.shape[2:]
assert H == 32 and W == 32, 'Input to network must be 32x32, ' 'but got {}x{}'.format(H, W)
def forward(self, x):
self._check_input(x)
x = self.conv1(x)
x = F.max_pool2d(x, 2)
x = self.conv2(x)
x = F.max_pool2d(x, 2)
x = self.conv3(x)
x = F.max_pool2d(x, 2)
x = self.conv4(x)
x = F.max_pool2d(x, 2)
return x.view(x.size(0), -1)
class DGdata(Dataset):
def __init__(self, root_dir, image_size, domains=None, transform = None):
self.root_dir = root_dir
if root_dir[-1] != "/":
self.root_dir = self.root_dir + "/"
self.categories = ['0', '1', '2', '3', '4', '5', '6','7', '8', '9']
if domains is None:
self.domains = ["mnist", "mnist_m", "svhn", "syn"]
else:
self.domains = domains
if transform is None:
|
else:
self.transform = transform
# make a list of all the files in the root_dir
# and read the labels
self.img_files = []
self.labels = []
self.domain_labels = []
for domain in self.domains:
for category in self.categories:
for image in os.listdir(self.root_dir+domain+'/'+category):
self.img_files.append(image)
self.labels.append(self.categories.index(category))
self.domain_labels.append(self.domains.index(domain))
def __len__(self):
return len(self.img_files)
def __getitem__(self, idx):
if torch.is_tensor(idx):
idx = idx.tolist()
img_path = self.root_dir + self.domains[self.domain_labels[idx]] + "/" + self.categories[self.labels[idx]] + "/" + self.img_files[idx]
image = PIL.Image.open(img_path)
label = self.labels[idx]
return self.transform(image), label
class Flatten(nn.Module):
def forward(self, input):
return input.view(input.size(0), -1)
class UnFlatten(nn.Module):
def forward(self, input, size=64):
return input.view(input.size(0), size, 1, 1)
class VAE_Digits(nn.Module):
def __init__(self, image_channels=1, h_dim=64, z_dim=32):
super(VAE_Digits, self).__init__()
self.encoder = nn.Sequential(
nn.Conv2d(image_channels, 4, kernel_size=3, stride=2,padding=1),
nn.ReLU(),
nn.Conv2d(4, 8, kernel_size=3, stride=2,padding=1),
nn.ReLU(),
nn.Conv2d(8, 16, kernel_size=3, stride=2,padding=1),
nn.ReLU(),
Flatten()
)
self.fc1 = nn.Linear(h_dim, z_dim)
self.fc2 = nn.Linear(h_dim, z_dim)
self.fc3 = nn.Linear(z_dim, h_dim)
self.decoder = nn.Sequential(
UnFlatten(),
nn.ConvTranspose2d(h_dim, 16, kernel_size=2, stride=1),
nn.ReLU(),
nn.ConvTranspose2d(16, 8, kernel_size=2, stride=2),
nn.ReLU(),
nn.ConvTranspose2d(8, 4, kernel_size=2, stride=2),
nn.Sigmoid(),
)
def reparameterize(self, mu, logvar):
std = torch.exp(0.5*logvar)
eps = torch.randn_like(std)
z = mu + eps*std
return z
def bottleneck(self, h):
mu, logvar = self.fc1(h), self.fc2(h)
z = self.reparameterize(mu, logvar)
return z, mu, logvar
def encode(self, x):
x = x.view(-1, 1, 16,16)
h = self.encoder(x)
z, mu, logvar = self.bottleneck(h)
return z, mu, logvar
def decode(self, z):
z = self.fc3(z)
z = self.decoder(z)
return z.view(-1, 1, 16,16)
def forward(self, x):
z, mu, logvar = self.encode(x)
z = self.decode(z)
return z, mu, logvar
digits_fnet = ConvNet(c_hidden=64)
checkpoint = torch.load('../Models/digits_fnet.pt')
digits_fnet.load_state_dict(checkpoint['model_state_dict'])
digits_fnet = digits_fnet.to(dev)
layers = []
layers.append(nn.Linear(FEATURE_DIM, CLASSES))
classifier = torch.nn.Sequential(*layers).to(dev)
CELoss = nn.CrossEntropyLoss()
classifier = classifier.to(dev)
data_transforms = transforms.Compose([transforms.RandomResizedCrop(size=IMAGE_SIZE), transforms.ToTensor()] )
ds = DGdata(".", IMAGE_SIZE, [src_path], transform=data_transforms)
dataloader = DataLoader(ds, batch_size=64, shuffle=True, num_workers = 4)
digits_fnet.eval()
opt = torch.optim.Adam(classifier.parameters(), lr=0.003)
for epoch in range(15):
step_wise_loss = []
step_wise_accuracy = []
for image_batch, labels in (dataloader):
image_batch = image_batch.float()
if dev is not None:
image_batch, labels = image_batch.to(dev), labels.to(dev)
# zero the parameter gradients
opt.zero_grad()
z = digits_fnet(image_batch).to(dev)
pred = classifier(z)
loss = CELoss(pred, labels)
accuracy = (pred.argmax(dim=1) == labels).float().sum()/pred.shape[0]
loss.backward()
opt.step()
step_wise_loss.append(loss.detach().cpu().numpy())
step_wise_accuracy.append(accuracy.detach().cpu().numpy())
print("Epoch " + str(epoch) + " Loss " + str(np.mean(step_wise_loss)) + " Accuracy " + str(np.mean(step_wise_accuracy)))
vae = VAE_Digits().to(dev)
VAEoptim = LARS(torch.optim.SGD(vae.parameters(), lr=0.005))
dataloader_vae = DataLoader(ds, batch_size=64, shuffle=True, num_workers = 4)
#modified loss
def loss_function(recon_x, x, mu, logvar):
l2 = F.mse_loss(recon_x, x.view(-1, 1, 16, 16), reduction='mean')
KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
l1 = F.l1_loss(recon_x, x.view(-1, 1, 16, 16), reduction='mean')
return l1 + l2 + KLD
def trainVAE(epoch):
vae.train()
train_loss = 0
print(epoch)
for batch_idx, (image_batch, _) in enumerate(dataloader_vae):
image_batch = image_batch.float()
image_batch = image_batch.to(dev)
VAEoptim.zero_grad()
h = digits_fnet(image_batch).to(dev)
#print(h.shape)
h = h.view(-1, 1, 16,16)
#print(h.shape)
h=h.detach()
recon_batch, mu, logvar = vae(h)
loss = loss_function(recon_batch, h, mu, logvar)
loss.backward()
train_loss += loss.item()
VAEoptim.step()
print('====> Epoch: {} Average loss: {:.4f}'.format(
epoch, train_loss / len(dataloader_vae.dataset)))
for epoch in range(1, 150):
trainVAE(epoch)
if (epoch)%10 == 0:
torch.save({'epoch' : epoch,
'model_state_dict': vae.state_dict(),
'optimizer_state_dict': VAEoptim.state_dict()
}, CHECKPOINT_DIR+"VAEepoch_digits_"+str(epoch)+".pt")
############################################ inference - target projection ##############################################################
vae.eval()
data_transforms = transforms.Compose([transforms.RandomResizedCrop(size=IMAGE_SIZE), transforms.ToTensor()] )
test_data = DGdata(".", IMAGE_SIZE, [target | self.transform = transforms.ToTensor() | conditional_block |
digits_DG_Gphi_projection.py |
class ConvNet(Backbone):
def __init__(self, c_hidden=64):
super().__init__()
self.conv1 = Convolution(3, c_hidden)
self.conv2 = Convolution(c_hidden, c_hidden)
self.conv3 = Convolution(c_hidden, c_hidden)
self.conv4 = Convolution(c_hidden, c_hidden)
self._out_features = 2**2 * c_hidden
def _check_input(self, x):
H, W = x.shape[2:]
assert H == 32 and W == 32, 'Input to network must be 32x32, ' 'but got {}x{}'.format(H, W)
def forward(self, x):
self._check_input(x)
x = self.conv1(x)
x = F.max_pool2d(x, 2)
x = self.conv2(x)
x = F.max_pool2d(x, 2)
x = self.conv3(x)
x = F.max_pool2d(x, 2)
x = self.conv4(x)
x = F.max_pool2d(x, 2)
return x.view(x.size(0), -1)
class DGdata(Dataset):
def __init__(self, root_dir, image_size, domains=None, transform = None):
self.root_dir = root_dir
if root_dir[-1] != "/":
self.root_dir = self.root_dir + "/"
self.categories = ['0', '1', '2', '3', '4', '5', '6','7', '8', '9']
if domains is None:
self.domains = ["mnist", "mnist_m", "svhn", "syn"]
else:
self.domains = domains
if transform is None:
self.transform = transforms.ToTensor()
else:
self.transform = transform
# make a list of all the files in the root_dir
# and read the labels
self.img_files = []
self.labels = []
self.domain_labels = []
for domain in self.domains:
for category in self.categories:
for image in os.listdir(self.root_dir+domain+'/'+category):
self.img_files.append(image)
self.labels.append(self.categories.index(category))
self.domain_labels.append(self.domains.index(domain))
def __len__(self):
return len(self.img_files)
def __getitem__(self, idx):
if torch.is_tensor(idx):
idx = idx.tolist()
img_path = self.root_dir + self.domains[self.domain_labels[idx]] + "/" + self.categories[self.labels[idx]] + "/" + self.img_files[idx]
image = PIL.Image.open(img_path)
label = self.labels[idx]
return self.transform(image), label
class Flatten(nn.Module):
def forward(self, input):
return input.view(input.size(0), -1)
class UnFlatten(nn.Module):
def forward(self, input, size=64):
return input.view(input.size(0), size, 1, 1)
class VAE_Digits(nn.Module):
def __init__(self, image_channels=1, h_dim=64, z_dim=32):
super(VAE_Digits, self).__init__()
self.encoder = nn.Sequential(
nn.Conv2d(image_channels, 4, kernel_size=3, stride=2,padding=1),
nn.ReLU(),
nn.Conv2d(4, 8, kernel_size=3, stride=2,padding=1),
nn.ReLU(),
nn.Conv2d(8, 16, kernel_size=3, stride=2,padding=1),
nn.ReLU(),
Flatten()
)
self.fc1 = nn.Linear(h_dim, z_dim)
self.fc2 = nn.Linear(h_dim, z_dim)
self.fc3 = nn.Linear(z_dim, h_dim)
self.decoder = nn.Sequential(
UnFlatten(),
nn.ConvTranspose2d(h_dim, 16, kernel_size=2, stride=1),
nn.ReLU(),
nn.ConvTranspose2d(16, 8, kernel_size=2, stride=2),
nn.ReLU(),
nn.ConvTranspose2d(8, 4, kernel_size=2, stride=2),
nn.Sigmoid(),
)
def reparameterize(self, mu, logvar):
std = torch.exp(0.5*logvar)
eps = torch.randn_like(std)
z = mu + eps*std
return z
def bottleneck(self, h):
mu, logvar = self.fc1(h), self.fc2(h)
z = self.reparameterize(mu, logvar)
return z, mu, logvar
def encode(self, x):
x = x.view(-1, 1, 16,16)
h = self.encoder(x)
z, mu, logvar = self.bottleneck(h)
return z, mu, logvar
def decode(self, z):
z = self.fc3(z)
z = self.decoder(z)
return z.view(-1, 1, 16,16)
def forward(self, x):
z, mu, logvar = self.encode(x)
z = self.decode(z)
return z, mu, logvar
digits_fnet = ConvNet(c_hidden=64)
checkpoint = torch.load('../Models/digits_fnet.pt')
digits_fnet.load_state_dict(checkpoint['model_state_dict'])
digits_fnet = digits_fnet.to(dev)
layers = []
layers.append(nn.Linear(FEATURE_DIM, CLASSES))
classifier = torch.nn.Sequential(*layers).to(dev)
CELoss = nn.CrossEntropyLoss()
classifier = classifier.to(dev)
data_transforms = transforms.Compose([transforms.RandomResizedCrop(size=IMAGE_SIZE), transforms.ToTensor()] )
ds = DGdata(".", IMAGE_SIZE, [src_path], transform=data_transforms)
dataloader = DataLoader(ds, batch_size=64, shuffle=True, num_workers = 4)
digits_fnet.eval()
opt = torch.optim.Adam(classifier.parameters(), lr=0.003)
for epoch in range(15):
step_wise_loss = []
step_wise_accuracy = []
for image_batch, labels in (dataloader):
image_batch = image_batch.float()
if dev is not None:
image_batch, labels = image_batch.to(dev), labels.to(dev)
# zero the parameter gradients
opt.zero_grad()
z = digits_fnet(image_batch).to(dev)
pred = classifier(z)
loss = CELoss(pred, labels)
accuracy = (pred.argmax(dim=1) == labels).float().sum()/pred.shape[0]
loss.backward()
opt.step()
step_wise_loss.append(loss.detach().cpu().numpy())
step_wise_accuracy.append(accuracy.detach().cpu().numpy())
print("Epoch " + str(epoch) + " Loss " + str(np.mean(step_wise_loss)) + " Accuracy " + str(np.mean(step_wise_accuracy)))
vae = VAE_Digits().to(dev)
VAEoptim = LARS(torch.optim.SGD(vae.parameters(), lr=0.005))
dataloader_vae = DataLoader(ds, batch_size=64, shuffle=True, num_workers = 4)
#modified loss
def loss_function(recon_x, x, mu, logvar):
l2 = F.mse_loss(recon_x, x.view(-1, 1, 16, 16), reduction='mean')
KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
l1 = F.l1_loss(recon_x, x.view(-1, 1, 16, 16), reduction='mean')
return l1 + l2 + KLD
def trainVAE(epoch):
vae.train()
train_loss = 0
print(epoch)
for batch_idx, (image_batch, _) in enumerate(dataloader_vae):
image_batch = image_batch.float()
image_batch = image_batch.to(dev)
VAEoptim.zero_grad()
h = digits_fnet(image_batch).to(dev)
#print(h.shape)
h = h.view(-1, 1, 16,16)
#print(h.shape)
h=h.detach()
recon_batch, mu, logvar = vae(h)
loss = loss_function(recon_batch, h, mu, logvar)
loss.backward()
train_loss += loss.item()
VAEoptim.step()
print('====> Epoch: {} Average loss: {:.4f}'.format(
epoch, train_loss / len(dataloader_vae.dataset)))
for epoch in range(1, 150):
trainVAE(epoch)
if (epoch)%10 == 0:
torch.save({'epoch' : epoch,
'model_state_dict': vae.state_dict(),
'optimizer_state_dict': VAEoptim.state_dict()
}, CHECKPOINT_DIR+"VAEepoch_digits_"+str(epoch)+".pt")
############################################ inference - target projection ##############################################################
vae.eval()
data_transforms = transforms.Compose([transforms.Random | def __init__(self, c_in, c_out):
super().__init__()
self.conv = nn.Conv2d(c_in, c_out, 3, stride=1, padding=1)
self.relu = nn.ReLU(True)
def forward(self, x):
return self.relu(self.conv(x)) | identifier_body |
|
script.js | -nav-parent-active')
panel.css('max-height',panel.prop('scrollHeight') + "px")
} else {
panel.attr('style','');
$(this).toggleClass('links-nav-parent-active')
}
}
})
//menu-script
$('.m-nav-icon').on('click',function(event){
$('.header-overley').addClass('show-overlay');
$('body').addClass('stop-scroll');
$('.m-nav-hiiden').addClass('m-nav-hiiden-active')
})
$('.close-menu-icon, .header-overley').on('click', function(){
$('.header-overley').removeClass('show-overlay');
$('body').removeClass('stop-scroll');
$('.m-nav-hiiden').removeClass('m-nav-hiiden-active')
})
//get scroll-width
function getScrollBarWidth () {
var $outer = $('<div>').css({visibility: 'hidden', width: 100, overflow: 'scroll'}).appendTo('body'),
widthWithScroll = $('<div>').css({width: '100%'}).appendTo($outer).outerWidth();
$outer.remove();
return 100 - widthWithScroll;
};
//tabs
$(".tab-t").on("click",function(e){
$('.tab-t').removeClass('tab-t-active')
$(this).addClass('tab-t-active');
var activeWidth = $(this).innerWidth();
var itemPos = $(this).position();
$(".tab-t-selector").css({
"left":itemPos.left + "px",
"width": activeWidth + "px"
});
$('.offer').removeClass('active-tab');
$('[data-tab='+$(this).attr('data-select-tab')+']').addClass('active-tab');
})
if($('div').is(".tab-t-selector")){
$(".tab-t-selector").css({
"left":$('.tab-t-active').position().left + "px",
"width": $('.tab-t-active').innerWidth() + "px"
});
}
//price-tabs
$('.img-tab-c-th-img').on("click",function(e){
$(this).closest('.img-tab-c-th').next().find('img').attr('src',$(this).attr('data-full'))
$('.img-tab-c-th-img').removeClass('active-img-tab-c-th-img');
$(this).addClass('active-img-tab-c-th-img');
});
//menu
if($(window).width() > 992) {
$(window).scroll(function(){
if($(this).scrollTop()>400){
$('.site-header').addClass('fixed-header');
$('body').addClass('nav-fixed');
}
if ($(this).scrollTop()<350 && $('.site-header').hasClass('fixed-header')){
$('.site-header').addClass('header-animated');
}
if ($(this).scrollTop()>350 && $('.site-header').hasClass('header-animated')){
$('.site-header').removeClass('header-animated');
}
if ($(this).scrollTop() < 200){
$('.site-header').removeClass('fixed-header');
$('.site-header').removeClass('header-animated');
$('body').removeClass('nav-fixed');
}
});
}
//modal
function hideModal(){
$('[data-modal]').removeClass('visible-modal');
$('.modal-overley').removeClass('modal-overley-show');
setTimeout(function(){
$('body').removeClass('stop-scroll');
$('body').css('padding-right',0+'px');
$('.site-header').css('padding-right',0+'px')
}, 300);
}
$(".close-modal, .modal-overley").on("click",function(e){
hideModal()
})
$(document).keydown(function(eventObject){
if (eventObject.which == 27)
hideModal()
});
$('[data-modal-open]').on("click",function(e){
event.preventDefault()
$('[data-modal='+ $(this).attr('data-modal-open') +']').addClass('visible-modal')
if($(this).attr('data-modal-open')==1){
$('[data-modal=1] .modal-header-t').text($(this).prev('.cb-c-text').find('.bloc-t').text());
$('[data-modal=1] .modal-hero-descr').text($(this).prev('.cb-c-text').find('.descr').text());
$('[data-modal=1] .modal-hero-img').attr('src',$(this).next('.cb-c-img').attr('src'));
}
if($(this).attr('data-modal-open')==3){
$('[data-modal=3] .centured-m-t').text($(this).parentsUntil('.hf-t').find('h1').text());
$('[data-modal=3] .centured-m-d').text($(this).parentsUntil('.hf-t').find('.hero-content p:first-child').text());
$('[data-modal=3] .main-request-img').attr('src',$('.hf-img img').attr('src'));
}
$('.modal-overley').addClass('modal-overley-show');
$('body').addClass('stop-scroll');
$('body').css('padding-right',getScrollBarWidth ()+'px');
$('.site-header').css('padding-right',getScrollBarWidth ()+'px');
})
// centured-modal-close
$('.centured-modal').on("click",function(e){
hideModal()
}).children()
.click(function(e){
e.stopPropagation();
})
| if($('div').is('.post-nav-container')){
if($(window).width() > 768){
$(".sp-text-col h2,.sp-text-col h3,.sp-text-col h4").each(function(i) {
var current = $(this);
current.attr("id", "title" + i);
$(".sp-links .post-nav-container").append("<a calass='post-nav-link' id='link" + i + "' href='#title" + i + "' title='" + $(this).text() + "' data-anchor='" + true + "'>" + current.html() + "</a>");
});
//post-nav-active
$(window).scroll(function(){
var $sections = $('.sp-text-col h2,.sp-text-col h3,.sp-text-col h4');
$sections.each(function(i,el){
var top = $(el).offset().top;
console.log($(window).scrollTop())
var id = $(el).attr('id');
if( (top - $(window).scrollTop()) > 0 && (top - $(window).scrollTop()) < 120){
$('.post-nav-link-active').removeClass('post-nav-link-active');
$('a[href="#'+id+'"]').addClass('post-nav-link-active');
$(".post-nav-selector").css({
"top":$('a[href="#'+id+'"]').position().top + "px",
"height": $('a[href="#'+id+'"]').innerHeight() + "px"
});
}
})
});
}else{
$(".sp-text-col h2,.sp-text-col h3,.sp-text-col h4").each(function(i) {
var current = $(this);
current.attr("id", "title" + i);
$(".sp-mobile-nav .post-nav-container").append("<a calass='post-nav-link' id='link" + i + "' href='#title" + i + "' title='" + $(this).text() + "' data-anchor='" + true + "'>" + current.html() + "</a>");
});
}
}
//like-button
$('.sp-like-button').on("click",function(e){
$(this).addClass('sp-like-button-liked');
$('.sp-l-text').text(Number.parseInt($('.sp-l-text').text())+1);
})
//quiz
var curentStage=1;
$('.cond-quiz-counter-curent').text(curentStage);
$('.cond-quiz-footer-next').prop('disabled',true)
$('.count-line-counter').css('width',(100 / $('.cond-quiz-body').length) + '%')
$('.c-check input').on("change",function(e){
if($('.c-check input:checked').length > 0){
$('.cond-quiz-footer-next').prop('disabled',false)
}
else{
$('.cond-quiz-footer-next').prop('disabled',true)
}
})
$('.c-q-c-c-item').on("click",function(e){
$(this).toggleClass('c-q-c-c-item-selected')
if($('.c-q-c-c-item-selected').length > 0){
$('.cond-quiz-footer-next').prop('disabled',false)
}
else{
$('.cond-quiz-footer-next').prop('disabled',true)
}
})
$('.cond-quiz-footer-next').on("click",function(e){
if(curentStage==1){
$('[data-stage='+curentStage+'] .c-check input:checked').each(function(i) {
var values = $('[data-field-id=field--1]').val();
values += $(this).parent('.c-check').text();
$('[data-field-id=field--1]').val(values.replace(/\s/g, '')+',');
});
}
if(curentStage==2){
$('.c-q-c-c-item-selected').each(function(i) {
var values = $('[data-field-id=field--2]').val();
values += $(this).find('.c-q-c-c-item-descr').text();
$('[data-field-id=field--2]').val(values.replace(/\s/g, '')+',');
});
}
if(curentStage==3){
$('[data-stage='+curentStage+'] .c-check input:checked').each(function(i) {
var values = $('[data-field-id=field--3]').val();
values += $(this).parent('.c-check').text();
$('[data-field-id=field--3]').val(values.replace(/\s/g, '')+',');
| //post-nav | random_line_split |
script.js | -parent-active')
panel.css('max-height',panel.prop('scrollHeight') + "px")
} else {
panel.attr('style','');
$(this).toggleClass('links-nav-parent-active')
}
}
})
//menu-script
$('.m-nav-icon').on('click',function(event){
$('.header-overley').addClass('show-overlay');
$('body').addClass('stop-scroll');
$('.m-nav-hiiden').addClass('m-nav-hiiden-active')
})
$('.close-menu-icon, .header-overley').on('click', function(){
$('.header-overley').removeClass('show-overlay');
$('body').removeClass('stop-scroll');
$('.m-nav-hiiden').removeClass('m-nav-hiiden-active')
})
//get scroll-width
function | () {
var $outer = $('<div>').css({visibility: 'hidden', width: 100, overflow: 'scroll'}).appendTo('body'),
widthWithScroll = $('<div>').css({width: '100%'}).appendTo($outer).outerWidth();
$outer.remove();
return 100 - widthWithScroll;
};
//tabs
$(".tab-t").on("click",function(e){
$('.tab-t').removeClass('tab-t-active')
$(this).addClass('tab-t-active');
var activeWidth = $(this).innerWidth();
var itemPos = $(this).position();
$(".tab-t-selector").css({
"left":itemPos.left + "px",
"width": activeWidth + "px"
});
$('.offer').removeClass('active-tab');
$('[data-tab='+$(this).attr('data-select-tab')+']').addClass('active-tab');
})
if($('div').is(".tab-t-selector")){
$(".tab-t-selector").css({
"left":$('.tab-t-active').position().left + "px",
"width": $('.tab-t-active').innerWidth() + "px"
});
}
//price-tabs
$('.img-tab-c-th-img').on("click",function(e){
$(this).closest('.img-tab-c-th').next().find('img').attr('src',$(this).attr('data-full'))
$('.img-tab-c-th-img').removeClass('active-img-tab-c-th-img');
$(this).addClass('active-img-tab-c-th-img');
});
//menu
if($(window).width() > 992) {
$(window).scroll(function(){
if($(this).scrollTop()>400){
$('.site-header').addClass('fixed-header');
$('body').addClass('nav-fixed');
}
if ($(this).scrollTop()<350 && $('.site-header').hasClass('fixed-header')){
$('.site-header').addClass('header-animated');
}
if ($(this).scrollTop()>350 && $('.site-header').hasClass('header-animated')){
$('.site-header').removeClass('header-animated');
}
if ($(this).scrollTop() < 200){
$('.site-header').removeClass('fixed-header');
$('.site-header').removeClass('header-animated');
$('body').removeClass('nav-fixed');
}
});
}
//modal
function hideModal(){
$('[data-modal]').removeClass('visible-modal');
$('.modal-overley').removeClass('modal-overley-show');
setTimeout(function(){
$('body').removeClass('stop-scroll');
$('body').css('padding-right',0+'px');
$('.site-header').css('padding-right',0+'px')
}, 300);
}
$(".close-modal, .modal-overley").on("click",function(e){
hideModal()
})
$(document).keydown(function(eventObject){
if (eventObject.which == 27)
hideModal()
});
$('[data-modal-open]').on("click",function(e){
event.preventDefault()
$('[data-modal='+ $(this).attr('data-modal-open') +']').addClass('visible-modal')
if($(this).attr('data-modal-open')==1){
$('[data-modal=1] .modal-header-t').text($(this).prev('.cb-c-text').find('.bloc-t').text());
$('[data-modal=1] .modal-hero-descr').text($(this).prev('.cb-c-text').find('.descr').text());
$('[data-modal=1] .modal-hero-img').attr('src',$(this).next('.cb-c-img').attr('src'));
}
if($(this).attr('data-modal-open')==3){
$('[data-modal=3] .centured-m-t').text($(this).parentsUntil('.hf-t').find('h1').text());
$('[data-modal=3] .centured-m-d').text($(this).parentsUntil('.hf-t').find('.hero-content p:first-child').text());
$('[data-modal=3] .main-request-img').attr('src',$('.hf-img img').attr('src'));
}
$('.modal-overley').addClass('modal-overley-show');
$('body').addClass('stop-scroll');
$('body').css('padding-right',getScrollBarWidth ()+'px');
$('.site-header').css('padding-right',getScrollBarWidth ()+'px');
})
// centured-modal-close
$('.centured-modal').on("click",function(e){
hideModal()
}).children()
.click(function(e){
e.stopPropagation();
})
//post-nav
if($('div').is('.post-nav-container')){
if($(window).width() > 768){
$(".sp-text-col h2,.sp-text-col h3,.sp-text-col h4").each(function(i) {
var current = $(this);
current.attr("id", "title" + i);
$(".sp-links .post-nav-container").append("<a calass='post-nav-link' id='link" + i + "' href='#title" + i + "' title='" + $(this).text() + "' data-anchor='" + true + "'>" + current.html() + "</a>");
});
//post-nav-active
$(window).scroll(function(){
var $sections = $('.sp-text-col h2,.sp-text-col h3,.sp-text-col h4');
$sections.each(function(i,el){
var top = $(el).offset().top;
console.log($(window).scrollTop())
var id = $(el).attr('id');
if( (top - $(window).scrollTop()) > 0 && (top - $(window).scrollTop()) < 120){
$('.post-nav-link-active').removeClass('post-nav-link-active');
$('a[href="#'+id+'"]').addClass('post-nav-link-active');
$(".post-nav-selector").css({
"top":$('a[href="#'+id+'"]').position().top + "px",
"height": $('a[href="#'+id+'"]').innerHeight() + "px"
});
}
})
});
}else{
$(".sp-text-col h2,.sp-text-col h3,.sp-text-col h4").each(function(i) {
var current = $(this);
current.attr("id", "title" + i);
$(".sp-mobile-nav .post-nav-container").append("<a calass='post-nav-link' id='link" + i + "' href='#title" + i + "' title='" + $(this).text() + "' data-anchor='" + true + "'>" + current.html() + "</a>");
});
}
}
//like-button
$('.sp-like-button').on("click",function(e){
$(this).addClass('sp-like-button-liked');
$('.sp-l-text').text(Number.parseInt($('.sp-l-text').text())+1);
})
//quiz
var curentStage=1;
$('.cond-quiz-counter-curent').text(curentStage);
$('.cond-quiz-footer-next').prop('disabled',true)
$('.count-line-counter').css('width',(100 / $('.cond-quiz-body').length) + '%')
$('.c-check input').on("change",function(e){
if($('.c-check input:checked').length > 0){
$('.cond-quiz-footer-next').prop('disabled',false)
}
else{
$('.cond-quiz-footer-next').prop('disabled',true)
}
})
$('.c-q-c-c-item').on("click",function(e){
$(this).toggleClass('c-q-c-c-item-selected')
if($('.c-q-c-c-item-selected').length > 0){
$('.cond-quiz-footer-next').prop('disabled',false)
}
else{
$('.cond-quiz-footer-next').prop('disabled',true)
}
})
$('.cond-quiz-footer-next').on("click",function(e){
if(curentStage==1){
$('[data-stage='+curentStage+'] .c-check input:checked').each(function(i) {
var values = $('[data-field-id=field--1]').val();
values += $(this).parent('.c-check').text();
$('[data-field-id=field--1]').val(values.replace(/\s/g, '')+',');
});
}
if(curentStage==2){
$('.c-q-c-c-item-selected').each(function(i) {
var values = $('[data-field-id=field--2]').val();
values += $(this).find('.c-q-c-c-item-descr').text();
$('[data-field-id=field--2]').val(values.replace(/\s/g, '')+',');
});
}
if(curentStage==3){
$('[data-stage='+curentStage+'] .c-check input:checked').each(function(i) {
var values = $('[data-field-id=field--3]').val();
values += $(this).parent('.c-check').text();
$('[data-field-id=field--3]').val(values.replace(/\s/g, '')+',');
| getScrollBarWidth | identifier_name |
script.js | -parent-active')
panel.css('max-height',panel.prop('scrollHeight') + "px")
} else {
panel.attr('style','');
$(this).toggleClass('links-nav-parent-active')
}
}
})
//menu-script
$('.m-nav-icon').on('click',function(event){
$('.header-overley').addClass('show-overlay');
$('body').addClass('stop-scroll');
$('.m-nav-hiiden').addClass('m-nav-hiiden-active')
})
$('.close-menu-icon, .header-overley').on('click', function(){
$('.header-overley').removeClass('show-overlay');
$('body').removeClass('stop-scroll');
$('.m-nav-hiiden').removeClass('m-nav-hiiden-active')
})
//get scroll-width
function getScrollBarWidth () {
var $outer = $('<div>').css({visibility: 'hidden', width: 100, overflow: 'scroll'}).appendTo('body'),
widthWithScroll = $('<div>').css({width: '100%'}).appendTo($outer).outerWidth();
$outer.remove();
return 100 - widthWithScroll;
};
//tabs
$(".tab-t").on("click",function(e){
$('.tab-t').removeClass('tab-t-active')
$(this).addClass('tab-t-active');
var activeWidth = $(this).innerWidth();
var itemPos = $(this).position();
$(".tab-t-selector").css({
"left":itemPos.left + "px",
"width": activeWidth + "px"
});
$('.offer').removeClass('active-tab');
$('[data-tab='+$(this).attr('data-select-tab')+']').addClass('active-tab');
})
if($('div').is(".tab-t-selector")){
$(".tab-t-selector").css({
"left":$('.tab-t-active').position().left + "px",
"width": $('.tab-t-active').innerWidth() + "px"
});
}
//price-tabs
$('.img-tab-c-th-img').on("click",function(e){
$(this).closest('.img-tab-c-th').next().find('img').attr('src',$(this).attr('data-full'))
$('.img-tab-c-th-img').removeClass('active-img-tab-c-th-img');
$(this).addClass('active-img-tab-c-th-img');
});
//menu
if($(window).width() > 992) {
$(window).scroll(function(){
if($(this).scrollTop()>400){
$('.site-header').addClass('fixed-header');
$('body').addClass('nav-fixed');
}
if ($(this).scrollTop()<350 && $('.site-header').hasClass('fixed-header')){
$('.site-header').addClass('header-animated');
}
if ($(this).scrollTop()>350 && $('.site-header').hasClass('header-animated')){
$('.site-header').removeClass('header-animated');
}
if ($(this).scrollTop() < 200){
$('.site-header').removeClass('fixed-header');
$('.site-header').removeClass('header-animated');
$('body').removeClass('nav-fixed');
}
});
}
//modal
function hideModal() |
$(".close-modal, .modal-overley").on("click",function(e){
hideModal()
})
$(document).keydown(function(eventObject){
if (eventObject.which == 27)
hideModal()
});
$('[data-modal-open]').on("click",function(e){
event.preventDefault()
$('[data-modal='+ $(this).attr('data-modal-open') +']').addClass('visible-modal')
if($(this).attr('data-modal-open')==1){
$('[data-modal=1] .modal-header-t').text($(this).prev('.cb-c-text').find('.bloc-t').text());
$('[data-modal=1] .modal-hero-descr').text($(this).prev('.cb-c-text').find('.descr').text());
$('[data-modal=1] .modal-hero-img').attr('src',$(this).next('.cb-c-img').attr('src'));
}
if($(this).attr('data-modal-open')==3){
$('[data-modal=3] .centured-m-t').text($(this).parentsUntil('.hf-t').find('h1').text());
$('[data-modal=3] .centured-m-d').text($(this).parentsUntil('.hf-t').find('.hero-content p:first-child').text());
$('[data-modal=3] .main-request-img').attr('src',$('.hf-img img').attr('src'));
}
$('.modal-overley').addClass('modal-overley-show');
$('body').addClass('stop-scroll');
$('body').css('padding-right',getScrollBarWidth ()+'px');
$('.site-header').css('padding-right',getScrollBarWidth ()+'px');
})
// centured-modal-close
$('.centured-modal').on("click",function(e){
hideModal()
}).children()
.click(function(e){
e.stopPropagation();
})
//post-nav
if($('div').is('.post-nav-container')){
if($(window).width() > 768){
$(".sp-text-col h2,.sp-text-col h3,.sp-text-col h4").each(function(i) {
var current = $(this);
current.attr("id", "title" + i);
$(".sp-links .post-nav-container").append("<a calass='post-nav-link' id='link" + i + "' href='#title" + i + "' title='" + $(this).text() + "' data-anchor='" + true + "'>" + current.html() + "</a>");
});
//post-nav-active
$(window).scroll(function(){
var $sections = $('.sp-text-col h2,.sp-text-col h3,.sp-text-col h4');
$sections.each(function(i,el){
var top = $(el).offset().top;
console.log($(window).scrollTop())
var id = $(el).attr('id');
if( (top - $(window).scrollTop()) > 0 && (top - $(window).scrollTop()) < 120){
$('.post-nav-link-active').removeClass('post-nav-link-active');
$('a[href="#'+id+'"]').addClass('post-nav-link-active');
$(".post-nav-selector").css({
"top":$('a[href="#'+id+'"]').position().top + "px",
"height": $('a[href="#'+id+'"]').innerHeight() + "px"
});
}
})
});
}else{
$(".sp-text-col h2,.sp-text-col h3,.sp-text-col h4").each(function(i) {
var current = $(this);
current.attr("id", "title" + i);
$(".sp-mobile-nav .post-nav-container").append("<a calass='post-nav-link' id='link" + i + "' href='#title" + i + "' title='" + $(this).text() + "' data-anchor='" + true + "'>" + current.html() + "</a>");
});
}
}
//like-button
$('.sp-like-button').on("click",function(e){
$(this).addClass('sp-like-button-liked');
$('.sp-l-text').text(Number.parseInt($('.sp-l-text').text())+1);
})
//quiz
var curentStage=1;
$('.cond-quiz-counter-curent').text(curentStage);
$('.cond-quiz-footer-next').prop('disabled',true)
$('.count-line-counter').css('width',(100 / $('.cond-quiz-body').length) + '%')
$('.c-check input').on("change",function(e){
if($('.c-check input:checked').length > 0){
$('.cond-quiz-footer-next').prop('disabled',false)
}
else{
$('.cond-quiz-footer-next').prop('disabled',true)
}
})
$('.c-q-c-c-item').on("click",function(e){
$(this).toggleClass('c-q-c-c-item-selected')
if($('.c-q-c-c-item-selected').length > 0){
$('.cond-quiz-footer-next').prop('disabled',false)
}
else{
$('.cond-quiz-footer-next').prop('disabled',true)
}
})
$('.cond-quiz-footer-next').on("click",function(e){
if(curentStage==1){
$('[data-stage='+curentStage+'] .c-check input:checked').each(function(i) {
var values = $('[data-field-id=field--1]').val();
values += $(this).parent('.c-check').text();
$('[data-field-id=field--1]').val(values.replace(/\s/g, '')+',');
});
}
if(curentStage==2){
$('.c-q-c-c-item-selected').each(function(i) {
var values = $('[data-field-id=field--2]').val();
values += $(this).find('.c-q-c-c-item-descr').text();
$('[data-field-id=field--2]').val(values.replace(/\s/g, '')+',');
});
}
if(curentStage==3){
$('[data-stage='+curentStage+'] .c-check input:checked').each(function(i) {
var values = $('[data-field-id=field--3]').val();
values += $(this).parent('.c-check').text();
$('[data-field-id=field--3]').val(values.replace(/\s/g, '')+', | {
$('[data-modal]').removeClass('visible-modal');
$('.modal-overley').removeClass('modal-overley-show');
setTimeout(function(){
$('body').removeClass('stop-scroll');
$('body').css('padding-right',0+'px');
$('.site-header').css('padding-right',0+'px')
}, 300);
} | identifier_body |
script.js | -parent-active')
panel.css('max-height',panel.prop('scrollHeight') + "px")
} else {
panel.attr('style','');
$(this).toggleClass('links-nav-parent-active')
}
}
})
//menu-script
$('.m-nav-icon').on('click',function(event){
$('.header-overley').addClass('show-overlay');
$('body').addClass('stop-scroll');
$('.m-nav-hiiden').addClass('m-nav-hiiden-active')
})
$('.close-menu-icon, .header-overley').on('click', function(){
$('.header-overley').removeClass('show-overlay');
$('body').removeClass('stop-scroll');
$('.m-nav-hiiden').removeClass('m-nav-hiiden-active')
})
//get scroll-width
function getScrollBarWidth () {
var $outer = $('<div>').css({visibility: 'hidden', width: 100, overflow: 'scroll'}).appendTo('body'),
widthWithScroll = $('<div>').css({width: '100%'}).appendTo($outer).outerWidth();
$outer.remove();
return 100 - widthWithScroll;
};
//tabs
$(".tab-t").on("click",function(e){
$('.tab-t').removeClass('tab-t-active')
$(this).addClass('tab-t-active');
var activeWidth = $(this).innerWidth();
var itemPos = $(this).position();
$(".tab-t-selector").css({
"left":itemPos.left + "px",
"width": activeWidth + "px"
});
$('.offer').removeClass('active-tab');
$('[data-tab='+$(this).attr('data-select-tab')+']').addClass('active-tab');
})
if($('div').is(".tab-t-selector")){
$(".tab-t-selector").css({
"left":$('.tab-t-active').position().left + "px",
"width": $('.tab-t-active').innerWidth() + "px"
});
}
//price-tabs
$('.img-tab-c-th-img').on("click",function(e){
$(this).closest('.img-tab-c-th').next().find('img').attr('src',$(this).attr('data-full'))
$('.img-tab-c-th-img').removeClass('active-img-tab-c-th-img');
$(this).addClass('active-img-tab-c-th-img');
});
//menu
if($(window).width() > 992) {
$(window).scroll(function(){
if($(this).scrollTop()>400){
$('.site-header').addClass('fixed-header');
$('body').addClass('nav-fixed');
}
if ($(this).scrollTop()<350 && $('.site-header').hasClass('fixed-header')){
$('.site-header').addClass('header-animated');
}
if ($(this).scrollTop()>350 && $('.site-header').hasClass('header-animated')){
$('.site-header').removeClass('header-animated');
}
if ($(this).scrollTop() < 200){
$('.site-header').removeClass('fixed-header');
$('.site-header').removeClass('header-animated');
$('body').removeClass('nav-fixed');
}
});
}
//modal
function hideModal(){
$('[data-modal]').removeClass('visible-modal');
$('.modal-overley').removeClass('modal-overley-show');
setTimeout(function(){
$('body').removeClass('stop-scroll');
$('body').css('padding-right',0+'px');
$('.site-header').css('padding-right',0+'px')
}, 300);
}
$(".close-modal, .modal-overley").on("click",function(e){
hideModal()
})
$(document).keydown(function(eventObject){
if (eventObject.which == 27)
hideModal()
});
$('[data-modal-open]').on("click",function(e){
event.preventDefault()
$('[data-modal='+ $(this).attr('data-modal-open') +']').addClass('visible-modal')
if($(this).attr('data-modal-open')==1){
$('[data-modal=1] .modal-header-t').text($(this).prev('.cb-c-text').find('.bloc-t').text());
$('[data-modal=1] .modal-hero-descr').text($(this).prev('.cb-c-text').find('.descr').text());
$('[data-modal=1] .modal-hero-img').attr('src',$(this).next('.cb-c-img').attr('src'));
}
if($(this).attr('data-modal-open')==3){
$('[data-modal=3] .centured-m-t').text($(this).parentsUntil('.hf-t').find('h1').text());
$('[data-modal=3] .centured-m-d').text($(this).parentsUntil('.hf-t').find('.hero-content p:first-child').text());
$('[data-modal=3] .main-request-img').attr('src',$('.hf-img img').attr('src'));
}
$('.modal-overley').addClass('modal-overley-show');
$('body').addClass('stop-scroll');
$('body').css('padding-right',getScrollBarWidth ()+'px');
$('.site-header').css('padding-right',getScrollBarWidth ()+'px');
})
// centured-modal-close
$('.centured-modal').on("click",function(e){
hideModal()
}).children()
.click(function(e){
e.stopPropagation();
})
//post-nav
if($('div').is('.post-nav-container')){
if($(window).width() > 768){
$(".sp-text-col h2,.sp-text-col h3,.sp-text-col h4").each(function(i) {
var current = $(this);
current.attr("id", "title" + i);
$(".sp-links .post-nav-container").append("<a calass='post-nav-link' id='link" + i + "' href='#title" + i + "' title='" + $(this).text() + "' data-anchor='" + true + "'>" + current.html() + "</a>");
});
//post-nav-active
$(window).scroll(function(){
var $sections = $('.sp-text-col h2,.sp-text-col h3,.sp-text-col h4');
$sections.each(function(i,el){
var top = $(el).offset().top;
console.log($(window).scrollTop())
var id = $(el).attr('id');
if( (top - $(window).scrollTop()) > 0 && (top - $(window).scrollTop()) < 120){
$('.post-nav-link-active').removeClass('post-nav-link-active');
$('a[href="#'+id+'"]').addClass('post-nav-link-active');
$(".post-nav-selector").css({
"top":$('a[href="#'+id+'"]').position().top + "px",
"height": $('a[href="#'+id+'"]').innerHeight() + "px"
});
}
})
});
}else{
$(".sp-text-col h2,.sp-text-col h3,.sp-text-col h4").each(function(i) {
var current = $(this);
current.attr("id", "title" + i);
$(".sp-mobile-nav .post-nav-container").append("<a calass='post-nav-link' id='link" + i + "' href='#title" + i + "' title='" + $(this).text() + "' data-anchor='" + true + "'>" + current.html() + "</a>");
});
}
}
//like-button
$('.sp-like-button').on("click",function(e){
$(this).addClass('sp-like-button-liked');
$('.sp-l-text').text(Number.parseInt($('.sp-l-text').text())+1);
})
//quiz
var curentStage=1;
$('.cond-quiz-counter-curent').text(curentStage);
$('.cond-quiz-footer-next').prop('disabled',true)
$('.count-line-counter').css('width',(100 / $('.cond-quiz-body').length) + '%')
$('.c-check input').on("change",function(e){
if($('.c-check input:checked').length > 0){
$('.cond-quiz-footer-next').prop('disabled',false)
}
else{
$('.cond-quiz-footer-next').prop('disabled',true)
}
})
$('.c-q-c-c-item').on("click",function(e){
$(this).toggleClass('c-q-c-c-item-selected')
if($('.c-q-c-c-item-selected').length > 0){
$('.cond-quiz-footer-next').prop('disabled',false)
}
else{
$('.cond-quiz-footer-next').prop('disabled',true)
}
})
$('.cond-quiz-footer-next').on("click",function(e){
if(curentStage==1) |
if(curentStage==2){
$('.c-q-c-c-item-selected').each(function(i) {
var values = $('[data-field-id=field--2]').val();
values += $(this).find('.c-q-c-c-item-descr').text();
$('[data-field-id=field--2]').val(values.replace(/\s/g, '')+',');
});
}
if(curentStage==3){
$('[data-stage='+curentStage+'] .c-check input:checked').each(function(i) {
var values = $('[data-field-id=field--3]').val();
values += $(this).parent('.c-check').text();
$('[data-field-id=field--3]').val(values.replace(/\s/g, '')+', | {
$('[data-stage='+curentStage+'] .c-check input:checked').each(function(i) {
var values = $('[data-field-id=field--1]').val();
values += $(this).parent('.c-check').text();
$('[data-field-id=field--1]').val(values.replace(/\s/g, '')+',');
});
} | conditional_block |
CORAL_train.py | ", "", "")
flags.DEFINE_integer('n_test', 10000, 'Number of test images')
flags.DEFINE_string('test_txt', '', 'Test text(label) path')
flags.DEFINE_string('test_img', '', 'Test images path')
flags.DEFINE_string("output_loss_txt", "/yuwhan/Edisk/yuwhan/Edisk/4th_paper/age_banchmark/UTK/loss_CORAL.txt", "")
FLAGS = flags.FLAGS
FLAGS(sys.argv)
optimizer = tf.keras.optimizers.Adam(FLAGS.lr,beta_1=0.9, beta_2=0.99)
def _func(filename, label):
image_string = tf.io.read_file(filename)
decode_image = tf.image.decode_jpeg(image_string, channels=3)
decode_image = tf.image.resize(decode_image, [FLAGS.img_size - 8, FLAGS.img_size - 8]) / 255.
#decode_image = tf.image.random_crop(decode_image, [FLAGS.img_size - 8, FLAGS.img_size - 8, 3])
if random() > 0.5:
decode_image = tf.image.flip_left_right(decode_image)
#decode_image = tf.image.per_image_standardization(decode_image)
label = label - 16
one_hot = tf.one_hot(label, FLAGS.num_classes)
return decode_image, one_hot, label
def val_func(name, label):
image_string = tf.io.read_file(name)
decode_image = tf.image.decode_jpeg(image_string, channels=3)
decode_image = tf.image.resize(decode_image, [FLAGS.img_size - 8, FLAGS.img_size - 8]) / 255.
#decode_image = tf.image.per_image_standardization(decode_image)
label = int(label) - 16
one_hot = tf.one_hot(label, FLAGS.num_classes)
return decode_image, one_hot
#@tf.function
def run_model(model, images):
|
@tf.function
def train_step(model, images, levels, imp):
with tf.GradientTape() as tape:
logits, probs = run_model(model, images)
#total_loss = (-tf.reduce_sum((tf.nn.log_softmax(logits, axis=2)[:,:,1]*levels + tf.nn.log_softmax(logits, axis=2)[:,:,0]*(1-levels))*imp, 1))
# total_loss = (-tf.reduce_sum( (tf.math.log_sigmoid(logits)*levels + tf.math.log(1. - tf.nn.sigmoid(logits))*(1-levels))*imp, 1))
total_loss = (-tf.reduce_sum( (tf.math.log_sigmoid(logits)*levels + (tf.math.log_sigmoid(logits) - logits)*(1-levels))*imp, 1))
#total_loss = -tf.reduce_sum((tf.math.log(tf.nn.softmax(logits, 2)[:, :, 1] + 1e-7) * levels \
# + tf.math.log(tf.nn.softmax(logits, 2)[:, :, 0] + 1e-7) * (1 - levels)) * imp, 1)
total_loss = tf.reduce_mean(total_loss)
gradients = tape.gradient(total_loss, model.trainable_variables)
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
return total_loss
def task_importance_weights(data):
label = np.array(data).astype(np.float32)
num_examples = label.size
y = np.unique(label)
m = np.zeros(label.shape)
for i, t in enumerate(np.arange(np.min(y), np.max(y))):
m_k = np.max([label[label > t].size,
num_examples - label[label > t].size])
#print(m_k)
m_k = tf.cast(tf.convert_to_tensor(m_k), tf.float32)
m[i] = tf.sqrt(m_k)
# m[i] = float(m_k)**(0.5)
max_ = np.max(m)
imp = tf.cast(m / max_, tf.float32)
#print(imp)
return imp
@tf.function
def test_MAE(model, images, labels):
logits, probs = model(images, training=False)
predict = probs > 0.5
predict = tf.cast(predict, tf.float32)
pre_age = tf.reduce_sum(predict, 1)
grd_age = tf.argmax(labels, 1) + 1
grd_age = tf.cast(grd_age, tf.float32)
AE = tf.reduce_sum(tf.math.abs(grd_age - pre_age))
return AE
def make_levels(labels):
levels = []
for i in range(FLAGS.batch_size):
l = [1] * (labels[i].numpy()) + [0]*(FLAGS.num_classes - 1 - labels[i].numpy())
l = tf.cast(l, tf.float32)
levels.append(l)
return tf.convert_to_tensor(levels, tf.float32)
def main(argv=None):
# train_model = resnet_type1(input_shape=(FLAGS.img_size - 8, FLAGS.img_size - 8, 3), NUM_CLASSES=FLAGS.num_classes)
train_model = ResNet34(input_shape=(FLAGS.img_size - 8, FLAGS.img_size - 8, FLAGS.ch), include_top=False,
batch_size=FLAGS.batch_size, weight_path=FLAGS.weights, weights='imagenet')
regularizer = tf.keras.regularizers.l2(0.000005)
initializer = tf.keras.initializers.glorot_normal()
for layer in train_model.layers:
for attr in ['kernel_regularizer']:
if hasattr(layer, attr):
setattr(layer, attr, regularizer)
# for attr_ in ["kernel_initializer"]:
# if hasattr(layer, attr_):
# setattr(layer, attr_, initializer)
x = train_model.output
avgpool = tf.keras.layers.GlobalAveragePooling2D()(x)
# avgpool = tf.reshape(avgpool, [avgpool.shape[0], -1])
# fc = tf.keras.layers.Dense(1, use_bias=False)(avgpool)
# logits = Linear(NUM_CLASSES - 1)(fc)
logits = tf.keras.layers.Dense(FLAGS.num_classes-1, use_bias=False)(avgpool)
logits = Linear(FLAGS.num_classes - 1)(logits)
probs = tf.nn.sigmoid(logits)
train_model = tf.keras.Model(inputs=train_model.input, outputs=[logits, probs])
train_model.summary()
#for m in train_model.layers:
# if isinstance(m, tf.keras.layers.Conv2D):
# a = m.output_mask
# n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
# m.weight.data.normal_(0, (2. / n)**.5)
# elif isinstance(m, tf.keras.layers.BatchNormalization):
# m.get_weights
# m.weight.data.fill_(1)
# m.bias.data.zero_()
if FLAGS.pre_checkpoint is True:
ckpt = tf.train.Checkpoint(train_model=train_model, optimizer=optimizer)
ckpt_manager = tf.train.CheckpointManager(ckpt, FLAGS.pre_checkpoint_path, max_to_keep=5)
# if a checkpoint exists, restore the latest checkpoint.
if ckpt_manager.latest_checkpoint:
print(ckpt_manager.latest_checkpoint)
ckpt.restore(ckpt_manager.latest_checkpoint)
print ('Latest checkpoint restored!!')
if FLAGS.train == True:
data_name = np.loadtxt(FLAGS.txt_path, dtype='<U100', skiprows=0, usecols=0)
data_name = [FLAGS.img_path + data_name_ for data_name_ in data_name]
data_label = np.loadtxt(FLAGS.txt_path, dtype=np.int32, skiprows=0, usecols=1)
imp = task_importance_weights(data_label-16)
imp = imp[0:FLAGS.num_classes-1]
val_data_name = np.loadtxt(FLAGS.val_txt_path, dtype='<U100', skiprows=0, usecols=[0, 1, 2, 3])
print(len(val_data_name))
WM_img, WM_age = [], []
WF_img, WF_age = [], []
BM_img, BM_age = [], []
BF_img, BF_age = [], []
for i in range(len(val_data_name)):
if val_data_name[i][2] == "M" and val_data_name[i][3] == "W":
WM_img.append(FLAGS.val_img_path + val_data_name[i][0])
WM_age.append(val_data_name[i][1])
if val_data_name[i][2] == "F" and val_data_name[i][3] == "W":
WF_img.append(FLAGS.val_img_path + val_data_name[i][0])
WF_age.append(val_data_name[i][1])
if val_data_name[i][2] == "M" and val_data_name[i][3] == "B":
BM_img.append(FLAGS.val_img_path + val_data_name[i][0])
BM_age.append(val_data_name[i][1])
if val_data_name[i][2] == "F" and val_data_name[i][3] == "B":
BF_img.append(FLAGS.val_img_path + val_data_name[i][0])
BF_age.append(val_data_name[i][1])
print(len(WM_img), len(WF_img), len(BM_img), len(BF_img))
WM_img, WM_age = np.array(WM | logits, probs = model(images, training=True)
return logits, probs | identifier_body |
CORAL_train.py | .000005)
initializer = tf.keras.initializers.glorot_normal()
for layer in train_model.layers:
for attr in ['kernel_regularizer']:
if hasattr(layer, attr):
setattr(layer, attr, regularizer)
# for attr_ in ["kernel_initializer"]:
# if hasattr(layer, attr_):
# setattr(layer, attr_, initializer)
x = train_model.output
avgpool = tf.keras.layers.GlobalAveragePooling2D()(x)
# avgpool = tf.reshape(avgpool, [avgpool.shape[0], -1])
# fc = tf.keras.layers.Dense(1, use_bias=False)(avgpool)
# logits = Linear(NUM_CLASSES - 1)(fc)
logits = tf.keras.layers.Dense(FLAGS.num_classes-1, use_bias=False)(avgpool)
logits = Linear(FLAGS.num_classes - 1)(logits)
probs = tf.nn.sigmoid(logits)
train_model = tf.keras.Model(inputs=train_model.input, outputs=[logits, probs])
train_model.summary()
#for m in train_model.layers:
# if isinstance(m, tf.keras.layers.Conv2D):
# a = m.output_mask
# n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
# m.weight.data.normal_(0, (2. / n)**.5)
# elif isinstance(m, tf.keras.layers.BatchNormalization):
# m.get_weights
# m.weight.data.fill_(1)
# m.bias.data.zero_()
if FLAGS.pre_checkpoint is True:
ckpt = tf.train.Checkpoint(train_model=train_model, optimizer=optimizer)
ckpt_manager = tf.train.CheckpointManager(ckpt, FLAGS.pre_checkpoint_path, max_to_keep=5)
# if a checkpoint exists, restore the latest checkpoint.
if ckpt_manager.latest_checkpoint:
print(ckpt_manager.latest_checkpoint)
ckpt.restore(ckpt_manager.latest_checkpoint)
print ('Latest checkpoint restored!!')
if FLAGS.train == True:
data_name = np.loadtxt(FLAGS.txt_path, dtype='<U100', skiprows=0, usecols=0)
data_name = [FLAGS.img_path + data_name_ for data_name_ in data_name]
data_label = np.loadtxt(FLAGS.txt_path, dtype=np.int32, skiprows=0, usecols=1)
imp = task_importance_weights(data_label-16)
imp = imp[0:FLAGS.num_classes-1]
val_data_name = np.loadtxt(FLAGS.val_txt_path, dtype='<U100', skiprows=0, usecols=[0, 1, 2, 3])
print(len(val_data_name))
WM_img, WM_age = [], []
WF_img, WF_age = [], []
BM_img, BM_age = [], []
BF_img, BF_age = [], []
for i in range(len(val_data_name)):
if val_data_name[i][2] == "M" and val_data_name[i][3] == "W":
WM_img.append(FLAGS.val_img_path + val_data_name[i][0])
WM_age.append(val_data_name[i][1])
if val_data_name[i][2] == "F" and val_data_name[i][3] == "W":
WF_img.append(FLAGS.val_img_path + val_data_name[i][0])
WF_age.append(val_data_name[i][1])
if val_data_name[i][2] == "M" and val_data_name[i][3] == "B":
BM_img.append(FLAGS.val_img_path + val_data_name[i][0])
BM_age.append(val_data_name[i][1])
if val_data_name[i][2] == "F" and val_data_name[i][3] == "B":
BF_img.append(FLAGS.val_img_path + val_data_name[i][0])
BF_age.append(val_data_name[i][1])
print(len(WM_img), len(WF_img), len(BM_img), len(BF_img))
WM_img, WM_age = np.array(WM_img), np.array(WM_age)
WF_img, WF_age = np.array(WF_img), np.array(WF_age)
BM_img, BM_age = np.array(BM_img), np.array(BM_age)
BF_img, BF_age = np.array(BF_img), np.array(BF_age)
all_val_list = [[WM_img, WM_age], [WF_img, WF_age], [BM_img, BM_age], [BF_img, BF_age]]
batch_idx = len(data_label) // FLAGS.batch_size
#current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
#train_log_dir = FLAGS.graphs + current_time + '/train'
#val_log_dir = FLAGS.graphs + current_time + '/val'
#train_summary_writer = tf.summary.create_file_writer(train_log_dir)
#val_summary_writer = tf.summary.create_file_writer(val_log_dir)
loss_f = open(FLAGS.output_loss_txt, "w")
count = 0
for epoch in range(FLAGS.epochs):
A = list(zip(data_name, data_label))
shuffle(A)
data_name, data_label = zip(*A)
data_name = np.array(data_name)
data_label = np.array(data_label)
data_generator = tf.data.Dataset.from_tensor_slices((data_name, data_label))
data_generator = data_generator.shuffle(len(data_name))
data_generator = data_generator.map(_func)
data_generator = data_generator.batch(FLAGS.batch_size)
data_generator = data_generator.prefetch(tf.data.experimental.AUTOTUNE)
it = iter(data_generator)
#imp = task_importance_weights(data_label)
#imp = imp[0:FLAGS.num_classes-1]
for step in range(batch_idx):
batch_images, batch_labels, age = next(it)
levels = make_levels(age)
total_loss = train_step(train_model, batch_images, levels, imp)
#with val_summary_writer.as_default():
# tf.summary.scalar(u'total loss', loss, step=count)
if count % 10 == 0:
#MAE = test_MAE(train_model, batch_images, batch_labels, levels)
print('Epoch: {} [{}/{}] loss = {}'.format(epoch + 1, step + 1, batch_idx, total_loss))
if count % 100 == 0:
test_list = ["WM", "WF", "BM", "BF"]
for j in range(len(all_val_list)):
val_img, val_lab = all_val_list[j]
val_data_generator = tf.data.Dataset.from_tensor_slices((val_img, val_lab))
val_data_generator = val_data_generator.map(val_func)
val_data_generator = val_data_generator.batch(1)
val_data_generator = val_data_generator.prefetch(tf.data.experimental.AUTOTUNE)
val_idx = len(val_img) // 1
val_it = iter(val_data_generator)
AE = 0
for i in range(val_idx):
img, lab = next(val_it)
pre_age = test_MAE(train_model, img, lab)
AE += pre_age
print("MAE = {} ({})".format(AE / len(val_img), test_list[j]))
loss_f.write("Epochs: {}, step = {}".format(epoch, count))
loss_f.write(" --> ")
loss_f.write(test_list[j])
loss_f.write(": ")
loss_f.write(str(AE / len(val_img)))
loss_f.write(", ")
loss_f.write("\n")
loss_f.flush()
# print("==========")
# print("[2]MAE = {}".format(MAE))
# print("==========")
# model_dir = FLAGS.save_checkpoint
# folder_name = int((count + 1)/val_idx)
# folder_name_str = "%s/%s" % (model_dir, folder_name)
# if not os.path.isdir(folder_name_str):
# print("Make {} folder to save checkpoint".format(folder_name))
# os.makedirs(folder_name_str)
# ckpt = tf.train.Checkpoint(train_model=train_model, optimizer=optimizer)
# checkpoint_dir = folder_name_str + "/" + "CORAL_{}_steps.ckpt".format(count)
# ckpt_manager = tf.train.CheckpointManager(ckpt, checkpoint_dir, 5)
# ckpt_manager.save()
# with val_summary_writer.as_default():
# tf.summary.scalar(u'[2]MAE', MAE, step=count)
count += 1
else:
| data_name = np.loadtxt(FLAGS.test_txt, dtype='<U100', skiprows=0, usecols=0)
data_name = [FLAGS.test_img + data_name_ for data_name_ in data_name]
data_label = np.loadtxt(FLAGS.txt_path, dtype=np.float32, skiprows=0, usecols=1)
data_generator = tf.data.Dataset.from_tensor_slices((data_name, data_label))
data_generator = data_generator.shuffle(len(data_name))
data_generator = data_generator.map(_func)
data_generator = data_generator.batch(1)
data_generator = data_generator.prefetch(tf.data.experimental.AUTOTUNE)
MAE = 0
it = iter(data_generator)
for i in range(FLAGS.n_test):
image, labels, opp_labels = next(it)
_, probs = train_model(image, training=False)
predict = probs > 0.5
predict = tf.cast(predict, tf.float32) | conditional_block |
|
CORAL_train.py | ", "", "")
flags.DEFINE_integer('n_test', 10000, 'Number of test images')
flags.DEFINE_string('test_txt', '', 'Test text(label) path')
flags.DEFINE_string('test_img', '', 'Test images path')
flags.DEFINE_string("output_loss_txt", "/yuwhan/Edisk/yuwhan/Edisk/4th_paper/age_banchmark/UTK/loss_CORAL.txt", "")
FLAGS = flags.FLAGS
FLAGS(sys.argv)
optimizer = tf.keras.optimizers.Adam(FLAGS.lr,beta_1=0.9, beta_2=0.99)
def _func(filename, label):
image_string = tf.io.read_file(filename)
decode_image = tf.image.decode_jpeg(image_string, channels=3)
decode_image = tf.image.resize(decode_image, [FLAGS.img_size - 8, FLAGS.img_size - 8]) / 255.
#decode_image = tf.image.random_crop(decode_image, [FLAGS.img_size - 8, FLAGS.img_size - 8, 3])
if random() > 0.5:
decode_image = tf.image.flip_left_right(decode_image)
#decode_image = tf.image.per_image_standardization(decode_image)
label = label - 16
one_hot = tf.one_hot(label, FLAGS.num_classes)
return decode_image, one_hot, label
def val_func(name, label):
image_string = tf.io.read_file(name)
decode_image = tf.image.decode_jpeg(image_string, channels=3)
decode_image = tf.image.resize(decode_image, [FLAGS.img_size - 8, FLAGS.img_size - 8]) / 255.
#decode_image = tf.image.per_image_standardization(decode_image)
label = int(label) - 16
one_hot = tf.one_hot(label, FLAGS.num_classes)
return decode_image, one_hot
#@tf.function
def | (model, images):
logits, probs = model(images, training=True)
return logits, probs
@tf.function
def train_step(model, images, levels, imp):
with tf.GradientTape() as tape:
logits, probs = run_model(model, images)
#total_loss = (-tf.reduce_sum((tf.nn.log_softmax(logits, axis=2)[:,:,1]*levels + tf.nn.log_softmax(logits, axis=2)[:,:,0]*(1-levels))*imp, 1))
# total_loss = (-tf.reduce_sum( (tf.math.log_sigmoid(logits)*levels + tf.math.log(1. - tf.nn.sigmoid(logits))*(1-levels))*imp, 1))
total_loss = (-tf.reduce_sum( (tf.math.log_sigmoid(logits)*levels + (tf.math.log_sigmoid(logits) - logits)*(1-levels))*imp, 1))
#total_loss = -tf.reduce_sum((tf.math.log(tf.nn.softmax(logits, 2)[:, :, 1] + 1e-7) * levels \
# + tf.math.log(tf.nn.softmax(logits, 2)[:, :, 0] + 1e-7) * (1 - levels)) * imp, 1)
total_loss = tf.reduce_mean(total_loss)
gradients = tape.gradient(total_loss, model.trainable_variables)
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
return total_loss
def task_importance_weights(data):
label = np.array(data).astype(np.float32)
num_examples = label.size
y = np.unique(label)
m = np.zeros(label.shape)
for i, t in enumerate(np.arange(np.min(y), np.max(y))):
m_k = np.max([label[label > t].size,
num_examples - label[label > t].size])
#print(m_k)
m_k = tf.cast(tf.convert_to_tensor(m_k), tf.float32)
m[i] = tf.sqrt(m_k)
# m[i] = float(m_k)**(0.5)
max_ = np.max(m)
imp = tf.cast(m / max_, tf.float32)
#print(imp)
return imp
@tf.function
def test_MAE(model, images, labels):
logits, probs = model(images, training=False)
predict = probs > 0.5
predict = tf.cast(predict, tf.float32)
pre_age = tf.reduce_sum(predict, 1)
grd_age = tf.argmax(labels, 1) + 1
grd_age = tf.cast(grd_age, tf.float32)
AE = tf.reduce_sum(tf.math.abs(grd_age - pre_age))
return AE
def make_levels(labels):
levels = []
for i in range(FLAGS.batch_size):
l = [1] * (labels[i].numpy()) + [0]*(FLAGS.num_classes - 1 - labels[i].numpy())
l = tf.cast(l, tf.float32)
levels.append(l)
return tf.convert_to_tensor(levels, tf.float32)
def main(argv=None):
# train_model = resnet_type1(input_shape=(FLAGS.img_size - 8, FLAGS.img_size - 8, 3), NUM_CLASSES=FLAGS.num_classes)
train_model = ResNet34(input_shape=(FLAGS.img_size - 8, FLAGS.img_size - 8, FLAGS.ch), include_top=False,
batch_size=FLAGS.batch_size, weight_path=FLAGS.weights, weights='imagenet')
regularizer = tf.keras.regularizers.l2(0.000005)
initializer = tf.keras.initializers.glorot_normal()
for layer in train_model.layers:
for attr in ['kernel_regularizer']:
if hasattr(layer, attr):
setattr(layer, attr, regularizer)
# for attr_ in ["kernel_initializer"]:
# if hasattr(layer, attr_):
# setattr(layer, attr_, initializer)
x = train_model.output
avgpool = tf.keras.layers.GlobalAveragePooling2D()(x)
# avgpool = tf.reshape(avgpool, [avgpool.shape[0], -1])
# fc = tf.keras.layers.Dense(1, use_bias=False)(avgpool)
# logits = Linear(NUM_CLASSES - 1)(fc)
logits = tf.keras.layers.Dense(FLAGS.num_classes-1, use_bias=False)(avgpool)
logits = Linear(FLAGS.num_classes - 1)(logits)
probs = tf.nn.sigmoid(logits)
train_model = tf.keras.Model(inputs=train_model.input, outputs=[logits, probs])
train_model.summary()
#for m in train_model.layers:
# if isinstance(m, tf.keras.layers.Conv2D):
# a = m.output_mask
# n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
# m.weight.data.normal_(0, (2. / n)**.5)
# elif isinstance(m, tf.keras.layers.BatchNormalization):
# m.get_weights
# m.weight.data.fill_(1)
# m.bias.data.zero_()
if FLAGS.pre_checkpoint is True:
ckpt = tf.train.Checkpoint(train_model=train_model, optimizer=optimizer)
ckpt_manager = tf.train.CheckpointManager(ckpt, FLAGS.pre_checkpoint_path, max_to_keep=5)
# if a checkpoint exists, restore the latest checkpoint.
if ckpt_manager.latest_checkpoint:
print(ckpt_manager.latest_checkpoint)
ckpt.restore(ckpt_manager.latest_checkpoint)
print ('Latest checkpoint restored!!')
if FLAGS.train == True:
data_name = np.loadtxt(FLAGS.txt_path, dtype='<U100', skiprows=0, usecols=0)
data_name = [FLAGS.img_path + data_name_ for data_name_ in data_name]
data_label = np.loadtxt(FLAGS.txt_path, dtype=np.int32, skiprows=0, usecols=1)
imp = task_importance_weights(data_label-16)
imp = imp[0:FLAGS.num_classes-1]
val_data_name = np.loadtxt(FLAGS.val_txt_path, dtype='<U100', skiprows=0, usecols=[0, 1, 2, 3])
print(len(val_data_name))
WM_img, WM_age = [], []
WF_img, WF_age = [], []
BM_img, BM_age = [], []
BF_img, BF_age = [], []
for i in range(len(val_data_name)):
if val_data_name[i][2] == "M" and val_data_name[i][3] == "W":
WM_img.append(FLAGS.val_img_path + val_data_name[i][0])
WM_age.append(val_data_name[i][1])
if val_data_name[i][2] == "F" and val_data_name[i][3] == "W":
WF_img.append(FLAGS.val_img_path + val_data_name[i][0])
WF_age.append(val_data_name[i][1])
if val_data_name[i][2] == "M" and val_data_name[i][3] == "B":
BM_img.append(FLAGS.val_img_path + val_data_name[i][0])
BM_age.append(val_data_name[i][1])
if val_data_name[i][2] == "F" and val_data_name[i][3] == "B":
BF_img.append(FLAGS.val_img_path + val_data_name[i][0])
BF_age.append(val_data_name[i][1])
print(len(WM_img), len(WF_img), len(BM_img), len(BF_img))
WM_img, WM_age = np.array(WM | run_model | identifier_name |
CORAL_train.py | ))*imp, 1))
#total_loss = -tf.reduce_sum((tf.math.log(tf.nn.softmax(logits, 2)[:, :, 1] + 1e-7) * levels \
# + tf.math.log(tf.nn.softmax(logits, 2)[:, :, 0] + 1e-7) * (1 - levels)) * imp, 1)
total_loss = tf.reduce_mean(total_loss)
gradients = tape.gradient(total_loss, model.trainable_variables)
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
return total_loss
def task_importance_weights(data):
label = np.array(data).astype(np.float32)
num_examples = label.size
y = np.unique(label)
m = np.zeros(label.shape)
for i, t in enumerate(np.arange(np.min(y), np.max(y))):
m_k = np.max([label[label > t].size,
num_examples - label[label > t].size])
#print(m_k)
m_k = tf.cast(tf.convert_to_tensor(m_k), tf.float32)
m[i] = tf.sqrt(m_k)
# m[i] = float(m_k)**(0.5)
max_ = np.max(m)
imp = tf.cast(m / max_, tf.float32)
#print(imp)
return imp
@tf.function
def test_MAE(model, images, labels):
logits, probs = model(images, training=False)
predict = probs > 0.5
predict = tf.cast(predict, tf.float32)
pre_age = tf.reduce_sum(predict, 1)
grd_age = tf.argmax(labels, 1) + 1
grd_age = tf.cast(grd_age, tf.float32)
AE = tf.reduce_sum(tf.math.abs(grd_age - pre_age))
return AE
def make_levels(labels):
levels = []
for i in range(FLAGS.batch_size):
l = [1] * (labels[i].numpy()) + [0]*(FLAGS.num_classes - 1 - labels[i].numpy())
l = tf.cast(l, tf.float32)
levels.append(l)
return tf.convert_to_tensor(levels, tf.float32)
def main(argv=None):
# train_model = resnet_type1(input_shape=(FLAGS.img_size - 8, FLAGS.img_size - 8, 3), NUM_CLASSES=FLAGS.num_classes)
train_model = ResNet34(input_shape=(FLAGS.img_size - 8, FLAGS.img_size - 8, FLAGS.ch), include_top=False,
batch_size=FLAGS.batch_size, weight_path=FLAGS.weights, weights='imagenet')
regularizer = tf.keras.regularizers.l2(0.000005)
initializer = tf.keras.initializers.glorot_normal()
for layer in train_model.layers:
for attr in ['kernel_regularizer']:
if hasattr(layer, attr):
setattr(layer, attr, regularizer)
# for attr_ in ["kernel_initializer"]:
# if hasattr(layer, attr_):
# setattr(layer, attr_, initializer)
x = train_model.output
avgpool = tf.keras.layers.GlobalAveragePooling2D()(x)
# avgpool = tf.reshape(avgpool, [avgpool.shape[0], -1])
# fc = tf.keras.layers.Dense(1, use_bias=False)(avgpool)
# logits = Linear(NUM_CLASSES - 1)(fc)
logits = tf.keras.layers.Dense(FLAGS.num_classes-1, use_bias=False)(avgpool)
logits = Linear(FLAGS.num_classes - 1)(logits)
probs = tf.nn.sigmoid(logits)
train_model = tf.keras.Model(inputs=train_model.input, outputs=[logits, probs])
train_model.summary()
#for m in train_model.layers:
# if isinstance(m, tf.keras.layers.Conv2D):
# a = m.output_mask
# n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
# m.weight.data.normal_(0, (2. / n)**.5)
# elif isinstance(m, tf.keras.layers.BatchNormalization):
# m.get_weights
# m.weight.data.fill_(1)
# m.bias.data.zero_()
if FLAGS.pre_checkpoint is True:
ckpt = tf.train.Checkpoint(train_model=train_model, optimizer=optimizer)
ckpt_manager = tf.train.CheckpointManager(ckpt, FLAGS.pre_checkpoint_path, max_to_keep=5)
# if a checkpoint exists, restore the latest checkpoint.
if ckpt_manager.latest_checkpoint:
print(ckpt_manager.latest_checkpoint)
ckpt.restore(ckpt_manager.latest_checkpoint)
print ('Latest checkpoint restored!!')
if FLAGS.train == True:
data_name = np.loadtxt(FLAGS.txt_path, dtype='<U100', skiprows=0, usecols=0)
data_name = [FLAGS.img_path + data_name_ for data_name_ in data_name]
data_label = np.loadtxt(FLAGS.txt_path, dtype=np.int32, skiprows=0, usecols=1)
imp = task_importance_weights(data_label-16)
imp = imp[0:FLAGS.num_classes-1]
val_data_name = np.loadtxt(FLAGS.val_txt_path, dtype='<U100', skiprows=0, usecols=[0, 1, 2, 3])
print(len(val_data_name))
WM_img, WM_age = [], []
WF_img, WF_age = [], []
BM_img, BM_age = [], []
BF_img, BF_age = [], []
for i in range(len(val_data_name)):
if val_data_name[i][2] == "M" and val_data_name[i][3] == "W":
WM_img.append(FLAGS.val_img_path + val_data_name[i][0])
WM_age.append(val_data_name[i][1])
if val_data_name[i][2] == "F" and val_data_name[i][3] == "W":
WF_img.append(FLAGS.val_img_path + val_data_name[i][0])
WF_age.append(val_data_name[i][1])
if val_data_name[i][2] == "M" and val_data_name[i][3] == "B":
BM_img.append(FLAGS.val_img_path + val_data_name[i][0])
BM_age.append(val_data_name[i][1])
if val_data_name[i][2] == "F" and val_data_name[i][3] == "B":
BF_img.append(FLAGS.val_img_path + val_data_name[i][0])
BF_age.append(val_data_name[i][1])
print(len(WM_img), len(WF_img), len(BM_img), len(BF_img))
WM_img, WM_age = np.array(WM_img), np.array(WM_age)
WF_img, WF_age = np.array(WF_img), np.array(WF_age)
BM_img, BM_age = np.array(BM_img), np.array(BM_age)
BF_img, BF_age = np.array(BF_img), np.array(BF_age)
all_val_list = [[WM_img, WM_age], [WF_img, WF_age], [BM_img, BM_age], [BF_img, BF_age]]
batch_idx = len(data_label) // FLAGS.batch_size
#current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
#train_log_dir = FLAGS.graphs + current_time + '/train'
#val_log_dir = FLAGS.graphs + current_time + '/val'
#train_summary_writer = tf.summary.create_file_writer(train_log_dir)
#val_summary_writer = tf.summary.create_file_writer(val_log_dir)
loss_f = open(FLAGS.output_loss_txt, "w")
count = 0
for epoch in range(FLAGS.epochs):
A = list(zip(data_name, data_label))
shuffle(A)
data_name, data_label = zip(*A)
data_name = np.array(data_name)
data_label = np.array(data_label)
data_generator = tf.data.Dataset.from_tensor_slices((data_name, data_label))
data_generator = data_generator.shuffle(len(data_name))
data_generator = data_generator.map(_func)
data_generator = data_generator.batch(FLAGS.batch_size)
data_generator = data_generator.prefetch(tf.data.experimental.AUTOTUNE)
it = iter(data_generator)
#imp = task_importance_weights(data_label)
#imp = imp[0:FLAGS.num_classes-1]
for step in range(batch_idx):
batch_images, batch_labels, age = next(it)
levels = make_levels(age)
total_loss = train_step(train_model, batch_images, levels, imp)
#with val_summary_writer.as_default():
# tf.summary.scalar(u'total loss', loss, step=count)
if count % 10 == 0:
#MAE = test_MAE(train_model, batch_images, batch_labels, levels)
print('Epoch: {} [{}/{}] loss = {}'.format(epoch + 1, step + 1, batch_idx, total_loss))
if count % 100 == 0:
test_list = ["WM", "WF", "BM", "BF"]
for j in range(len(all_val_list)):
val_img, val_lab = all_val_list[j]
val_data_generator = tf.data.Dataset.from_tensor_slices((val_img, val_lab))
val_data_generator = val_data_generator.map(val_func)
val_data_generator = val_data_generator.batch(1) | val_data_generator = val_data_generator.prefetch(tf.data.experimental.AUTOTUNE) | random_line_split |
|
sales-component.component.ts | SalePaymentMethod } from 'app/InventoryApp/Models/DTOs/SalePaymentMethod';
import { SaleUserBranchProductsDTO } from 'app/InventoryApp/Models/DTOs/SaleUserBranchProductsDTO';
import { DxStoreOptions } from 'app/InventoryApp/Models/DxStoreOptions';
import { LoginResponse } from 'app/InventoryApp/Models/LoginResponse';
import { UIResponse } from 'app/InventoryApp/Models/UIResponse';
import { PaymentScreenComponent } from 'app/InventoryApp/Selling/PaymentScreen/payment-screen.component';
import { DxStoreService } from 'app/InventoryApp/services/dx-store.service';
import { NormalSatisService } from 'app/InventoryApp/services/normal-satis.service';
import { SwalService } from 'app/InventoryApp/services/Swal.Service';
import { DxDataGridComponent, DxLookupComponent } from 'devextreme-angular';
import CustomStore from 'devextreme/data/custom_store';
import DataSource from 'devextreme/data/data_source';
import { Subscription } from 'rxjs';
import { tap } from 'rxjs/operators';
@Component({
selector: 'app-sales-component',
templateUrl: './sales-component.component.html',
styleUrls: ['./sales-component.component.scss'],
encapsulation: ViewEncapsulation.None,
animations: fuseAnimations
})
export class SalesComponentComponent implements OnInit {
RangeStartDate: Date;
RangeEndDate: Date;
Genders: any = [{ Value: 0, ViewValue: 'Erkek' }, { Value: 1, ViewValue: 'Kadın' }]
// Here I used Material Table
ProductsToSellDisplayedColumns = ['ProductName', 'ProductBarcode', 'ProductCode', 'ColorName', 'Gender', 'ProductYear', 'SellingPrice', 'Size', 'BranchName', 'actions'];
ProductsToSellDataSource: ProductView[] = [];
ProductsToSellTableRows: ProductView[] = [];
@ViewChild("soledProductsGrid") soledProductsGrid: DxDataGridComponent;
@ViewChild("customerInfoLookup") customerInfoLookup: DxLookupComponent;
paymentDetailText: string;
// soledProductsDetailsText: DxDataGridComponent;
ProductsToSellTotalPrice: number;
// Here I am using DevExtreme
displayedColumnsSelledProducts = ['ProductName', 'ProductBarcode', 'ProductCode', 'ColorName', 'Gender', 'ProductYear', 'SellingPrice', 'Size', 'BranchName'];
SoledProductsDatasource: SaleUserBranchProductsDTO[];
soledProductsDS: DataSource;
// I am using this to unsubscribe after leaving component
private unsubscribe: Subscription[] = [];
ProductAndPriceFormGroup: FormGroup;
ProductsToSellTableId: number = 0;
ProductSellingDto: ProductSellingDto;
@ViewChild('PriceInput') PriceInput: ElementRef;
@ViewChild('productCode') productCode: ElementRef;
filterByToday: Array<any>;
today: Date = new Date();
userDetails = JSON.parse(localStorage.getItem('user')) as LoginResponse;
UserList = [{ Id: 1, Name: "Orhan" }, { Id: 1015, Name: "Uğur" }]
selectedUserId: number;
Operations: any = [{ Id: 0, Value: 'Satıldı' }, { Id: 1, Value: 'İade Edildi' }, { Id: 2, Value: 'Başka bir ürünle değiştirild' }, , { Id: 3, Value: 'Değiştirlen bir ürünün yerine bu alındı' }]
constructor(public _translate: TranslateService,
private normalSatisSerice: NormalSatisService,
private swal: SwalService,
public dialog: MatDialog,
private fb: FormBuilder,
private dxStore: DxStoreService) {
this.InitlizeSelledProductsDatasource();
this.InitilizeProductAndPriceForm();
}
ngOnInit(): void {
}
ngOnDestroy(): void {
this.unsubscribe.forEach(sb => sb.unsubscribe());
}
InitilizeProductAndPriceForm() {
this.ProductAndPriceFormGroup = this.fb.group({
ProductBarcode: ['', Validators.compose([
Validators.required
])
],
SellingPrice: ['', Validators.compose([
Validators.required,
])],
UserId: [1, Validators.compose([
Validators.required,
])],
});
}
public hasError = (controlName: string, errorName: string) => {
return this.ProductAndPriceFormGroup.controls[controlName].hasError(errorName);
}
InitlizeSelledProductsDatasource() {
let storeOptions: DxStoreOptions = {
loadUrl: "NormalSatis/GetSelledProductsByUserId", loadParams: { Id: this.userDetails.userId }, Key: "Id"
};
this.soledProductsDS = new DataSource({
store: this.dxStore.GetStore(storeOptions)
})
// this.normalSatisSerice.GetSoledProductsByUserID(1).toPromise().then((res: UIResponse<SaleUserBranchProductsDTO[]>) => {
// this.SoledProductsDatasource = res.Entity;
// this.ProductsToSellTableRows = [];
// });
}
productView: ProductView;
AddProduct() {
this.selectedUserId = this.ProductAndPriceFormGroup.controls.UserId.value;
this.productView.SellingPrice = this.ProductAndPriceFormGroup.controls.SellingPrice.value;
this.ProductsToSellTableRows.push(this.productView);
this.AssingDataToProductsToSellTable();
this.ProductAndPriceFormGroup.reset();
this.lowProductCount = false;
this.hasCampaign = false;
}
AssingDataToProductsToSellTable() {
this.ProductsToSellDataSource = this.ProductsToSellTableRows;
}
DeleteFromProductsToSellTable(row: ProductView) {
this.ProductsToSellTableRows = this.ProductsToSellTableRows.filter(fi => fi.TempId != row.TempId);
this.AssingDataToProductsToSellTable();
}
getGendere(gender | {
// 0 means Erkek, 1 means Kadin
return gender ? "Kadın" : "Erkek"
}
openSatisDialog() {
const dialogRef = this.dialog.open(PaymentScreenComponent, {
height: '600px',
width: '800px',
data: { Total: this.ProductsToSellTotalPrice = this.ProductsToSellDataSource.map(t => t.SellingPrice).reduce((acc, value) => +acc + +value, 0), CustomerInfoId: 0 }
});
this.unsubscribe.push(dialogRef.afterClosed().subscribe(async (result: PaymentPopup[]) => {
if (result?.length > 0) {
this.ProductsToSellDataSource = [];
let PaymentMethodIds: number[] = result.map(value => value.PaymentMethodId);
let ProductIds: number[] = this.ProductsToSellTableRows.map(value => value.Id);
let SellincPrices: number[] = this.ProductsToSellTableRows.map(value => value.SellingPrice);
let CampaignIds: number[] = this.ProductsToSellTableRows.map(value => value.CampaingId);
let salePaymentMethods: SalePaymentMethod[] = result.map(value => <SalePaymentMethod>{ Amount: value.Amount, DefferedPaymentCount: value.DefferedPaymentCount, PaymentMethodId: value.PaymentMethodId });
//UserId: this.userDetails.userId,
let ProductSellingDto: ProductSellingDto = { ProductIdsAndPricesAndCampaignIds: { SellingPrices: SellincPrices, ProductIds: ProductIds, CampaignIds: CampaignIds }, CustomerInfoId: result[0].CustomerInfo.Id, CustomerName: result[0].CustomerInfo.CustomerName, CustomerPhone: result[0].CustomerInfo.CustomerPhone, Receipt: result[0].Receipt, PaymentMethodIds: PaymentMethodIds, Total: this.ProductsToSellTotalPrice, UserId: this.selectedUserId, BranchId: this.ProductsToSellTableRows[0].BranchId, SalePaymentMethods: salePaymentMethods };
await this.normalSatisSerice.SellProducts(ProductSellingDto).pipe(tap(t => this.swal.showSuccessMessage())).toPromise();
this.ProductsToSellTableRows = [];
this.soledProductsGrid.instance.refresh();
}
}));
}
isProductExist = false;
lowProductCount = false;
hasCampaign = false;
isProductCountEnough = false;
async productCodeFocusOut() {
this.PriceInput.nativeElement.focus();
const productCode = this.ProductAndPriceFormGroup.controls.ProductBarcode.value;
if (productCode && productCode.length == 12) {
let res: UIResponse<ProductView> = await this.normalSatisSerice.GetProductDetails(productCode).toPromise();
if (!res.IsError) {
this.isProductExist = true;
this.productView = res.Entity;
this.ProductAndPriceFormGroup.controls.SellingPrice.setValue(this.productView.SellingPrice);
this.productView.TempId = this.ProductsToSellTableId++;
let ProductCount = this.ProductsToSellDataSource.filter(fi => fi.Id == this.productView.Id).length;
this.productView.Count -= ProductCount;
if (this.productView.Count <= 10) {
this.lowProductCount = true;
} else {
this.lowProductCount = false;
}
if (this.productView.Count == 0) {
this.isProductCountEnough = false;
} else {
this.isProductCountEnough = true;
}
if (this.productView.CampaingId != 0) | : number) | identifier_name |
sales-component.component.ts | SalePaymentMethod } from 'app/InventoryApp/Models/DTOs/SalePaymentMethod';
import { SaleUserBranchProductsDTO } from 'app/InventoryApp/Models/DTOs/SaleUserBranchProductsDTO';
import { DxStoreOptions } from 'app/InventoryApp/Models/DxStoreOptions';
import { LoginResponse } from 'app/InventoryApp/Models/LoginResponse';
import { UIResponse } from 'app/InventoryApp/Models/UIResponse';
import { PaymentScreenComponent } from 'app/InventoryApp/Selling/PaymentScreen/payment-screen.component';
import { DxStoreService } from 'app/InventoryApp/services/dx-store.service';
import { NormalSatisService } from 'app/InventoryApp/services/normal-satis.service';
import { SwalService } from 'app/InventoryApp/services/Swal.Service';
import { DxDataGridComponent, DxLookupComponent } from 'devextreme-angular';
import CustomStore from 'devextreme/data/custom_store';
import DataSource from 'devextreme/data/data_source';
import { Subscription } from 'rxjs';
import { tap } from 'rxjs/operators';
@Component({
selector: 'app-sales-component',
templateUrl: './sales-component.component.html',
styleUrls: ['./sales-component.component.scss'],
encapsulation: ViewEncapsulation.None,
animations: fuseAnimations
})
export class SalesComponentComponent implements OnInit {
RangeStartDate: Date;
RangeEndDate: Date;
Genders: any = [{ Value: 0, ViewValue: 'Erkek' }, { Value: 1, ViewValue: 'Kadın' }]
// Here I used Material Table
ProductsToSellDisplayedColumns = ['ProductName', 'ProductBarcode', 'ProductCode', 'ColorName', 'Gender', 'ProductYear', 'SellingPrice', 'Size', 'BranchName', 'actions'];
ProductsToSellDataSource: ProductView[] = [];
ProductsToSellTableRows: ProductView[] = [];
@ViewChild("soledProductsGrid") soledProductsGrid: DxDataGridComponent;
@ViewChild("customerInfoLookup") customerInfoLookup: DxLookupComponent;
paymentDetailText: string;
// soledProductsDetailsText: DxDataGridComponent;
ProductsToSellTotalPrice: number;
// Here I am using DevExtreme
displayedColumnsSelledProducts = ['ProductName', 'ProductBarcode', 'ProductCode', 'ColorName', 'Gender', 'ProductYear', 'SellingPrice', 'Size', 'BranchName'];
SoledProductsDatasource: SaleUserBranchProductsDTO[];
soledProductsDS: DataSource;
// I am using this to unsubscribe after leaving component
private unsubscribe: Subscription[] = [];
ProductAndPriceFormGroup: FormGroup;
ProductsToSellTableId: number = 0;
ProductSellingDto: ProductSellingDto;
@ViewChild('PriceInput') PriceInput: ElementRef;
@ViewChild('productCode') productCode: ElementRef;
filterByToday: Array<any>;
today: Date = new Date();
userDetails = JSON.parse(localStorage.getItem('user')) as LoginResponse;
UserList = [{ Id: 1, Name: "Orhan" }, { Id: 1015, Name: "Uğur" }]
selectedUserId: number;
Operations: any = [{ Id: 0, Value: 'Satıldı' }, { Id: 1, Value: 'İade Edildi' }, { Id: 2, Value: 'Başka bir ürünle değiştirild' }, , { Id: 3, Value: 'Değiştirlen bir ürünün yerine bu alındı' }]
constructor(public _translate: TranslateService,
private normalSatisSerice: NormalSatisService,
private swal: SwalService,
public dialog: MatDialog,
private fb: FormBuilder,
private dxStore: DxStoreService) {
this.InitlizeSelledProductsDatasource();
this.InitilizeProductAndPriceForm();
}
ngOnInit(): void {
}
ngOnDest | : void {
this.unsubscribe.forEach(sb => sb.unsubscribe());
}
InitilizeProductAndPriceForm() {
this.ProductAndPriceFormGroup = this.fb.group({
ProductBarcode: ['', Validators.compose([
Validators.required
])
],
SellingPrice: ['', Validators.compose([
Validators.required,
])],
UserId: [1, Validators.compose([
Validators.required,
])],
});
}
public hasError = (controlName: string, errorName: string) => {
return this.ProductAndPriceFormGroup.controls[controlName].hasError(errorName);
}
InitlizeSelledProductsDatasource() {
let storeOptions: DxStoreOptions = {
loadUrl: "NormalSatis/GetSelledProductsByUserId", loadParams: { Id: this.userDetails.userId }, Key: "Id"
};
this.soledProductsDS = new DataSource({
store: this.dxStore.GetStore(storeOptions)
})
// this.normalSatisSerice.GetSoledProductsByUserID(1).toPromise().then((res: UIResponse<SaleUserBranchProductsDTO[]>) => {
// this.SoledProductsDatasource = res.Entity;
// this.ProductsToSellTableRows = [];
// });
}
productView: ProductView;
AddProduct() {
this.selectedUserId = this.ProductAndPriceFormGroup.controls.UserId.value;
this.productView.SellingPrice = this.ProductAndPriceFormGroup.controls.SellingPrice.value;
this.ProductsToSellTableRows.push(this.productView);
this.AssingDataToProductsToSellTable();
this.ProductAndPriceFormGroup.reset();
this.lowProductCount = false;
this.hasCampaign = false;
}
AssingDataToProductsToSellTable() {
this.ProductsToSellDataSource = this.ProductsToSellTableRows;
}
DeleteFromProductsToSellTable(row: ProductView) {
this.ProductsToSellTableRows = this.ProductsToSellTableRows.filter(fi => fi.TempId != row.TempId);
this.AssingDataToProductsToSellTable();
}
getGendere(gender: number) {
// 0 means Erkek, 1 means Kadin
return gender ? "Kadın" : "Erkek"
}
openSatisDialog() {
const dialogRef = this.dialog.open(PaymentScreenComponent, {
height: '600px',
width: '800px',
data: { Total: this.ProductsToSellTotalPrice = this.ProductsToSellDataSource.map(t => t.SellingPrice).reduce((acc, value) => +acc + +value, 0), CustomerInfoId: 0 }
});
this.unsubscribe.push(dialogRef.afterClosed().subscribe(async (result: PaymentPopup[]) => {
if (result?.length > 0) {
this.ProductsToSellDataSource = [];
let PaymentMethodIds: number[] = result.map(value => value.PaymentMethodId);
let ProductIds: number[] = this.ProductsToSellTableRows.map(value => value.Id);
let SellincPrices: number[] = this.ProductsToSellTableRows.map(value => value.SellingPrice);
let CampaignIds: number[] = this.ProductsToSellTableRows.map(value => value.CampaingId);
let salePaymentMethods: SalePaymentMethod[] = result.map(value => <SalePaymentMethod>{ Amount: value.Amount, DefferedPaymentCount: value.DefferedPaymentCount, PaymentMethodId: value.PaymentMethodId });
//UserId: this.userDetails.userId,
let ProductSellingDto: ProductSellingDto = { ProductIdsAndPricesAndCampaignIds: { SellingPrices: SellincPrices, ProductIds: ProductIds, CampaignIds: CampaignIds }, CustomerInfoId: result[0].CustomerInfo.Id, CustomerName: result[0].CustomerInfo.CustomerName, CustomerPhone: result[0].CustomerInfo.CustomerPhone, Receipt: result[0].Receipt, PaymentMethodIds: PaymentMethodIds, Total: this.ProductsToSellTotalPrice, UserId: this.selectedUserId, BranchId: this.ProductsToSellTableRows[0].BranchId, SalePaymentMethods: salePaymentMethods };
await this.normalSatisSerice.SellProducts(ProductSellingDto).pipe(tap(t => this.swal.showSuccessMessage())).toPromise();
this.ProductsToSellTableRows = [];
this.soledProductsGrid.instance.refresh();
}
}));
}
isProductExist = false;
lowProductCount = false;
hasCampaign = false;
isProductCountEnough = false;
async productCodeFocusOut() {
this.PriceInput.nativeElement.focus();
const productCode = this.ProductAndPriceFormGroup.controls.ProductBarcode.value;
if (productCode && productCode.length == 12) {
let res: UIResponse<ProductView> = await this.normalSatisSerice.GetProductDetails(productCode).toPromise();
if (!res.IsError) {
this.isProductExist = true;
this.productView = res.Entity;
this.ProductAndPriceFormGroup.controls.SellingPrice.setValue(this.productView.SellingPrice);
this.productView.TempId = this.ProductsToSellTableId++;
let ProductCount = this.ProductsToSellDataSource.filter(fi => fi.Id == this.productView.Id).length;
this.productView.Count -= ProductCount;
if (this.productView.Count <= 10) {
this.lowProductCount = true;
} else {
this.lowProductCount = false;
}
if (this.productView.Count == 0) {
this.isProductCountEnough = false;
} else {
this.isProductCountEnough = true;
}
if (this.productView.CampaingId != | roy() | identifier_body |
sales-component.component.ts | DTO } from 'app/InventoryApp/Models/DTOs/SaleUserBranchProductsDTO';
import { DxStoreOptions } from 'app/InventoryApp/Models/DxStoreOptions';
import { LoginResponse } from 'app/InventoryApp/Models/LoginResponse';
import { UIResponse } from 'app/InventoryApp/Models/UIResponse';
import { PaymentScreenComponent } from 'app/InventoryApp/Selling/PaymentScreen/payment-screen.component';
import { DxStoreService } from 'app/InventoryApp/services/dx-store.service';
import { NormalSatisService } from 'app/InventoryApp/services/normal-satis.service';
import { SwalService } from 'app/InventoryApp/services/Swal.Service';
import { DxDataGridComponent, DxLookupComponent } from 'devextreme-angular';
import CustomStore from 'devextreme/data/custom_store';
import DataSource from 'devextreme/data/data_source';
import { Subscription } from 'rxjs';
import { tap } from 'rxjs/operators';
@Component({
selector: 'app-sales-component',
templateUrl: './sales-component.component.html',
styleUrls: ['./sales-component.component.scss'],
encapsulation: ViewEncapsulation.None,
animations: fuseAnimations
})
export class SalesComponentComponent implements OnInit {
RangeStartDate: Date;
RangeEndDate: Date;
Genders: any = [{ Value: 0, ViewValue: 'Erkek' }, { Value: 1, ViewValue: 'Kadın' }]
// Here I used Material Table
ProductsToSellDisplayedColumns = ['ProductName', 'ProductBarcode', 'ProductCode', 'ColorName', 'Gender', 'ProductYear', 'SellingPrice', 'Size', 'BranchName', 'actions'];
ProductsToSellDataSource: ProductView[] = [];
ProductsToSellTableRows: ProductView[] = [];
@ViewChild("soledProductsGrid") soledProductsGrid: DxDataGridComponent;
@ViewChild("customerInfoLookup") customerInfoLookup: DxLookupComponent;
paymentDetailText: string;
// soledProductsDetailsText: DxDataGridComponent;
ProductsToSellTotalPrice: number;
// Here I am using DevExtreme
displayedColumnsSelledProducts = ['ProductName', 'ProductBarcode', 'ProductCode', 'ColorName', 'Gender', 'ProductYear', 'SellingPrice', 'Size', 'BranchName'];
SoledProductsDatasource: SaleUserBranchProductsDTO[];
soledProductsDS: DataSource;
// I am using this to unsubscribe after leaving component
private unsubscribe: Subscription[] = [];
ProductAndPriceFormGroup: FormGroup;
ProductsToSellTableId: number = 0;
ProductSellingDto: ProductSellingDto;
@ViewChild('PriceInput') PriceInput: ElementRef;
@ViewChild('productCode') productCode: ElementRef;
filterByToday: Array<any>;
today: Date = new Date();
userDetails = JSON.parse(localStorage.getItem('user')) as LoginResponse;
UserList = [{ Id: 1, Name: "Orhan" }, { Id: 1015, Name: "Uğur" }]
selectedUserId: number;
Operations: any = [{ Id: 0, Value: 'Satıldı' }, { Id: 1, Value: 'İade Edildi' }, { Id: 2, Value: 'Başka bir ürünle değiştirild' }, , { Id: 3, Value: 'Değiştirlen bir ürünün yerine bu alındı' }]
constructor(public _translate: TranslateService,
private normalSatisSerice: NormalSatisService,
private swal: SwalService,
public dialog: MatDialog,
private fb: FormBuilder,
private dxStore: DxStoreService) {
this.InitlizeSelledProductsDatasource();
this.InitilizeProductAndPriceForm();
}
ngOnInit(): void {
}
ngOnDestroy(): void {
this.unsubscribe.forEach(sb => sb.unsubscribe());
}
InitilizeProductAndPriceForm() {
this.ProductAndPriceFormGroup = this.fb.group({
ProductBarcode: ['', Validators.compose([
Validators.required
])
],
SellingPrice: ['', Validators.compose([
Validators.required,
])],
UserId: [1, Validators.compose([
Validators.required,
])],
});
}
public hasError = (controlName: string, errorName: string) => {
return this.ProductAndPriceFormGroup.controls[controlName].hasError(errorName);
}
InitlizeSelledProductsDatasource() {
let storeOptions: DxStoreOptions = {
loadUrl: "NormalSatis/GetSelledProductsByUserId", loadParams: { Id: this.userDetails.userId }, Key: "Id"
};
this.soledProductsDS = new DataSource({
store: this.dxStore.GetStore(storeOptions)
})
// this.normalSatisSerice.GetSoledProductsByUserID(1).toPromise().then((res: UIResponse<SaleUserBranchProductsDTO[]>) => {
// this.SoledProductsDatasource = res.Entity;
// this.ProductsToSellTableRows = [];
// });
}
productView: ProductView;
AddProduct() {
this.selectedUserId = this.ProductAndPriceFormGroup.controls.UserId.value;
this.productView.SellingPrice = this.ProductAndPriceFormGroup.controls.SellingPrice.value;
this.ProductsToSellTableRows.push(this.productView);
this.AssingDataToProductsToSellTable();
this.ProductAndPriceFormGroup.reset();
this.lowProductCount = false;
this.hasCampaign = false;
}
AssingDataToProductsToSellTable() {
this.ProductsToSellDataSource = this.ProductsToSellTableRows;
}
DeleteFromProductsToSellTable(row: ProductView) {
this.ProductsToSellTableRows = this.ProductsToSellTableRows.filter(fi => fi.TempId != row.TempId);
this.AssingDataToProductsToSellTable();
}
getGendere(gender: number) {
// 0 means Erkek, 1 means Kadin
return gender ? "Kadın" : "Erkek"
}
openSatisDialog() {
const dialogRef = this.dialog.open(PaymentScreenComponent, {
height: '600px',
width: '800px',
data: { Total: this.ProductsToSellTotalPrice = this.ProductsToSellDataSource.map(t => t.SellingPrice).reduce((acc, value) => +acc + +value, 0), CustomerInfoId: 0 }
});
this.unsubscribe.push(dialogRef.afterClosed().subscribe(async (result: PaymentPopup[]) => {
if (result?.length > 0) {
this.ProductsToSellDataSource = [];
let PaymentMethodIds: number[] = result.map(value => value.PaymentMethodId);
let ProductIds: number[] = this.ProductsToSellTableRows.map(value => value.Id);
let SellincPrices: number[] = this.ProductsToSellTableRows.map(value => value.SellingPrice);
let CampaignIds: number[] = this.ProductsToSellTableRows.map(value => value.CampaingId);
let salePaymentMethods: SalePaymentMethod[] = result.map(value => <SalePaymentMethod>{ Amount: value.Amount, DefferedPaymentCount: value.DefferedPaymentCount, PaymentMethodId: value.PaymentMethodId });
//UserId: this.userDetails.userId,
let ProductSellingDto: ProductSellingDto = { ProductIdsAndPricesAndCampaignIds: { SellingPrices: SellincPrices, ProductIds: ProductIds, CampaignIds: CampaignIds }, CustomerInfoId: result[0].CustomerInfo.Id, CustomerName: result[0].CustomerInfo.CustomerName, CustomerPhone: result[0].CustomerInfo.CustomerPhone, Receipt: result[0].Receipt, PaymentMethodIds: PaymentMethodIds, Total: this.ProductsToSellTotalPrice, UserId: this.selectedUserId, BranchId: this.ProductsToSellTableRows[0].BranchId, SalePaymentMethods: salePaymentMethods };
await this.normalSatisSerice.SellProducts(ProductSellingDto).pipe(tap(t => this.swal.showSuccessMessage())).toPromise();
this.ProductsToSellTableRows = [];
this.soledProductsGrid.instance.refresh();
}
}));
}
isProductExist = false;
lowProductCount = false;
hasCampaign = false;
isProductCountEnough = false;
async productCodeFocusOut() {
this.PriceInput.nativeElement.focus();
const productCode = this.ProductAndPriceFormGroup.controls.ProductBarcode.value;
if (productCode && productCode.length == 12) {
let res: UIResponse<ProductView> = await this.normalSatisSerice.GetProductDetails(productCode).toPromise();
if (!res.IsError) {
this.isProductExist = true;
this.productView = res.Entity;
this.ProductAndPriceFormGroup.controls.SellingPrice.setValue(this.productView.SellingPrice);
this.productView.TempId = this.ProductsToSellTableId++;
let ProductCount = this.ProductsToSellDataSource.filter(fi => fi.Id == this.productView.Id).length;
this.productView.Count -= ProductCount;
if (this.productView.Count <= 10) {
this.lowProductCount = true;
} else {
this.lowProductCount = false;
}
if (this.productView.Count == 0) {
this.isProductCountEnough = false;
} else {
this.isProductCountEnough = true;
}
if (this.productView.CampaingId != 0) {
this.hasCampaign = true;
} else {
this.h | asCampaign = false;
}
} else {
| conditional_block |
|
sales-component.component.ts | SalePaymentMethod } from 'app/InventoryApp/Models/DTOs/SalePaymentMethod';
import { SaleUserBranchProductsDTO } from 'app/InventoryApp/Models/DTOs/SaleUserBranchProductsDTO';
import { DxStoreOptions } from 'app/InventoryApp/Models/DxStoreOptions';
import { LoginResponse } from 'app/InventoryApp/Models/LoginResponse';
import { UIResponse } from 'app/InventoryApp/Models/UIResponse';
import { PaymentScreenComponent } from 'app/InventoryApp/Selling/PaymentScreen/payment-screen.component';
import { DxStoreService } from 'app/InventoryApp/services/dx-store.service';
import { NormalSatisService } from 'app/InventoryApp/services/normal-satis.service';
import { SwalService } from 'app/InventoryApp/services/Swal.Service';
import { DxDataGridComponent, DxLookupComponent } from 'devextreme-angular';
import CustomStore from 'devextreme/data/custom_store';
import DataSource from 'devextreme/data/data_source';
import { Subscription } from 'rxjs';
import { tap } from 'rxjs/operators';
@Component({
selector: 'app-sales-component',
templateUrl: './sales-component.component.html',
styleUrls: ['./sales-component.component.scss'],
encapsulation: ViewEncapsulation.None,
animations: fuseAnimations
})
export class SalesComponentComponent implements OnInit {
RangeStartDate: Date;
RangeEndDate: Date;
Genders: any = [{ Value: 0, ViewValue: 'Erkek' }, { Value: 1, ViewValue: 'Kadın' }]
// Here I used Material Table
ProductsToSellDisplayedColumns = ['ProductName', 'ProductBarcode', 'ProductCode', 'ColorName', 'Gender', 'ProductYear', 'SellingPrice', 'Size', 'BranchName', 'actions'];
ProductsToSellDataSource: ProductView[] = [];
ProductsToSellTableRows: ProductView[] = [];
@ViewChild("soledProductsGrid") soledProductsGrid: DxDataGridComponent;
@ViewChild("customerInfoLookup") customerInfoLookup: DxLookupComponent;
paymentDetailText: string;
// soledProductsDetailsText: DxDataGridComponent;
ProductsToSellTotalPrice: number;
// Here I am using DevExtreme
displayedColumnsSelledProducts = ['ProductName', 'ProductBarcode', 'ProductCode', 'ColorName', 'Gender', 'ProductYear', 'SellingPrice', 'Size', 'BranchName'];
SoledProductsDatasource: SaleUserBranchProductsDTO[];
soledProductsDS: DataSource;
// I am using this to unsubscribe after leaving component
private unsubscribe: Subscription[] = [];
ProductAndPriceFormGroup: FormGroup;
ProductsToSellTableId: number = 0;
ProductSellingDto: ProductSellingDto;
@ViewChild('PriceInput') PriceInput: ElementRef;
@ViewChild('productCode') productCode: ElementRef;
filterByToday: Array<any>;
today: Date = new Date();
userDetails = JSON.parse(localStorage.getItem('user')) as LoginResponse;
UserList = [{ Id: 1, Name: "Orhan" }, { Id: 1015, Name: "Uğur" }]
selectedUserId: number;
Operations: any = [{ Id: 0, Value: 'Satıldı' }, { Id: 1, Value: 'İade Edildi' }, { Id: 2, Value: 'Başka bir ürünle değiştirild' }, , { Id: 3, Value: 'Değiştirlen bir ürünün yerine bu alındı' }]
constructor(public _translate: TranslateService,
private normalSatisSerice: NormalSatisService,
private swal: SwalService,
public dialog: MatDialog,
private fb: FormBuilder,
private dxStore: DxStoreService) {
this.InitlizeSelledProductsDatasource();
this.InitilizeProductAndPriceForm();
}
ngOnInit(): void {
}
ngOnDestroy(): void {
this.unsubscribe.forEach(sb => sb.unsubscribe());
}
InitilizeProductAndPriceForm() {
this.ProductAndPriceFormGroup = this.fb.group({
ProductBarcode: ['', Validators.compose([
Validators.required
])
],
SellingPrice: ['', Validators.compose([
Validators.required,
])],
UserId: [1, Validators.compose([
Validators.required,
])],
});
}
public hasError = (controlName: string, errorName: string) => {
return this.ProductAndPriceFormGroup.controls[controlName].hasError(errorName);
}
InitlizeSelledProductsDatasource() {
let storeOptions: DxStoreOptions = {
loadUrl: "NormalSatis/GetSelledProductsByUserId", loadParams: { Id: this.userDetails.userId }, Key: "Id"
};
this.soledProductsDS = new DataSource({
store: this.dxStore.GetStore(storeOptions)
})
// this.normalSatisSerice.GetSoledProductsByUserID(1).toPromise().then((res: UIResponse<SaleUserBranchProductsDTO[]>) => {
// this.SoledProductsDatasource = res.Entity;
// this.ProductsToSellTableRows = [];
// });
}
productView: ProductView;
AddProduct() {
this.selectedUserId = this.ProductAndPriceFormGroup.controls.UserId.value;
this.productView.SellingPrice = this.ProductAndPriceFormGroup.controls.SellingPrice.value;
this.ProductsToSellTableRows.push(this.productView);
this.AssingDataToProductsToSellTable();
this.ProductAndPriceFormGroup.reset();
this.lowProductCount = false;
this.hasCampaign = false;
}
AssingDataToProductsToSellTable() {
this.ProductsToSellDataSource = this.ProductsToSellTableRows;
}
DeleteFromProductsToSellTable(row: ProductView) {
this.ProductsToSellTableRows = this.ProductsToSellTableRows.filter(fi => fi.TempId != row.TempId);
this.AssingDataToProductsToSellTable();
}
getGendere(gender: number) {
// 0 means Erkek, 1 means Kadin
return gender ? "Kadın" : "Erkek"
}
openSatisDialog() {
const dialogRef = this.dialog.open(PaymentScreenComponent, {
height: '600px',
width: '800px',
data: { Total: this.ProductsToSellTotalPrice = this.ProductsToSellDataSource.map(t => t.SellingPrice).reduce((acc, value) => +acc + +value, 0), CustomerInfoId: 0 }
});
this.unsubscribe.push(dialogRef.afterClosed().subscribe(async (result: PaymentPopup[]) => {
if (result?.length > 0) {
this.ProductsToSellDataSource = [];
let PaymentMethodIds: number[] = result.map(value => value.PaymentMethodId);
let ProductIds: number[] = this.ProductsToSellTableRows.map(value => value.Id);
let SellincPrices: number[] = this.ProductsToSellTableRows.map(value => value.SellingPrice);
let CampaignIds: number[] = this.ProductsToSellTableRows.map(value => value.CampaingId);
let salePaymentMethods: SalePaymentMethod[] = result.map(value => <SalePaymentMethod>{ Amount: value.Amount, DefferedPaymentCount: value.DefferedPaymentCount, PaymentMethodId: value.PaymentMethodId });
//UserId: this.userDetails.userId,
let ProductSellingDto: ProductSellingDto = { ProductIdsAndPricesAndCampaignIds: { SellingPrices: SellincPrices, ProductIds: ProductIds, CampaignIds: CampaignIds }, CustomerInfoId: result[0].CustomerInfo.Id, CustomerName: result[0].CustomerInfo.CustomerName, CustomerPhone: result[0].CustomerInfo.CustomerPhone, Receipt: result[0].Receipt, PaymentMethodIds: PaymentMethodIds, Total: this.ProductsToSellTotalPrice, UserId: this.selectedUserId, BranchId: this.ProductsToSellTableRows[0].BranchId, SalePaymentMethods: salePaymentMethods };
await this.normalSatisSerice.SellProducts(ProductSellingDto).pipe(tap(t => this.swal.showSuccessMessage())).toPromise();
this.ProductsToSellTableRows = [];
this.soledProductsGrid.instance.refresh();
}
}));
} | hasCampaign = false;
isProductCountEnough = false;
async productCodeFocusOut() {
this.PriceInput.nativeElement.focus();
const productCode = this.ProductAndPriceFormGroup.controls.ProductBarcode.value;
if (productCode && productCode.length == 12) {
let res: UIResponse<ProductView> = await this.normalSatisSerice.GetProductDetails(productCode).toPromise();
if (!res.IsError) {
this.isProductExist = true;
this.productView = res.Entity;
this.ProductAndPriceFormGroup.controls.SellingPrice.setValue(this.productView.SellingPrice);
this.productView.TempId = this.ProductsToSellTableId++;
let ProductCount = this.ProductsToSellDataSource.filter(fi => fi.Id == this.productView.Id).length;
this.productView.Count -= ProductCount;
if (this.productView.Count <= 10) {
this.lowProductCount = true;
} else {
this.lowProductCount = false;
}
if (this.productView.Count == 0) {
this.isProductCountEnough = false;
} else {
this.isProductCountEnough = true;
}
if (this.productView.CampaingId != 0) |
isProductExist = false;
lowProductCount = false; | random_line_split |
doc_zh_CN.go | ErrMessageTooLong is returned when attempting to encrypt a message which is too
// large for the size of the public key.
var ErrMessageTooLong = errors.New("crypto/rsa: message too long for RSA public key size")
// ErrVerification represents a failure to verify a signature. It is deliberately
// vague to avoid adaptive attacks.
var ErrVerification = errors.New("crypto/rsa: verification error")
// DecryptOAEP decrypts ciphertext using RSA-OAEP. If random != nil, DecryptOAEP
// uses RSA blinding to avoid timing side-channel attacks.
// DecryptOAEP解密RSA-OAEP算法加密的数据。如果random不是nil，函数会注意规避时间侧信道攻击。
func DecryptOAEP(hash hash.Hash, random io.Reader, priv *PrivateKey, ciphertext []byte, label []byte) (msg []byte, err error)
// DecryptPKCS1v15 decrypts a plaintext using RSA and the padding scheme from
// PKCS#1 v1.5. If rand != nil, it uses RSA blinding to avoid timing side-channel | func DecryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (out []byte, err error)
// DecryptPKCS1v15SessionKey decrypts a session key using RSA and the padding
// scheme from PKCS#1 v1.5. If rand != nil, it uses RSA blinding to avoid timing
// side-channel attacks. It returns an error if the ciphertext is the wrong length
// or if the ciphertext is greater than the public modulus. Otherwise, no error is
// returned. If the padding is valid, the resulting plaintext message is copied
// into key. Otherwise, key is unchanged. These alternatives occur in constant
// time. It is intended that the user of this function generate a random session
// key beforehand and continue the protocol with the resulting value. This will
// remove any possibility that an attacker can learn any information about the
// plaintext. See ``Chosen Ciphertext Attacks Against Protocols Based on the RSA
// Encryption Standard PKCS #1'', Daniel Bleichenbacher, Advances in Cryptology
// (Crypto '98).
// DecryptPKCS1v15SessionKey使用PKCS#1
// v1.5规定的填充方案和RSA算法解密会话密钥。如果random不是nil，函数会注意规避时间侧信道攻击。
//
// 如果密文长度不对，或者如果密文比公共模数的长度还长，会返回错误；否则，不会返回任何错误。如果填充是合法的，生成的明文信息会拷贝进key；否则，key不会被修改。这些情况都会在固定时间内出现（规避时间侧信道攻击）。本函数的目的是让程序的使用者事先生成一个随机的会话密钥，并用运行时的值继续协议。这样可以避免任何攻击者从明文窃取信息的可能性。
//
// 参见”Chosen Ciphertext Attacks Against Protocols Based on the RSA Encryption
// Standard PKCS #1”。
func DecryptPKCS1v15SessionKey(rand io.Reader, priv *PrivateKey, ciphertext []byte, key []byte) (err error)
// EncryptOAEP encrypts the given message with RSA-OAEP. The message must be no
// longer than the length of the public modulus less twice the hash length plus 2.
// 采用RSA-OAEP算法加密给出的数据。数据不能超过((公共模数的长度)-2*( hash长度)+2)字节。
func EncryptOAEP(hash hash.Hash, random io.Reader, pub *PublicKey, msg []byte, label []byte) (out []byte, err error)
// EncryptPKCS1v15 encrypts the given message with RSA and the padding scheme from
// PKCS#1 v1.5. The message must be no longer than the length of the public modulus
// minus 11 bytes. WARNING: use of this function to encrypt plaintexts other than
// session keys is dangerous. Use RSA OAEP in new protocols.
// EncryptPKCS1v15使用PKCS#1
// v1.5规定的填充方案和RSA算法加密msg。信息不能超过((公共模数的长度)-11)字节。注意：使用本函数加密明文（而不是会话密钥）是危险的，请尽量在新协议中使用RSA
// OAEP。
func EncryptPKCS1v15(rand io.Reader, pub *PublicKey, msg []byte) (out []byte, err error)
// SignPKCS1v15 calculates the signature of hashed using RSASSA-PKCS1-V1_5-SIGN
// from RSA PKCS#1 v1.5. Note that hashed must be the result of hashing the input
// message using the given hash function. If hash is zero, hashed is signed
// directly. This isn't advisable except for interoperability.
// SignPKCS1v15使用RSA PKCS#1
// v1.5规定的RSASSA-PKCS1-V1_5-SIGN签名方案计算签名。注意hashed必须是使用提供给本函数的hash参数对（要签名的）原始数据进行hash的结果。
func SignPKCS1v15(rand io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte) (s []byte, err error)
// SignPSS calculates the signature of hashed using RSASSA-PSS [1]. Note that
// hashed must be the result of hashing the input message using the given hash
// function. The opts argument may be nil, in which case sensible defaults are
// used.
// SignPSS采用RSASSA-PSS方案计算签名。注意hashed必须是使用提供给本函数的hash参数对（要签名的）原始数据进行hash的结果。opts参数可以为nil，此时会使用默认参数。
func SignPSS(rand io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte, opts *PSSOptions) (s []byte, err error)
// VerifyPKCS1v15 verifies an RSA PKCS#1 v1.5 signature. hashed is the result of
// hashing the input message using the given hash function and sig is the
// signature. A valid signature is indicated by returning a nil error. If hash is
// zero then hashed is used directly. This isn't advisable except for
// interoperability.
// VerifyPKCS1v15认证RSA PKCS#1
// v1.5签名。hashed是使用提供的hash参数对（要签名的）原始数据进行hash的结果。合法的签名会返回nil，否则表示签名不合法。
func VerifyPKCS1v15(pub *PublicKey, hash crypto.Hash, hashed []byte, sig []byte) (err error)
// VerifyPSS verifies a PSS signature. hashed is the result of hashing the input
// message using the given hash function and sig is the signature. A valid
// signature is indicated by returning a nil error. The opts argument may be nil,
// in which case sensible defaults are used.
// VerifyPSS认证一个PSS签名。hashed是使用提供给本函数的hash参数对（要签名的）原始数据进行hash的结果。合法的签名会返回nil，否则表示签名不合法。opts参数可以为nil，此时会使用默认参数。
func VerifyPSS(pub *PublicKey, hash crypto.Hash, hashed []byte, sig []byte, opts *PSSOptions) error
// CRTValue contains the precomputed chinese remainder theorem values.
// CRTValue包含预先计算的中国剩余定理的值。
type CRTValue struct {
Exp *big.Int // D mod (prime-1).
Coeff *big.Int // R·Coeff ≡ 1 mod Prime.
R *big.Int // product of primes prior to this (inc p and q).
}
// PSSOptions contains options for creating and verifying PSS signatures.
// PSSOptions包含用于创建和认证PSS签名的参数。
type PSSOptions struct {
// SaltLength controls the length of the salt used in the PSS
// signature. It can either be a number of bytes, or one of the special
// PSSSaltLength constants.
SaltLength int
// Hash, if not zero, overrides the hash function passed to SignPSS.
// This is the only way to specify the hash function when using the
// crypto.Signer interface.
Hash crypto.Hash
}
// HashFunc returns pssOpts.Hash so that PSSOptions implements crypto.SignerOpts.
func (pssOpts *PSSOptions) HashFunc() crypto.Hash
type PrecomputedValues struct {
Dp, Dq *big.Int // D mod (P-1) (or mod Q-1)
Qinv *big.Int // Q^-1 mod P
// CRTValues is used for the 3rd and subsequent primes. Due to a
// historical accident, the CRT for the first two primes is handled
// differently in PKCS#1 and interoperability is sufficiently
// important that we mirror this.
CRTValues []CRTValue
}
// A PrivateKey represents an RSA key
// 代表一个RSA私钥。
type PrivateKey struct {
PublicKey // public part.
D *big.Int // private exponent
Primes []*big.Int // prime factors of N, has >= 2 elements.
// Precomputed contains precomputed values that | // attacks.
// DecryptPKCS1v15使用PKCS#1
// v1.5规定的填充方案和RSA算法解密密文。如果random不是nil，函数会注意规避时间侧信道攻击。 | random_line_split |
doc_zh_CN.go | TooLong is returned when attempting to encrypt a message which is too
// large for the size of the public key.
var ErrMessageTooLong = errors.New("crypto/rsa: message too long for RSA public key size")
// ErrVerification represents a failure to verify a signature. It is deliberately
// vague to avoid adaptive attacks.
var ErrVerification = errors.New("crypto/rsa: verification error")
// DecryptOAEP decrypts ciphertext using RSA-OAEP. If random != nil, DecryptOAEP
// uses RSA blinding to avoid timing side-channel attacks.
// DecryptOAEP解密RSA-OAEP算法加密的数据。如果random不是nil，函数会注意规避时间侧信道攻击。
func DecryptOAEP(hash hash.Hash, random io.Reader, priv *PrivateKey, ciphertext []byte, label []byte) (msg []byte, err error)
// DecryptPKCS1v15 decrypts a plaintext using RSA and the padding scheme from
// PKCS#1 v1.5. If rand != nil, it uses RSA blinding to avoid timing side-channel
// attacks.
// DecryptPKCS1v15使用PKCS#1
// v1.5规定的填充方案和RSA算法解密密文。如果random不是nil，函数会注意规避时间侧信道攻击。
func DecryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (out []byte, err error)
// DecryptPKCS1v15SessionKey decrypts a session key using RSA and the padding
// scheme from PKCS#1 v1.5. If rand != nil, it uses RSA blinding to avoid timing
// side-channel attacks. It returns an error if the ciphertex | length
// or if the ciphertext is greater than the public modulus. Otherwise, no error is
// returned. If the padding is valid, the resulting plaintext message is copied
// into key. Otherwise, key is unchanged. These alternatives occur in constant
// time. It is intended that the user of this function generate a random session
// key beforehand and continue the protocol with the resulting value. This will
// remove any possibility that an attacker can learn any information about the
// plaintext. See ``Chosen Ciphertext Attacks Against Protocols Based on the RSA
// Encryption Standard PKCS #1'', Daniel Bleichenbacher, Advances in Cryptology
// (Crypto '98).
// DecryptPKCS1v15SessionKey使用PKCS#1
// v1.5规定的填充方案和RSA算法解密会话密钥。如果random不是nil，函数会注意规避时间侧信道攻击。
//
// 如果密文长度不对，或者如果密文比公共模数的长度还长，会返回错误；否则，不会返回任何错误。如果填充是合法的，生成的明文信息会拷贝进key；否则，key不会被修改。这些情况都会在固定时间内出现（规避时间侧信道攻击）。本函数的目的是让程序的使用者事先生成一个随机的会话密钥，并用运行时的值继续协议。这样可以避免任何攻击者从明文窃取信息的可能性。
//
// 参见”Chosen Ciphertext Attacks Against Protocols Based on the RSA Encryption
// Standard PKCS #1”。
func DecryptPKCS1v15SessionKey(rand io.Reader, priv *PrivateKey, ciphertext []byte, key []byte) (err error)
// EncryptOAEP encrypts the given message with RSA-OAEP. The message must be no
// longer than the length of the public modulus less twice the hash length plus 2.
// 采用RSA-OAEP算法加密给出的数据。数据不能超过((公共模数的长度)-2*( hash长度)+2)字节。
func EncryptOAEP(hash hash.Hash, random io.Reader, pub *PublicKey, msg []byte, label []byte) (out []byte, err error)
// EncryptPKCS1v15 encrypts the given message with RSA and the padding scheme from
// PKCS#1 v1.5. The message must be no longer than the length of the public modulus
// minus 11 bytes. WARNING: use of this function to encrypt plaintexts other than
// session keys is dangerous. Use RSA OAEP in new protocols.
// EncryptPKCS1v15使用PKCS#1
// v1.5规定的填充方案和RSA算法加密msg。信息不能超过((公共模数的长度)-11)字节。注意：使用本函数加密明文（而不是会话密钥）是危险的，请尽量在新协议中使用RSA
// OAEP。
func EncryptPKCS1v15(rand io.Reader, pub *PublicKey, msg []byte) (out []byte, err error)
// SignPKCS1v15 calculates the signature of hashed using RSASSA-PKCS1-V1_5-SIGN
// from RSA PKCS#1 v1.5. Note that hashed must be the result of hashing the input
// message using the given hash function. If hash is zero, hashed is signed
// directly. This isn't advisable except for interoperability.
// SignPKCS1v15使用RSA PKCS#1
// v1.5规定的RSASSA-PKCS1-V1_5-SIGN签名方案计算签名。注意hashed必须是使用提供给本函数的hash参数对（要签名的）原始数据进行hash的结果。
func SignPKCS1v15(rand io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte) (s []byte, err error)
// SignPSS calculates the signature of hashed using RSASSA-PSS [1]. Note that
// hashed must be the result of hashing the input message using the given hash
// function. The opts argument may be nil, in which case sensible defaults are
// used.
// SignPSS采用RSASSA-PSS方案计算签名。注意hashed必须是使用提供给本函数的hash参数对（要签名的）原始数据进行hash的结果。opts参数可以为nil，此时会使用默认参数。
func SignPSS(rand io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte, opts *PSSOptions) (s []byte, err error)
// VerifyPKCS1v15 verifies an RSA PKCS#1 v1.5 signature. hashed is the result of
// hashing the input message using the given hash function and sig is the
// signature. A valid signature is indicated by returning a nil error. If hash is
// zero then hashed is used directly. This isn't advisable except for
// interoperability.
// VerifyPKCS1v15认证RSA PKCS#1
// v1.5签名。hashed是使用提供的hash参数对（要签名的）原始数据进行hash的结果。合法的签名会返回nil，否则表示签名不合法。
func VerifyPKCS1v15(pub *PublicKey, hash crypto.Hash, hashed []byte, sig []byte) (err error)
// VerifyPSS verifies a PSS signature. hashed is the result of hashing the input
// message using the given hash function and sig is the signature. A valid
// signature is indicated by returning a nil error. The opts argument may be nil,
// in which case sensible defaults are used.
// VerifyPSS认证一个PSS签名。hashed是使用提供给本函数的hash参数对（要签名的）原始数据进行hash的结果。合法的签名会返回nil，否则表示签名不合法。opts参数可以为nil，此时会使用默认参数。
func VerifyPSS(pub *PublicKey, hash crypto.Hash, hashed []byte, sig []byte, opts *PSSOptions) error
// CRTValue contains the precomputed chinese remainder theorem values.
// CRTValue包含预先计算的中国剩余定理的值。
type CRTValue struct {
Exp *big.Int // D mod (prime-1).
Coeff *big.Int // R·Coeff ≡ 1 mod Prime.
R *big.Int // product of primes prior to this (inc p and q).
}
// PSSOptions contains options for creating and verifying PSS signatures.
// PSSOptions包含用于创建和认证PSS签名的参数。
type PSSOptions struct {
// SaltLength controls the length of the salt used in the PSS
// signature. It can either be a number of bytes, or one of the special
// PSSSaltLength constants.
SaltLength int
// Hash, if not zero, overrides the hash function passed to SignPSS.
// This is the only way to specify the hash function when using the
// crypto.Signer interface.
Hash crypto.Hash
}
// HashFunc returns pssOpts.Hash so that PSSOptions implements crypto.SignerOpts.
func (pssOpts *PSSOptions) HashFunc() crypto.Hash
type PrecomputedValues struct {
Dp, Dq *big.Int // D mod (P-1) (or mod Q-1)
Qinv *big.Int // Q^-1 mod P
// CRTValues is used for the 3rd and subsequent primes. Due to a
// historical accident, the CRT for the first two primes is handled
// differently in PKCS#1 and interoperability is sufficiently
// important that we mirror this.
CRTValues []CRTValue
}
// A PrivateKey represents an RSA key
// 代表一个RSA私钥。
type PrivateKey struct {
PublicKey // public part.
D *big.Int // private exponent
Primes []*big.Int // prime factors of N, has >= 2 elements.
// Precomputed contains | t is the wrong | identifier_name |
types.rs | <T: Encodable + Decodable + Send + Clone> {
current_term: u64,
voted_for: Option<u64>, // request_vote cares if this is `None`
log: File,
last_index: u64, // The last index of the file.
last_term: u64, // The last index of the file.
marker: marker::PhantomData<T>, // A marker... Because of
// https://github.com/rust-lang/rfcs/blob/master/text/0738-variance.md#the-corner-case-unused-parameters-and-parameters-that-are-only-used-unsafely
}
impl<T: Encodable + Decodable + Send + Clone> PersistentState<T> {
pub fn new(current_term: u64, log_path: Path) -> PersistentState<T> {
let mut open_opts = OpenOptions::new();
open_opts.read(true);
open_opts.write(true);
open_opts.create(true);
let mut file = open_opts.open(&log_path).unwrap();
write!(&mut file, "{:20} {:20}\n", current_term, 0).unwrap();
PersistentState {
current_term: current_term,
voted_for: None,
log: file,
last_index: 0,
last_term: 0,
marker: marker::PhantomData,
}
}
/// Gets the `last_index` which you can use to make append requests with.
pub fn get_last_index(&self) -> u64 { self.last_index }
pub fn get_last_term(&self) -> u64 { self.last_term }
/// Gets the `current_term` which is used for request vote.
pub fn get_current_term(&self) -> u64 { self.current_term }
/// Sets the current_term. **This should reflect on stable storage.**
pub fn set_current_term(&mut self, new: u64) -> io::Result<()> {
// The first line is the header with `current_term`, `voted_for`.
self.log.seek(io::SeekFrom::Start(0)); // Take the start.
self.current_term = new;
// TODO: What do we do about the none case?
write!(&mut self.log, "{:20} {:20}\n", self.current_term, self.voted_for.unwrap_or(0))
}
/// Increments the current_term. **This should reflect on stable storage.**
pub fn inc_current_term(&mut self) { self.current_term += 1 }
/// Gets the `voted_for`.
pub fn get_voted_for(&mut self) -> Option<u64> { self.voted_for }
/// Sets the `voted_for. **This should reflect on stable storage.**
pub fn set_voted_for(&mut self, new: Option<u64>) -> io::Result<()> {
// The first line is the header with `current_term`, `voted_for`.
self.log.seek(io::SeekFrom::Start(0)); // Take the start.
self.voted_for = new;
// TODO: What do we do about the none case?
write!(&mut self.log, "{:20} {:20}\n", self.current_term, self.voted_for.unwrap_or(0))
}
pub fn append_entries(&mut self, prev_log_index: u64, prev_log_term: u64,
entries: Vec<(u64, T)>) -> io::Result<()> {
// TODO: No checking of `prev_log_index` & `prev_log_term` yet... Do we need to?
let position = try!(self.move_to(prev_log_index + 1));
let number = entries.len();
let last_term = entries[entries.len() -1].0;
try!(self.purge_from_bytes(position)); // Update `last_log_index` later.
// TODO: Possibly purge.
for (term, entry) in entries {
// TODO: I don't like the "doubling" here. How can we do this better?
write!(&mut self.log, "{} {}\n", term, PersistentState::encode(entry));
}
self.last_index = if prev_log_index == 0 {
number as u64 - 1
} else { prev_log_index + number as u64 };
self.last_term = last_term;
Ok(())
}
fn encode(entry: T) -> String {
let json_encoded = json::encode(&entry)
.unwrap(); // TODO: Don't unwrap.
json_encoded.as_bytes().to_base64(Config {
char_set: CharacterSet::UrlSafe,
newline: Newline::LF,
pad: false,
line_length: None,
})
}
fn decode(bytes: String) -> Result<T, rustc_serialize::json::DecoderError> {
let based = bytes.from_base64()
.ok().expect("Decoding error. log likely corrupt.");
let string = str::from_utf8(based.as_slice())
.unwrap();
json::decode::<T>(string)
}
/// Returns the number of bytes containing `line` lines.
/// TODO: Cache?
fn move_to(&mut self, line: u64) -> io::Result<u64> {
// Gotcha: The first line is NOT a log entry.
let mut lines_read = 0u64;
self.log.seek(io::SeekFrom::Start(0)); // Take the start.
// Go until we've reached `from` new lines.
let _ = self.log.by_ref().chars().skip_while(|opt| {
match *opt {
Ok(val) => {
if val == '\n' {
lines_read += 1;
if lines_read > line { // Greater than here because the first line is a bust.
false // At right location.
} else {
true // Not done yet, more lines to go.
}
} else {
true // Not a new line.
}
},
_ => false // At EOF. Nothing to purge.
}
}).next(); // Side effects.
self.log.seek(io::SeekFrom::Current(0)) // Where are we?
}
/// Do *not* invoke this unless you update the `last_index`!
fn purge_from_bytes(&mut self, from_bytes: u64) -> io::Result<()> {
self.log.set_len(from_bytes) // Chop off the file at the given position.
}
/// Removes all entries from `from` to the last entry, inclusively.
pub fn purge_from_index(&mut self, from_line: u64) -> io::Result<()> {
let position = try!(self.move_to(from_line));
self.last_index = from_line - 1;
self.purge_from_bytes(position)
}
pub fn retrieve_entries(&mut self, start: u64, end: u64) -> io::Result<Vec<(u64, T)>> {
let position = self.move_to(start);
let mut index = start;
let mut out = vec![];
let mut read_in = self.log.by_ref()
.chars()
.take_while(|val| val.is_ok())
.filter_map(|val| val.ok()); // We don't really care about issues here.
for index in range(start, end +1) {
let mut chars = read_in.by_ref()
.take_while(|&val| val != '\n')
.collect::<String>();
if chars.len() == 0 { continue; }
let entry = try!(parse_entry::<T>(chars));
out.push(entry);
}
Ok(out)
}
pub fn retrieve_entry(&mut self, index: u64) -> io::Result<(u64, T)> {
let position = self.move_to(index);
let mut chars = self.log.by_ref()
.chars()
.take_while(|val| val.is_ok())
.filter_map(|val| val.ok()) // We don't really care about issues here.
.take_while(|&val| val != '\n').collect::<String>();
parse_entry::<T>(chars)
}
}
fn parse_entry<T: Encodable + Decodable + Send + Clone>(val: String) -> io::Result<(u64, T)> {
let mut splits = val.split(' ');
let term = {
let chunk = splits.next()
.and_then(|v| v.parse::<u64>().ok());
match chunk {
Some(v) => v,
None => return Err(io::Error::new(io::ErrorKind::InvalidInput, "Could not parse term.", None)),
}
};
let encoded = {
let chunk = splits.next();
match chunk {
Some(v) => v,
None => return Err(io::Error::new(io::ErrorKind::InvalidInput, "Could not parse encoded data.", None)),
}
};
let decoded: T = PersistentState::decode(encoded.to_string())
.ok().expect("Could not unwrap log entry.");
Ok((term, decoded))
}
/// Volatile state
#[derive(Copy)]
pub struct VolatileState {
pub commit_index: u64,
pub last_applied: u64
}
/// Leader Only
/// **Reinitialized after election.**
#[derive(PartialEq, Eq, Clone)]
pub struct LeaderState {
pub next_index: Vec<u64>,
pub match_index: Vec | PersistentState | identifier_name |
|
types.rs | pub fn append_entries(&mut self, prev_log_index: u64, prev_log_term: u64,
entries: Vec<(u64, T)>) -> io::Result<()> {
// TODO: No checking of `prev_log_index` & `prev_log_term` yet... Do we need to?
let position = try!(self.move_to(prev_log_index + 1));
let number = entries.len();
let last_term = entries[entries.len() -1].0;
try!(self.purge_from_bytes(position)); // Update `last_log_index` later.
// TODO: Possibly purge.
for (term, entry) in entries {
// TODO: I don't like the "doubling" here. How can we do this better?
write!(&mut self.log, "{} {}\n", term, PersistentState::encode(entry));
}
self.last_index = if prev_log_index == 0 {
number as u64 - 1
} else { prev_log_index + number as u64 };
self.last_term = last_term;
Ok(())
}
fn encode(entry: T) -> String {
let json_encoded = json::encode(&entry)
.unwrap(); // TODO: Don't unwrap.
json_encoded.as_bytes().to_base64(Config {
char_set: CharacterSet::UrlSafe,
newline: Newline::LF,
pad: false,
line_length: None,
})
}
fn decode(bytes: String) -> Result<T, rustc_serialize::json::DecoderError> {
let based = bytes.from_base64()
.ok().expect("Decoding error. log likely corrupt.");
let string = str::from_utf8(based.as_slice())
.unwrap();
json::decode::<T>(string)
}
/// Returns the number of bytes containing `line` lines.
/// TODO: Cache?
fn move_to(&mut self, line: u64) -> io::Result<u64> {
// Gotcha: The first line is NOT a log entry.
let mut lines_read = 0u64;
self.log.seek(io::SeekFrom::Start(0)); // Take the start.
// Go until we've reached `from` new lines.
let _ = self.log.by_ref().chars().skip_while(|opt| {
match *opt {
Ok(val) => {
if val == '\n' {
lines_read += 1;
if lines_read > line { // Greater than here because the first line is a bust.
false // At right location.
} else {
true // Not done yet, more lines to go.
}
} else {
true // Not a new line.
}
},
_ => false // At EOF. Nothing to purge.
}
}).next(); // Side effects.
self.log.seek(io::SeekFrom::Current(0)) // Where are we?
}
/// Do *not* invoke this unless you update the `last_index`!
fn purge_from_bytes(&mut self, from_bytes: u64) -> io::Result<()> {
self.log.set_len(from_bytes) // Chop off the file at the given position.
}
/// Removes all entries from `from` to the last entry, inclusively.
pub fn purge_from_index(&mut self, from_line: u64) -> io::Result<()> {
let position = try!(self.move_to(from_line));
self.last_index = from_line - 1;
self.purge_from_bytes(position)
}
pub fn retrieve_entries(&mut self, start: u64, end: u64) -> io::Result<Vec<(u64, T)>> {
let position = self.move_to(start);
let mut index = start;
let mut out = vec![];
let mut read_in = self.log.by_ref()
.chars()
.take_while(|val| val.is_ok())
.filter_map(|val| val.ok()); // We don't really care about issues here.
for index in range(start, end +1) {
let mut chars = read_in.by_ref()
.take_while(|&val| val != '\n')
.collect::<String>();
if chars.len() == 0 { continue; }
let entry = try!(parse_entry::<T>(chars));
out.push(entry);
}
Ok(out)
}
pub fn retrieve_entry(&mut self, index: u64) -> io::Result<(u64, T)> {
let position = self.move_to(index);
let mut chars = self.log.by_ref()
.chars()
.take_while(|val| val.is_ok())
.filter_map(|val| val.ok()) // We don't really care about issues here.
.take_while(|&val| val != '\n').collect::<String>();
parse_entry::<T>(chars)
}
}
fn parse_entry<T: Encodable + Decodable + Send + Clone>(val: String) -> io::Result<(u64, T)> {
let mut splits = val.split(' ');
let term = {
let chunk = splits.next()
.and_then(|v| v.parse::<u64>().ok());
match chunk {
Some(v) => v,
None => return Err(io::Error::new(io::ErrorKind::InvalidInput, "Could not parse term.", None)),
}
};
let encoded = {
let chunk = splits.next();
match chunk {
Some(v) => v,
None => return Err(io::Error::new(io::ErrorKind::InvalidInput, "Could not parse encoded data.", None)),
}
};
let decoded: T = PersistentState::decode(encoded.to_string())
.ok().expect("Could not unwrap log entry.");
Ok((term, decoded))
}
/// Volatile state
#[derive(Copy)]
pub struct VolatileState {
pub commit_index: u64,
pub last_applied: u64
}
/// Leader Only
/// **Reinitialized after election.**
#[derive(PartialEq, Eq, Clone)]
pub struct LeaderState {
pub next_index: Vec<u64>,
pub match_index: Vec<u64>
}
/// Nodes can either be:
///
/// * A `Follower`, which replicates AppendEntries requests and votes for it's leader.
/// * A `Leader`, which leads the cluster by serving incoming requests, ensuring data is
/// replicated, and issuing heartbeats..
/// * A `Candidate`, which campaigns in an election and may become a `Leader` (if it gets enough
/// votes) or a `Follower`, if it hears from a `Leader`.
#[derive(PartialEq, Eq, Clone)]
pub enum NodeState {
Follower,
Leader(LeaderState),
Candidate(Vec<Transaction>),
}
#[derive(PartialEq, Eq, Clone)]
pub struct Transaction {
pub uuid: Uuid,
pub state: TransactionState,
}
/// Used to signify the state of of a Request/Response pair. This is only needed
/// on the original sender... not on the reciever.
#[derive(PartialEq, Eq, Copy, Clone)]
pub enum TransactionState {
Polling,
Accepted,
Rejected,
}
#[test]
fn test_persistent_state() {
let path = Path::new("/tmp/test_path");
fs::remove_file(&path.clone());
let mut state = PersistentState::new(0, path.clone());
// Add 0, 1
assert_eq!(state.append_entries(0, 0,
vec![(0, "Zero".to_string()),
(1, "One".to_string())]),
Ok(()));
// Check index.
assert_eq!(state.get_last_index(), 1);
// Check 0
assert_eq!(state.retrieve_entry(0),
Ok((0, "Zero".to_string())));
// Check 0, 1
assert_eq!(state.retrieve_entries(0, 1),
Ok(vec![(0, "Zero".to_string()),
(1, "One".to_string())
]));
// Check 1
assert_eq!(state.retrieve_entry(1),
Ok((1, "One".to_string())));
// Add 2, 3
assert_eq!(state.append_entries(1, 2,
vec![(2, "Two".to_string()),
(3, "Three".to_string())]),
Ok(()));
assert_eq!(state.get_last_index(), 3);
// Check 2, 3
assert_eq!(state.retrieve_entries(2, 3),
Ok(vec![(2, "Two".to_string()),
(3, "Three".to_string())
]));
// Remove 2, 3
assert_eq!(state.purge_from_index(2),
Ok(()));
assert_eq!(state.get_last_index(), 1);
// Check 3,4 are removed, and that code handles lack of entry gracefully.
assert_eq!(state.retrieve_entries(0, 4),
Ok(vec![(0, "Zero".to_string()),
(1, "One".to_string())
]));
// Add 2,3,4.
assert_eq!(state.append_entries(1, 2,
vec![(2, "Two".to_string()), | (3, "Three".to_string()),
(4, "Four".to_string())]),
Ok(()));
assert_eq!(state.get_last_index(), 4); | random_line_split |
|
types.rs | #the-corner-case-unused-parameters-and-parameters-that-are-only-used-unsafely
}
impl<T: Encodable + Decodable + Send + Clone> PersistentState<T> {
pub fn new(current_term: u64, log_path: Path) -> PersistentState<T> {
let mut open_opts = OpenOptions::new();
open_opts.read(true);
open_opts.write(true);
open_opts.create(true);
let mut file = open_opts.open(&log_path).unwrap();
write!(&mut file, "{:20} {:20}\n", current_term, 0).unwrap();
PersistentState {
current_term: current_term,
voted_for: None,
log: file,
last_index: 0,
last_term: 0,
marker: marker::PhantomData,
}
}
/// Gets the `last_index` which you can use to make append requests with.
pub fn get_last_index(&self) -> u64 { self.last_index }
pub fn get_last_term(&self) -> u64 { self.last_term }
/// Gets the `current_term` which is used for request vote.
pub fn get_current_term(&self) -> u64 { self.current_term }
/// Sets the current_term. **This should reflect on stable storage.**
pub fn set_current_term(&mut self, new: u64) -> io::Result<()> {
// The first line is the header with `current_term`, `voted_for`.
self.log.seek(io::SeekFrom::Start(0)); // Take the start.
self.current_term = new;
// TODO: What do we do about the none case?
write!(&mut self.log, "{:20} {:20}\n", self.current_term, self.voted_for.unwrap_or(0))
}
/// Increments the current_term. **This should reflect on stable storage.**
pub fn inc_current_term(&mut self) { self.current_term += 1 }
/// Gets the `voted_for`.
pub fn get_voted_for(&mut self) -> Option<u64> { self.voted_for }
/// Sets the `voted_for. **This should reflect on stable storage.**
pub fn set_voted_for(&mut self, new: Option<u64>) -> io::Result<()> {
// The first line is the header with `current_term`, `voted_for`.
self.log.seek(io::SeekFrom::Start(0)); // Take the start.
self.voted_for = new;
// TODO: What do we do about the none case?
write!(&mut self.log, "{:20} {:20}\n", self.current_term, self.voted_for.unwrap_or(0))
}
pub fn append_entries(&mut self, prev_log_index: u64, prev_log_term: u64,
entries: Vec<(u64, T)>) -> io::Result<()> {
// TODO: No checking of `prev_log_index` & `prev_log_term` yet... Do we need to?
let position = try!(self.move_to(prev_log_index + 1));
let number = entries.len();
let last_term = entries[entries.len() -1].0;
try!(self.purge_from_bytes(position)); // Update `last_log_index` later.
// TODO: Possibly purge.
for (term, entry) in entries {
// TODO: I don't like the "doubling" here. How can we do this better?
write!(&mut self.log, "{} {}\n", term, PersistentState::encode(entry));
}
self.last_index = if prev_log_index == 0 {
number as u64 - 1
} else | ;
self.last_term = last_term;
Ok(())
}
fn encode(entry: T) -> String {
let json_encoded = json::encode(&entry)
.unwrap(); // TODO: Don't unwrap.
json_encoded.as_bytes().to_base64(Config {
char_set: CharacterSet::UrlSafe,
newline: Newline::LF,
pad: false,
line_length: None,
})
}
fn decode(bytes: String) -> Result<T, rustc_serialize::json::DecoderError> {
let based = bytes.from_base64()
.ok().expect("Decoding error. log likely corrupt.");
let string = str::from_utf8(based.as_slice())
.unwrap();
json::decode::<T>(string)
}
/// Returns the number of bytes containing `line` lines.
/// TODO: Cache?
fn move_to(&mut self, line: u64) -> io::Result<u64> {
// Gotcha: The first line is NOT a log entry.
let mut lines_read = 0u64;
self.log.seek(io::SeekFrom::Start(0)); // Take the start.
// Go until we've reached `from` new lines.
let _ = self.log.by_ref().chars().skip_while(|opt| {
match *opt {
Ok(val) => {
if val == '\n' {
lines_read += 1;
if lines_read > line { // Greater than here because the first line is a bust.
false // At right location.
} else {
true // Not done yet, more lines to go.
}
} else {
true // Not a new line.
}
},
_ => false // At EOF. Nothing to purge.
}
}).next(); // Side effects.
self.log.seek(io::SeekFrom::Current(0)) // Where are we?
}
/// Do *not* invoke this unless you update the `last_index`!
fn purge_from_bytes(&mut self, from_bytes: u64) -> io::Result<()> {
self.log.set_len(from_bytes) // Chop off the file at the given position.
}
/// Removes all entries from `from` to the last entry, inclusively.
pub fn purge_from_index(&mut self, from_line: u64) -> io::Result<()> {
let position = try!(self.move_to(from_line));
self.last_index = from_line - 1;
self.purge_from_bytes(position)
}
pub fn retrieve_entries(&mut self, start: u64, end: u64) -> io::Result<Vec<(u64, T)>> {
let position = self.move_to(start);
let mut index = start;
let mut out = vec![];
let mut read_in = self.log.by_ref()
.chars()
.take_while(|val| val.is_ok())
.filter_map(|val| val.ok()); // We don't really care about issues here.
for index in range(start, end +1) {
let mut chars = read_in.by_ref()
.take_while(|&val| val != '\n')
.collect::<String>();
if chars.len() == 0 { continue; }
let entry = try!(parse_entry::<T>(chars));
out.push(entry);
}
Ok(out)
}
pub fn retrieve_entry(&mut self, index: u64) -> io::Result<(u64, T)> {
let position = self.move_to(index);
let mut chars = self.log.by_ref()
.chars()
.take_while(|val| val.is_ok())
.filter_map(|val| val.ok()) // We don't really care about issues here.
.take_while(|&val| val != '\n').collect::<String>();
parse_entry::<T>(chars)
}
}
fn parse_entry<T: Encodable + Decodable + Send + Clone>(val: String) -> io::Result<(u64, T)> {
let mut splits = val.split(' ');
let term = {
let chunk = splits.next()
.and_then(|v| v.parse::<u64>().ok());
match chunk {
Some(v) => v,
None => return Err(io::Error::new(io::ErrorKind::InvalidInput, "Could not parse term.", None)),
}
};
let encoded = {
let chunk = splits.next();
match chunk {
Some(v) => v,
None => return Err(io::Error::new(io::ErrorKind::InvalidInput, "Could not parse encoded data.", None)),
}
};
let decoded: T = PersistentState::decode(encoded.to_string())
.ok().expect("Could not unwrap log entry.");
Ok((term, decoded))
}
/// Volatile state
#[derive(Copy)]
pub struct VolatileState {
pub commit_index: u64,
pub last_applied: u64
}
/// Leader Only
/// **Reinitialized after election.**
#[derive(PartialEq, Eq, Clone)]
pub struct LeaderState {
pub next_index: Vec<u64>,
pub match_index: Vec<u64>
}
/// Nodes can either be:
///
/// * A `Follower`, which replicates AppendEntries requests and votes for it's leader.
/// * A `Leader`, which leads the cluster by serving incoming requests, ensuring data is
/// replicated, and issuing heartbeats..
/// * A `Candidate`, which campaigns in an election and may become a `Leader` (if it gets enough
/// votes) or a `Follower`, if it hears from a `Leader`.
#[derive(PartialEq, Eq, Clone)]
pub enum NodeState | { prev_log_index + number as u64 } | conditional_block |
sync.go |
}
type timestampedError struct {
t time.Time
err error
}
func createSyncHandler(fromName, toName string,
from blobserver.Storage, to blobserver.BlobReceiver,
queue sorted.KeyValue, isToIndex bool) (*SyncHandler, error) {
h := &SyncHandler{
copierPoolSize: 3,
from: from,
to: to,
fromName: fromName,
toName: toName,
queue: queue,
toIndex: isToIndex,
blobc: make(chan blob.SizedRef, 8),
status: "not started",
blobStatus: make(map[string]fmt.Stringer),
}
return h, nil
}
func createIdleSyncHandler(fromName, toName string) (*SyncHandler, error) {
h := &SyncHandler{
fromName: fromName,
toName: toName,
idle: true,
status: "disabled",
}
return h, nil
}
func (sh *SyncHandler) discoveryMap() map[string]interface{} {
// TODO(mpl): more status info
return map[string]interface{}{
"from": sh.fromName,
"to": sh.toName,
"toIndex": sh.toIndex,
}
}
func (sh *SyncHandler) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
sh.lk.Lock()
defer sh.lk.Unlock()
fmt.Fprintf(rw, "<h1>%s to %s Sync Status</h1><p><b>Current status: </b>%s</p>",
sh.fromName, sh.toName, html.EscapeString(sh.status))
if sh.idle {
return
}
fmt.Fprintf(rw, "<h2>Stats:</h2><ul>")
fmt.Fprintf(rw, "<li>Blobs copied: %d</li>", sh.totalCopies)
fmt.Fprintf(rw, "<li>Bytes copied: %d</li>", sh.totalCopyBytes)
if !sh.recentCopyTime.IsZero() {
fmt.Fprintf(rw, "<li>Most recent copy: %s</li>", sh.recentCopyTime.Format(time.RFC3339))
}
fmt.Fprintf(rw, "<li>Copy errors: %d</li>", sh.totalErrors)
fmt.Fprintf(rw, "</ul>")
if len(sh.blobStatus) > 0 {
fmt.Fprintf(rw, "<h2>Current Copies:</h2><ul>")
for blobstr, sfn := range sh.blobStatus {
fmt.Fprintf(rw, "<li>%s: %s</li>\n",
blobstr, html.EscapeString(sfn.String()))
}
fmt.Fprintf(rw, "</ul>")
}
if len(sh.recentErrors) > 0 {
fmt.Fprintf(rw, "<h2>Recent Errors:</h2><ul>")
for _, te := range sh.recentErrors {
fmt.Fprintf(rw, "<li>%s: %s</li>\n",
te.t.Format(time.RFC3339),
html.EscapeString(te.err.Error()))
}
fmt.Fprintf(rw, "</ul>")
}
}
func (sh *SyncHandler) setStatus(s string, args ...interface{}) {
s = time.Now().UTC().Format(time.RFC3339) + ": " + fmt.Sprintf(s, args...)
sh.lk.Lock()
defer sh.lk.Unlock()
sh.status = s
}
func (sh *SyncHandler) setBlobStatus(blobref string, s fmt.Stringer) {
sh.lk.Lock()
defer sh.lk.Unlock()
if s != nil {
sh.blobStatus[blobref] = s
} else {
delete(sh.blobStatus, blobref)
}
}
func (sh *SyncHandler) addErrorToLog(err error) {
sh.logf("%v", err)
sh.lk.Lock()
defer sh.lk.Unlock()
sh.recentErrors = append(sh.recentErrors, timestampedError{time.Now().UTC(), err})
if len(sh.recentErrors) > maxErrors {
// Kinda lame, but whatever. Only for errors, rare.
copy(sh.recentErrors[:maxErrors], sh.recentErrors[1:maxErrors+1])
sh.recentErrors = sh.recentErrors[:maxErrors]
}
}
type copyResult struct {
sb blob.SizedRef
err error
}
func blobserverEnumerator(ctx *context.Context, src blobserver.BlobEnumerator) func(chan<- blob.SizedRef, <-chan struct{}) error {
return func(dst chan<- blob.SizedRef, intr <-chan struct{}) error {
return blobserver.EnumerateAll(ctx, src, func(sb blob.SizedRef) error {
select {
case dst <- sb:
case <-intr:
return errors.New("interrupted")
}
return nil
})
}
}
func (sh *SyncHandler) enumerateQueuedBlobs(dst chan<- blob.SizedRef, intr <-chan struct{}) error {
defer close(dst)
it := sh.queue.Find("", "")
for it.Next() {
br, ok := blob.Parse(it.Key())
size, err := strconv.ParseInt(it.Value(), 10, 64)
if !ok || err != nil {
sh.logf("ERROR: bogus sync queue entry: %q => %q", it.Key(), it.Value())
continue
}
select {
case dst <- blob.SizedRef{br, size}:
case <-intr:
return it.Close()
}
}
return it.Close()
}
func (sh *SyncHandler) enumerateBlobc(first blob.SizedRef) func(chan<- blob.SizedRef, <-chan struct{}) error {
return func(dst chan<- blob.SizedRef, intr <-chan struct{}) error {
defer close(dst)
dst <- first
for {
select {
case sb := <-sh.blobc:
dst <- sb
default:
return nil
}
}
}
}
func (sh *SyncHandler) runSync(srcName string, enumSrc func(chan<- blob.SizedRef, <-chan struct{}) error) int {
enumch := make(chan blob.SizedRef, 8)
errch := make(chan error, 1)
intr := make(chan struct{})
defer close(intr)
go func() { errch <- enumSrc(enumch, intr) }()
nCopied := 0
toCopy := 0
workch := make(chan blob.SizedRef, 1000)
resch := make(chan copyResult, 8)
for sb := range enumch {
toCopy++
workch <- sb
if toCopy <= sh.copierPoolSize {
go sh.copyWorker(resch, workch)
}
sh.setStatus("Enumerating queued blobs: %d", toCopy)
}
close(workch)
for i := 0; i < toCopy; i++ {
sh.setStatus("Copied %d/%d of batch of queued blobs", nCopied, toCopy)
res := <-resch
sh.lk.Lock()
if res.err == nil {
nCopied++
sh.totalCopies++
sh.totalCopyBytes += res.sb.Size
sh.recentCopyTime = time.Now().UTC()
} else {
sh.totalErrors++
}
sh.lk.Unlock()
}
if err := <-errch; err != nil {
sh.addErrorToLog(fmt.Errorf("replication error for source %q, enumerate from source: %v", srcName, err))
return nCopied
}
return nCopied
}
func (sh *SyncHandler) syncQueueLoop() {
for {
t0 := time.Now()
for sh.runSync(sh.fromName, sh.enumerateQueuedBlobs) > 0 {
// Loop, before sleeping.
}
sh.setStatus("Sleeping briefly before next long poll.")
d := queueSyncInterval - time.Since(t0)
select {
case <-time.After(d):
case sb := <-sh.blobc:
// Blob arrived.
sh.runSync(sh.fromName, sh.enumerateBlobc(sb))
}
}
}
func (sh *SyncHandler) copyWorker(res chan<- copyResult, work <-chan blob.SizedRef) {
for sb := range work {
res <- copyResult{sb, sh.copyBlob(sb, 0)}
}
}
type statusFunc func() string
func (sf statusFunc) String() string { return sf() }
type status string
func (s status) String() string { return string(s) }
func (sh *SyncHandler) copyBlob(sb blob.SizedRef, tryCount int) error {
key := sb.Ref.String()
set := func(s fmt.Stringer) {
sh.setBlobStatus(key, s)
}
defer set(nil)
errorf := func(s string, args ...interface{}) error {
// TODO: increment error stats
err := fmt.Errorf("replication error for blob %s: "+s,
append([]interface{}{sb.Ref}, args...)...)
sh.addErrorToLog(err)
return err
}
set(status("sending GET to source"))
rc, fromSize, err := sh.from.FetchStreaming(sb.Ref)
if err != nil {
return errorf("source fetch: %v", err)
}
defer rc.Close()
if fromSize != sb.Size | {
return errorf("source fetch size mismatch: get=%d, enumerate=%d", fromSize, sb.Size)
} | conditional_block |
|
sync.go | ) String() string {
return fmt.Sprintf("[SyncHandler %v -> %v]", sh.fromName, sh.toName)
}
func (sh *SyncHandler) logf(format string, args ...interface{}) {
log.Printf(sh.String()+" "+format, args...)
}
var (
_ blobserver.Storage = (*SyncHandler)(nil)
_ blobserver.HandlerIniter = (*SyncHandler)(nil)
)
func init() {
blobserver.RegisterHandlerConstructor("sync", newSyncFromConfig)
}
func newSyncFromConfig(ld blobserver.Loader, conf jsonconfig.Obj) (http.Handler, error) {
var (
from = conf.RequiredString("from")
to = conf.RequiredString("to")
fullSync = conf.OptionalBool("fullSyncOnStart", false)
blockFullSync = conf.OptionalBool("blockingFullSyncOnStart", false)
idle = conf.OptionalBool("idle", false)
queueConf = conf.OptionalObject("queue")
)
if err := conf.Validate(); err != nil {
return nil, err
}
if idle {
synch, err := createIdleSyncHandler(from, to)
if err != nil {
return nil, err
}
return synch, nil
}
if len(queueConf) == 0 {
return nil, errors.New(`Missing required "queue" object`)
}
q, err := sorted.NewKeyValue(queueConf)
if err != nil {
return nil, err
}
isToIndex := false
fromBs, err := ld.GetStorage(from)
if err != nil {
return nil, err
}
toBs, err := ld.GetStorage(to)
if err != nil {
return nil, err
}
if _, ok := fromBs.(*index.Index); !ok {
if _, ok := toBs.(*index.Index); ok {
isToIndex = true
}
}
sh, err := createSyncHandler(from, to, fromBs, toBs, q, isToIndex)
if err != nil {
return nil, err
}
if fullSync || blockFullSync {
didFullSync := make(chan bool, 1)
go func() {
n := sh.runSync("queue", sh.enumerateQueuedBlobs)
sh.logf("Queue sync copied %d blobs", n)
n = sh.runSync("full", blobserverEnumerator(context.TODO(), fromBs))
sh.logf("Full sync copied %d blobs", n)
didFullSync <- true
sh.syncQueueLoop()
}()
if blockFullSync {
sh.logf("Blocking startup, waiting for full sync from %q to %q", from, to)
<-didFullSync
sh.logf("Full sync complete.")
}
} else {
go sh.syncQueueLoop()
}
blobserver.GetHub(fromBs).AddReceiveHook(sh.enqueue)
return sh, nil
}
func (sh *SyncHandler) InitHandler(hl blobserver.FindHandlerByTyper) error {
_, h, err := hl.FindHandlerByType("root")
if err == blobserver.ErrHandlerTypeNotFound {
// It's optional. We register ourselves if it's there.
return nil
}
if err != nil {
return err
}
h.(*RootHandler).registerSyncHandler(sh)
return nil
}
type timestampedError struct {
t time.Time
err error
}
func createSyncHandler(fromName, toName string,
from blobserver.Storage, to blobserver.BlobReceiver,
queue sorted.KeyValue, isToIndex bool) (*SyncHandler, error) {
h := &SyncHandler{
copierPoolSize: 3,
from: from,
to: to,
fromName: fromName,
toName: toName,
queue: queue,
toIndex: isToIndex,
blobc: make(chan blob.SizedRef, 8),
status: "not started",
blobStatus: make(map[string]fmt.Stringer),
}
return h, nil
}
func createIdleSyncHandler(fromName, toName string) (*SyncHandler, error) {
h := &SyncHandler{
fromName: fromName,
toName: toName,
idle: true,
status: "disabled",
}
return h, nil
}
func (sh *SyncHandler) discoveryMap() map[string]interface{} {
// TODO(mpl): more status info
return map[string]interface{}{
"from": sh.fromName,
"to": sh.toName,
"toIndex": sh.toIndex,
}
}
func (sh *SyncHandler) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
sh.lk.Lock()
defer sh.lk.Unlock()
| if sh.idle {
return
}
fmt.Fprintf(rw, "<h2>Stats:</h2><ul>")
fmt.Fprintf(rw, "<li>Blobs copied: %d</li>", sh.totalCopies)
fmt.Fprintf(rw, "<li>Bytes copied: %d</li>", sh.totalCopyBytes)
if !sh.recentCopyTime.IsZero() {
fmt.Fprintf(rw, "<li>Most recent copy: %s</li>", sh.recentCopyTime.Format(time.RFC3339))
}
fmt.Fprintf(rw, "<li>Copy errors: %d</li>", sh.totalErrors)
fmt.Fprintf(rw, "</ul>")
if len(sh.blobStatus) > 0 {
fmt.Fprintf(rw, "<h2>Current Copies:</h2><ul>")
for blobstr, sfn := range sh.blobStatus {
fmt.Fprintf(rw, "<li>%s: %s</li>\n",
blobstr, html.EscapeString(sfn.String()))
}
fmt.Fprintf(rw, "</ul>")
}
if len(sh.recentErrors) > 0 {
fmt.Fprintf(rw, "<h2>Recent Errors:</h2><ul>")
for _, te := range sh.recentErrors {
fmt.Fprintf(rw, "<li>%s: %s</li>\n",
te.t.Format(time.RFC3339),
html.EscapeString(te.err.Error()))
}
fmt.Fprintf(rw, "</ul>")
}
}
func (sh *SyncHandler) setStatus(s string, args ...interface{}) {
s = time.Now().UTC().Format(time.RFC3339) + ": " + fmt.Sprintf(s, args...)
sh.lk.Lock()
defer sh.lk.Unlock()
sh.status = s
}
func (sh *SyncHandler) setBlobStatus(blobref string, s fmt.Stringer) {
sh.lk.Lock()
defer sh.lk.Unlock()
if s != nil {
sh.blobStatus[blobref] = s
} else {
delete(sh.blobStatus, blobref)
}
}
func (sh *SyncHandler) addErrorToLog(err error) {
sh.logf("%v", err)
sh.lk.Lock()
defer sh.lk.Unlock()
sh.recentErrors = append(sh.recentErrors, timestampedError{time.Now().UTC(), err})
if len(sh.recentErrors) > maxErrors {
// Kinda lame, but whatever. Only for errors, rare.
copy(sh.recentErrors[:maxErrors], sh.recentErrors[1:maxErrors+1])
sh.recentErrors = sh.recentErrors[:maxErrors]
}
}
type copyResult struct {
sb blob.SizedRef
err error
}
func blobserverEnumerator(ctx *context.Context, src blobserver.BlobEnumerator) func(chan<- blob.SizedRef, <-chan struct{}) error {
return func(dst chan<- blob.SizedRef, intr <-chan struct{}) error {
return blobserver.EnumerateAll(ctx, src, func(sb blob.SizedRef) error {
select {
case dst <- sb:
case <-intr:
return errors.New("interrupted")
}
return nil
})
}
}
func (sh *SyncHandler) enumerateQueuedBlobs(dst chan<- blob.SizedRef, intr <-chan struct{}) error {
defer close(dst)
it := sh.queue.Find("", "")
for it.Next() {
br, ok := blob.Parse(it.Key())
size, err := strconv.ParseInt(it.Value(), 10, 64)
if !ok || err != nil {
sh.logf("ERROR: bogus sync queue entry: %q => %q", it.Key(), it.Value())
continue
}
select {
case dst <- blob.SizedRef{br, size}:
case <-intr:
return it.Close()
}
}
return it.Close()
}
func (sh *SyncHandler) enumerateBlobc(first blob.SizedRef) func(chan<- blob.SizedRef, <-chan struct{}) error {
return func(dst chan<- blob.SizedRef, intr <-chan struct{}) error {
defer close(dst)
dst <- first
for {
select {
case sb := <-sh.blobc:
dst <- sb
default:
return nil
}
}
}
}
func (sh *SyncHandler) runSync(srcName string, enumSrc func(chan<- blob.SizedRef, <-chan struct{}) error) int {
enumch := make(chan blob.SizedRef, 8 | fmt.Fprintf(rw, "<h1>%s to %s Sync Status</h1><p><b>Current status: </b>%s</p>",
sh.fromName, sh.toName, html.EscapeString(sh.status)) | random_line_split |
sync.go | ) String() string {
return fmt.Sprintf("[SyncHandler %v -> %v]", sh.fromName, sh.toName)
}
func (sh *SyncHandler) logf(format string, args ...interface{}) {
log.Printf(sh.String()+" "+format, args...)
}
var (
_ blobserver.Storage = (*SyncHandler)(nil)
_ blobserver.HandlerIniter = (*SyncHandler)(nil)
)
func init() {
blobserver.RegisterHandlerConstructor("sync", newSyncFromConfig)
}
func newSyncFromConfig(ld blobserver.Loader, conf jsonconfig.Obj) (http.Handler, error) {
var (
from = conf.RequiredString("from")
to = conf.RequiredString("to")
fullSync = conf.OptionalBool("fullSyncOnStart", false)
blockFullSync = conf.OptionalBool("blockingFullSyncOnStart", false)
idle = conf.OptionalBool("idle", false)
queueConf = conf.OptionalObject("queue")
)
if err := conf.Validate(); err != nil {
return nil, err
}
if idle {
synch, err := createIdleSyncHandler(from, to)
if err != nil {
return nil, err
}
return synch, nil
}
if len(queueConf) == 0 {
return nil, errors.New(`Missing required "queue" object`)
}
q, err := sorted.NewKeyValue(queueConf)
if err != nil {
return nil, err
}
isToIndex := false
fromBs, err := ld.GetStorage(from)
if err != nil {
return nil, err
}
toBs, err := ld.GetStorage(to)
if err != nil {
return nil, err
}
if _, ok := fromBs.(*index.Index); !ok {
if _, ok := toBs.(*index.Index); ok {
isToIndex = true
}
}
sh, err := createSyncHandler(from, to, fromBs, toBs, q, isToIndex)
if err != nil {
return nil, err
}
if fullSync || blockFullSync {
didFullSync := make(chan bool, 1)
go func() {
n := sh.runSync("queue", sh.enumerateQueuedBlobs)
sh.logf("Queue sync copied %d blobs", n)
n = sh.runSync("full", blobserverEnumerator(context.TODO(), fromBs))
sh.logf("Full sync copied %d blobs", n)
didFullSync <- true
sh.syncQueueLoop()
}()
if blockFullSync {
sh.logf("Blocking startup, waiting for full sync from %q to %q", from, to)
<-didFullSync
sh.logf("Full sync complete.")
}
} else {
go sh.syncQueueLoop()
}
blobserver.GetHub(fromBs).AddReceiveHook(sh.enqueue)
return sh, nil
}
func (sh *SyncHandler) InitHandler(hl blobserver.FindHandlerByTyper) error {
_, h, err := hl.FindHandlerByType("root")
if err == blobserver.ErrHandlerTypeNotFound {
// It's optional. We register ourselves if it's there.
return nil
}
if err != nil {
return err
}
h.(*RootHandler).registerSyncHandler(sh)
return nil
}
type timestampedError struct {
t time.Time
err error
}
func createSyncHandler(fromName, toName string,
from blobserver.Storage, to blobserver.BlobReceiver,
queue sorted.KeyValue, isToIndex bool) (*SyncHandler, error) {
h := &SyncHandler{
copierPoolSize: 3,
from: from,
to: to,
fromName: fromName,
toName: toName,
queue: queue,
toIndex: isToIndex,
blobc: make(chan blob.SizedRef, 8),
status: "not started",
blobStatus: make(map[string]fmt.Stringer),
}
return h, nil
}
func createIdleSyncHandler(fromName, toName string) (*SyncHandler, error) {
h := &SyncHandler{
fromName: fromName,
toName: toName,
idle: true,
status: "disabled",
}
return h, nil
}
func (sh *SyncHandler) discoveryMap() map[string]interface{} {
// TODO(mpl): more status info
return map[string]interface{}{
"from": sh.fromName,
"to": sh.toName,
"toIndex": sh.toIndex,
}
}
func (sh *SyncHandler) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
sh.lk.Lock()
defer sh.lk.Unlock()
fmt.Fprintf(rw, "<h1>%s to %s Sync Status</h1><p><b>Current status: </b>%s</p>",
sh.fromName, sh.toName, html.EscapeString(sh.status))
if sh.idle {
return
}
fmt.Fprintf(rw, "<h2>Stats:</h2><ul>")
fmt.Fprintf(rw, "<li>Blobs copied: %d</li>", sh.totalCopies)
fmt.Fprintf(rw, "<li>Bytes copied: %d</li>", sh.totalCopyBytes)
if !sh.recentCopyTime.IsZero() {
fmt.Fprintf(rw, "<li>Most recent copy: %s</li>", sh.recentCopyTime.Format(time.RFC3339))
}
fmt.Fprintf(rw, "<li>Copy errors: %d</li>", sh.totalErrors)
fmt.Fprintf(rw, "</ul>")
if len(sh.blobStatus) > 0 {
fmt.Fprintf(rw, "<h2>Current Copies:</h2><ul>")
for blobstr, sfn := range sh.blobStatus {
fmt.Fprintf(rw, "<li>%s: %s</li>\n",
blobstr, html.EscapeString(sfn.String()))
}
fmt.Fprintf(rw, "</ul>")
}
if len(sh.recentErrors) > 0 {
fmt.Fprintf(rw, "<h2>Recent Errors:</h2><ul>")
for _, te := range sh.recentErrors {
fmt.Fprintf(rw, "<li>%s: %s</li>\n",
te.t.Format(time.RFC3339),
html.EscapeString(te.err.Error()))
}
fmt.Fprintf(rw, "</ul>")
}
}
func (sh *SyncHandler) setStatus(s string, args ...interface{}) {
s = time.Now().UTC().Format(time.RFC3339) + ": " + fmt.Sprintf(s, args...)
sh.lk.Lock()
defer sh.lk.Unlock()
sh.status = s
}
func (sh *SyncHandler) setBlobStatus(blobref string, s fmt.Stringer) {
sh.lk.Lock()
defer sh.lk.Unlock()
if s != nil {
sh.blobStatus[blobref] = s
} else {
delete(sh.blobStatus, blobref)
}
}
func (sh *SyncHandler) addErrorToLog(err error) {
sh.logf("%v", err)
sh.lk.Lock()
defer sh.lk.Unlock()
sh.recentErrors = append(sh.recentErrors, timestampedError{time.Now().UTC(), err})
if len(sh.recentErrors) > maxErrors {
// Kinda lame, but whatever. Only for errors, rare.
copy(sh.recentErrors[:maxErrors], sh.recentErrors[1:maxErrors+1])
sh.recentErrors = sh.recentErrors[:maxErrors]
}
}
type copyResult struct {
sb blob.SizedRef
err error
}
func | (ctx *context.Context, src blobserver.BlobEnumerator) func(chan<- blob.SizedRef, <-chan struct{}) error {
return func(dst chan<- blob.SizedRef, intr <-chan struct{}) error {
return blobserver.EnumerateAll(ctx, src, func(sb blob.SizedRef) error {
select {
case dst <- sb:
case <-intr:
return errors.New("interrupted")
}
return nil
})
}
}
func (sh *SyncHandler) enumerateQueuedBlobs(dst chan<- blob.SizedRef, intr <-chan struct{}) error {
defer close(dst)
it := sh.queue.Find("", "")
for it.Next() {
br, ok := blob.Parse(it.Key())
size, err := strconv.ParseInt(it.Value(), 10, 64)
if !ok || err != nil {
sh.logf("ERROR: bogus sync queue entry: %q => %q", it.Key(), it.Value())
continue
}
select {
case dst <- blob.SizedRef{br, size}:
case <-intr:
return it.Close()
}
}
return it.Close()
}
func (sh *SyncHandler) enumerateBlobc(first blob.SizedRef) func(chan<- blob.SizedRef, <-chan struct{}) error {
return func(dst chan<- blob.SizedRef, intr <-chan struct{}) error {
defer close(dst)
dst <- first
for {
select {
case sb := <-sh.blobc:
dst <- sb
default:
return nil
}
}
}
}
func (sh *SyncHandler) runSync(srcName string, enumSrc func(chan<- blob.SizedRef, <-chan struct{}) error) int {
enumch := make(chan blob.SizedRef, | blobserverEnumerator | identifier_name |
sync.go | ) String() string {
return fmt.Sprintf("[SyncHandler %v -> %v]", sh.fromName, sh.toName)
}
func (sh *SyncHandler) logf(format string, args ...interface{}) {
log.Printf(sh.String()+" "+format, args...)
}
var (
_ blobserver.Storage = (*SyncHandler)(nil)
_ blobserver.HandlerIniter = (*SyncHandler)(nil)
)
func init() {
blobserver.RegisterHandlerConstructor("sync", newSyncFromConfig)
}
func newSyncFromConfig(ld blobserver.Loader, conf jsonconfig.Obj) (http.Handler, error) {
var (
from = conf.RequiredString("from")
to = conf.RequiredString("to")
fullSync = conf.OptionalBool("fullSyncOnStart", false)
blockFullSync = conf.OptionalBool("blockingFullSyncOnStart", false)
idle = conf.OptionalBool("idle", false)
queueConf = conf.OptionalObject("queue")
)
if err := conf.Validate(); err != nil {
return nil, err
}
if idle {
synch, err := createIdleSyncHandler(from, to)
if err != nil {
return nil, err
}
return synch, nil
}
if len(queueConf) == 0 {
return nil, errors.New(`Missing required "queue" object`)
}
q, err := sorted.NewKeyValue(queueConf)
if err != nil {
return nil, err
}
isToIndex := false
fromBs, err := ld.GetStorage(from)
if err != nil {
return nil, err
}
toBs, err := ld.GetStorage(to)
if err != nil {
return nil, err
}
if _, ok := fromBs.(*index.Index); !ok {
if _, ok := toBs.(*index.Index); ok {
isToIndex = true
}
}
sh, err := createSyncHandler(from, to, fromBs, toBs, q, isToIndex)
if err != nil {
return nil, err
}
if fullSync || blockFullSync {
didFullSync := make(chan bool, 1)
go func() {
n := sh.runSync("queue", sh.enumerateQueuedBlobs)
sh.logf("Queue sync copied %d blobs", n)
n = sh.runSync("full", blobserverEnumerator(context.TODO(), fromBs))
sh.logf("Full sync copied %d blobs", n)
didFullSync <- true
sh.syncQueueLoop()
}()
if blockFullSync {
sh.logf("Blocking startup, waiting for full sync from %q to %q", from, to)
<-didFullSync
sh.logf("Full sync complete.")
}
} else {
go sh.syncQueueLoop()
}
blobserver.GetHub(fromBs).AddReceiveHook(sh.enqueue)
return sh, nil
}
func (sh *SyncHandler) InitHandler(hl blobserver.FindHandlerByTyper) error {
_, h, err := hl.FindHandlerByType("root")
if err == blobserver.ErrHandlerTypeNotFound {
// It's optional. We register ourselves if it's there.
return nil
}
if err != nil {
return err
}
h.(*RootHandler).registerSyncHandler(sh)
return nil
}
type timestampedError struct {
t time.Time
err error
}
func createSyncHandler(fromName, toName string,
from blobserver.Storage, to blobserver.BlobReceiver,
queue sorted.KeyValue, isToIndex bool) (*SyncHandler, error) {
h := &SyncHandler{
copierPoolSize: 3,
from: from,
to: to,
fromName: fromName,
toName: toName,
queue: queue,
toIndex: isToIndex,
blobc: make(chan blob.SizedRef, 8),
status: "not started",
blobStatus: make(map[string]fmt.Stringer),
}
return h, nil
}
func createIdleSyncHandler(fromName, toName string) (*SyncHandler, error) {
h := &SyncHandler{
fromName: fromName,
toName: toName,
idle: true,
status: "disabled",
}
return h, nil
}
func (sh *SyncHandler) discoveryMap() map[string]interface{} {
// TODO(mpl): more status info
return map[string]interface{}{
"from": sh.fromName,
"to": sh.toName,
"toIndex": sh.toIndex,
}
}
func (sh *SyncHandler) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
sh.lk.Lock()
defer sh.lk.Unlock()
fmt.Fprintf(rw, "<h1>%s to %s Sync Status</h1><p><b>Current status: </b>%s</p>",
sh.fromName, sh.toName, html.EscapeString(sh.status))
if sh.idle {
return
}
fmt.Fprintf(rw, "<h2>Stats:</h2><ul>")
fmt.Fprintf(rw, "<li>Blobs copied: %d</li>", sh.totalCopies)
fmt.Fprintf(rw, "<li>Bytes copied: %d</li>", sh.totalCopyBytes)
if !sh.recentCopyTime.IsZero() {
fmt.Fprintf(rw, "<li>Most recent copy: %s</li>", sh.recentCopyTime.Format(time.RFC3339))
}
fmt.Fprintf(rw, "<li>Copy errors: %d</li>", sh.totalErrors)
fmt.Fprintf(rw, "</ul>")
if len(sh.blobStatus) > 0 {
fmt.Fprintf(rw, "<h2>Current Copies:</h2><ul>")
for blobstr, sfn := range sh.blobStatus {
fmt.Fprintf(rw, "<li>%s: %s</li>\n",
blobstr, html.EscapeString(sfn.String()))
}
fmt.Fprintf(rw, "</ul>")
}
if len(sh.recentErrors) > 0 {
fmt.Fprintf(rw, "<h2>Recent Errors:</h2><ul>")
for _, te := range sh.recentErrors {
fmt.Fprintf(rw, "<li>%s: %s</li>\n",
te.t.Format(time.RFC3339),
html.EscapeString(te.err.Error()))
}
fmt.Fprintf(rw, "</ul>")
}
}
func (sh *SyncHandler) setStatus(s string, args ...interface{}) {
s = time.Now().UTC().Format(time.RFC3339) + ": " + fmt.Sprintf(s, args...)
sh.lk.Lock()
defer sh.lk.Unlock()
sh.status = s
}
func (sh *SyncHandler) setBlobStatus(blobref string, s fmt.Stringer) {
sh.lk.Lock()
defer sh.lk.Unlock()
if s != nil {
sh.blobStatus[blobref] = s
} else {
delete(sh.blobStatus, blobref)
}
}
func (sh *SyncHandler) addErrorToLog(err error) {
sh.logf("%v", err)
sh.lk.Lock()
defer sh.lk.Unlock()
sh.recentErrors = append(sh.recentErrors, timestampedError{time.Now().UTC(), err})
if len(sh.recentErrors) > maxErrors {
// Kinda lame, but whatever. Only for errors, rare.
copy(sh.recentErrors[:maxErrors], sh.recentErrors[1:maxErrors+1])
sh.recentErrors = sh.recentErrors[:maxErrors]
}
}
type copyResult struct {
sb blob.SizedRef
err error
}
func blobserverEnumerator(ctx *context.Context, src blobserver.BlobEnumerator) func(chan<- blob.SizedRef, <-chan struct{}) error |
func (sh *SyncHandler) enumerateQueuedBlobs(dst chan<- blob.SizedRef, intr <-chan struct{}) error {
defer close(dst)
it := sh.queue.Find("", "")
for it.Next() {
br, ok := blob.Parse(it.Key())
size, err := strconv.ParseInt(it.Value(), 10, 64)
if !ok || err != nil {
sh.logf("ERROR: bogus sync queue entry: %q => %q", it.Key(), it.Value())
continue
}
select {
case dst <- blob.SizedRef{br, size}:
case <-intr:
return it.Close()
}
}
return it.Close()
}
func (sh *SyncHandler) enumerateBlobc(first blob.SizedRef) func(chan<- blob.SizedRef, <-chan struct{}) error {
return func(dst chan<- blob.SizedRef, intr <-chan struct{}) error {
defer close(dst)
dst <- first
for {
select {
case sb := <-sh.blobc:
dst <- sb
default:
return nil
}
}
}
}
func (sh *SyncHandler) runSync(srcName string, enumSrc func(chan<- blob.SizedRef, <-chan struct{}) error) int {
enumch := make(chan blob.SizedRef, | {
return func(dst chan<- blob.SizedRef, intr <-chan struct{}) error {
return blobserver.EnumerateAll(ctx, src, func(sb blob.SizedRef) error {
select {
case dst <- sb:
case <-intr:
return errors.New("interrupted")
}
return nil
})
}
} | identifier_body |
feature_table.rs | QualifierValue::nom)), |(_, v)| v);
map(
tuple((parse_name, opt(parse_value))),
|(name, value)| Qualifier{ name, value }
)(input)
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum QualifierValue {
QuotedText(String),
VocabularyTerm(FtString),
ReferenceNumber(u32),
}
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for QualifierValue{
fn nom(input: &'a str) -> IResult<&'a str, QualifierValue, E> {
let parse_quoted_text =
map(
tuple((tag("\""), take_while(|c| c != '"'), tag("\""))),
|(_, v, _): (&str, &str, &str)| QualifierValue::QuotedText(v.to_string()));
let parse_vocabulary_term =
map(
FtString::nom,
QualifierValue::VocabularyTerm);
let parse_reference_number =
map(
tuple((tag("["), u32::nom, tag("]"))),
|(_, d, _)| QualifierValue::ReferenceNumber(d));
alt((
parse_quoted_text,
parse_vocabulary_term,
parse_reference_number
))(input)
}
}
//
//
// Location data model starts here
//
// Should really be in a sub-module I guess
//
//
/// A point within a sequence, representing a specific nucleotide. Counts from 1.
#[derive(Debug, PartialEq, Eq)]
pub struct Point(u32);
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for Point {
fn nom(input: &'a str) -> IResult<&'a str, Point, E> {
map(u32::nom, Point)(input)
}
}
/// A position between two bases in a sequence.
/// pub
/// For example, 122^123. The locations must be consecutive.
///
/// For example, 100^1 for a circular sequence of length 100.
#[derive(Debug, PartialEq, Eq)]
pub struct Between(u32, u32);
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for Between {
fn nom(input: &'a str) -> IResult<&'a str, Between, E> {
map(
tuple((
u32::nom,
tag("^"),
u32::nom
)),
|(from, _, to)| Between(from, to)
)(input)
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum Position {
Point(Point),
Between(Between)
}
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for Position {
fn nom(input: &'a str) -> IResult<&'a str, Position, E> {
alt((
map(Between::nom, Position::Between),
map(Point::nom, Position::Point)
))(input)
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum Local {
Point(Point),
Between(Between),
Within { from: Point, to: Point },
Span { from: Position, to: Position, before_from: bool, after_to: bool },
}
impl Local {
pub fn span(from: u32, to: u32) -> Local {
Local::Span {
from: Position::Point(Point(from)),
to: Position::Point(Point(to)),
before_from: false,
after_to: false }
}
}
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for Local {
fn nom(input: &'a str) -> IResult<&'a str, Local, E> {
let parse_within = map(
tuple((Point::nom, tag("."), Point::nom)),
|(from, _, to)| Local::Within { from, to });
let parse_span = map(
tuple((
opt(tag("<")), Position::nom, tag(".."), opt(tag(">")), Position::nom)),
|(before_from, from, _, after_to, to)| Local::Span {
from,
to,
before_from: before_from.is_some(),
after_to: after_to.is_some() }
);
alt((
map(Between::nom, Local::Between),
parse_within,
parse_span,
map(Point::nom, Local::Point), // must do this last as it's a prefix of the others
))(input)
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum Loc {
Remote { within: String, at: Local },
Local(Local)
}
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for Loc {
fn nom(input: &'a str) -> IResult<&'a str, Loc, E> {
let parse_accession = take_while1(|c| {
let b = c as u8;
is_alphanumeric(b) || b == b'.'
});
alt((
map(
tuple((parse_accession, tag(":"), Local::nom)),
|(within, _, at)| Loc::Remote { within: within.to_string(), at }
),
map(Local::nom, Loc::Local)
))(input)
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum LocOp {
Loc(Loc),
Complement(Box<LocOp>),
Join(Vec<LocOp>),
Order(Vec<LocOp>)
}
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for LocOp {
fn nom(input: &'a str) -> IResult<&'a str, LocOp, E> {
let parse_complement =
map(
tuple((
tag("complement("),
cut(LocOp::nom),
tag(")")
)),
|(_, loc, _)| loc
);
let parse_join =
map(
tuple((
tag("join("),
cut(separated_list(tag(","), LocOp::nom)),
tag(")")
)),
|(_, locs, _)| locs
);
let parse_order =
map(
tuple((
tag("order("),
cut(separated_list(tag(","), LocOp::nom)),
tag(")")
)),
|(_, locs, _)| locs
);
alt((
map(Loc::nom, LocOp::Loc),
map(parse_complement, |loc| LocOp::Complement(Box::new(loc))),
map(parse_join, LocOp::Join),
map(parse_order, LocOp::Order)
))(input)
}
}
#[cfg(test)]
mod tests {
use super::*;
use nom::error::{
convert_error,
VerboseError,
};
fn assert_nom_to_expected<'a, T>() -> impl Fn(&'a str, T) -> ()
where
T: Nommed<&'a str, VerboseError<&'a str>> + std::fmt::Debug + PartialEq
{
move |input: &str, expected: T| {
match T::nom(input) {
Ok((rem, ref res)) if !rem.is_empty() => panic!("Non-empty remaining input {}, parsed out {:?}", rem, res),
Ok((_, res)) => assert_eq!(res, expected, "Got result {:?} but expected {:?}", res, expected),
Err(nom::Err::Error(e)) | Err(nom::Err::Failure(e)) => panic!("Problem: {}", convert_error(input, e)),
e => panic!("Unknown error: {:?}", e)
}
}
}
// #[test]
// fn test_parse_feature_record_from_spec() {
// let expect = assert_nom_to_expected::<FeatureRecord>();
// expect(
// r#"
// source 1..1000
// /culture_collection="ATCC:11775"
// /culture_collection="CECT:515"
// "#,
// FeatureRecord {
// key: "source".to_string(),
// location: LocOp::Loc(Loc::Local(Local::span(1, 1000))),
// qualifiers: vec![]
// }
// )
// }
#[test]
fn test_parse_qualifiers_from_spec() {
let expect = assert_nom_to_expected::<Qualifier>();
expect(
"/pseudo",
Qualifier {
name: FtString("pseudo".to_string()),
value: None });
expect(
"/citation=[1]",
Qualifier {
name: FtString("citation".to_string()),
value: Some(QualifierValue::ReferenceNumber(1)) });
expect(
"/gene=\"arsC\"",
Qualifier {
name: FtString("gene".to_string()),
value: Some(QualifierValue::QuotedText("arsC".to_string()))});
expect(
"/rpt_type=DISPERSED",
Qualifier {
name: FtString("rpt_type".to_string()),
value: Some(QualifierValue::VocabularyTerm(FtString("DISPERSED".to_string())))});
}
#[test]
fn test_parse_locations_from_spec() {
let expect = assert_nom_to_expected::<LocOp>();
expect(
"467",
LocOp::Loc(Loc::Local(Local::Point(Point(467)))));
| random_line_split |
||
feature_table.rs | , FtString, E> {
let uc = Interval('A', 'Z');
let lc = Interval('a', 'z');
let di = Interval('0', '9');
let misc = "_-'*";
let ft_char = {
move |c: char|
uc.contains(&c) ||
lc.contains(&c) ||
di.contains(&c) ||
misc.contains(c)
};
let alpha = {
move |c: char|
uc.contains(&c) ||
lc.contains(&c)
};
map(
verify(
take_while_m_n(1, 20, ft_char),
move |s: &str| s.chars().any(alpha)
),
|s: &str| FtString(s.to_string())
)(input)
}
}
#[derive(Debug, PartialEq, Eq)]
pub struct Qualifier {
name: FtString,
value: Option<QualifierValue>
}
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for Qualifier {
fn nom(input: &'a str) -> IResult<&'a str, Qualifier, E> {
let parse_name = map(tuple((tag("/"), FtString::nom)), |(_, n)| n);
let parse_value = map(tuple((tag("="), QualifierValue::nom)), |(_, v)| v);
map(
tuple((parse_name, opt(parse_value))),
|(name, value)| Qualifier{ name, value }
)(input)
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum QualifierValue {
QuotedText(String),
VocabularyTerm(FtString),
ReferenceNumber(u32),
}
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for QualifierValue{
fn nom(input: &'a str) -> IResult<&'a str, QualifierValue, E> {
let parse_quoted_text =
map(
tuple((tag("\""), take_while(|c| c != '"'), tag("\""))),
|(_, v, _): (&str, &str, &str)| QualifierValue::QuotedText(v.to_string()));
let parse_vocabulary_term =
map(
FtString::nom,
QualifierValue::VocabularyTerm);
let parse_reference_number =
map(
tuple((tag("["), u32::nom, tag("]"))),
|(_, d, _)| QualifierValue::ReferenceNumber(d));
alt((
parse_quoted_text,
parse_vocabulary_term,
parse_reference_number
))(input)
}
}
//
//
// Location data model starts here
//
// Should really be in a sub-module I guess
//
//
/// A point within a sequence, representing a specific nucleotide. Counts from 1.
#[derive(Debug, PartialEq, Eq)]
pub struct Point(u32);
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for Point {
fn nom(input: &'a str) -> IResult<&'a str, Point, E> {
map(u32::nom, Point)(input)
}
}
/// A position between two bases in a sequence.
/// pub
/// For example, 122^123. The locations must be consecutive.
///
/// For example, 100^1 for a circular sequence of length 100.
#[derive(Debug, PartialEq, Eq)]
pub struct Between(u32, u32);
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for Between {
fn nom(input: &'a str) -> IResult<&'a str, Between, E> {
map(
tuple((
u32::nom,
tag("^"),
u32::nom
)),
|(from, _, to)| Between(from, to)
)(input)
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum Position {
Point(Point),
Between(Between)
}
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for Position {
fn nom(input: &'a str) -> IResult<&'a str, Position, E> {
alt((
map(Between::nom, Position::Between),
map(Point::nom, Position::Point)
))(input)
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum Local {
Point(Point),
Between(Between),
Within { from: Point, to: Point },
Span { from: Position, to: Position, before_from: bool, after_to: bool },
}
impl Local {
pub fn span(from: u32, to: u32) -> Local {
Local::Span {
from: Position::Point(Point(from)),
to: Position::Point(Point(to)),
before_from: false,
after_to: false }
}
}
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for Local {
fn nom(input: &'a str) -> IResult<&'a str, Local, E> | ))(input)
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum Loc {
Remote { within: String, at: Local },
Local(Local)
}
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for Loc {
fn nom(input: &'a str) -> IResult<&'a str, Loc, E> {
let parse_accession = take_while1(|c| {
let b = c as u8;
is_alphanumeric(b) || b == b'.'
});
alt((
map(
tuple((parse_accession, tag(":"), Local::nom)),
|(within, _, at)| Loc::Remote { within: within.to_string(), at }
),
map(Local::nom, Loc::Local)
))(input)
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum LocOp {
Loc(Loc),
Complement(Box<LocOp>),
Join(Vec<LocOp>),
Order(Vec<LocOp>)
}
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for LocOp {
fn nom(input: &'a str) -> IResult<&'a str, LocOp, E> {
let parse_complement =
map(
tuple((
tag("complement("),
cut(LocOp::nom),
tag(")")
)),
|(_, loc, _)| loc
);
let parse_join =
map(
tuple((
tag("join("),
cut(separated_list(tag(","), LocOp::nom)),
tag(")")
)),
|(_, locs, _)| locs
);
let parse_order =
map(
tuple((
tag("order("),
cut(separated_list(tag(","), LocOp::nom)),
tag(")")
)),
|(_, locs, _)| locs
);
alt((
map(Loc::nom, LocOp::Loc),
map(parse_complement, |loc| LocOp::Complement(Box::new(loc))),
map(parse_join, LocOp::Join),
map(parse_order, LocOp::Order)
))(input)
}
}
#[cfg(test)]
mod tests {
use super::*;
use nom::error::{
convert_error,
VerboseError,
};
fn assert_nom_to_expected<'a, T>() -> impl Fn(&'a str, T) -> ()
where
T: Nommed<&'a str, VerboseError<&'a str>> + std::fmt::Debug + PartialEq
{
move |input: &str, expected: T| {
match T::nom(input) {
Ok((rem, ref res)) if !rem.is_empty() => panic!("Non-empty remaining input {}, parsed out {:?}", rem, res),
Ok((_, res)) => assert_eq!(res, expected, "Got result {:?} but expected {:?}", res, expected),
Err(nom::Err::Error(e)) | Err(nom::Err::Failure(e)) => panic!("Problem: {}", convert_error(input, e)),
e => panic!("Unknown error: {:?}", e)
}
}
}
// #[test]
// fn test_parse_feature_record_from_spec() {
// let expect = assert_nom_to_expected::<FeatureRecord>();
// expect(
// r#"
// source 1..1000
// /culture_collection="ATCC:11775"
// /culture_collection="CECT:515"
// "#,
// FeatureRecord {
// key: "source".to_string(),
// | {
let parse_within = map(
tuple((Point::nom, tag("."), Point::nom)),
|(from, _, to)| Local::Within { from, to });
let parse_span = map(
tuple((
opt(tag("<")), Position::nom, tag(".."), opt(tag(">")), Position::nom)),
|(before_from, from, _, after_to, to)| Local::Span {
from,
to,
before_from: before_from.is_some(),
after_to: after_to.is_some() }
);
alt((
map(Between::nom, Local::Between),
parse_within,
parse_span,
map(Point::nom, Local::Point), // must do this last as it's a prefix of the others | identifier_body |
feature_table.rs | {
key: String,
location: LocOp,
qualifiers: Vec<Qualifier>
}
// impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for FeatureRecord {
// fn nom(input: &'a str) -> IResult<&'a str, FeatureRecord, E> {
// }
// }
/// An ID that's valid within the feature table.
///
/// This is:
/// * At least one letter
/// * Upper case, lower case letters
/// * Numbers 0..9
/// * Underscore (_)
/// * Hyphen (-)
/// * Single quote (')
/// * Asterisk (*)
/// The maximum length is 20 characters.
#[derive(Debug, PartialEq, Eq)]
pub struct FtString(String);
// litle utility for ranges.
//
// Note: couldn't use 'a'..='b' because this is an iterator, so doesn't
// implement `Copy`.
#[derive(Clone, Copy)]
struct Interval<T>(T, T);
impl <T : PartialOrd> Interval<T> {
fn contains(&self, e: &T) -> bool {
self.0 <= *e &&
*e <= self.1
}
}
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for FtString {
fn nom(input: &'a str) -> IResult<&'a str, FtString, E> {
let uc = Interval('A', 'Z');
let lc = Interval('a', 'z');
let di = Interval('0', '9');
let misc = "_-'*";
let ft_char = {
move |c: char|
uc.contains(&c) ||
lc.contains(&c) ||
di.contains(&c) ||
misc.contains(c)
};
let alpha = {
move |c: char|
uc.contains(&c) ||
lc.contains(&c)
};
map(
verify(
take_while_m_n(1, 20, ft_char),
move |s: &str| s.chars().any(alpha)
),
|s: &str| FtString(s.to_string())
)(input)
}
}
#[derive(Debug, PartialEq, Eq)]
pub struct Qualifier {
name: FtString,
value: Option<QualifierValue>
}
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for Qualifier {
fn nom(input: &'a str) -> IResult<&'a str, Qualifier, E> {
let parse_name = map(tuple((tag("/"), FtString::nom)), |(_, n)| n);
let parse_value = map(tuple((tag("="), QualifierValue::nom)), |(_, v)| v);
map(
tuple((parse_name, opt(parse_value))),
|(name, value)| Qualifier{ name, value }
)(input)
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum QualifierValue {
QuotedText(String),
VocabularyTerm(FtString),
ReferenceNumber(u32),
}
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for QualifierValue{
fn nom(input: &'a str) -> IResult<&'a str, QualifierValue, E> {
let parse_quoted_text =
map(
tuple((tag("\""), take_while(|c| c != '"'), tag("\""))),
|(_, v, _): (&str, &str, &str)| QualifierValue::QuotedText(v.to_string()));
let parse_vocabulary_term =
map(
FtString::nom,
QualifierValue::VocabularyTerm);
let parse_reference_number =
map(
tuple((tag("["), u32::nom, tag("]"))),
|(_, d, _)| QualifierValue::ReferenceNumber(d));
alt((
parse_quoted_text,
parse_vocabulary_term,
parse_reference_number
))(input)
}
}
//
//
// Location data model starts here
//
// Should really be in a sub-module I guess
//
//
/// A point within a sequence, representing a specific nucleotide. Counts from 1.
#[derive(Debug, PartialEq, Eq)]
pub struct Point(u32);
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for Point {
fn nom(input: &'a str) -> IResult<&'a str, Point, E> {
map(u32::nom, Point)(input)
}
}
/// A position between two bases in a sequence.
/// pub
/// For example, 122^123. The locations must be consecutive.
///
/// For example, 100^1 for a circular sequence of length 100.
#[derive(Debug, PartialEq, Eq)]
pub struct Between(u32, u32);
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for Between {
fn nom(input: &'a str) -> IResult<&'a str, Between, E> {
map(
tuple((
u32::nom,
tag("^"),
u32::nom
)),
|(from, _, to)| Between(from, to)
)(input)
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum Position {
Point(Point),
Between(Between)
}
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for Position {
fn nom(input: &'a str) -> IResult<&'a str, Position, E> {
alt((
map(Between::nom, Position::Between),
map(Point::nom, Position::Point)
))(input)
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum Local {
Point(Point),
Between(Between),
Within { from: Point, to: Point },
Span { from: Position, to: Position, before_from: bool, after_to: bool },
}
impl Local {
pub fn span(from: u32, to: u32) -> Local {
Local::Span {
from: Position::Point(Point(from)),
to: Position::Point(Point(to)),
before_from: false,
after_to: false }
}
}
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for Local {
fn nom(input: &'a str) -> IResult<&'a str, Local, E> {
let parse_within = map(
tuple((Point::nom, tag("."), Point::nom)),
|(from, _, to)| Local::Within { from, to });
let parse_span = map(
tuple((
opt(tag("<")), Position::nom, tag(".."), opt(tag(">")), Position::nom)),
|(before_from, from, _, after_to, to)| Local::Span {
from,
to,
before_from: before_from.is_some(),
after_to: after_to.is_some() }
);
alt((
map(Between::nom, Local::Between),
parse_within,
parse_span,
map(Point::nom, Local::Point), // must do this last as it's a prefix of the others
))(input)
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum Loc {
Remote { within: String, at: Local },
Local(Local)
}
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for Loc {
fn nom(input: &'a str) -> IResult<&'a str, Loc, E> {
let parse_accession = take_while1(|c| {
let b = c as u8;
is_alphanumeric(b) || b == b'.'
});
alt((
map(
tuple((parse_accession, tag(":"), Local::nom)),
|(within, _, at)| Loc::Remote { within: within.to_string(), at }
),
map(Local::nom, Loc::Local)
))(input)
}
}
#[derive(Debug, PartialEq, Eq)]
pub enum LocOp {
Loc(Loc),
Complement(Box<LocOp>),
Join(Vec<LocOp>),
Order(Vec<LocOp>)
}
impl <'a, E : ParseError<&'a str>> Nommed<&'a str, E> for LocOp {
fn nom(input: &'a str) -> IResult<&'a str, LocOp, E> {
let parse_complement =
map(
tuple((
tag("complement("),
cut(LocOp::nom),
tag(")")
)),
|(_, loc, _)| loc
);
let parse_join =
map(
tuple((
tag("join("),
cut(separated_list(tag(","), LocOp::nom)),
tag(")")
)),
|(_, locs, _)| locs
);
let parse_order =
map(
tuple((
tag("order("),
cut(separated_list(tag(","), LocOp::nom)),
tag(")")
)),
|(_, locs, _)| locs
);
alt((
map(Loc::nom, LocOp::Loc),
map(parse_complement, |loc| LocOp::Complement(Box::new(loc))),
map(parse_join, LocOp::Join),
map(parse_order, LocOp::Order)
)) | FeatureRecord | identifier_name |
|
room_list_item.go | this.SetLastMsg(fmt.Sprintf("%s: %s",
gopp.StrSuf4ui(msgo.PeerNameUi, 9, 1), msgo.LastMsgUi), msgo.Time, msgo.EventId)
this.totalCount += 1
if uictx.msgwin.item == this {
uictx.uiw.LabelMsgCount2.SetText(fmt.Sprintf("%3d", this.totalCount))
uictx.uiw.LabelMsgCount.SetText(fmt.Sprintf("%3d", this.totalCount))
}
this.unreadedCount += 1
this.ToolButton.SetText(fmt.Sprintf("%d", this.unreadedCount))
// this.floatUnreadCountLabel.SetText(fmt.Sprintf("%d", this.unreadedCount))
}
func (this *RoomListItem) UpdateMessageMimeContent(msgo *Message, msgiw *MessageItem) {
if !msgo.IsFile() {
return
}
fil := msgo.GetFileInfoLine()
gopp.NilPrint(fil, msgo.Msg)
if fil == nil {
return
}
locfname := store.GetFSC().GetFilePath(fil.Md5str)
rmturl := thscli.HttpFsUrlFor(fil.Md5str)
reloadMsgItem := func(txt string) { msgiw.Label_5.SetText(txt) }
locdir := store.GetFSC().GetDir()
if ok, _ := afero.Exists(afero.NewOsFs(), locfname); ok {
richtxt := Msg2FileText(fil, locdir)
log.Println(msgo.Msg, richtxt)
reloadMsgItem(richtxt)
} else {
richtxt := fmt.Sprintf("Loading... %s: %s", fil.Mime, humanize.Bytes(uint64(fil.Length)))
log.Println(msgo.Msg, richtxt)
reloadMsgItem(richtxt)
go func() {
time.Sleep(3 * time.Second)
ro := &grequests.RequestOptions{}
resp, err := grequests.Get(rmturl, ro)
gopp.ErrPrint(err, rmturl)
err = resp.DownloadToFile(locfname)
gopp.ErrPrint(err, rmturl)
runOnUiThread(func() { reloadMsgItem("Switching...") })
time.Sleep(3 * time.Second)
richtxt := Msg2FileText(fil, locdir)
log.Println(msgo.Msg, richtxt)
runOnUiThread(func() { reloadMsgItem(richtxt) })
}()
}
}
func (this *RoomListItem) UpdateMessageState(msgo *Message) {
for idx := len(this.msgos) - 1; idx >= 0; idx-- {
msgo_ := this.msgos[idx]
if msgo_.UserCode == msgo.UserCode {
msgo_.EventId = msgo.EventId
msgo_.Sent = msgo.Sent
break
}
}
for idx := len(this.msgitmdl) - 1; idx >= 0; idx-- {
msgitm := this.msgitmdl[idx]
if msgitm.UserCode == msgo.UserCode {
if !msgitm.Sent && msgo.Sent {
msgitm.Sent = msgo.Sent
msgitm.LabelSendState.Clear()
msgitm.LabelSendState.SetToolTip(gopp.ToStr(gopp.ToStrs(msgo.Sent, msgo.UserCode)))
}
break
}
}
}
func (this *RoomListItem) ClearAvatar(frndpk string) {
this.cticon = GetIdentIcon(frndpk)
this.ToolButton_2.SetIcon(this.cticon)
uictx.msgwin.SetIconForItem(this)
}
func (this *RoomListItem) SetAvatar(idico *qtgui.QIcon) {
this.cticon = idico
this.ToolButton_2.SetIcon(this.cticon)
uictx.msgwin.SetIconForItem(this)
}
func (this *RoomListItem) SetAvatarForId(frndpk string) {
locfname := store.GetFSC().GetFilePath(frndpk)
idico := qtgui.NewQIcon2(locfname)
this.SetAvatar(idico)
}
func (this *RoomListItem) SetAvatarForMessage(msgo *Message, frndpk string) {
fil := msgo.GetFileInfoLine()
gopp.NilPrint(fil, msgo.Msg)
if fil == nil {
return
}
locfname := store.GetFSC().GetFilePath(frndpk)
rmturl := thscli.HttpFsUrlFor(frndpk)
setFriendIcon := func(thefname string) {
icon := qtgui.NewQIcon2(thefname)
if icon != nil && !icon.IsNull() {
this.SetAvatar(icon)
} else {
log.Println("Friend icon not supported:", locfname)
}
}
if fil.Length == 0 { // clear avatar
this.ClearAvatar(frndpk)
return
}
go func() {
ro := &grequests.RequestOptions{}
resp, err := grequests.Get(rmturl, ro)
gopp.ErrPrint(err, rmturl)
err = resp.DownloadToFile(locfname)
gopp.ErrPrint(err, rmturl)
runOnUiThread(func() { setFriendIcon(locfname) })
}()
}
func (this *RoomListItem) FindMessageByUserCode(userCode int64) *Message {
for idx := len(this.msgos) - 1; idx >= 0; idx-- {
msgo_ := this.msgos[idx]
if msgo_.UserCode == userCode {
return msgo_
}
}
return nil
}
func (this *RoomListItem) FindMessageViewByEventId(eventId int64) *MessageItem {
for idx := len(this.msgos) - 1; idx >= 0; idx-- {
msgo_ := this.msgos[idx]
if msgo_.EventId == eventId {
return this.msgitmdl[idx]
}
}
return nil
}
// TODO 计算是否省略掉显示与上一条相同的用户名
func (this *RoomListItem) AddMessageHiddenCloseSameUser(prev bool) {
// prev is true, compare [0], [1]
// prev is false, compare [len-2], [len-1]
if len(this.msgos) < 2 {
return
}
var m0, m1 *Message
if prev {
m0 = this.msgos[0]
m1 = this.msgos[1]
} else {
m0 = this.msgos[len(this.msgos)-2]
m1 = this.msgos[len(this.msgos)-1]
}
if m0.PeerNameUi == m1.PeerNameUi {
// can not get Ui_MessageItemView
}
}
func (this *RoomListItem) GetName() string {
return gopp.IfElseStr(this.isgroup, this.grpInfo.GetTitle(), this.frndInfo.GetName())
}
func (this *RoomListItem) GetId() string {
if this.isgroup {
// log.Println(this.grpInfo.GetGroupId(), this.grpInfo.Title)
}
return gopp.IfElseStr(this.isgroup, this.grpInfo.GetGroupId(), this.frndInfo.GetPubkey())
}
func (this *RoomListItem) GetNum() uint32 {
return uint32(gopp.IfElseInt(this.isgroup, int(this.grpInfo.GetGnum()), int(this.frndInfo.GetFnum())))
}
func (this *RoomListItem) UpdateName(name string) {
if this.isgroup {
if this.grpInfo.Title != name {
this.grpInfo.Title = name
this.SetContactInfo(this.grpInfo)
// this.Label_2.SetText(gopp.StrSuf4ui(name, 26))
// this.Label_2.SetToolTip(name)
// this.ToolButton_2.SetToolTip(name + "." + this.GetId()[:7])
}
} else {
if this.frndInfo.Name != name {
this.frndInfo.Name = name
this.SetContactInfo(this.frndInfo)
// this.Label_2.SetText(gopp.StrSuf4ui(name, 26))
// this.Label_2.SetToolTip(name)
// this.ToolButton_2.SetToolTip(name + "." + this.GetId()[:7])
}
}
}
func (this *RoomListItem) UpdateStatusMessage(statusText string) {
if !this.isgroup {
if this.frndInfo.Stmsg != statusText {
this.frndInfo.Stmsg = statusText
this.SetContactInfo(this.frndInfo)
}
} else {
}
}
func (this *RoomListItem) UpdateReaded() {
mw := uictx.mw
curval := mw.ScrollArea_2.VerticalScrollBar().Value()
minval := mw.ScrollArea_2.VerticalScrollBar().Minimum()
maxval := mw.ScrollArea_2.VerticalScrollBar().Maximum()
log.Println(this.unreadedCount, this.pressed, curval, minval, maxval)
if this.unreadedCount > 0 && this.pressed {
if curval == maxval || maxval == -1 {
this.unreadedCount = 0
this.ToolButton.SetText("")
}
}
}
// TODO how custom setting this
func init() {
if runtime.GOOS == "android" {
secondsEastOfUTC := int((8 * time.Hour | ).Seconds())
cqzone := time.FixedZone("Chongqing", secondsEastOfUTC)
time.Local = cqzone
}
}
// 两类时间，server time, client time
func (this *RoomListItem) SetLastMsg(ms | identifier_body |
|
room_list_item.go | qtwidgets.DeleteQMenu(item.menu)
}
item.menu = nil
if item.cticon != nil {
qtgui.DeleteQIcon(item.cticon)
}
item.cticon = nil
if item.sticon != nil {
qtgui.DeleteQIcon(item.sticon)
}
item.sticon = nil
item.OnConextMenu = nil
item.subws = nil
item.msgitmdl = nil
item.msgos = nil
}
}
/////////////////
type RoomListItem struct {
*Ui_ContactItemView
OnConextMenu func(w *qtwidgets.QWidget, pos *qtcore.QPoint)
cticon *qtgui.QIcon
sticon *qtgui.QIcon
subws []qtwidgets.QWidget_ITF
menu *qtwidgets.QMenu
floatUnreadCountLabel *qtwidgets.QLabel
msgitmdl []*MessageItem
msgos []*Message
pressed bool
hovered bool
isgroup bool
frndInfo *thspbs.FriendInfo
grpInfo *thspbs.GroupInfo
unreadedCount int
totalCount int
timeline thscli.TimeLine
WaitSyncStoreTimeLineCount int
LastMsgEventId int64
}
func NewRoomListItem() *RoomListItem {
this := &RoomListItem{}
this.Ui_ContactItemView = NewUi_ContactItemView2()
this.initUis()
this.initEvents()
return this
}
func NewRoomListItem2(info *thspbs.FriendInfo) *RoomListItem {
this := &RoomListItem{}
this.Ui_ContactItemView = NewUi_ContactItemView2()
this.initUis()
this.SetContactInfo(info)
this.initEvents()
return this
}
func NewRoomListItem3(info *thspbs.GroupInfo) *RoomListItem {
this := &RoomListItem{}
this.Ui_ContactItemView = NewUi_ContactItemView2()
this.initUis()
this.SetContactInfo(info)
this.initEvents()
return this
}
func (this *RoomListItem) initUis() {
if !gopp.IsAndroid() {
this.ToolButton.SetIconSize(qtcore.NewQSize1(12, 12))
}
this.floatUnreadCountLabel = this.floatTextOverWidget(this.ToolButton)
// this.Ui_ContactItemView.ContactItemView.SetMinimumHeight(20 * 2)
}
func (this *RoomListItem) initEvents() {
labs := []*qtwidgets.QLabel{this.Label_2, this.Label_3, this.Label_4, this.LabelLastMsgTime}
for _, lab := range labs {
lab.Clear()
lab.SetAttribute(qtcore.Qt__WA_TranslucentBackground, false)
lab.SetMouseTracking(true)
this.subws = append(this.subws, lab)
}
this.ToolButton.SetText("")
this.ToolButton.SetMouseTracking(true) |
onMousePress := func(event *qtgui.QMouseEvent) {
uictx.gtreco.onMousePress(this, event)
// log.Println(event)
if event.Button() == qtcore.Qt__LeftButton {
for _, room := range uictx.ctitmdl {
if room != this {
room.SetPressState(false)
}
}
this.SetPressState(true)
}
}
onMouseRelease := func(event *qtgui.QMouseEvent) {
// log.Println(event)
uictx.gtreco.onMouseRelease(this, event)
}
onMouseMove := func(event *qtgui.QMouseEvent) {
uictx.gtreco.onMouseMove(this, event)
if true {
return
}
// log.Println(event)
if !this.hovered {
this.hovered = true
for _, room := range uictx.ctitmdl {
if room != this {
room.OnHover(false)
}
}
if !this.pressed {
this.OnHover(true)
}
}
}
_ = onMouseMove
onMouseLeave := func(event *qtcore.QEvent) {
this.OnHover(false)
}
onMouseEnter := func(event *qtcore.QEvent) {
this.OnHover(true)
}
w.InheritMousePressEvent(onMousePress)
w.InheritMouseReleaseEvent(onMouseRelease)
// w.InheritMouseMoveEvent(onMouseMove)
w.InheritLeaveEvent(onMouseLeave)
w.InheritEnterEvent(onMouseEnter)
for _, lab := range labs {
lab.InheritMousePressEvent(onMousePress)
lab.InheritMouseReleaseEvent(onMouseRelease)
// lab.InheritMouseMoveEvent(onMouseMove)
}
w.InheritContextMenuEvent(func(event *qtgui.QContextMenuEvent) {
gpos := event.GlobalPos()
log.Println(event.Type(), gpos.X(), gpos.Y())
if this.OnConextMenu != nil {
this.OnConextMenu(w, gpos)
}
})
}
func (this *RoomListItem) OnContextMenu2(gpos *qtcore.QPoint) {
w := this.ContactItemView
if this.OnConextMenu != nil {
this.OnConextMenu(w, gpos)
}
}
func (this *RoomListItem) SetContactInfo(info interface{}) {
trtxt := gopp.StrSuf4ui
switch ct := info.(type) {
case *thspbs.FriendInfo:
this.frndInfo = ct
name := gopp.IfElseStr(ct.GetName() == "", ct.GetPubkey()[:7], ct.GetName())
nametip := gopp.IfElseStr(ct.GetName() == "", ct.GetPubkey()[:17], ct.GetName())
this.Label_2.SetText(trtxt(name, 26))
this.Label_2.SetToolTip(nametip)
this.Label_4.SetText(trtxt(ct.GetStmsg(), 36))
this.Label_4.SetToolTip(ct.GetStmsg())
SetQLabelElideText(this.Label_2, name, "")
SetQLabelElideText(this.Label_4, ct.Stmsg, "")
avataricon := store.GetFSC().GetFilePath(ct.GetPubkey())
if gopp.FileExist(avataricon) {
this.cticon = qtgui.NewQIcon2(avataricon)
this.ToolButton_2.SetIcon(this.cticon)
} else {
this.cticon = GetIdentIcon(ct.Pubkey)
this.ToolButton_2.SetIcon(this.cticon)
}
if ct.GetConnStatus() == 0 {
this.sticon = qtgui.NewQIcon2(":/icons/offline_30.png")
this.ToolButton.SetIcon(this.sticon)
}
if ct.Fnum == thscom.FileHelperFnum {
this.cticon = qtgui.NewQIcon2(":/icons/filehelper.png")
this.ToolButton_2.SetIcon(this.cticon)
}
case *thspbs.GroupInfo:
this.grpInfo = ct
this.isgroup = true
this.Label_4.SetHidden(true)
this.Label_2.SetText(trtxt(ct.GetTitle(), 26))
this.Label_2.SetToolTip(ct.GetTitle())
suff := fmt.Sprintf(" %s%d", NameNumSep(), len(ct.Members))
SetQLabelElideText(this.Label_2, ct.Title, suff)
// this maybe call multiple times, so -20 -20 then, the item is 0 height.
// this.QWidget_PTR().SetFixedHeight(this.QWidget_PTR().Height() - 20)
if false {
this.cticon = qtgui.NewQIcon2(":/icons/groupgray.png")
} else {
this.cticon = GetInitAvatar(gopp.IfElseStr(ct.Title == "", ct.GroupId, ct.Title))
}
this.ToolButton_2.SetIcon(this.cticon)
this.setConnStatus(int32(thscli.CONN_STATUS_UDP))
default:
log.Fatalln("wtf")
}
this.ToolButton_2.SetToolTip(this.GetName() + "." + gopp.SubStr(this.GetId(), 7))
}
func (this *RoomListItem) AddMessage(msgo *Message, prev bool) {
// check in list
for _, msgoe := range this.msgos {
if msgoe.EventId == msgo.EventId && msgo.EventId != 0 {
log.Printf("msg already in list: %d, %+v\n", msgo.EventId, msgo)
return
}
}
if prev {
this.msgos = append([]*Message{msgo}, this.msgos...)
msgiw := NewMessageItem()
msgiw.Sent = msgo.Sent
msgiw.UserCode = msgo.UserCode
this.msgitmdl = append([]*MessageItem{msgiw}, this.msgitmdl...)
this.AddMessageImpl(msgo, msgiw, prev)
this.UpdateMessageMimeContent(msgo, msgiw)
} else {
this.msgos = append(this.msgos, msgo)
msgiw := NewMessageItem()
msgiw.Sent = msgo.Sent
msgiw.UserCode = msgo.UserCode
this.msgitmdl = append(this.msgitmdl, msgiw)
this.AddMessageImpl(msgo, msgiw, prev)
this.UpdateMessageMimeContent(msgo, msgiw)
// test and update storage's sync info
if msgo.EventId >= this.timeline | this.ToolButton_2.SetMouseTracking(true)
w := this.ContactItemView
w.SetMouseTracking(true) | random_line_split |
room_list_item.go | ui
switch ct := info.(type) {
case *thspbs.FriendInfo:
this.frndInfo = ct
name := gopp.IfElseStr(ct.GetName() == "", ct.GetPubkey()[:7], ct.GetName())
nametip := gopp.IfElseStr(ct.GetName() == "", ct.GetPubkey()[:17], ct.GetName())
this.Label_2.SetText(trtxt(name, 26))
this.Label_2.SetToolTip(nametip)
this.Label_4.SetText(trtxt(ct.GetStmsg(), 36))
this.Label_4.SetToolTip(ct.GetStmsg())
SetQLabelElideText(this.Label_2, name, "")
SetQLabelElideText(this.Label_4, ct.Stmsg, "")
avataricon := store.GetFSC().GetFilePath(ct.GetPubkey())
if gopp.FileExist(avataricon) {
this.cticon = qtgui.NewQIcon2(avataricon)
this.ToolButton_2.SetIcon(this.cticon)
} else {
this.cticon = GetIdentIcon(ct.Pubkey)
this.ToolButton_2.SetIcon(this.cticon)
}
if ct.GetConnStatus() == 0 {
this.sticon = qtgui.NewQIcon2(":/icons/offline_30.png")
this.ToolButton.SetIcon(this.sticon)
}
if ct.Fnum == thscom.FileHelperFnum {
this.cticon = qtgui.NewQIcon2(":/icons/filehelper.png")
this.ToolButton_2.SetIcon(this.cticon)
}
case *thspbs.GroupInfo:
this.grpInfo = ct
this.isgroup = true
this.Label_4.SetHidden(true)
this.Label_2.SetText(trtxt(ct.GetTitle(), 26))
this.Label_2.SetToolTip(ct.GetTitle())
suff := fmt.Sprintf(" %s%d", NameNumSep(), len(ct.Members))
SetQLabelElideText(this.Label_2, ct.Title, suff)
// this maybe call multiple times, so -20 -20 then, the item is 0 height.
// this.QWidget_PTR().SetFixedHeight(this.QWidget_PTR().Height() - 20)
if false {
this.cticon = qtgui.NewQIcon2(":/icons/groupgray.png")
} else {
this.cticon = GetInitAvatar(gopp.IfElseStr(ct.Title == "", ct.GroupId, ct.Title))
}
this.ToolButton_2.SetIcon(this.cticon)
this.setConnStatus(int32(thscli.CONN_STATUS_UDP))
default:
log.Fatalln("wtf")
}
this.ToolButton_2.SetToolTip(this.GetName() + "." + gopp.SubStr(this.GetId(), 7))
}
func (this *RoomListItem) AddMessage(msgo *Message, prev bool) {
// check in list
for _, msgoe := range this.msgos {
if msgoe.EventId == msgo.EventId && msgo.EventId != 0 {
log.Printf("msg already in list: %d, %+v\n", msgo.EventId, msgo)
return
}
}
if prev {
this.msgos = append([]*Message{msgo}, this.msgos...)
msgiw := NewMessageItem()
msgiw.Sent = msgo.Sent
msgiw.UserCode = msgo.UserCode
this.msgitmdl = append([]*MessageItem{msgiw}, this.msgitmdl...)
this.AddMessageImpl(msgo, msgiw, prev)
this.UpdateMessageMimeContent(msgo, msgiw)
} else {
this.msgos = append(this.msgos, msgo)
msgiw := NewMessageItem()
msgiw.Sent = msgo.Sent
msgiw.UserCode = msgo.UserCode
this.msgitmdl = append(this.msgitmdl, msgiw)
this.AddMessageImpl(msgo, msgiw, prev)
this.UpdateMessageMimeContent(msgo, msgiw)
// test and update storage's sync info
if msgo.EventId >= this.timeline.NextBatch {
this.timeline.NextBatch = msgo.EventId + 1
this.WaitSyncStoreTimeLineCount += 1
if this.WaitSyncStoreTimeLineCount >= 1 /*common.PullPageSize*/ {
this.WaitSyncStoreTimeLineCount = 0
go hisfet.RefreshPrevStorageTimeLine(&this.timeline, this.GetId(), this.GetName())
}
}
}
}
func (this *RoomListItem) AddMessageImpl(msgo *Message, msgiw *MessageItem, prev bool) {
showMeIcon := msgo.Me // 是否显示自己的icon。根据是否是自己的消息
showName := true
showPeerIcon := !showMeIcon
msgiw.Label_5.SetText(msgo.MsgUi)
msgiw.LabelUserName4MessageItem.SetText(fmt.Sprintf("%s", msgo.PeerNameUi))
msgiw.LabelMsgTime.SetText(Time2Today(msgo.Time))
msgiw.LabelMsgTime.SetToolTip(gopp.TimeToFmt1(msgo.Time))
msgiw.ToolButton_3.SetVisible(showMeIcon)
msgiw.ToolButton_2.SetVisible(showPeerIcon)
msgiw.LabelUserName4MessageItem.SetVisible(showName)
msgiw.ToolButton.SetVisible(false)
if msgo.Me && !msgo.Sent {
msgiw.LabelSendState.SetPixmap(qtgui.NewQPixmap3p(":/icons/[email protected]"))
}
if msgo.Me {
msgiw.LabelSendState.SetToolTip(gopp.ToStr(gopp.ToStrs(msgo.Sent, msgo.UserCode)))
} else /*!msgo.Me*/ {
// msgiw.LabelSendState.SetVisible(false)
}
if uictx.msgwin.item == this {
vlo3 := uictx.uiw.VerticalLayout_3
if prev {
vlo3.InsertWidgetp(0, msgiw.QWidget_PTR())
} else {
vlo3.Layout().AddWidget(msgiw.QWidget_PTR())
}
}
this.SetLastMsg(fmt.Sprintf("%s: %s",
gopp.StrSuf4ui(msgo.PeerNameUi, 9, 1), msgo.LastMsgUi), msgo.Time, msgo.EventId)
this.totalCount += 1
if uictx.msgwin.item == this {
uictx.uiw.LabelMsgCount2.SetText(fmt.Sprintf("%3d", this.totalCount))
uictx.uiw.LabelMsgCount.SetText(fmt.Sprintf("%3d", this.totalCount))
}
this.unreadedCount += 1
this.ToolButton.SetText(fmt.Sprintf("%d", this.unreadedCount))
// this.floatUnreadCountLabel.SetText(fmt.Sprintf("%d", this.unreadedCount))
}
func (this *RoomListItem) UpdateMessageMimeContent(msgo *Message, msgiw *MessageItem) {
if !msgo.IsFile() {
return
}
fil := msgo.GetFileInfoLine()
gopp.NilPrint(fil, msgo.Msg)
if fil == nil {
return
}
locfname := store.GetFSC().GetFilePath(fil.Md5str)
rmturl := thscli.HttpFsUrlFor(fil.Md5str)
reloadMsgItem := func(txt string) { msgiw.Label_5.SetText(txt) }
locdir := store.GetFSC().GetDir()
if ok, _ := afero.Exists(afero.NewOsFs(), locfname); ok {
richtxt := Msg2FileText(fil, locdir)
log.Println(msgo.Msg, richtxt)
reloadMsgItem(richtxt)
} else {
richtxt := fmt.Sprintf("Loading... %s: %s", fil.Mime, humanize.Bytes(uint64(fil.Length)))
log.Println(msgo.Msg, richtxt)
reloadMsgItem(richtxt)
go func() {
time.Sleep(3 * time.Second)
ro := &grequests.RequestOptions{}
resp, err := grequests.Get(rmturl, ro)
gopp.ErrPrint(err, rmturl)
err = resp.DownloadToFile(locfname)
gopp.ErrPrint(err, rmturl)
runOnUiThread(func() { reloadMsgItem("Switching...") })
time.Sleep(3 * time.Second)
richtxt := Msg2FileText(fil, locdir)
log.Println(msgo.Msg, richtxt)
runOnUiThread(func() { reloadMsgItem(richtxt) })
}()
}
}
func (this *RoomListItem) UpdateMessageState(msgo *Message) {
for idx := len(this.msgos) - 1; idx >= 0; idx-- {
msgo_ := this.msgos[idx]
if msgo_.UserCode == msgo.UserCode {
msgo_.EventId = msgo.EventId
msgo_.Sent = msgo.Sent
break
}
}
for idx := len(this.msgitmdl) - 1; idx >= 0; idx-- {
msgitm := this.msgitmdl[idx]
if msgitm.UserCode == msgo.UserCode {
if !msgitm.Sent && msgo.Sent {
msgitm.Sent = msgo.Sent
msgitm.LabelSendState.Clear()
msgitm.LabelSendState.SetToolTip(gopp.ToStr(gopp.ToStrs(msgo.Sent, msgo.UserCode)))
}
break
}
}
}
func (this *RoomListItem) ClearAvatar(frndpk string) {
this.c | ticon = Get | identifier_name |
|
room_list_item.go | TimeLine(&this.timeline, this.GetId(), this.GetName())
}
}
}
}
func (this *RoomListItem) AddMessageImpl(msgo *Message, msgiw *MessageItem, prev bool) {
showMeIcon := msgo.Me // 是否显示自己的icon。根据是否是自己的消息
showName := true
showPeerIcon := !showMeIcon
msgiw.Label_5.SetText(msgo.MsgUi)
msgiw.LabelUserName4MessageItem.SetText(fmt.Sprintf("%s", msgo.PeerNameUi))
msgiw.LabelMsgTime.SetText(Time2Today(msgo.Time))
msgiw.LabelMsgTime.SetToolTip(gopp.TimeToFmt1(msgo.Time))
msgiw.ToolButton_3.SetVisible(showMeIcon)
msgiw.ToolButton_2.SetVisible(showPeerIcon)
msgiw.LabelUserName4MessageItem.SetVisible(showName)
msgiw.ToolButton.SetVisible(false)
if msgo.Me && !msgo.Sent {
msgiw.LabelSendState.SetPixmap(qtgui.NewQPixmap3p(":/icons/[email protected]"))
}
if msgo.Me {
msgiw.LabelSendState.SetToolTip(gopp.ToStr(gopp.ToStrs(msgo.Sent, msgo.UserCode)))
} else /*!msgo.Me*/ {
// msgiw.LabelSendState.SetVisible(false)
}
if uictx.msgwin.item == this {
vlo3 := uictx.uiw.VerticalLayout_3
if prev {
vlo3.InsertWidgetp(0, msgiw.QWidget_PTR())
} else {
vlo3.Layout().AddWidget(msgiw.QWidget_PTR())
}
}
this.SetLastMsg(fmt.Sprintf("%s: %s",
gopp.StrSuf4ui(msgo.PeerNameUi, 9, 1), msgo.LastMsgUi), msgo.Time, msgo.EventId)
this.totalCount += 1
if uictx.msgwin.item == this {
uictx.uiw.LabelMsgCount2.SetText(fmt.Sprintf("%3d", this.totalCount))
uictx.uiw.LabelMsgCount.SetText(fmt.Sprintf("%3d", this.totalCount))
}
this.unreadedCount += 1
this.ToolButton.SetText(fmt.Sprintf("%d", this.unreadedCount))
// this.floatUnreadCountLabel.SetText(fmt.Sprintf("%d", this.unreadedCount))
}
func (this *RoomListItem) UpdateMessageMimeContent(msgo *Message, msgiw *MessageItem) {
if !msgo.IsFile() {
return
}
fil := msgo.GetFileInfoLine()
gopp.NilPrint(fil, msgo.Msg)
if fil == nil {
return
}
locfname := store.GetFSC().GetFilePath(fil.Md5str)
rmturl := thscli.HttpFsUrlFor(fil.Md5str)
reloadMsgItem := func(txt string) { msgiw.Label_5.SetText(txt) }
locdir := store.GetFSC().GetDir()
if ok, _ := afero.Exists(afero.NewOsFs(), locfname); ok {
richtxt := Msg2FileText(fil, locdir)
log.Println(msgo.Msg, richtxt)
reloadMsgItem(richtxt)
} else {
richtxt := fmt.Sprintf("Loading... %s: %s", fil.Mime, humanize.Bytes(uint64(fil.Length)))
log.Println(msgo.Msg, richtxt)
reloadMsgItem(richtxt)
go func() {
time.Sleep(3 * time.Second)
ro := &grequests.RequestOptions{}
resp, err := grequests.Get(rmturl, ro)
gopp.ErrPrint(err, rmturl)
err = resp.DownloadToFile(locfname)
gopp.ErrPrint(err, rmturl)
runOnUiThread(func() { reloadMsgItem("Switching...") })
time.Sleep(3 * time.Second)
richtxt := Msg2FileText(fil, locdir)
log.Println(msgo.Msg, richtxt)
runOnUiThread(func() { reloadMsgItem(richtxt) })
}()
}
}
func (this *RoomListItem) UpdateMessageState(msgo *Message) {
for idx := len(this.msgos) - 1; idx >= 0; idx-- {
msgo_ := this.msgos[idx]
if msgo_.UserCode == msgo.UserCode {
msgo_.EventId = msgo.EventId
msgo_.Sent = msgo.Sent
break
}
}
for idx := len(this.msgitmdl) - 1; idx >= 0; idx-- {
msgitm := this.msgitmdl[idx]
if msgitm.UserCode == msgo.UserCode {
if !msgitm.Sent && msgo.Sent {
msgitm.Sent = msgo.Sent
msgitm.LabelSendState.Clear()
msgitm.LabelSendState.SetToolTip(gopp.ToStr(gopp.ToStrs(msgo.Sent, msgo.UserCode)))
}
break
}
}
}
func (this *RoomListItem) ClearAvatar(frndpk string) {
this.cticon = GetIdentIcon(frndpk)
this.ToolButton_2.SetIcon(this.cticon)
uictx.msgwin.SetIconForItem(this)
}
func (this *RoomListItem) SetAvatar(idico *qtgui.QIcon) {
this.cticon = idico
this.ToolButton_2.SetIcon(this.cticon)
uictx.msgwin.SetIconForItem(this)
}
func (this *RoomListItem) SetAvatarForId(frndpk string) {
locfname := store.GetFSC().GetFilePath(frndpk)
idico := qtgui.NewQIcon2(locfname)
this.SetAvatar(idico)
}
func (this *RoomListItem) SetAvatarForMessage(msgo *Message, frndpk string) {
fil := msgo.GetFileInfoLine()
gopp.NilPrint(fil, msgo.Msg)
if fil == nil {
return
}
locfname := store.GetFSC().GetFilePath(frndpk)
rmturl := thscli.HttpFsUrlFor(frndpk)
setFriendIcon := func(thefname string) {
icon := qtgui.NewQIcon2(thefname)
if icon != nil && !icon.IsNull() {
this.SetAvatar(icon)
} else {
log.Println("Friend icon not supported:", locfname)
}
}
if fil.Length == 0 { // clear avatar
this.ClearAvatar(frndpk)
return
}
go func() {
ro := &grequests.RequestOptions{}
resp, err := grequests.Get(rmturl, ro)
gopp.ErrPrint(err, rmturl)
err = resp.DownloadToFile(locfname)
gopp.ErrPrint(err, rmturl)
runOnUiThread(func() { setFriendIcon(locfname) })
}()
}
func (this *RoomListItem) FindMessageByUserCode(userCode int64) *Message {
for idx := len(this.msgos) - 1; idx >= 0; idx-- {
msgo_ := this.msgos[idx]
if msgo_.UserCode == userCode {
return msgo_
}
}
return nil
}
func (this *RoomListItem) FindMessageViewByEventId(eventId int64) *MessageItem {
for idx := len(this.msgos) - 1; idx >= 0; idx-- {
msgo_ := this.msgos[idx]
if msgo_.EventId == eventId {
return this.msgitmdl[idx]
}
}
return nil
}
// TODO 计算是否省略掉显示与上一条相同的用户名
func (this *RoomListItem) AddMessageHiddenCloseSameUser(prev bool) {
// prev is true, compare [0], [1]
// prev is false, compare [len-2], [len-1]
if len(this.msgos) < 2 {
return
}
var m0, m1 *Message
if prev {
m0 = this.msgos[0]
m1 = this.msgos[1]
} else {
m0 = this.msgos[len(this.msgos)-2]
m1 = this.msgos[len(this.msgos)-1]
}
if m0.PeerNameUi == m1.PeerNameUi {
// can not get Ui_MessageItemView
}
}
func (this *RoomListItem) GetName() string {
return gopp.IfElseStr(this.isgroup, this.grpInfo.GetTitle(), this.frndInfo.GetName())
}
func (this *RoomListItem) GetId() string {
if this.isgroup {
// log.Println(this.grpInfo.GetGroupId(), this.grpInfo.Title)
}
return gopp.IfElseStr(this.isgroup, this.grpInfo.GetGroupId(), this.frndInfo.GetPubkey())
}
func (this *RoomListItem) GetNum() uint32 {
return uint32(gopp.IfElseInt(this.isgroup, int(this.grpInfo.GetGnum()), int(this.frndInfo.GetFnum())))
}
func (this *RoomListItem) UpdateName(name string) {
if this.isgroup {
if this.grpInfo.Title != name {
this.grpInfo.Title = name
this.SetContactInfo(this.grpInfo)
// | this.Label_2.SetText(gopp.StrSuf4ui(name, 26))
// this.Label_2.SetToolTip(name)
// this.ToolButton_2.SetToolTip(name + "." + this.GetId()[:7])
}
} else {
if this.frndInfo.Name != name {
this.frndInfo.Name = name
| conditional_block |
|
bibtexParser.ts | (this);
}
}
type Node =
| RootNode
| TextNode
| BlockNode
| EntryNode
| CommentNode
| PreambleNode
| StringNode
| FieldNode
| ConcatNode
| LiteralNode
| BracedNode
| QuotedNode;
export function generateAST(input: string): RootNode {
const rootNode = new RootNode();
let node: Node = rootNode;
let line = 1;
let column = 0;
for (let i = 0; i < input.length; i++) {
const char = input[i]!;
const prev = input[i - 1]!;
if (char === '\n') {
line++;
column = 0;
}
column++;
switch (node.type) {
case 'root': {
node = char === '@' ? new BlockNode(node) : new TextNode(node, char);
break;
}
case 'text': {
// Whitespace or closing curly brace should precede an entry. This might
// not be correct but allows parsing of "valid" bibtex files in the
// wild.
if (char === '@' && /[\s\r\n}]/.test(prev)) {
node = new BlockNode(node.parent);
} else {
node.text += char;
}
break;
}
case 'block': {
if (char === '@') {
// everything prior to this was a comment
const prevNode =
node.parent.children[node.parent.children.length - 2];
if (prevNode?.type === 'text') {
prevNode.text += '@' + node.command;
} else {
// insert text node 1 from the end
node.parent.children.pop();
new TextNode(node.parent, '@' + node.command);
node.parent.children.push(node);
}
node.command = '';
} else if (char === '{' || char === '(') {
const commandTrimmed = node.command.trim();
if (commandTrimmed === '' || /\s/.test(commandTrimmed)) {
// A block without a command is invalid. It's sometimes used in comments though, e.g. @(#)
// replace the block node
node.parent.children.pop();
node = new TextNode(node.parent, '@' + node.command + char);
} else {
node.command = commandTrimmed;
const command: string = node.command.toLowerCase();
const [braces, parens] = char === '{' ? [1, 0] : [0, 1];
const raw = '@' + command + char;
switch (command) {
case 'string':
node = new StringNode(node, raw, braces, parens);
break;
case 'preamble':
node = new PreambleNode(node, raw, braces, parens);
break;
case 'comment':
node = new CommentNode(node, raw, braces, parens);
break;
default:
node = new EntryNode(node, char);
break;
}
}
} else if (char.match(/[=#,})[\]]/)) {
// replace the block node
node.parent.children.pop();
node = new TextNode(node.parent, '@' + node.command + char);
} else {
node.command += char;
}
break;
}
case 'comment':
case 'string':
case 'preamble':
if (char === '{') {
node.braces++;
} else if (char === '}') {
node.braces--;
} else if (char === '(') {
node.parens++;
} else if (char === ')') {
node.parens--;
}
node.raw += char;
if (node.braces === 0 && node.parens === 0) {
node = node.parent.parent; // root
}
break;
case 'entry': {
if (isWhitespace(char)) {
if (!node.key) {
// Before key, ignore
} else {
// Ensure subsequent characters are not appended to the key
node.keyEnded = true;
}
} else if (char === ',') {
node = new FieldNode(node);
} else if (
(node.wrapType === '{' && char === '}') ||
(node.wrapType === '(' && char === ')')
) {
node = node.parent.parent; // root
} else if (char === '=' && node.key && isValidFieldName(node.key)) {
// Entry has no key, this is a field name
const field: FieldNode = new FieldNode(node, node.key);
node.fields.push(field);
node.key = undefined;
node = field.value;
} else if (node.keyEnded) {
throw new BibTeXSyntaxError(
input,
node,
i,
line,
column,
`The entry key cannot contain whitespace`
);
} else if (!isValidKeyCharacter(char)) {
throw new BibTeXSyntaxError(
input,
node,
i,
line,
column,
`The entry key cannot contain the character (${char})`
);
} else {
node.key = (node.key ?? '') + char;
}
break;
}
case 'field': {
if (char === '}' || char === ')') {
node.name = node.name.trim();
node = node.parent.parent.parent; // root
} else if (char === '=') {
node.name = node.name.trim();
node = node.value;
} else if (char === ',') {
node.name = node.name.trim();
node = new FieldNode(node.parent);
} else if (!isValidFieldName(char)) {
throw new BibTeXSyntaxError(input, node, i, line, column);
} else if (!node.name) {
if (!isWhitespace(char)) {
node.parent.fields.push(node);
node.name = char;
} else {
// noop
}
} else {
node.name += char;
}
break;
}
case 'concat': {
if (isWhitespace(char)) {
break; // noop
} else if (node.canConsumeValue) {
if (/[#=,}()[\]]/.test(char)) {
throw new BibTeXSyntaxError(input, node, i, line, column);
} else {
node.canConsumeValue = false;
if (char === '{') {
node = new BracedNode(node);
} else if (char === '"') {
node = new QuotedNode(node);
} else {
node = new LiteralNode(node, char);
}
}
} else {
if (char === ',') {
node = new FieldNode(node.parent.parent);
} else if (char === '}' || char === ')') {
node = node.parent.parent.parent.parent; // root
} else if (char === '#') {
node.canConsumeValue = true;
} else {
throw new BibTeXSyntaxError(input, node, i, line, column);
}
}
break;
}
case 'literal':
if (isWhitespace(char)) {
// end of literal
node = node.parent;
} else if (char === ',') {
node = new FieldNode(node.parent.parent.parent);
} else if (char === '}') {
node = node.parent.parent.parent.parent.parent; // root
} else if (char === '#') {
node = node.parent;
node.canConsumeValue = true;
} else {
node.value += char;
}
break;
// Values may be enclosed in curly braces. Curly braces may be used within
// the value but they must be balanced.
case 'braced':
if (char === '}' && node.depth === 0) {
node = node.parent; // values
break;
} else if (char === '{') {
node.depth++;
} else if (char === '}') {
node.depth--;
}
node.value += char;
break;
// Values may be enclosed in double quotes. Curly braces may be used
// within quoted values but they must be balanced.
//
// To escape a double quote, surround it with braces `{"}`.
// https://web.archive.org/web/20210422110817/https://maverick.inria.fr/~Xavier.Decoret/resources/xdkbibtex/bibtex_summary.html
case 'quoted':
if (char === '"' && node.depth === 0) {
node = node.parent; // values
break;
} else if (char === '{') {
node.depth++;
} else if (char === '}') {
node.depth--;
if (node.depth < 0) {
throw new BibTeXSyntaxError(input, node, i, line, column);
}
}
node.value += char;
break;
}
}
return rootNode;
}
function | isWhitespace | identifier_name |
|
bibtexParser.ts | string,
public braces: number,
public parens: number
) {
parent.block = this;
}
}
export class EntryNode {
type = 'entry' as const;
key?: string;
keyEnded?: boolean;
fields: FieldNode[];
constructor(public parent: BlockNode, public wrapType: '{' | '(') {
parent.block = this;
this.fields = [];
}
}
export class FieldNode {
type = 'field' as const;
/** Each value is concatenated */
value: ConcatNode;
constructor(public parent: EntryNode, public name: string = '') {
this.value = new ConcatNode(this);
}
}
class ConcatNode {
type = 'concat' as const;
concat: (LiteralNode | BracedNode | QuotedNode)[];
canConsumeValue = true;
constructor(public parent: FieldNode) {
this.concat = [];
}
}
class LiteralNode {
type = 'literal' as const;
constructor(public parent: ConcatNode, public value: string) {
parent.concat.push(this);
}
}
class BracedNode {
type = 'braced' as const;
value = '';
/** Used to count opening and closing braces */
depth = 0;
constructor(public parent: ConcatNode) {
parent.concat.push(this);
}
}
class QuotedNode {
type = 'quoted' as const;
value = '';
/** Used to count opening and closing braces */
depth = 0;
constructor(public parent: ConcatNode) {
parent.concat.push(this);
}
}
type Node =
| RootNode
| TextNode
| BlockNode
| EntryNode
| CommentNode
| PreambleNode
| StringNode
| FieldNode
| ConcatNode
| LiteralNode
| BracedNode
| QuotedNode;
export function generateAST(input: string): RootNode {
const rootNode = new RootNode();
let node: Node = rootNode;
let line = 1;
let column = 0;
for (let i = 0; i < input.length; i++) {
const char = input[i]!;
const prev = input[i - 1]!;
if (char === '\n') {
line++;
column = 0;
}
column++;
switch (node.type) {
case 'root': {
node = char === '@' ? new BlockNode(node) : new TextNode(node, char);
break;
}
case 'text': {
// Whitespace or closing curly brace should precede an entry. This might
// not be correct but allows parsing of "valid" bibtex files in the
// wild.
if (char === '@' && /[\s\r\n}]/.test(prev)) {
node = new BlockNode(node.parent);
} else {
node.text += char;
}
break;
}
case 'block': {
if (char === '@') {
// everything prior to this was a comment
const prevNode =
node.parent.children[node.parent.children.length - 2];
if (prevNode?.type === 'text') {
prevNode.text += '@' + node.command;
} else {
// insert text node 1 from the end
node.parent.children.pop(); | node.parent.children.push(node);
}
node.command = '';
} else if (char === '{' || char === '(') {
const commandTrimmed = node.command.trim();
if (commandTrimmed === '' || /\s/.test(commandTrimmed)) {
// A block without a command is invalid. It's sometimes used in comments though, e.g. @(#)
// replace the block node
node.parent.children.pop();
node = new TextNode(node.parent, '@' + node.command + char);
} else {
node.command = commandTrimmed;
const command: string = node.command.toLowerCase();
const [braces, parens] = char === '{' ? [1, 0] : [0, 1];
const raw = '@' + command + char;
switch (command) {
case 'string':
node = new StringNode(node, raw, braces, parens);
break;
case 'preamble':
node = new PreambleNode(node, raw, braces, parens);
break;
case 'comment':
node = new CommentNode(node, raw, braces, parens);
break;
default:
node = new EntryNode(node, char);
break;
}
}
} else if (char.match(/[=#,})[\]]/)) {
// replace the block node
node.parent.children.pop();
node = new TextNode(node.parent, '@' + node.command + char);
} else {
node.command += char;
}
break;
}
case 'comment':
case 'string':
case 'preamble':
if (char === '{') {
node.braces++;
} else if (char === '}') {
node.braces--;
} else if (char === '(') {
node.parens++;
} else if (char === ')') {
node.parens--;
}
node.raw += char;
if (node.braces === 0 && node.parens === 0) {
node = node.parent.parent; // root
}
break;
case 'entry': {
if (isWhitespace(char)) {
if (!node.key) {
// Before key, ignore
} else {
// Ensure subsequent characters are not appended to the key
node.keyEnded = true;
}
} else if (char === ',') {
node = new FieldNode(node);
} else if (
(node.wrapType === '{' && char === '}') ||
(node.wrapType === '(' && char === ')')
) {
node = node.parent.parent; // root
} else if (char === '=' && node.key && isValidFieldName(node.key)) {
// Entry has no key, this is a field name
const field: FieldNode = new FieldNode(node, node.key);
node.fields.push(field);
node.key = undefined;
node = field.value;
} else if (node.keyEnded) {
throw new BibTeXSyntaxError(
input,
node,
i,
line,
column,
`The entry key cannot contain whitespace`
);
} else if (!isValidKeyCharacter(char)) {
throw new BibTeXSyntaxError(
input,
node,
i,
line,
column,
`The entry key cannot contain the character (${char})`
);
} else {
node.key = (node.key ?? '') + char;
}
break;
}
case 'field': {
if (char === '}' || char === ')') {
node.name = node.name.trim();
node = node.parent.parent.parent; // root
} else if (char === '=') {
node.name = node.name.trim();
node = node.value;
} else if (char === ',') {
node.name = node.name.trim();
node = new FieldNode(node.parent);
} else if (!isValidFieldName(char)) {
throw new BibTeXSyntaxError(input, node, i, line, column);
} else if (!node.name) {
if (!isWhitespace(char)) {
node.parent.fields.push(node);
node.name = char;
} else {
// noop
}
} else {
node.name += char;
}
break;
}
case 'concat': {
if (isWhitespace(char)) {
break; // noop
} else if (node.canConsumeValue) {
if (/[#=,}()[\]]/.test(char)) {
throw new BibTeXSyntaxError(input, node, i, line, column);
} else {
node.canConsumeValue = false;
if (char === '{') {
node = new BracedNode(node);
} else if (char === '"') {
node = new QuotedNode(node);
} else {
node = new LiteralNode(node, char);
}
}
} else {
if (char === ',') {
node = new FieldNode(node.parent.parent);
} else if (char === '}' || char === ')') {
node = node.parent.parent.parent.parent; // root
} else if (char === '#') {
node.canConsumeValue = true;
} else {
throw new BibTeXSyntaxError(input, node, i, line, column);
}
}
break;
}
case 'literal':
if (isWhitespace(char)) {
// end of literal
node = node.parent;
} else if (char === ',') {
node = new FieldNode(node.parent.parent.parent);
} else if (char === '}') {
node = node.parent.parent.parent.parent.parent; // root
} else if (char === '#') {
node = node.parent;
node.canConsumeValue = true;
} else {
node.value += char;
}
break;
// Values may be | new TextNode(node.parent, '@' + node.command); | random_line_split |
bibtexParser.ts | RootNode();
let node: Node = rootNode;
let line = 1;
let column = 0;
for (let i = 0; i < input.length; i++) {
const char = input[i]!;
const prev = input[i - 1]!;
if (char === '\n') {
line++;
column = 0;
}
column++;
switch (node.type) {
case 'root': {
node = char === '@' ? new BlockNode(node) : new TextNode(node, char);
break;
}
case 'text': {
// Whitespace or closing curly brace should precede an entry. This might
// not be correct but allows parsing of "valid" bibtex files in the
// wild.
if (char === '@' && /[\s\r\n}]/.test(prev)) {
node = new BlockNode(node.parent);
} else {
node.text += char;
}
break;
}
case 'block': {
if (char === '@') {
// everything prior to this was a comment
const prevNode =
node.parent.children[node.parent.children.length - 2];
if (prevNode?.type === 'text') {
prevNode.text += '@' + node.command;
} else {
// insert text node 1 from the end
node.parent.children.pop();
new TextNode(node.parent, '@' + node.command);
node.parent.children.push(node);
}
node.command = '';
} else if (char === '{' || char === '(') {
const commandTrimmed = node.command.trim();
if (commandTrimmed === '' || /\s/.test(commandTrimmed)) {
// A block without a command is invalid. It's sometimes used in comments though, e.g. @(#)
// replace the block node
node.parent.children.pop();
node = new TextNode(node.parent, '@' + node.command + char);
} else {
node.command = commandTrimmed;
const command: string = node.command.toLowerCase();
const [braces, parens] = char === '{' ? [1, 0] : [0, 1];
const raw = '@' + command + char;
switch (command) {
case 'string':
node = new StringNode(node, raw, braces, parens);
break;
case 'preamble':
node = new PreambleNode(node, raw, braces, parens);
break;
case 'comment':
node = new CommentNode(node, raw, braces, parens);
break;
default:
node = new EntryNode(node, char);
break;
}
}
} else if (char.match(/[=#,})[\]]/)) {
// replace the block node
node.parent.children.pop();
node = new TextNode(node.parent, '@' + node.command + char);
} else {
node.command += char;
}
break;
}
case 'comment':
case 'string':
case 'preamble':
if (char === '{') {
node.braces++;
} else if (char === '}') {
node.braces--;
} else if (char === '(') {
node.parens++;
} else if (char === ')') {
node.parens--;
}
node.raw += char;
if (node.braces === 0 && node.parens === 0) {
node = node.parent.parent; // root
}
break;
case 'entry': {
if (isWhitespace(char)) {
if (!node.key) {
// Before key, ignore
} else {
// Ensure subsequent characters are not appended to the key
node.keyEnded = true;
}
} else if (char === ',') {
node = new FieldNode(node);
} else if (
(node.wrapType === '{' && char === '}') ||
(node.wrapType === '(' && char === ')')
) {
node = node.parent.parent; // root
} else if (char === '=' && node.key && isValidFieldName(node.key)) {
// Entry has no key, this is a field name
const field: FieldNode = new FieldNode(node, node.key);
node.fields.push(field);
node.key = undefined;
node = field.value;
} else if (node.keyEnded) {
throw new BibTeXSyntaxError(
input,
node,
i,
line,
column,
`The entry key cannot contain whitespace`
);
} else if (!isValidKeyCharacter(char)) {
throw new BibTeXSyntaxError(
input,
node,
i,
line,
column,
`The entry key cannot contain the character (${char})`
);
} else {
node.key = (node.key ?? '') + char;
}
break;
}
case 'field': {
if (char === '}' || char === ')') {
node.name = node.name.trim();
node = node.parent.parent.parent; // root
} else if (char === '=') {
node.name = node.name.trim();
node = node.value;
} else if (char === ',') {
node.name = node.name.trim();
node = new FieldNode(node.parent);
} else if (!isValidFieldName(char)) {
throw new BibTeXSyntaxError(input, node, i, line, column);
} else if (!node.name) {
if (!isWhitespace(char)) {
node.parent.fields.push(node);
node.name = char;
} else {
// noop
}
} else {
node.name += char;
}
break;
}
case 'concat': {
if (isWhitespace(char)) {
break; // noop
} else if (node.canConsumeValue) {
if (/[#=,}()[\]]/.test(char)) {
throw new BibTeXSyntaxError(input, node, i, line, column);
} else {
node.canConsumeValue = false;
if (char === '{') {
node = new BracedNode(node);
} else if (char === '"') {
node = new QuotedNode(node);
} else {
node = new LiteralNode(node, char);
}
}
} else {
if (char === ',') {
node = new FieldNode(node.parent.parent);
} else if (char === '}' || char === ')') {
node = node.parent.parent.parent.parent; // root
} else if (char === '#') {
node.canConsumeValue = true;
} else {
throw new BibTeXSyntaxError(input, node, i, line, column);
}
}
break;
}
case 'literal':
if (isWhitespace(char)) {
// end of literal
node = node.parent;
} else if (char === ',') {
node = new FieldNode(node.parent.parent.parent);
} else if (char === '}') {
node = node.parent.parent.parent.parent.parent; // root
} else if (char === '#') {
node = node.parent;
node.canConsumeValue = true;
} else {
node.value += char;
}
break;
// Values may be enclosed in curly braces. Curly braces may be used within
// the value but they must be balanced.
case 'braced':
if (char === '}' && node.depth === 0) {
node = node.parent; // values
break;
} else if (char === '{') {
node.depth++;
} else if (char === '}') {
node.depth--;
}
node.value += char;
break;
// Values may be enclosed in double quotes. Curly braces may be used
// within quoted values but they must be balanced.
//
// To escape a double quote, surround it with braces `{"}`.
// https://web.archive.org/web/20210422110817/https://maverick.inria.fr/~Xavier.Decoret/resources/xdkbibtex/bibtex_summary.html
case 'quoted':
if (char === '"' && node.depth === 0) {
node = node.parent; // values
break;
} else if (char === '{') {
node.depth++;
} else if (char === '}') {
node.depth--;
if (node.depth < 0) {
throw new BibTeXSyntaxError(input, node, i, line, column);
}
}
node.value += char;
break;
}
}
return rootNode;
}
function isWhitespace(string: string): boolean {
return /^[ \t\n\r]*$/.test(string);
}
/**
* Certain characters are special in latex: {}%#$~. These cannot be used in
* \cite without error. See https://tex.stackexchange.com/a/408548
*/
function isValidKeyCharacter(char: string): boolean | {
return !/[#%{}~$,]/.test(char);
} | identifier_body |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.