Saravanan666/pypi-org huggingface dataset:
Package: arches-for-science
Welcome to Arches for Science!Please see theproject pagefor more information on the Arches project.The Arches Installation Guide and Arches User Guide are availablehere.How to setup Arches for Science for your project1. InstallationImportant: Installing the arches-for-science app will install Arches as a dependency. This may replace your current install of Arches with a version from PyPi. If you've installed Arches for development using the--editableflag, you'll need to reinstall Arches after installing arches-for-scienceIf installing for developmentClone the arches-for-science repo and checkout the latestdev/x.x.xbranch.
Navigate to thearches-for-sciencedirectory from your terminal and run:pip install -e .If installing for deployment, run:pip install arches-for-science2. Project ConfigurationIf you don't already have an Arches project, you'll need to create one by following the instructions in the Archesdocumentation.
Since Arches for Science usesCantaloupeas its IIIF server, take notice of the
Cantaloupeinstallation instructions, too.When your project is ready add "arches_templating", "arches_for_science", and "pgtrigger" to INSTALLED_APPS and "arches_for_science" to ARCHES_APPLICATIONS in your project's settings.py file:INSTALLED_APPS = (
    ...
    "arches_templating",
    "arches_for_science",
    "pgtrigger",
    "myappname",
)

ARCHES_APPLICATIONS = ('arches_for_science',)Also add the following lines to settings.py. (Note:arches-project createbefore Arches 6.2.6 or 7.5.0 did not createRENDERERS, so you may need toadd it firstbefore extending it as shown below):FUNCTION_LOCATIONS.append("arches_for_science.pkg.extensions.functions")

TEMPLATES[0]["OPTIONS"]["context_processors"].append("arches_for_science.utils.context_processors.project_settings")

RENDERERS += [
    {
        "name": "xy-reader",
        "title": "XY Data File Reader",
        "description": "Use for all instrument outputs with x-y data",
        "id": "e93b7b27-40d8-4141-996e-e59ff08742f3",
        "iconclass": "fa fa-bolt",
        "component": "views/components/cards/file-renderers/xy-reader",
        "ext": "txt",
        "type": "text/plain",   
        "exclude": "",
    },
]

XY_TEXT_FILE_FORMATS = ["txt"]

