_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q36600 | cloudformationContainerDefinition | train | func cloudformationContainerDefinition(cd *ecs.ContainerDefinition) *ContainerDefinitionProperties {
labels := make(map[string]interface{})
for k, v := range cd.DockerLabels {
labels[k] = *v
}
c := &ContainerDefinitionProperties{
Name: *cd.Name,
Command: cd.Command,
Cpu: *cd.Cpu,
Im... | go | {
"resource": ""
} |
q36601 | runTaskResource | train | func runTaskResource(role interface{}) troposphere.Resource {
return troposphere.Resource{
Type: "AWS::Lambda::Function",
Properties: map[string]interface{}{
"Description": fmt.Sprintf("Lambda function to run an ECS task"),
"Handler": "index.handler",
"Role": role,
"Runtime": "python2.7"... | go | {
"resource": ""
} |
q36602 | tagsFromLabels | train | func tagsFromLabels(labels map[string]string) []*cloudformation.Tag {
tags := cloudformationTags{}
for k, v := range labels {
tags = append(tags, &cloudformation.Tag{Key: aws.String(k), Value: aws.String(v)})
}
sort.Sort(tags)
return tags
} | go | {
"resource": ""
} |
q36603 | AsyncEvents | train | func AsyncEvents(e EventStream) EventStream {
s := &asyncEventStream{
e: e,
events: make(chan Event, 100),
}
go s.start()
return s
} | go | {
"resource": ""
} |
q36604 | NewClient | train | func NewClient(config *oauth2.Config) *Client {
return &Client{
Config: config,
backoff: backoff,
}
} | go | {
"resource": ""
} |
q36605 | IsOrganizationMember | train | func (c *Client) IsOrganizationMember(organization, token string) (bool, error) {
req, err := c.NewRequest("HEAD", fmt.Sprintf("/user/memberships/orgs/%s", organization), nil)
if err != nil {
return false, err
}
tokenAuth(req, token)
resp, err := c.Do(req, nil)
if err != nil {
if resp != nil && resp.StatusC... | go | {
"resource": ""
} |
q36606 | IsTeamMember | train | func (c *Client) IsTeamMember(teamID, token string) (bool, error) {
u, err := c.GetUser(token)
if err != nil {
return false, err
}
req, err := c.NewRequest("GET", fmt.Sprintf("/teams/%s/memberships/%s", teamID, u.Login), nil)
if err != nil {
return false, err
}
tokenAuth(req, token)
var t TeamMembership
... | go | {
"resource": ""
} |
q36607 | OrganizationAppCreate | train | func (c *Client) OrganizationAppCreate(options *OrganizationAppCreateOpts, message string) (*OrganizationApp, error) {
rh := RequestHeaders{CommitMessage: message}
var organizationAppRes OrganizationApp
return &organizationAppRes, c.PostWithHeaders(&organizationAppRes, "/organizations/apps", options, rh.Headers())
} | go | {
"resource": ""
} |
q36608 | OrganizationAppList | train | func (c *Client) OrganizationAppList(lr *ListRange) ([]OrganizationApp, error) {
req, err := c.NewRequest("GET", "/organizations/apps", nil, nil)
if err != nil {
return nil, err
}
if lr != nil {
lr.SetHeader(req)
}
var organizationAppsRes []OrganizationApp
return organizationAppsRes, c.DoReq(req, &organiza... | go | {
"resource": ""
} |
q36609 | OrganizationAppListForOrganization | train | func (c *Client) OrganizationAppListForOrganization(organizationIdentity string, lr *ListRange) ([]OrganizationApp, error) {
req, err := c.NewRequest("GET", "/organizations/"+organizationIdentity+"/apps", nil, nil)
if err != nil {
return nil, err
}
if lr != nil {
lr.SetHeader(req)
}
var organizationAppsRes ... | go | {
"resource": ""
} |
q36610 | OrganizationAppInfo | train | func (c *Client) OrganizationAppInfo(appIdentity string) (*OrganizationApp, error) {
var organizationApp OrganizationApp
return &organizationApp, c.Get(&organizationApp, "/organizations/apps/"+appIdentity)
} | go | {
"resource": ""
} |
q36611 | OrganizationAppUpdateLocked | train | func (c *Client) OrganizationAppUpdateLocked(appIdentity string, locked bool) (*OrganizationApp, error) {
params := struct {
Locked bool `json:"locked"`
}{
Locked: locked,
}
var organizationAppRes OrganizationApp
return &organizationAppRes, c.Patch(&organizationAppRes, "/organizations/apps/"+appIdentity, param... | go | {
"resource": ""
} |
q36612 | OrganizationAppTransferToOrganization | train | func (c *Client) OrganizationAppTransferToOrganization(appIdentity string, owner string) (*OrganizationApp, error) {
params := struct {
Owner string `json:"owner"`
}{
Owner: owner,
}
var organizationAppRes OrganizationApp
return &organizationAppRes, c.Patch(&organizationAppRes, "/organizations/apps/"+appIdenti... | go | {
"resource": ""
} |
q36613 | MakeRedirectAuthenticationRequest | train | func (sp *ServiceProvider) MakeRedirectAuthenticationRequest(relayState string) (*url.URL, error) {
req, err := sp.MakeAuthenticationRequest(sp.GetSSOBindingLocation(HTTPRedirectBinding))
if err != nil {
return nil, err
}
return req.Redirect(relayState), nil
} | go | {
"resource": ""
} |
q36614 | getIDPSigningCert | train | func (sp *ServiceProvider) getIDPSigningCert() []byte {
cert := ""
for _, keyDescriptor := range sp.IDPMetadata.IDPSSODescriptor.KeyDescriptor {
if keyDescriptor.Use == "signing" {
cert = keyDescriptor.KeyInfo.Certificate
break
}
}
// If there are no explicitly signing certs, just return the first
// n... | go | {
"resource": ""
} |
q36615 | MakePostAuthenticationRequest | train | func (sp *ServiceProvider) MakePostAuthenticationRequest(relayState string) ([]byte, error) {
req, err := sp.MakeAuthenticationRequest(sp.GetSSOBindingLocation(HTTPPostBinding))
if err != nil {
return nil, err
}
return req.Post(relayState), nil
} | go | {
"resource": ""
} |
q36616 | Get | train | func (aa AssertionAttributes) Get(name string) *AssertionAttribute {
for _, attr := range aa {
if attr.Name == name {
return &attr
}
if attr.FriendlyName == name {
return &attr
}
}
return nil
} | go | {
"resource": ""
} |
q36617 | InitiateLogin | train | func (sp *ServiceProvider) InitiateLogin(w http.ResponseWriter) error {
acsURL, _ := url.Parse(sp.AcsURL)
binding := HTTPRedirectBinding
bindingLocation := sp.GetSSOBindingLocation(binding)
if bindingLocation == "" {
binding = HTTPPostBinding
bindingLocation = sp.GetSSOBindingLocation(binding)
}
req, err :=... | go | {
"resource": ""
} |
q36618 | Parse | train | func (sp *ServiceProvider) Parse(w http.ResponseWriter, r *http.Request) (*Assertion, error) {
allowIdPInitiated := ""
possibleRequestIDs := []string{allowIdPInitiated}
// Find the request id that relates to this RelayState.
relayState := r.PostFormValue("RelayState")
if sp.cookieSecret() != nil && relayState != ... | go | {
"resource": ""
} |
q36619 | RealIP | train | func (r *Resolver) RealIP(req *http.Request) string {
var hdrRealIP string
if r.XRealIp {
hdrRealIP = req.Header.Get("X-Real-Ip")
}
var hdrForwardedFor string
if r.XForwardedFor {
hdrForwardedFor = req.Header.Get("X-Forwarded-For")
}
if len(hdrForwardedFor) == 0 && len(hdrRealIP) == 0 {
return ipAddrFrom... | go | {
"resource": ""
} |
q36620 | Middleware | train | func Middleware(h http.Handler, r *Resolver) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
ip := r.RealIP(req)
h.ServeHTTP(w, req.WithContext(context.WithValue(req.Context(), realIPKey, ip)))
})
} | go | {
"resource": ""
} |
q36621 | RealIP | train | func RealIP(req *http.Request) string {
ip, ok := req.Context().Value(realIPKey).(string)
if !ok {
// Fallback to a secure resolver.
return DefaultResolver.RealIP(req)
}
return ip
} | go | {
"resource": ""
} |
q36622 | reverse | train | func reverse(ss []string) {
last := len(ss) - 1
for i := 0; i < len(ss)/2; i++ {
ss[i], ss[last-i] = ss[last-i], ss[i]
}
} | go | {
"resource": ""
} |
q36623 | NewStatsd | train | func NewStatsd(addr, prefix string) (*Statsd, error) {
c, err := statsd.NewClient(addr, prefix)
if err != nil {
return nil, err
}
return &Statsd{
client: c,
}, nil
} | go | {
"resource": ""
} |
q36624 | RunAttachedWithDocker | train | func RunAttachedWithDocker(s twelvefactor.Scheduler, client *dockerutil.Client) *AttachedScheduler {
return &AttachedScheduler{
Scheduler: s,
dockerScheduler: NewScheduler(client),
}
} | go | {
"resource": ""
} |
q36625 | Run | train | func (s *AttachedScheduler) Run(ctx context.Context, app *twelvefactor.Manifest) error {
if len(app.Processes) != 1 {
return fmt.Errorf("docker: cannot run mutliple processes with attached scheduler")
}
p := app.Processes[0]
// Attached means stdout, stdin is attached.
attached := p.Stdin != nil || p.Stdout != ... | go | {
"resource": ""
} |
q36626 | Tasks | train | func (s *AttachedScheduler) Tasks(ctx context.Context, app string) ([]*twelvefactor.Task, error) {
if !s.ShowAttached {
return s.Scheduler.Tasks(ctx, app)
}
type instancesResult struct {
instances []*twelvefactor.Task
err error
}
ch := make(chan instancesResult, 1)
go func() {
attachedInstances, e... | go | {
"resource": ""
} |
q36627 | Stop | train | func (s *AttachedScheduler) Stop(ctx context.Context, maybeContainerID string) error {
if !s.ShowAttached {
return s.Scheduler.Stop(ctx, maybeContainerID)
}
err := s.dockerScheduler.Stop(ctx, maybeContainerID)
// If there's no container with this ID, delegate to the wrapped
// scheduler.
if _, ok := err.(*doc... | go | {
"resource": ""
} |
q36628 | InstancesFromAttachedRuns | train | func (s *Scheduler) InstancesFromAttachedRuns(ctx context.Context, app string) ([]*twelvefactor.Task, error) {
// Filter only docker containers that were started as an attached run.
attached := fmt.Sprintf("%s=%s", runLabel, Attached)
return s.instances(ctx, app, attached)
} | go | {
"resource": ""
} |
q36629 | instances | train | func (s *Scheduler) instances(ctx context.Context, app string, labels ...string) ([]*twelvefactor.Task, error) {
var instances []*twelvefactor.Task
containers, err := s.docker.ListContainers(docker.ListContainersOptions{
Filters: map[string][]string{
"label": append([]string{
fmt.Sprintf("%s=%s", appLabel, ... | go | {
"resource": ""
} |
q36630 | Stop | train | func (s *Scheduler) Stop(ctx context.Context, containerID string) error {
container, err := s.docker.InspectContainer(containerID)
if err != nil {
return err
}
// Some extra protection around stopping containers. We don't want to
// allow users to stop containers that may have been started outside of
// Empire... | go | {
"resource": ""
} |
q36631 | Fulfills | train | func (c *CIDRCondition) Fulfills(value interface{}, _ *Request) bool {
ips, ok := value.(string)
if !ok {
return false
}
_, cidrnet, err := net.ParseCIDR(c.CIDR)
if err != nil {
return false
}
ip := net.ParseIP(ips)
if ip == nil {
return false
}
return cidrnet.Contains(ip)
} | go | {
"resource": ""
} |
q36632 | Fulfills | train | func (c *BooleanCondition) Fulfills(value interface{}, _ *Request) bool {
val, ok := value.(bool)
return ok && val == c.BooleanValue
} | go | {
"resource": ""
} |
q36633 | Fulfills | train | func (c *EqualsSubjectCondition) Fulfills(value interface{}, r *Request) bool {
s, ok := value.(string)
return ok && s == r.Subject
} | go | {
"resource": ""
} |
q36634 | Update | train | func (m *MemoryManager) Update(policy Policy) error {
m.Lock()
defer m.Unlock()
m.Policies[policy.GetID()] = policy
return nil
} | go | {
"resource": ""
} |
q36635 | GetAll | train | func (m *MemoryManager) GetAll(limit, offset int64) (Policies, error) {
keys := make([]string, len(m.Policies))
i := 0
m.RLock()
for key := range m.Policies {
keys[i] = key
i++
}
start, end := pagination.Index(int(limit), int(offset), len(m.Policies))
sort.Strings(keys)
ps := make(Policies, len(keys[start:... | go | {
"resource": ""
} |
q36636 | Create | train | func (m *MemoryManager) Create(policy Policy) error {
m.Lock()
defer m.Unlock()
if _, found := m.Policies[policy.GetID()]; found {
return errors.New("Policy exists")
}
m.Policies[policy.GetID()] = policy
return nil
} | go | {
"resource": ""
} |
q36637 | Get | train | func (m *MemoryManager) Get(id string) (Policy, error) {
m.RLock()
defer m.RUnlock()
p, ok := m.Policies[id]
if !ok {
return nil, errors.New("Not found")
}
return p, nil
} | go | {
"resource": ""
} |
q36638 | Delete | train | func (m *MemoryManager) Delete(id string) error {
m.Lock()
defer m.Unlock()
delete(m.Policies, id)
return nil
} | go | {
"resource": ""
} |
q36639 | Fulfills | train | func (c *StringPairsEqualCondition) Fulfills(value interface{}, _ *Request) bool {
pairs, PairsOk := value.([]interface{})
if !PairsOk {
return false
}
for _, v := range pairs {
pair, PairOk := v.([]interface{})
if !PairOk || (len(pair) != 2) {
return false
}
a, AOk := pair[0].(string)
b, BOk := pa... | go | {
"resource": ""
} |
q36640 | Fulfills | train | func (c *StringMatchCondition) Fulfills(value interface{}, _ *Request) bool {
s, ok := value.(string)
matches, _ := regexp.MatchString(c.Matches, s)
return ok && matches
} | go | {
"resource": ""
} |
q36641 | IsAllowed | train | func (l *Ladon) IsAllowed(r *Request) (err error) {
policies, err := l.Manager.FindRequestCandidates(r)
if err != nil {
return err
}
// Although the manager is responsible of matching the policies, it might decide to just scan for
// subjects, it might return all policies, or it might have a different pattern m... | go | {
"resource": ""
} |
q36642 | DoPoliciesAllow | train | func (l *Ladon) DoPoliciesAllow(r *Request, policies []Policy) (err error) {
var allowed = false
var deciders = Policies{}
// Iterate through all policies
for _, p := range policies {
// Does the action match with one of the policies?
// This is the first check because usually actions are a superset of get|upd... | go | {
"resource": ""
} |
q36643 | Fulfills | train | func (c *ResourceContainsCondition) Fulfills(value interface{}, r *Request) bool {
filter, ok := value.(map[string]interface{})
if !ok {
return false
}
valueString, ok := filter["value"].(string)
if !ok || len(valueString) < 1 {
return false
}
//If no delimiter provided default to "equals" check
delimite... | go | {
"resource": ""
} |
q36644 | Matches | train | func (m *RegexpMatcher) Matches(p Policy, haystack []string, needle string) (bool, error) {
var reg *regexp.Regexp
var err error
for _, h := range haystack {
// This means that the current haystack item does not contain a regular expression
if strings.Count(h, string(p.GetStartDelimiter())) == 0 {
// If we h... | go | {
"resource": ""
} |
q36645 | AddCondition | train | func (cs Conditions) AddCondition(key string, c Condition) {
cs[key] = c
} | go | {
"resource": ""
} |
q36646 | MarshalJSON | train | func (cs Conditions) MarshalJSON() ([]byte, error) {
out := make(map[string]*jsonCondition, len(cs))
for k, c := range cs {
raw, err := json.Marshal(c)
if err != nil {
return []byte{}, errors.WithStack(err)
}
out[k] = &jsonCondition{
Type: c.GetName(),
Options: json.RawMessage(raw),
}
}
retu... | go | {
"resource": ""
} |
q36647 | UnmarshalJSON | train | func (cs Conditions) UnmarshalJSON(data []byte) error {
if cs == nil {
return errors.New("Can not be nil")
}
var jcs map[string]jsonCondition
var dc Condition
if err := json.Unmarshal(data, &jcs); err != nil {
return errors.WithStack(err)
}
for k, jc := range jcs {
var found bool
for name, c := range ... | go | {
"resource": ""
} |
q36648 | Fulfills | train | func (c *StringEqualCondition) Fulfills(value interface{}, _ *Request) bool {
s, ok := value.(string)
return ok && s == c.Equals
} | go | {
"resource": ""
} |
q36649 | delimiterIndices | train | func delimiterIndices(s string, delimiterStart, delimiterEnd byte) ([]int, error) {
var level, idx int
idxs := make([]int, 0)
for i := 0; i < len(s); i++ {
switch s[i] {
case delimiterStart:
if level++; level == 1 {
idx = i
}
case delimiterEnd:
if level--; level == 0 {
idxs = append(idxs, idx,... | go | {
"resource": ""
} |
q36650 | UnmarshalJSON | train | func (p *DefaultPolicy) UnmarshalJSON(data []byte) error {
var pol = struct {
ID string `json:"id" gorethink:"id"`
Description string `json:"description" gorethink:"description"`
Subjects []string `json:"subjects" gorethink:"subjects"`
Effect string `json:"effect" gorethink:"effe... | go | {
"resource": ""
} |
q36651 | Tidy | train | func Tidy(r io.Reader, xmlIn bool) ([]byte, error) {
f, err := ioutil.TempFile("/tmp", "sajari-convert-")
if err != nil {
return nil, err
}
defer os.Remove(f.Name())
io.Copy(f, r)
var output []byte
if xmlIn {
output, err = exec.Command("tidy", "-xml", "-numeric", "-asxml", "-quiet", "-utf8", f.Name()).Outpu... | go | {
"resource": ""
} |
q36652 | Done | train | func (l *LocalFile) Done() {
l.Close()
if l.unlink {
os.Remove(l.Name())
}
} | go | {
"resource": ""
} |
q36653 | ConvertODT | train | func ConvertODT(r io.Reader) (string, map[string]string, error) {
meta := make(map[string]string)
var textBody string
b, err := ioutil.ReadAll(r)
if err != nil {
return "", nil, err
}
zr, err := zip.NewReader(bytes.NewReader(b), int64(len(b)))
if err != nil {
return "", nil, fmt.Errorf("error unzipping data... | go | {
"resource": ""
} |
q36654 | DecodedLen | train | func DecodedLen(src []byte) (int, error) {
v, _, err := decodedLen(src)
return v, err
} | go | {
"resource": ""
} |
q36655 | Reset | train | func (r *Reader) Reset(reader io.Reader) {
r.r = reader
r.err = nil
r.i = 0
r.j = 0
r.readHeader = false
} | go | {
"resource": ""
} |
q36656 | ConvertURL | train | func ConvertURL(input io.Reader, readability bool) (string, map[string]string, error) {
meta := make(map[string]string)
buf := new(bytes.Buffer)
_, err := buf.ReadFrom(input)
if err != nil {
return "", nil, err
}
g := goose.New()
article, err := g.ExtractFromURL(buf.String())
if err != nil {
return "", ni... | go | {
"resource": ""
} |
q36657 | ConvertRTF | train | func ConvertRTF(r io.Reader) (string, map[string]string, error) {
f, err := NewLocalFile(r, "/tmp", "sajari-convert-")
if err != nil {
return "", nil, fmt.Errorf("error creating local file: %v", err)
}
defer f.Done()
var output string
tmpOutput, err := exec.Command("unrtf", "--nopict", "--text", f.Name()).Outp... | go | {
"resource": ""
} |
q36658 | ConvertDocx | train | func ConvertDocx(r io.Reader) (string, map[string]string, error) {
meta := make(map[string]string)
var textHeader, textBody, textFooter string
b, err := ioutil.ReadAll(r)
if err != nil {
return "", nil, err
}
zr, err := zip.NewReader(bytes.NewReader(b), int64(len(b)))
if err != nil {
return "", nil, fmt.Err... | go | {
"resource": ""
} |
q36659 | DocxXMLToText | train | func DocxXMLToText(r io.Reader) (string, error) {
return XMLToText(r, []string{"br", "p", "tab"}, []string{"instrText", "script"}, true)
} | go | {
"resource": ""
} |
q36660 | ConvertHTML | train | func ConvertHTML(r io.Reader, readability bool) (string, map[string]string, error) {
meta := make(map[string]string)
buf := new(bytes.Buffer)
_, err := buf.ReadFrom(r)
if err != nil {
return "", nil, err
}
cleanXML, err := Tidy(buf, false)
if err != nil {
log.Println("Tidy:", err)
// Tidy failed, so we n... | go | {
"resource": ""
} |
q36661 | acceptedHTMLTag | train | func acceptedHTMLTag(tagName string) bool {
for _, tag := range acceptedHTMLTags {
if tag == tagName {
return true
}
}
return false
} | go | {
"resource": ""
} |
q36662 | HTMLReadability | train | func HTMLReadability(r io.Reader) []byte {
jr := justext.NewReader(r)
// TODO: Improve this!
jr.Stoplist = readabilityStopList
jr.LengthLow = HTMLReadabilityOptionsValues.LengthLow
jr.LengthHigh = HTMLReadabilityOptionsValues.LengthHigh
jr.StopwordsLow = HTMLReadabilityOptionsValues.StopwordsLow
jr.StopwordsHig... | go | {
"resource": ""
} |
q36663 | HTMLToText | train | func HTMLToText(input io.Reader) string {
text, _ := XMLToText(input, []string{"br", "p", "h1", "h2", "h3", "h4"}, []string{}, false)
return text
} | go | {
"resource": ""
} |
q36664 | Convert | train | func Convert(r io.Reader, mimeType string, readability bool) (*Response, error) {
start := time.Now()
var body string
var meta map[string]string
var err error
switch mimeType {
case "application/msword", "application/vnd.ms-word":
body, meta, err = ConvertDoc(r)
case "application/vnd.openxmlformats-officedoc... | go | {
"resource": ""
} |
q36665 | ConvertPath | train | func ConvertPath(path string) (*Response, error) {
mimeType := MimeTypeByExtension(path)
f, err := os.Open(path)
if err != nil {
return nil, err
}
defer f.Close()
return Convert(f, mimeType, true)
} | go | {
"resource": ""
} |
q36666 | ConvertPathReadability | train | func ConvertPathReadability(path string, readability bool) ([]byte, error) {
mimeType := MimeTypeByExtension(path)
f, err := os.Open(path)
if err != nil {
return nil, err
}
defer f.Close()
data, err := Convert(f, mimeType, readability)
if err != nil {
return nil, err
}
return json.Marshal(data)
} | go | {
"resource": ""
} |
q36667 | New | train | func New(opts ...Opt) *Client {
c := &Client{
endpoint: DefaultEndpoint,
protocol: DefaultProtocol,
httpClient: DefaultHTTPClient,
}
for _, opt := range opts {
opt(c)
}
return c
} | go | {
"resource": ""
} |
q36668 | Convert | train | func (c *Client) Convert(r io.Reader, filename string) (*Response, error) {
buf := &bytes.Buffer{}
w := multipart.NewWriter(buf)
part, err := w.CreateFormFile("input", filename)
if err != nil {
return nil, err
}
if _, err := io.Copy(part, r); err != nil {
return nil, err
}
if err := w.Close(); err != nil {
... | go | {
"resource": ""
} |
q36669 | ConvertPath | train | func ConvertPath(c *Client, path string) (*Response, error) {
f, err := os.Open(path)
if err != nil {
return nil, err
}
defer f.Close()
return c.Convert(f, f.Name())
} | go | {
"resource": ""
} |
q36670 | ConvertDoc | train | func ConvertDoc(r io.Reader) (string, map[string]string, error) {
f, err := NewLocalFile(r, "/tmp", "sajari-convert-")
if err != nil {
return "", nil, fmt.Errorf("error creating local file: %v", err)
}
defer f.Done()
// Meta data
mc := make(chan map[string]string, 1)
go func() {
meta := make(map[string]stri... | go | {
"resource": ""
} |
q36671 | ConvertImage | train | func ConvertImage(r io.Reader) (string, map[string]string, error) {
f, err := NewLocalFile(r, "/tmp", "sajari-convert-")
if err != nil {
return "", nil, fmt.Errorf("error creating local file: %v", err)
}
defer f.Done()
meta := make(map[string]string)
out := make(chan string, 1)
// TODO: Why is this done in a... | go | {
"resource": ""
} |
q36672 | SetImageLanguages | train | func SetImageLanguages(l string) {
langs.Lock()
langs.lang = l
langs.Unlock()
} | go | {
"resource": ""
} |
q36673 | ConvertPages | train | func ConvertPages(r io.Reader) (string, map[string]string, error) {
meta := make(map[string]string)
var textBody string
b, err := ioutil.ReadAll(r)
if err != nil {
return "", nil, fmt.Errorf("error reading data: %v", err)
}
zr, err := zip.NewReader(bytes.NewReader(b), int64(len(b)))
if err != nil {
return ... | go | {
"resource": ""
} |
q36674 | convertPath | train | func convertPath(path string, readability bool) ([]byte, error) {
mimeType := docconv.MimeTypeByExtension(path)
if *logLevel >= 1 {
log.Println("Converting file: " + path + " (" + mimeType + ")")
}
// Open file
f, err := os.Open(path)
if err != nil {
return nil, err
}
defer f.Close()
data, err := docconv... | go | {
"resource": ""
} |
q36675 | serve | train | func serve() {
http.HandleFunc("/convert", func(w http.ResponseWriter, r *http.Request) {
// Readability flag. Currently only used for HTML
var readability bool
if r.FormValue("readability") == "1" {
readability = true
if *logLevel >= 2 {
log.Println("Readability is on")
}
}
path := r.FormValue... | go | {
"resource": ""
} |
q36676 | ConvertXML | train | func ConvertXML(r io.Reader) (string, map[string]string, error) {
meta := make(map[string]string)
cleanXML, err := Tidy(r, true)
if err != nil {
return "", nil, fmt.Errorf("tidy error: %v", err)
}
result, err := XMLToText(bytes.NewReader(cleanXML), []string{}, []string{}, true)
if err != nil {
return "", nil,... | go | {
"resource": ""
} |
q36677 | XMLToText | train | func XMLToText(r io.Reader, breaks []string, skip []string, strict bool) (string, error) {
var result string
dec := xml.NewDecoder(r)
dec.Strict = strict
for {
t, err := dec.Token()
if err != nil {
if err == io.EOF {
break
}
return "", err
}
switch v := t.(type) {
case xml.CharData:
resu... | go | {
"resource": ""
} |
q36678 | XMLToMap | train | func XMLToMap(r io.Reader) (map[string]string, error) {
m := make(map[string]string)
dec := xml.NewDecoder(r)
var tagName string
for {
t, err := dec.Token()
if err != nil {
if err == io.EOF {
break
}
return nil, err
}
switch v := t.(type) {
case xml.StartElement:
tagName = string(v.Name.L... | go | {
"resource": ""
} |
q36679 | ForceDelete | train | func ForceDelete(db DB, model interface{}) error {
res, err := NewQuery(db, model).WherePK().ForceDelete()
if err != nil {
return err
}
return internal.AssertOneRow(res.RowsAffected())
} | go | {
"resource": ""
} |
q36680 | Decode | train | func Decode(strct interface{}, values Values) error {
v := reflect.Indirect(reflect.ValueOf(strct))
meta := structfilter.GetStruct(v.Type())
for name, values := range values {
name = strings.TrimPrefix(name, ":")
name = strings.TrimSuffix(name, "[]")
field := meta.Field(name)
if field != nil && !field.NoDe... | go | {
"resource": ""
} |
q36681 | ParseURL | train | func ParseURL(sURL string) (*Options, error) {
parsedURL, err := url.Parse(sURL)
if err != nil {
return nil, err
}
// scheme
if parsedURL.Scheme != "postgres" && parsedURL.Scheme != "postgresql" {
return nil, errors.New("pg: invalid scheme: " + parsedURL.Scheme)
}
// host and port
options := &Options{
A... | go | {
"resource": ""
} |
q36682 | Underscore | train | func Underscore(s string) string {
r := make([]byte, 0, len(s)+5)
for i := 0; i < len(s); i++ {
c := s[i]
if IsUpper(c) {
if i > 0 && i+1 < len(s) && (IsLower(s[i-1]) || IsLower(s[i+1])) {
r = append(r, '_', ToLower(c))
} else {
r = append(r, ToLower(c))
}
} else {
r = append(r, c)
}
}
r... | go | {
"resource": ""
} |
q36683 | Begin | train | func (db *baseDB) Begin() (*Tx, error) {
tx := &Tx{
db: db.withPool(pool.NewSingleConnPool(db.pool)),
ctx: db.db.Context(),
}
err := tx.begin()
if err != nil {
tx.close()
return nil, err
}
return tx, nil
} | go | {
"resource": ""
} |
q36684 | RunInTransaction | train | func (db *baseDB) RunInTransaction(fn func(*Tx) error) error {
tx, err := db.Begin()
if err != nil {
return err
}
return tx.RunInTransaction(fn)
} | go | {
"resource": ""
} |
q36685 | RunInTransaction | train | func (tx *Tx) RunInTransaction(fn func(*Tx) error) error {
defer func() {
if err := recover(); err != nil {
_ = tx.Rollback()
panic(err)
}
}()
if err := fn(tx); err != nil {
_ = tx.Rollback()
return err
}
return tx.Commit()
} | go | {
"resource": ""
} |
q36686 | Stmt | train | func (tx *Tx) Stmt(stmt *Stmt) *Stmt {
stmt, err := tx.Prepare(stmt.q)
if err != nil {
return &Stmt{stickyErr: err}
}
return stmt
} | go | {
"resource": ""
} |
q36687 | ExecContext | train | func (tx *Tx) ExecContext(c context.Context, query interface{}, params ...interface{}) (Result, error) {
return tx.exec(c, query, params...)
} | go | {
"resource": ""
} |
q36688 | Model | train | func (tx *Tx) Model(model ...interface{}) *orm.Query {
return orm.NewQuery(tx, model...)
} | go | {
"resource": ""
} |
q36689 | ModelContext | train | func (tx *Tx) ModelContext(c context.Context, model ...interface{}) *orm.Query {
return orm.NewQueryContext(c, tx, model...)
} | go | {
"resource": ""
} |
q36690 | CreateTable | train | func (tx *Tx) CreateTable(model interface{}, opt *orm.CreateTableOptions) error {
return orm.CreateTable(tx, model, opt)
} | go | {
"resource": ""
} |
q36691 | DropTable | train | func (tx *Tx) DropTable(model interface{}, opt *orm.DropTableOptions) error {
return orm.DropTable(tx, model, opt)
} | go | {
"resource": ""
} |
q36692 | CopyFrom | train | func (tx *Tx) CopyFrom(r io.Reader, query interface{}, params ...interface{}) (res Result, err error) {
err = tx.withConn(context.TODO(), func(cn *pool.Conn) error {
res, err = tx.db.copyFrom(cn, r, query, params...)
return err
})
return res, err
} | go | {
"resource": ""
} |
q36693 | CopyTo | train | func (tx *Tx) CopyTo(w io.Writer, query interface{}, params ...interface{}) (res Result, err error) {
err = tx.withConn(context.TODO(), func(cn *pool.Conn) error {
res, err = tx.db.copyTo(cn, w, query, params...)
return err
})
return res, err
} | go | {
"resource": ""
} |
q36694 | FormatQuery | train | func (tx *Tx) FormatQuery(dst []byte, query string, params ...interface{}) []byte {
return tx.db.FormatQuery(dst, query, params...)
} | go | {
"resource": ""
} |
q36695 | UnformattedQuery | train | func (ev *QueryEvent) UnformattedQuery() (string, error) {
b, err := queryString(ev.Query)
if err != nil {
return "", err
}
return string(b), nil
} | go | {
"resource": ""
} |
q36696 | FormattedQuery | train | func (ev *QueryEvent) FormattedQuery() (string, error) {
b, err := appendQuery(ev.DB, nil, ev.Query, ev.Params...)
if err != nil {
return "", err
}
return string(b), nil
} | go | {
"resource": ""
} |
q36697 | AddQueryHook | train | func (db *baseDB) AddQueryHook(hook QueryHook) {
db.queryHooks = append(db.queryHooks, hook)
} | go | {
"resource": ""
} |
q36698 | Close | train | func (ln *Listener) Close() error {
ln.mu.Lock()
defer ln.mu.Unlock()
if ln.closed {
return errListenerClosed
}
ln.closed = true
close(ln.exit)
return ln._closeTheCn(errListenerClosed)
} | go | {
"resource": ""
} |
q36699 | Listen | train | func (ln *Listener) Listen(channels ...string) error {
// Always append channels so DB.Listen works correctly.
ln.channels = appendIfNotExists(ln.channels, channels...)
cn, err := ln.conn()
if err != nil {
return err
}
err = ln.listen(cn, channels...)
if err != nil {
ln.releaseConn(cn, err, false)
return... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.