Saravanan666/pypi-org huggingface dataset:
Package: aleksis-app-untis
AlekSISThis is an application for use with theAlekSIS®platform.FeaturesImport absence reasonsImport absencesImport breaksImport classesImport eventsImport examsImport exported Untis database via MySQL importImport exported Untis XML filesImport holidaysImport lessonsImport roomsImport subjectsImport substitutionsImport supervision areasImport teachersImport time periodsLicenceCopyright © 2018, 2019, 2020, 2021, 2022 Jonathan Weth <dev@jonathanweth.de>
Copyright © 2018, 2019 Frank Poetzsch-Heffter <p-h@katharineum.de>
Copyright © 2019, 2020, 2021, 2022 Dominik George <dominik.george@teckids.org>
Copyright © 2019, 2020 Tom Teichler <tom.teichler@teckids.org>
Copyright © 2019 Julian Leucker <leuckeju@katharineum.de>
Copyright © 2019 mirabilos <thorsten.glaser@teckids.org>

Licenced under the EUPL, version 1.2 or later, by Teckids e.V. (Bonn, Germany).Please see the LICENCE.rst file accompanying this distribution for the
full licence text or on theEuropean Union Public Licencewebsitehttps://joinup.ec.europa.eu/collection/eupl/guidelines-users-and-developers(including all other official language versions).TrademarkAlekSIS® is a registered trademark of the AlekSIS open source project, represented
by Teckids e.V. Please refer to thetrademark policyfor hints on using the trademark
AlekSIS®.
Package: alem
Alem is a simple revision wrapper ofAlembic.Usage:Install by pip, “pip install alem”.
Then you get a command “alem”.Difference from Alembic:Add two arguments for Alembic subcommand revision, “–upgrade”/”-U” and
“–downgrade”/”-D”. They accept a string, separated by “;” for multiple sql
statements, or a file path of sql file. Sql statements in sql file can be
multiple lines or one line. You can ignore them as you want.
Attention: comment in sql file is not supported yet.The rest is to use it as Alembic.
Package: alembic-autogen-check
alembic-autogen-checkInstallpip install alembic-autogen-checkUsagePYTHONPATH=. alembic-autogen-checkThis assumes that analembic.inifile exists in the current working
directory. You can explicitly pass a config file:PYTHONPATH=. alembic-autogen-check --config path/to/alembic.ini
Package: alembic-autogenerate-enums
alembic-autogenerate-enumsThis package implements an Alembic hook that causesalembic revision --autogenerateto output PostgreSQLALTER TYPE .. ADD VALUESQL
statements as part of new migrations.UsageAdd the line:import alembic_autogenerate_enumsTo the top of yourenv.py.NotesSinceALTER TYPE .. ADD VALUEcannot run transactionally, eachop.sync_enum_values()call creates its own temporary private DB connection.
Seehttps://bitbucket.org/zzzeek/alembic/issues/123/a-way-to-run-non-transactional-ddlTestsWe have incredibly basic tests in asample project.mkvirtualenv alembic-autogenerateInstall the main autogenerate package and then the test harness:pip install -e .
pip install -e test-harnesscreateuser alembic-autogenerate
createdb -O alembic-autogenerate alembic-autogenerate_dbcd test-harness && pytest
Package: alembic-dddl
Alembic Dumb DDLA plugin forAlembicDB migration tool that adds support for arbitrary user-defined objects like views, functions, triggers, etc. in autogenerate command.Alembic DDDLdoes notcompare the objects in the code with their state in the database. Instead, itonly tracks if the source code of the script has changed, compared to the previous revision.InstallationYou can install Alembic Dumb DDL from pip:pipinstallalembic-dddlQuick startStep 1: save your DDL script in a file, and make sure that it overwrites the entities, not just creates them (e.g. start withDROP ... IF EXISTSor a similar construct for your DBMS).-- myapp/scripts/last_month_orders.sqlDROPVIEWIFEXISTSlast_month_orders;CREATEVIEWlast_month_ordersASSELECT*FROMordersWHEREorder_date>current_date-interval'30 days';Step 2: Wrap your script in aDDLclass:# myapp/models.pyfromalembic_dddlimportDDLfrompathlibimportPathSCRIPTS=Path(__file__).parent/"scripts"defload_sql(filename:str)->str:"""Helper function to load the contents of a file from a `scripts` directory"""return(SCRIPTS/filename).read_text()my_ddl=DDL(# will be used in revision filenamename="last_month_orders",# DDL script SQL code, will be used in the upgrade commandsql=load_sql("last_month_orders.sql"),# Cleanup SQL code, will be used in the first downgrade commanddown_sql="DROP VIEW IF EXISTS last_month_orders;",)Step 3: Register your script in alembic'senv.py:# migrations/env.pyfrommyapp.modelsimportmy_ddlfromalembic_dddlimportregister_ddlregister_ddl(my_ddl)# also supports a list# ...# the rest of the env.py fileFrom now on the alembic autogenerate command will keep track oflast_month_orders.sql, and if it changes — automatically add update code to your migration scripts to update your entities.Run the migration:$alembicrevision--autogenerate-m"last_month_orders"...
INFO[alembic_dddl.dddl]DetectednewDDL"last_month_orders"Generatingmyapp/migrations/versions/2024_01_08_0955-0c897e9399a9_last_month_orders.py...doneThe generated revision script:# migrations/versions/2024_01_08_0955-0c897e9399a9_last_month_orders.py...defupgrade()->None:# ### commands auto generated by Alembic - please adjust! ###op.run_ddl_script("2024_01_08_0955_last_month_orders_0c897e9399a9.sql")# ### end Alembic commands ###defdowngrade()->None:# ### commands auto generated by Alembic - please adjust! ###op.execute("DROP VIEW IF EXISTS last_month_orders;")# ### end Alembic commands ###For more info seetutorialor take a look at theExample Project.Why do it this way?Managing your custom entities with Alembic DDDL has several benefits:The DDL scripts are defined in one place in the source code, any change to them is reflected in git history through direct diffs.Any kind of SQL script and any DBMS is supported because the plugin does not interact with the database.The migrations for your DDL scripts are fully autogenerated, they are also clean and concise.Further readingTutorialHow it WorksConfigurationSetting up Logging
Package: alembic-migrate
alembic-migratealembic-migrate is a framework-independent fork of flask-migrate.InstallationTo install, runpip install alembic-migrateUsageCreate the following file structure:model/├──__init__.py├──base.py├──book.pyThen declare your SQLAlchemy Base and connection string inmodel/base.py.Note: the connection string doesn't need to match your
app's DB connection, it's only used for migrations.# model/base.pyfromsqlalchemy.ext.declarativeimportdeclarative_baseBase=declarative_base()defget_base():return{'base':Base,'sqlalchemy_url':'sqlite:///demo.db'}Let's add a model inmodel/book.py:from.baseimportBasefromsqlalchemyimportInteger,String,ColumnclassBook(Base):__tablename__='books'name=Column(String,primary_key=True)year=Column(Integer)Nowcd ..so that you are out of the model package and run:alembic-db initto setup the templatealembic-db migrateto create a migrationYou can also check out the example folder in this repo.Configuring base moduleThe base module containsget_base() -> dict. By defaultmodel.baseis used but you can change the environment variable:exportALEMBIC_BASE="my_model.base"Customize model import logicBy default, all*.pyfiles in the same package as the base will be loaded.
However if you want to split your models in subpackages or have custom logic
you should implementimport_modelsinside your base module.defimport_models():from.importcar,bookfrom.subimportother_modelsdefget_base():return...
Package: alembic-migration-fixtures
DescriptionPytest fixture to simplify writing tests against databases managed withalembic.
Before each test run, alembic migrations apply schema changes which then allows tests to only care about data.
This way your application code, and the database migrations get executed by the test.Only tested with PosgreSQL. However, code may work with other databases as well.InstallationInstall withpip install alembic-migration-fixturesor any other dependency manager.
Afterwards, create a pytest fixture calleddatabase_enginereturning an SQLAlchemyEngineinstance.WARNINGDo not specify the production / development / any other database where data is important in the engine fixture.
If you do so, the tests WILL truncate all tables and data loss WILL occur.UsageThis library provides a pytestfixturecalledtest_db_session.
Use this to replace the normal SQLAlchemy session used within the application, or else tests may not be independent
of one another.How the fixture works with your tests:Fixture recreates (wipes) the database schema based on the engine provided for the test sessionFixture runs alembic migrations (equivalent toalembic upgrade heads)Fixture creates a test database session within a transaction for the testYour test sets up data and runs the test using the session (includingCOMMITing transactions)Your test verifies data is in the databaseFixture rolls back the transaction (and any innerCOMMITed transactions in the test)This two-level transaction strategy makes it so any test is independent of one another,
since the database is empty after each test. Since the database schema only gets re-created once per session,
the test speed is only linearly dependent on the number of migrations.DevelopmentThis library uses thepoetrypackage manager, which has to be installed before installing
other dependencies. Afterwards, runpoetry installto create a virtualenv and install all dependencies.
To then activate that environment, usepoetry shell. To run a command in the environment without activating it,
usepoetry run <command>.Blackis used (and enforced via workflows) to format all code. Poetry will install it
automatically, but running it is up to the user. To format the entire project, runblack .inside the virtualenv.ContributingThis project uses the Apache 2.0 license and is maintained by the data science team @ Barbora. All contribution are
welcome in the form of PRs or raised issues.
Package: alembic-multischema
alembic-multischemaThis module provides the ability to act on multiple postgres schemas at once when using alembic.Functions:perSchema(**kwargs)Used to decorate the upgrade() and downgrade() functions in a migration. When upgrade or downgrade are decorated with perSchema() the decorated function will be called for a list of schemas in the current database.kwargs:schemas
A list of schema names to run the function against. If omitted perSchema() will automatically generate a list of non-system schemas from the current database by using getAllNonSystemSchemas()exclude
A list of schema names to exclude from running the function againstgetAllSchemas()Returns a list of all schemas in the current database.kwargs:exclude
A list of schema names to exclude from running the function againstgetAllNonSystemSchemas()Returns a list of schemas in the current database, omitting information_schema and pg_catalog.kwargs:exclude
A list of schema names to exclude from running the function againstExample Usage:"""CreateUsersTable

Revision ID: a6a219646b55
Revises:
Create Date: 2019-10-16 14:43:11.347575

"""
from alembic import op
import sqlalchemy as sa
from sqlalchemy.sql import text
from almebic_multischema import perSchema