X_FRAME_OPTIONS = "SAMEORIGIN"Next ensure arches and arches_for_science are included as dependencies in package.json"dependencies": {
    "arches": "archesproject/arches#dev/7.6.x",
    "arches_for_science": "archesproject/arches-for-science#dev/1.1.x"
}Update urls.py to include the arches-for-science urlsurlpatterns = [
    path("", include("arches.urls")),
    path("", include("arches_for_science.urls")),
    path("reports/", include("arches_templating.urls")),
] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)Install the arches application package (models and other data)python manage.py packages -o load_package -a arches_for_science -dev -yStart your projectpython manage.py runserverNext cd into your project's app directory (the one with package.json e.g.$PROJECT_NAME/$PROJECT_NAME/) install and build front-end dependencies:yarn install
yarn build_development
Package: arches-templating
arches-templatingAn application to add templating/reporting capabilities to Arches.InstallationInstall via pip, arches-templating (forthcoming).  Or install a development version by pulling down the repository and runningpip installfrom the local repo directory.Add the arches_templating module to the project's list of INSTALLED_APPLICATIONS.Run migrations from your project to install database.python manage.py migrate arches_templatingAdd urls to your project's urls.py if you wish to use the built-in view to submit your templates.path("your-base-url-here/", include("arches_templating.urls"))Alternatively, you can call the template engine directory and provide your data container and template ID.The Data ContainerThe data container is a json-based object that is provided to the template engine along with the template ID.  It is referenced by the template designer when creating the template - the paths in the template should match the ones being provided by the data container.Adding TemplatesCurrently, the only way to add templates is via the django admin interface.  Visit the /admin url of your site and upload your templates there.Creating TemplatesWe currently support five base tags.valuecontextifimageendEach of these tags requires a "path" attribute and is prefixed by "arches:".  For example:<arches:value path="path/in/data/container">Anendtag is required for thecontextandiftags.Thecontexttag will change the "context" of its child tags to whatever its path matches within the data container provided to the template engine.Functionally, this means that<arches:value path="foo/bar">and<arches:context path="foo">
<arches:value path="bar">
<arches:end>are functionally equivalent and referencing the same data within the data container.If the context is pointing to an array, this is currently the method being used to render table rows.Elements can be optionally rendered by aniftag.<arches:if path="foo">
Some optionally rendered content, depending on value at the "foo" path of your data container.
<arches:end>Animagetag can render an image from a URL or (optionally) a base64 encoded image from the backend.<arches:image path=“path_to_image_or_path_to_url”>Theiftag can be inverted by providing an "inverse" attribute set to true.<arches:if inverse="true" path="foo">Currently powerpoint, word, and spreadsheet templates are supported.  We welcome the addition of more implementations and improvements/bug fixes on the ones that currently exist.
Package: archethic
ArchEthic SDK for PythonThis repo aims to provide a Python SDK for the ArchEthic project.It is based on theofficial javascript sdk.Installationpip install archethicExampleimportarchethicapi=archethic.Api("https://testnet.archethic.net")# make sure you have funds in your wallet !seed='mySuperSeed'ref_index=api.get_transaction_index(archethic.derive_address(seed,0))rx_address=archethic.derive_address("rx_address",0)tx=archethic.TransactionBuilder('transfer')tx.add_uco_transfer(rx_address,10.102)tx.build(seed,ref_index)tx.origin_sign(archethic.ORIGIN_PRIVATE_KEY)transaction_fee=api.get_transaction_fee(tx)print(f"fee :{transaction_fee['fee']}UCOs")response=api.send_tx(tx)print(response)# prints :# fee : 0.12413171 UCOs# {'status': 'pending', 'transaction_address': '00008808978E67F37E0AFF023682AAB48843CF5B340A00B1F1C0668B003EC21E358F'}ContributionThank you for considering to help out with the source code.
We welcome contributions from anyone and are grateful for even the smallest of improvement.Please to follow this workflow:Fork it!Create your feature branch (git checkout -b my-new-feature)Commit your changes (git commit -am 'Add some feature')Push to the branch (git push origin my-new-feature)Create new Pull Request(copied from archethic-foundation)TODOsUtilsImplementation of utilsCryptographic functionsget_originKey()derive_keypair()derive_address()ec_encrypt()aes_encrypt()Transaction buildingcreate TransactionBuilder class (TB)TB.set_code()TB.set_content()TB.add_ownership()TB.add_UCO_transfer()TB.add_TOKEN_transfer()TB.add_recipient()TB.build()TB.origin_sign()TB.toJSON()Interacting with other signerTB.previous_signature_payload()TB.set_previous_signature_and_previous_public_key()TB.set_address()TB.origin_signature_payload()TB.set_origin_sign()Remote Endpoint callsaddOriginKey()TB.send_transaction()wait_confirmations()get_transaction_index()get_storage_nonce_public_key()get_transaction_fee()get_transaction_ownerships()Keychain / Wallet managementcomming soon
Package: archetypal
[![Build Status](https://github.com/samuelduchesne/archetypal/actions/workflows/python-package.yml/badge.svg?branch=main)](https://github.com/samuelduchesne/archetypal/actions/workflows/python-package.yml)
[![Coverage Status](https://coveralls.io/repos/github/samuelduchesne/archetypal/badge.svg)](https://coveralls.io/github/samuelduchesne/archetypal)
[![Documentation Status](https://readthedocs.org/projects/archetypal/badge/?version=latest)](https://archetypal.readthedocs.io/en/latest/?badge=latest)
[![DOI](https://joss.theoj.org/papers/10.21105/joss.01833/status.svg)](https://doi.org/10.21105/joss.01833)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)# Archetypalpython for building simulation archetypesRetrieve, construct, simulate, convert and analyze building simulation
templates## OverviewArchetypalis a Python package that helps handle building
archetypes.## Changes since v2.0.0The conversion of [EnergyPlus](https://energyplus.net) IDF models to
Trnsys
[TrnBuild](http://www.trnsys.com/features/suite-of-tools.php.html)
Models (compatible with the multizone building model) is now part of a
distinct package known as the
[trnslator](https://github.com/louisleroy5/trnslator).## FeaturesHere is a short overview of features that are part of archetypal:Building Complexity Reduction: A utility to transform a multizone
EnergyPlus model to a two-zone normalized model. Such models are
calledbuilding archetypesand are the foundation of the
[UMI Energy Module](https://umidocs.readthedocs.io/en/latest/docs/model-setup-template.html).
This tool will allow any EnergyPlus model to be imported into
[UMI](http://web.mit.edu/sustainabledesignlab/projects/umi/index.html)
and drastically speedup the UBEM process.## InstallationRecommended to use a conda environement running python 3.8. Pip install should work on all platforms (linux, macOS and Windows).
First,`cmd conda create-nvenv python=3.8 `-n venvis the name of your environement; it can be anything.
Then,`cmd pip install-Uarchetypal `## Local DevelopmentClone this repo locally`console git clonehttps://github.com/samuelduchesne/archetypal.git`Install dependencies:`console cd archetypal conda env create `This will create a new environment namedarchetypal. Don’t forget to activate the environment.Run Tests:`console python-mpytest tests/ `Generate Documentation:`console make html `
Package: archetype-python-sdk
Archetype?Everything you need to build and manage API SubscriptionsArchetype is a powerful, reliable purchase server with cross-platform support. Our open-source framework provides a backend and a wrapper around Stripe to make implementing API keys and creating quotas and subscriptions easy.Whether you are building a new API or already have millions of customers, you can use Archetype to:Fetch products, make purchases, and check subscription status with ournative SDKs.Host andconfigure productsremotely from our dashboard.Analyze the most important metrics for your app businessin one place.See customer transaction histories, chart lifetime value, andgrant promotional subscriptions.Sign up toget started for free.Getting started resourcesWith Archetype, you can keep track of all your app transactions in one place — whether your customers are charged through iOS, Android, or the web. As the single source of truth for your app business, we make sure your users’ subscription status is always up to date.Here are a few ways to get started:Jump right in with ourQuickstart GuideUseour APIto create or modify customers.Ready to start building?Simplified payments for your API are just a few lines of code away.Sign up tolaunch your API todayExplore the docs
Package: archetyper
Archetypes!This is a library developed to run what might be called a "souped-up dictionary method" for psychological text analysis. Or any kind of text analysis, really.The core idea behindArchetypesis that you pre-define a set of prototypical sentences that reflect the construct that you are looking to measure in a body of text. Using modern contextual embeddings, then, this library will aggregate your prototypes into anarchetypalrepresentation of your construct. Then, you can quantify texts in your corpus for their semantic similarity to your construct(s) of interest.Note: For the curious: no, this approach not inspired by anythingJungianin nature. In the past, I'vesaid a few thingsabout Jungian archetypes that have inspired scholars to write more than a few frustrated e-mails to me. Apologies to the Jungians.InstallationThis package is easily installable via pip via the following command:pip install archetyperRequirementsIf you want to run the library withoutpipinstalling as shown above, you will need to first install the following packages:numpytqdmtorchsentence_transformersnltkYou can try to install these all in one go by running the following command from your terminal/cmd:pip install numpy tqdm torch sentence_transformers nltkExamplesI have provided an example notebook in this repo that walks through the basic process of using this library, along with demonstrations of a few important "helper" functions to help you evaluate the statistical/psychometric qualities of your archetypes.CitationThis method is originally described in the following forthcoming paper:@inproceedings{varadarajan_archetypes_2024,
	address = {St. Julians, Malta},
	title = {Archetypes and {Entropy}: {Theory}-{Driven} {Extraction} of {Evidence} for {Suicide} {Risk}},
	booktitle = {Proceedings of the {Tenth} {Workshop} on {Computational} {Linguistics} and {Clinical} {Psychology}},
	publisher = {Association for Computational Linguistics},
	author = {Varadarajan, Vasudha and Lahnala, Allison and Ganesan, Adithya V. and Dey, Gourab and Mangalik, Siddharth and Bucur, Ana-Maria and Soni, Nikita and Rao, Rajath and Lanning, Kevin and Vallejo, Isabella and Flek, Lucie and Schwartz, H. Andrew and Welch, Charles and Boyd, Ryan L.},
	year = {2024},
}The citation above will be updated once the paper is actually published 😊
Package: archetypes
Archetypesarchetypesis ascikit-learncompatible Python package for archetypal analysis.InstallationUse the package managerpipto install archetypes.pipinstallarchetypesUsageimportarchetypesasarchimportnumpyasnpX=np.random.normal(0,1,(100,2))aa=arch.AA(n_archetypes=4)X_trans=aa.fit_transform(X)ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseDistributed under the BSD 3-Clause License. SeeLICENSEfor more information.
Package: archetypes.configure
IntroductionThis package adds a declarative interface for the registration of
Archetypes content classes.UsageUse anat:registerdirective to register each of your content
classes.Example configuration:<configure
    xmlns="http://namespaces.zope.org/zope"
    xmlns:five="http://namespaces.zope.org/five"
    xmlns:at="http://namespaces.plone.org/archetypes">

  <five:registerPackage package="." />

  <permission id="example.Add" title="collective.example: Add example" />

  <at:register
      class=".content.Example"
      permission="example.Add"
      />

</configure>You do not need to (and should not) callatapi.registerTypeon
your content classes. This is done automatically by the framework.CreditsMalthe Borch <mborch@gmail.com>Changes0.2 - 2011-09-14Compatibility with Zope 2.13.0.1 - 2010-12-01Initial release
Package: archetypes.fieldtraverser
OverviewThearchetypes.fieldtraverseris used to traverse to an Archetypes field and
access its storage.It patchesProducts.Archetypesso that it uses the fieldtraverser for access to
fields.Use CasesAccess to images, files or other binary data via AnnotationStorage instead of traditional AttributeStorage. archetypes.fieldtraverser eliminates the need to hack__bobo_traverse__for this. Advantage: When accessing objects with binary data stored in an AttributeStorage, much binary data chunks are loaded regardless if they are used. When doing this quite often the ZODB is unnecessarily stressed.You can use archetypes.fieldtraverser for simple Web Services which return just the content of Archetypes fields without the HTML rendered by widgets.Impress your friends by easily accessing field-contents via URLs.UsageIn an URL this traverser can be used to access a fields data by use of
the fieldname and the storage variant if needed (such as image sizes):obj/++atfield++FIELDNAMEorobj/++atfield++FIELDNAME-STORAGENAMEExampleTo access an original image from a field named ‘photo’:obj/++atfield++photoTo access its thumbnail with size named ‘thumb’:obj/++atfield++photo-thumbDependenciesProducts.ArchetypesInstallationInstall like any other Plone egg and import the GenericSetup profiles
in ZMI, portal_setup.Known IssuesThe ImageWidget, FileWidget and RichWidget are patched to use the++atfield++FIELDNAMEnotation for accessing binary contents. This patch is done
via updating the fields’_propertieswhich is then copied in the concrete
schematas.
But our default patch mechanism does not affect ATContentTypes (and possibly
other ConentTypes too) because they are loaded by Zope BEFORE the patches are
applied. This happens also for eggified products in Plone3.2 becauseProducts.ATContentTypesis being recognised as a Product by Zope/Five because
of the “Products” namespace. ThereforeProducts.ATContentTypesis loaded BEFORE
any eggs are loaded.
So we have to patch the concrete ATContentTypes too. Seepatch.pyfor more
information.Please note that RichWidget has the ability to upload and download files, and
therefore we also provide custom fieldtraverser aware widgets. BUT the
upload/download feature is deactivated by default in the RichWidget templates
and settings. The RichWidget patching is done just for completeness.So, if you include your own Products or eggs in the “Products” namespace you’ll
also have to patch your content types to use our fieldtraverser aware widgets.
With this in mind using this product should not be a problem.For your pleasureAn “Easter egg” can be found when opening “++resource++plone.jpg” in your Plone
site. For more information read archetypes/fieldtraverser/tests/plone.jpg.CREDITSCopyrightCopyright (c) 2008: BlueDynamics Alliance, AustriaAlan Farmer (c) 1997 from Bearos Records for plone.jpgCreditsJens Klein <jens@bluedynamics.com>Johannes Raggam <johannes@bluedynamics.com>Robert Niederreiter <rnix@squarewave.at>
Package: archetypes.gridfield
Introductionarchetypes.gridfield adds support for data grids which are not inline editable.
Rows are addable/editable using overlay window.Please note, current version requires branch of plone.app.jquerytools which is
included in the example buildout.Additionally, gridfield widget is displayed on the base_view form only (field
is not visible on the object edit form!!). This is not a bug but a feature.UsageInstall as usuall. After that you can add additional field to you content type:from archetypes.gridfield import GridField
...

GridField('field_name',
    row_interface = IProjectRow
)

...IProjectRow is a zope Interface which defines the data for one row.
The addform and editform are generated from this one:class IProjectRow(Interface):
    title   = schema.TextLine(title=u'Project name', required=True)
    kind    = schema.Choice(title=u'Project type',
                            vocabulary="project.projectTypesVocabulary")
    start_date = schema.Date(title=u'Start date', required=True)
    end_date   = schema.Date(title=u'End date', required=False)You may define custom add/edit forms and update widgets:from archetypes.gridfield.forms import AddForm, EditForm
from collective.z3cform.datetimewidget import DateFieldWidget

class ProjectAddForm(AddForm):
    def __init__(self, context, request):
        super(ProjectAddForm, self).__init__(context, request)
        self.fields['start_date'].widgetFactory = DateFieldWidget
        self.fields['end_date'].widgetFactory = DateFieldWidget

class ProjectEditForm(EditForm):
    def __init__(self, context, request):
        super(ProjectEditForm, self).__init__(context, request)
        self.fields['start_date'].widgetFactory = DateFieldWidget
        self.fields['end_date'].widgetFactory = DateFieldWidgetSince AddForm/EditForm is redefined, we must specify the forms in the field
definition:GridField('projects',
    row_interface = IProjectRow,
    add_form = ProjectAddForm,
    edit_form = ProjectEditForm,
    widget = GridWidget(label="Projects")
)ExampleIf you want to test archetypes.gridfield in separate buildout, checkout full
package from SVN and use example.cfg buildout configuration:svn co http://svn.plone.org/svn/archetypes/MoreFieldsAndWidgets/archetypes.gridfield/trunk gridfield
cd gridfield
python2.4 bootstrap.py
bin/buildout -c example.cfg
bin/instance fgFinally visit base_view template of any object, eg. frontpage:http://127.0.0.1:8080/portal/front-page/base_viewUsage in custom buildoutPlease note, package is still in the development. Requires branch of
plone.app.jquerytools and some custom version pins. Everything is set-up in
example buildout so copy the requirements from it.Changelog1.0dev (unreleased)Initial release
Package: archetypes.ldapstorage
DescriptionThis product features an Archetypes storage that stores field values inan LDAP directory.UsageSee directory 'examples/' for some examples of content types usingLDAPStorage.There are some issues regarding LDAPStorage and Archetypes:- the storage initialization requires the following parameters:- the LDAP RDN attribute. For example, in the folowing LDAPentry, the RDN attribute is 'cn':dn: cn=johndoe,dc=localhost,dc=localdomainobjectClass: inetOrgPersonuid: johndoecn: johndoesn: John Doe- the attribute that should be used to get the RDN value. It canbe a method, archetypes field or instance variable from whichthe value will be retrieved to construct the entry DN.NOTES:1) If an archetypes field is used, it must be usingLDAPStorage and you must ensure that the field is the RDNfield that you defined and its attribute is the RDN attribute.2) If you want to use a field that is not in LDAP,you should use its accessor, but note that LDAPStorage won't beable to know when its value changes. So, be sure that methods orvariables used as RDN mapping are not mutable.- the LDAP attribute to store the value from this field;The following example is correct:...StringField('name',storage = LDAPStorage('cn','name','cn',default_attrs = {'objectClass': ['inetOrgPerson'],},required_attrs = ['sn', 'cn'],),),...The following example would raise the exception'InvalidRDNError':...StringField('name',storage = LDAPStorage('cn','organization','cn',default_attrs = {'objectClass': ['inetOrgPerson'],},required_attrs = ['sn', 'cn'],),),...- it has also some additional parameters:- a dictionary of common attributes. This dictionary will beused to set default values in certain LDAP attributes, at thecreation of new entries. For example, this dictionary could be:>>> default_attrs = {'objectClass': 'inetOrgPerson'}- list of required attributes in LDAP schema. It will tell thestorage what fields are required in LDAP, so it knows they mustbe included in initialization. For example, the list, assumingthat the only object class used is 'inetOrgPerson', would be:>>> required_attrs = ['sn', 'cn']- the usage of this storage assumes that the defined schemas(LDAP and Archetypes) are compatible. Attributes that are requiredin LDAP schema, should be also required in Archetypes schema.TestsTo run unit tests you need to have a configured LDAP server, and fillthe settings in tests/config file.Requirements- CMFPlone 3.0- Archetypes 1.4- python-ldap- LDAPConnection 0.1a1 or newerTodoRead file todo.txt for details.CopyrightRicardo Alves <rsa at eurotux dot com>Eurotux Development Team <udp at eurotux dot com>LicenseThis software is released under GPL v2. Read LICENSE.txtChangelog=========0.1 - Unreleased----------------* Initial release