gets/sets the public metadata url
14506
def metadataURL(self, value):
        """"""
        if value != self._metadataURL:
            self._metadataURL = value
            self._metaFS = None
977901
public function metaData()
    {
        Meta::setTitle($this->title)
            ->set("description", $this->about)
            ->set("og:type", "website", "property")
            ->set("og:title", $this->title, "property")
            ->set("og:description", $this->description, "property")
            ->set("og:url", $this->href, "property")
            ->setImageOG(($this->hasFeaturedImage() ? $this->featuredImage : null))
            ->setCanonical($this->href)
            ->setWildcards(
                [
                '{{title}}' => $this->title,
                '{{sitename}}' => settings('siteTitle')
                ]
            );
    }
1149855
def request_metadata
      {
        uuid: request.uuid,
        url: request.original_url,
        headers: request.env.select { |key, _v| key =~ /^HTTP_/ },
        ip: request.remote_ip
      }
    end
1075860
def _set_metadata(self):
        
        meta = QueryDbMeta()
        with self._engine.connect() as conn:
            meta.bind = conn
            meta.reflect()
            self._meta = meta

        # Set an inspect attribute, whose subattributes
        # return individual tables / columns. Tables and columns
        # are special classes with .last() and other convenience methods
        self.inspect = QueryDbAttributes()
        for table in self._meta.tables:
            setattr(self.inspect, table,
                    QueryDbOrm(self._meta.tables[table], self))

            table_attr = getattr(self.inspect, table)
            table_cols = table_attr.table.columns

            for col in table_cols.keys():
                setattr(table_attr, col,
                        QueryDbOrm(table_cols[col], self))

            # Finally add some summary info:
            #   Table name
            #   Primary Key item or list
            #   N of Cols
            #   Distinct Col Values (class so NVARCHAR(20) and NVARCHAR(30) are not different)
            primary_keys = table_attr.table.primary_key.columns.keys()
            self._summary_info.append((
                table,
                primary_keys[0] if len(primary_keys) == 1 else primary_keys,
                len(table_cols),
                len(set([x.type.__class__ for x in table_cols.values()])),
                ))
884358
def set_metadata(self, set_id, fp):
        
        base_url = self.client.get_url('SET', 'GET', 'single', {'id': set_id})
        self._metadata.set(base_url, fp)
380887
def get_url(self, **kwargs):
        

        return build(
            self._request.path,
            self._request.GET,
            self._meta.prefix,
            **kwargs )
975524
def get_canonical_url(metadata, request):
    """"""
    slug_title = u'/{}'.format('-'.join(metadata['title'].split()))
    settings = get_current_registry().settings

    canon_host = settings.get('canonical-hostname',
                              re.sub('archive.', '', request.host))
    if metadata['canonical'] is None:
        canon_url = request.route_url(
                'content',
                ident_hash=metadata['id'],
                ignore=slug_title)
    else:
        canon_url = request.route_url(
                'content',
                ident_hash=metadata['canonical'],
                separator=':',
                page_ident_hash=metadata['id'],
                ignore=slug_title)

    return re.sub(request.host, canon_host, canon_url)
1276352
public PublicIpMetadata getPublicIp(Server serverRef, String publicIp) {
        return this.getPublicIp(idByRef(serverRef), publicIp);
    }
42771
def set_metadata(self, layer_id, version_id, fp):
        
        base_url = self.client.get_url('VERSION', 'GET', 'single', {'layer_id': layer_id, 'version_id': version_id})
        self._metadata.set(base_url, fp)
944022
private function extractAclFromMetadata() {
        $tmp = $this->metadata->getResource(WebAcl::ACL_LINK_PROP);
        if ($tmp !== null) {
            $this->aclUrl = $this->fedora->standardizeUri($tmp->getUri());
        }
    }
654867
def public_api(self,url):
        ''' '''
        try :
            url in api_urls
            return ast.literal_eval(requests.get(base_url + api_urls.get(url)).text)
        except Exception as e:
            print(e)
858564
def clean_tenant_url(url_string):
    
    if hasattr(settings, 'PUBLIC_SCHEMA_URLCONF'):
        if (settings.PUBLIC_SCHEMA_URLCONF and
                url_string.startswith(settings.PUBLIC_SCHEMA_URLCONF)):
            url_string = url_string[len(settings.PUBLIC_SCHEMA_URLCONF):]
    return url_string
733245
def url(ref)
      config = self.class.config(@repo, ref)

      lookup = config.keys.inject({}) do |acc, key|
        id = config[key]['id']
        acc[id] = config[key]['url']
        acc
      end

      lookup[@id]
    end
1240659
def _get_metadata_path(self, key):
        
        return "{group}/meta/{key}/meta".format(group=self.group._v_pathname,
                                                key=key)
996703
def resource_url(self):
        """"""
        if self._iam:
            self._resource_url = self._resource_url or _get_iam_rest_api_url_from_creds(self.rest_client, self.credentials)
        else:
            self._resource_url = self._resource_url or _get_rest_api_url_from_creds(self.session, self.credentials)
        return self._resource_url
44208
def get_ladder_metadata(session, url):
    """"""
    parsed = make_scrape_request(session, url)
    tag = parsed.find('a', href=re.compile(LADDER_ID_REGEX))
    return {
        'id': int(tag['href'].split('/')[-1]),
        'slug': url.split('/')[-1],
        'url': url
    }
592631
protected <T extends BullhornEntity> MetaData<T> handleGetMetaData(Map<String, String> uriVariables, Integer privateLabelId) {
        String url = restUrlFactory.assembleEntityUrlForMeta(privateLabelId);

        MetaData<T> response = this.performGetRequest(url, StandardMetaData.class, uriVariables);

        return response;

    }