# revision identifiers, used by Alembic.
revision = 'a6a219646b55'
down_revision = None
branch_labels = None
depends_on = None

@perSchema(schemas=["public", "foo", "bar"])
def upgrade():
    users = text(
      """CREATE TABLE users
          (
            id serial PRIMARY KEY,
            firstname VARCHAR (50) UNIQUE,
            lastname VARCHAR (50)
          );
      """)
    op.execute(users)

@perSchema(schemas=["public", "foo", "bar"])
def downgrade():
    op.execute(text("DROP TABLE users"))
Package: alembic_pastedeploy
This is a thin-wrapper of alembic which allows alembic to read pastedeploy-flavored ini config files.Supported featuresImporting defaults bygetandsetdirective:[alembic]
get sqlalchemy.url = sqlalchemy.urlGiving global-conf interpolants by--paste-globaloption from the commandline:$ alembic_pastedeploy --paste-global sqlalchemy.url=sqlite:///test.db upgrade head
Package: alembic-stubs
Alembic StubsThis package contains stub files from official repository ofAlembic.
It allows type checkers to be used with Alembic versions that do not have stubs (< 1.7.0).Installingalembic-stubs can be installed usingpip:pipinstallalembic-stubsRequirementsAlembic (< 1.7.0)LicenseAlembic is distributed under theMIT license.
Package: alembic-viz
####Installation`pip install alembic-viz --user`####Usage```bashUsage: alembic-viz [OPTIONS]Options:--config TEXT           path to alembic config file--name TEXT             name of the alembic ini section--filename TEXT         output file name without file extension--format [png|svg|pdf]  output file format--help                  Show this message and exit.```####Todo* add revision commit messages to graph* handle `depends_on` relationships properly* add test cases* ...
Package: aleo
Aleo Python SDKThe Aleo Python SDK provides a set of libraries aimed at empowering Python developers with zk (zero-knowledge)
programming capabilities via the usage of Aleo's zkSnarks.Currently this SDK is in alpha preview stage. It can be installed by using the following command:pip3installzkmlAlternatively, you can clone it fromGitHuband run:bashinstall.shThis will print out a simple aleo Private Key that is generated by the entropy present on your device.Future Work PlannedThis SDK will be expanded to include the following features:Aleo Account ManagementAleo program deployment, execution, and managementLeo program compilation and executionIt is also planned to integrate this SDK with Aleo's ZkML Package so that the full suite of Aleo program execution and account management capabilities can be used with ZkML.If you wish to contribute, please follow the contribution guidelines outlined onGitHub. For efficient workflows, we also encourage you to get in touch with the developers prior to contributing.
Package: aleph
# ALEPH
ALEPH is a bioinformatics tool to generate fragment-based libraries for molecular replacementALEPH is a bioinformatics tool to generate customised fold libraries for fragment-based molecular replacement.
It provides several algorithms to interpret and analyse protein structures.References:ALEPH: a network-oriented approach for the generation of fragment-based
libraries and for structure interpretation
Medina A, Trivino J, Borges R, Millan C , Uson I and Sammito MD
(2019) Acta Cryst. D Study WeekendExploiting tertiary structure through local folds for ab initio phasing
Sammito M, Millan C, Rodriguez DD, M. de Ilarduya I, Meindl K, De Marino I,
Petrillo G, Buey RM, de Pereda JM, Zeth K, Sheldrick GM and Uson I
(2013) Nat Methods. 10, 1099-1101.Email support:alephbugs@gmail.comBug tracking:https://gitlab.com/arcimboldo-team/ALEPH/-/issues
Package: aleph-alpha-client
Aleph Alpha ClientPython client for theAleph AlphaAPI.UsageSynchronous Clientimportosfromaleph_alpha_clientimportClient,CompletionRequest,Promptclient=Client(token=os.getenv("AA_TOKEN"))request=CompletionRequest(prompt=Prompt.from_text("Provide a short description of AI:"),maximum_tokens=64,)response=client.complete(request,model="luminous-extended")print(response.completions[0].completion)Asynchronous Clientimportosfromaleph_alpha_clientimportAsyncClient,CompletionRequest,Prompt# Can enter context manager within an async functionasyncwithAsyncClient(token=os.environ["AA_TOKEN"])asclient:request=CompletionRequest(prompt=Prompt.from_text("Provide a short description of AI:"),maximum_tokens=64,)response=awaitclient.complete(request,model="luminous-base")print(response.completions[0].completion)Interactive ExamplesThis table contains interactive code examples, further exercises can be found in theexamples repository.TemplateDescriptionInternal LinkColab Link1Calling the APITemplate 12Simple completionTemplate 23Simple searchTemplate 34Symmetric and Asymmetric SearchTemplate 45Hidden EmbeddingsTemplate 56Task-specific EndpointsTemplate 6InstallationThe latest stable version is deployed to PyPi so you can install this package via pip.pipinstallaleph-alpha-clientGet started using the client by firstcreating an account. Afterwards head over toyour profileto create an API token. Read more about how you can manage your API tokenshere.DevelopmentFor local development, start by creating a Python virtual environment as follows:python3 -m venv venv
. ./venv/bin/activateNext, install thetestanddevdependencies:pip install -e ".[test,dev]"Now you should be able to ...run all the tests usingpytestor,pytest -k <test_name>to run a specific testtypecheck the code and tests usingmypy aleph_alpha_clientresp.mypy testsformat the code usingblack .LinksHTTP API DocsInteractive Playground
Package: alephclient
alephclientCommand-line client for Aleph. It can be used to bulk import document sets via
the API, without direct access to the server. It requires an active API client
to perform uploads.InstallationInstall usingpip.pipinstallalephclientUsageRefer to thealephhandbook for an introduction on how to usealephclient,
e.g. to crawl a local file directory, or to stream entities:https://docs.alephdata.org/developers/alephclient
Package: aleph-client
Python Client for the aleph.im network, next generation network of decentralized big data applications.
Developement follows theAleph Whitepaper.DocumentationDocumentation (albeit still vastly incomplete as it is a work in progress) can be found athttp://aleph-client.readthedocs.io/or built from this repo with:$ python setup.py docsRequirementsLinux :Some cryptographic functionalities use curve secp256k1 and require installinglibsecp256k1.$ apt-get install -y python3-pip libsecp256k1-devmacOs :$ brew tap cuber/homebrew-libsecp256k1
$ brew install libsecp256k1InstallationUsing pip andPyPI:$ pip install aleph-clientInstallation for developmentIf you want NULS2 support you will need to install nuls2-python (currently only available on github):$ pip install git+https://github.com/aleph-im/nuls2-python.gitTo install from source and still be able to modify the source code:$ pip install -e .
or
$ python setup.py developUsing DockerUse the Aleph client and it’s CLI from within Docker or Podman with:$ docker run –rm -ti -v $(pwd)/data:/dataghcr.io/aleph-im/aleph-client/aleph-client:master –helpWarning: This will use an ephemeral key that will be discarded when stopping the container.
Package: alephmarcreader
alephmarcreaderGeneralPython library to read Marc obtained from Aleph, the catalogue of the library of the University of Basel.This library supports Marc21, MARCXML, and AlephX.DocumentationThe docstrings can be displayed with pydoc (from the project root):pydoc alephmarcreader.abstractalephmarcreader.AbstractAlephMarcReader. For the inner classes such asPerson, runpydoc alephmarcreader.abstractalephmarcreader.AbstractAlephMarcReader.Person.Designalephmarcreader.abstractalephmarcreader.AbstractAlephMarcReaderprovides methods to access Marc data.
It is an abstract class that has two abstract methods__get_fieldand__get_subfield_textthat have to be implemented in the subclass for the file format at hand.Unit TestsFrom the project root, runpython -m unittest alephmarcreader.tests.test_[Marc[21|XML]|X]Reader.Dependenciespymarc: install with piplxml: install with pipThe library works both with python2 and python3.UsageInstall the package withpip install alephmarcreader.Example usage:# importfromalephmarcreaderimportAlephMarcXMLReader# Read data from local filemarc=AlephMarcXMLReader('example_file.xml')# get some fieldsauthor=marc.get_author()[0]recipient=marc.get_recipient()[0]date=marc.get_date()[0]# print itprint(author.name)print(recipient.name)print(date)For an exhaustive list of the API, usepydoc, as described above.
Package: aleph-message
Aleph.im Message SpecificationThis library aims to provide an easy way to create, update and manipulate
messages from Aleph.im.It mainly consists inpydanticmodels that provide field type validation and IDE autocompletion for messages.This library provides:schema validation when parsing messages.cryptographic hash validation that theitem_hashmatches the content of the message.type validation using type checkers such asmypyin development environments.autocompletion support in development editors.Theitem_hashis commonly used as unique message identifier on Aleph.im.Cryptographic signatures are out of scope of this library and part of thealeph-sdk-pythonproject, due to their extended scope and dependency on cryptographic libraries.This library is used in both client and node software of Aleph.im.Usagepipinstallaleph-messageimportrequestsfromaleph_messageimportparse_messagefrompydanticimportValidationErrorALEPH_API_SERVER="https://official.aleph.cloud"MESSAGE_ITEM_HASH="9b21eb870d01bf64d23e1d4475e342c8f958fcd544adc37db07d8281da070b00"message_dict=requests.get(ALEPH_API_SERVER+"/api/v0/messages.json?hashes="+MESSAGE_ITEM_HASH).json()try:message=parse_message(message_dict["messages"][0])print(message.sender)exceptValidationErrorase:print(e.json(indent=4))
Package: aleph-sdk-python
aleph-sdk-pythonPython SDK for the Aleph.im network, next generation network of decentralized big data applications.Development follows theAleph Whitepaper.DocumentationDocumentation (albeit still vastly incomplete as it is a work in progress) can be found athttp://aleph-sdk-python.readthedocs.io/or built from this repo with:$pythonsetup.pydocsRequirementsLinuxSome cryptographic functionalities use curve secp256k1 and require installinglibsecp256k1.$apt-getinstall-ypython3-piplibsecp256k1-devUsing some chains may also require installinglibgmp3-dev.macOsThis project does not support Python 3.12 on macOS. Please use Python 3.11 instead.$brewtapcuber/homebrew-libsecp256k1
$brewinstalllibsecp256k1InstallationUsing pip andPyPI:$pipinstallaleph-sdk-python[ethereum,solana,tezos]Installation for developmentTo install from source and still be able to modify the source code:$pipinstall-e.[testing]or$pythonsetup.pydevelopUsage with LedgerHQ hardwareThe SDK supports signatures usingapp-ethereum,
the Ethereum app for the Ledger hardware wallets.This has been tested successfully on Linux (amd64).
Let us know if it works for you on other operating systems.Using a Ledger device on Linux requires root access or the setup of udev rules.Unlocking the device is required before using the relevant SDK functions.Debian / UbuntuInstallledger-wallets-udev.sudo apt-get install ledger-wallets-udevOn NixOSConfigurehardware.ledger.enable = true.Other Linux systemsSeehttps://github.com/LedgerHQ/udev-rules
Package: alerce
Welcome to ALeRCE Python Client.ALeRCEclient is a Python library to interact
with ALeRCE services and databases.For full documentation please visit the officialDocumentation:Installing ALeRCE Clientpip install alerceOr clone the repository and install from theregit clone https://github.com/alercebroker/alerce_client.git
cd alerce_client
python setup.py installUsagefrom alerce.core import Alerce
alerce = Alerce()

dataframe = alerce.query_objects(
    classifier="lc_classifier", 
    class_name="LPV", 
    format="pandas"
)

detections = alerce.query_detections("ZTF20aaelulu", format="pandas", sort="mjd")

magstats = alerce.query_magstats("ZTF20aaelulu")

query='''
SELECT
    oid, sgmag1, srmag1, simag1, szmag1, sgscore1
FROM
    ps1_ztf
WHERE
    oid = 'ZTF20aaelulu'
'''
detections_direct = alerce.send_query(query, format="pandas")ConfigurationBy default the Alerce object should be ready to use without any external
configuration, but in case you need to adjust any parameters then you
can configure the Alerce object in different ways.At the client object initializationYou can pass parameters to the Alerce class constructor to set the
parameters for API connection.For example using the ZTF API on localhost:5000 and the DB API on localhost:5050alerce = Alerce(ZTF_API_URL="<http://localhost:5000>", ZTF_DB_API_URL="<http://localhost:5050>")From a dictionary objectYou can pass parameters to the Alerce class from a dictionary object.my_config = {
    "ZTF_API_URL": "http://localhost:5000"
    "ZTF_DB_API_URL": "http://localhost:5050"
}
alerce = Alerce()
alerce.load_config_from_object(my_config)