Saravanan666/pypi-org huggingface dataset:
Package: elixir-dx
go from data to knowledgeElixirDxA collaborative notebook platform that enables teams to use and visualize data, together.RequirementsPython 3.8+InstallationpipinstalldxThen import the package:importdxUsageThedxlibrary currently enables DEX media type visualization of pandasDataFrameandSeriesobjects, as
well as numpyndarrayobjects. This can be handled in two ways:explicitdx.display()callssetting thedisplay_modeto update the IPython display formatter for a sessionWithdx.display()dx.display()will display a single dataset using the DEX media type. It currently supports:pandasDataFrameobjectsimportpandasaspdimportrandomdf=pd.DataFrame({'random_ints':[random.randint(0,100)for_inrange(500)],'random_floats':[random.random()for_inrange(500)],})dx.display(df)tabular data asdictorlisttypesdx.display([[1,5,10,20,500],[1,2,3,4,5],[0,0,0,0,1]]).csvor.jsonfilepathsdf=dx.random_dataframe()df.to_csv("dx_docs_sample.csv",index=False)dx.display("dx_docs_sample.csv")Withdx.set_display_mode()Using either"simple"or"enhanced"display modes will allowdxwill update the currentIPythondisplay formatters to allow DEX media type visualization of pandasDataFrameobjects for an entire notebook / kernel session instead of the defaultDataFramedisplay output.DetailsThis will adjust pandas options to:increasing the number of rows displayed to50000from pandas default of60increasing the number of columns displayed to50from pandas default of20enablinghtml.table_schema(Falseby default in pandas)This will also handle some basic column cleaning and generate a schema for theDataFrameusingpandas.io.json.build_table_schema. Depending on the display mode, the data will be transformed into either a list of dictionaries or list of lists of columnar values."simple"- list of dictionaries"enhanced"- list of listsNOTE:Unlikedx.display(), thisonlyaffects pandas DataFrames (or any types set insettings.RENDERABLE_OBJECTS); it does not affect the display of.csv/.jsonfile data, ordict/listoutputsdx.set_display_mode("simple")importdximportnumpyasnpimportpandasaspd# enable DEX display outputs from now ondx.set_display_mode("simple")df=pd.read_csv("dx_docs_sample.csv")dfdf2=pd.DataFrame([[1,5,10,20,500],[1,2,3,np.nan,5],[0,0,0,np.nan,1]],columns=['a','b','c','d','e'])df2If, at any point, you want to go back to the default display formatting (vanilla pandas output), use the"plain"display mode. This will revert the IPython display format update to its original state and put the pandas options back to their default values.dx.set_display_mode("plain")# revert to original pandas display outputs from now ondx.set_display_mode("plain")df=pd.read_csv("dx_docs_sample.csv")dfdf2=pd.DataFrame([[1,5,10,20,500],[1,2,3,np.nan,5],[0,0,0,np.nan,1]],columns=['a','b','c','d','e'])df2Generating Sample DataDocumentation coming soon!ContributingSeeCONTRIBUTING.md.Code of ConductWe follow the ElixirNotecode of conduct.LICENSESeeLICENSE.md.
Package: elixirlab-server
go from data to knowledgeElixirLab ServerMotivationElixirLab Server sits between ElixirLab and Elixir Server, and provides a
set of REST API handlers and utilities that are used by ElixirLab. It is a separate project in order to
accommodate creating JupyterLab-like applications from a more limited scope.Installpip install elixirlab-serverUsageSee the full documentation forElixirNote Lab Server Docs.Extending the ApplicationSubclass theLabServerAppand provide additional traits and handlers as appropriate for your application.ContributionPlease seeCONTRIBUTING.mdfor details.
Package: elixir-nbc
ElixirNBCThenbconverttool,elixir nbconvert, converts notebooks to various other
formats via Jinja templates. The nbconvert tool allows you to convert an.ipynbnotebook file into various static formats including:HTMLLaTeXPDFReveal JSMarkdown (md)ReStructured Text (rst)executable scriptUsageFrom the command line, use nbconvert to convert a Jupyter notebook (input) to a
a different format (output). The basic command structure is:$ elixir-nbconvert --to <output format> <input notebook>where<output format>is the desired output format and<input notebook>is the
filename of the Jupyter notebook.Convert notebook file,sample.ipynb, to HTML using:$ elixir-nbconvert --to html sample.ipynbThis command creates an HTML output file namedmynotebook.html.Dev InstallCheck if pandoc is installed (pandoc --version); if needed, install:sudo apt-get install pandocOrbrew install pandocInstall elixirnbc for development using:git clone git@github.com:ElixirNote/elixirnbc.git
cd elixirnbc
pip install -e .DocumentationDocumentation for Elixir NbcExamples of Elixir NbcTechnical SupportIssues and Bug Reports: A place to report
bugs or regressions found for nbconvertCommunity Technical Support and Discussion: A place for
installation, configuration, and troubleshooting assistannce by the Elixir community.
As a non-profit project and maintainers who are primarily volunteers, we encourage you
to ask questions and share your knowledge on Discourse.
Package: elixirnote
go from data to knowledgeElixirNoteElixirNoteis a next-generation web-based user interface for
Project Jupyter. The Commercial product such asHex,Deepnote... are also good choices.Read the current ElixirNote documentation onElixirNote Docs.Main FeaturesA new way to notebookUse SQL, Python, and Julia together, or aloneNo-code visualizationA magic, reactive execution modelAdvanced version controlPublish work as interactive data appsA full library of UI componentsDrag-and-drop layoutsInstant publishingLive commentingBuild organizational knowledgeDiscovery work in the knowledge libraryOrganize with categories and statusesSecurity firstSingle tenant / private VPC deploysHIPAA compliant, and BAA friendlySSO support through Google, Okta, Keycloak, and moreDocumentationGet StartedInstallationInterface OverviewWorking With FilesText EditorNotebooksTerminalsCommand PaletteFile & Output FormatExtensionsElixir ServerElixir HubRealtime CollaborationAPIsFAQGetting HelpWe encourage you to ask questions on theDiscourse forum. A question answered there can become a useful resource for others.Bug ReportTo report a bug please read theguidelinesand then open aGithub issue. To keep resolved issues self-contained, thelock botwill lock closed issues as resolved after a period of inactivity. If related discussion is still needed after an issue is locked, please open a new issue and reference the old issue.DevelopmentExtending ElixirNoteTo start developing an extension for ElixirNote, see thedeveloper documentationand theAPI docs.ContributingTo contribute code or documentation to ElixirNote itself, please read thecontributor documentation.ElixirNote follows the JupyterCommunity Guides🌈.LicenseElixirNote uses a shared copyright model that enables all contributors to maintain the
copyright on their contributions. All code is licensed under the terms of the revisedBSD license.
Package: elixir-py
Elixir flavored Erlang Binary Term Format for PythonBased on (https://github.com/okeuday/erlang_py)[https://github.com/okeuday/erlang_py]however forked in order to provide semetrical encoding / decodinga == decode(encode(a))Also converts None -> nil for better elixir compatibilityProvides all encoding and decoding for the Erlang Binary Term Format
(as defined athttp://erlang.org/doc/apps/erts/erl_ext_dist.html)
in a single Python module.Available as aPython package athttps://pypi.python.org/pypi/elixir_py/.Testspython setup.py testAuthorMichael Truog (mjtruog at protonmail dot com)
Kyle Hanson (me at khanson dot com)LicenseMIT License
Package: elixir-server
go from data to knowledgeElixir ServerTheElixirNoteServer provides the backend (i.e. the core services, APIs, and REST endpoints) for Elixir web applications like Elixir notebook, and Voila.For more information, read ourdocumentation here.Installation and Basic usageTo install the latest release locally, make sure you havepip installedand run:pip install elixir-serveror install from source:git clone git git@github.com:ElixirNote/elixirserver.git
cd elixirserver
pip install -e .ElixirServer currently supports Python>=3.6 on Linux, OSX and Windows.Versioning and BranchesIf Elixir Server is a dependency of your project/application, it is important that you pin it to a version that works for your application. Currently, Jupyter Server only has minor and patch versions. Different minor versions likely include API-changes while patch versions do not change API.When a new minor version is released on PyPI, a branch for that version will be created in this repository, and the version of the main branch will be bumped to the next minor version number. That way, the main branch always reflects the latest un-released version.To see the changes between releases, checkout theCHANGELOG.Usage - Running Elixir ServerRunning in a local installationLaunch with:elixir-serverTestingSeeCONTRIBUTING.ContributingIf you are interested in contributing to the project, seeCONTRIBUTING.rst.LicenseLicensing terms.
Package: elixir-shim
go from data to knowledgeElixir ShimThis project provides a way for ElixirNote and other frontends to switch
toElixir Serverfor their Python Web application backend.Basic UsageInstall from PyPI:pip install elixir-shimThis will automatically enable the extension in Elixir Server.UsageThis project also includes an API for shimming traits that moved fromNotebookAppin toServerAppin Elixir Server.
This can be used by applications that subclassedNotebookAppto leverage the Python server backend of Elixir Notebooks.
Such extensions shouldnowswitch toExtensionAppAPI in Elixir Server and addNotebookConfigShimMixinin
their inheritance list to properly handle moved traits.For example, an application class that previously looked like:fromnotebook.notebookappimportNotebookAppclassMyApplication(NotebookApp):should switch to look something like:fromjupyter_server.extension.applicationimportExtensionAppfromnotebook_shim.shimimportNotebookConfigShimMixinclassMyApplication(NotebookConfigShimMixin,ExtensionApp):
Package: elixs
elixs.dev Standart LibraryLibrarys includes:Config File LoaderMySQL interfaceLoggerColor interface (based on color4console)SimpleArgParserThe library is public on GitHub and Licensed under GNU AGPLv3.
Contact me via EMail:eliservices.server@gmail.comInstallationpipinstallelixsVersion NoteThe SimpleArgParser needs python 3.10 (included starting v0.1.3)!
The other functions are the same in v0.1.1 which only requires python 3.8.Usageimportelixscolor("Starting...","info")config_obj=ReadConfig("/path/to/dir","project.conf")conf_array=config_obj.getconfig("all")color("I got all configs!","success")sql=mySQL(config_obj)tables=sql.sendquery("SHOW TABLES;")sql.sendquery("CREATE TABLE firsttable;")sql.commit()sql.close()sqll=MySQLLogger(config_obj,"/path/to/dir")sqll.create_table("people",[["name","VARCHAR(10)"],["age","INTEGER"]])sqll.write(beacon)sqll.close()color("Script is over","error")Usage of SimpleArgParsefile test.py:importelixs# option1 = {Name of option: [[4 synonyms to enable (filled up with 1)], [and 4 to disable], default value]}option1={"Debug mode":[["+d","enable_debug","debug_on",1],["-d","disable_debug","debug_off",1],True]}# You can give up to 3 optionsoption2={"Django mode":[["+s","enable_django","django_on",1],["-s","disable_django","django_off",1],False]}ap=SimpleArgParser(option1,option2)# The second argument is the amout of options you expect.# It defines the number of elements in the tuple that is returneddebug,django=ap.parse(sys.argv,2)print(debug,django)>>>pythontest.py+s-d
FalseTrue

>>>pythontest.py-d
FalseFalse

>>>pythontest.py
TrueFalse
Package: eliza-gpt
Eliza-GPTEliza, the classic chatbot from the 1960s, running on OpenAI'sChat Completions API.Why?The main reason is that this seemed like a fun project to help me acquire a greater understanding of the Chat Completions API from OpenAI, which has become a sort of standard for turn-based conversation between a human and a machine.But also, it is great to have a fast and free service with negligible resource consumption that can be used as a stand-in for a real LLM when the quality of the responses do not matter, such as while doing development or testing.How To UseEliza-GPT is written in Python and can be installed withpip:$ pip install eliza-gptOnce installed, run it to start it as a local service on your computer:$ eliza-gpt
Eliza-GPT is running!
Set base_url="http://127.0.0.1:5005/v1" in your OpenAI client to connect.ConfigurationRun with--helpto learn about configuration options, which include:Setting the listening IP address and port.Adding an API key for authentication.Changing the (simulated) response times. Set to 0 to have near immediate responses.Connecting With a Chat ClientIf you are using the official Python client from OpenAI, add thebase_urloption to it as follows:openai_client = OpenAI(base_url='http://127.0.0.1:5005/v1')If you use Langchain, then use the following to connect to Eliza-GPT:chat = ChatOpenAI(base_url='http://127.0.0.1:5005/v1')If you have a custom client that talks directly to the chat completions endpoint, configurehttp://127.0.0.1:5005/v1as your endpoint.Eliza-GPT supports both the direct and streaming interfaces.ExamplesTheexamplesdirectory includes demonstration applications implemented with the OpenAI client and Langchain.Implementation DetailsEliza-GPT implements a portion of the OpenAI Chat Completions API, ignoring anything that isn't useful. In particular, at this time only the/v1/chat/completionsendpoint is implemented. Any other endpoint from the OpenAI API will return a 404 error to the caller.The following aspects of the Chat Completions endpoint are currently supported:The chat history given in themessagesargument. Only messages with roleuserare used to "prime" Eliza so that it provides a reasonable response.Thestreamargument, which determines if the response should be given in a single JSON object or as a stream of Server-Sent Events.Theseedoption, which makes it possible to have deterministic responses.These are not used or not implemented:Any messages in the chat history that have a role different thanuser.Model names. Eliza-GPT returns the requested model name in the response.Thenargument, which controls how many responses are returned. Eliza-GPT always returns a single response.Themax_tokensargument.Temperature and other LLM-specific tuning parameters.Thestopargument.Anything related to tools or functions that the model may call.Anything related to log probabilities.CreditsThe Eliza chatbot used in this project is calledEliza.pyand was created by Riccardo Di Maio.
Package: elizur
Elizur is an open source finance package for actuaries, finance professionals, and students.  The package currently helps with calculating annuity present values, annuity future values, cash flow expected present values, and life contingencies.  Elizur depends only on the Python 3 standard library andNumPyat runtime.  The project is named afterElizur Wright.If you like Elizur, support the project by clicking the :star: above!RequirementsPython 3.5+Installpip install elizurDocumentationRead the library documentationhereExamplesAll calculations accept a single numeric type or iterable (including numpy arrays) as inputGiven an interest rate calculate a discount factor>>>importelizur.life.annuityasann>>>ann.discount_factor(0.07)0.9345794>>>ann.discount_factor([0.07,0.06])array([0.93457944,0.94339623])Given a term and interest rate calculate the present value of an annuity>>>importelizur.life.annuityasann>>>ann.annuity_pv(n=10,i=0.07)7.023581540932602>>>ann.annuity_pv(n=[10,20],i=[0.07,0.08])array([7.02358154,9.81814741])Given a term and interest rate calculate the present value of an annuity increasing by one each period>>>importelizur.life.annuityasann>>>ann.increasing_annuity_pv(n=10,i=0.07)34.73913324929581>>>ann.increasing_annuity_pv(n=[10,20],i=[0.07,0.08])array([34.73913325,78.90793815])Given cash flows, probabilities, and interest rates calculate the expected present value>>>fromelizur.lifeimportexpected_present_value>>>expected_present_value(>>>cash_flows=(10,11,12),>>>probabilities=(0.99,0.98,0.97),>>>interest_rates=(0.05,0.06,0.07)>>>)28.88814436019514>>>expected_present_value(...cash_flows=(...(10,11,12),...(13,14,15)...),...probabilities=(...(0.99,0.98,0.97),...(0.96,0.95,0.94)...),...interest_rates=(...(0.05,0.06,0.07),...(0.08,0.09,0.10)...)...)array([28.88814436,33.74225435])Given a mortality table calculate life contingencies and probabilities>>>fromelizur.life.tableimportLifeTable,EXAMPLE_TABLE>>>life_table=LifeTable(EXAMPLE_TABLE)>>>life_table.qx(0)0.006271>>>life_table.qx(77)0.036094>>>life_table.tqxn(3,2,77)0.08770141840040623>>>life_table.Ax(0,0.07)0.01562517028789102>>>life_table.IAxn(0,0.07,30)0.04871771529491165>>>life_table.ax(0,0.07)14.046872397027947>>>life_table.axn_due(0,0.07,30)13.173054007415931Import a mortality table in a specific SOA CSV format and perform life contingency calculations.  Download a mortality table in csv format from the SOAhere.  This example uses the first table, 1941 CSO Basic Table ANB.>>>fromelizur.life.utilimportread_soa_csv_mort_table>>>fromelizur.life.tableimportLifeTable>>>mort_table=read_soa_csv_table("1941_cso_basic_table_anb.csv")>>>life_table=LifeTable(mort_table["values"])>>>life_table.qx(77)0.10364>>>life_table.Ax(0,0.07)0.03800673925889163There are many other possibilities.  Check out the reference section of thedocsfor a full list of functionality.ContributingCheckout the contributing guidehereif you'd like to contribute code or raise issueshere.
Package: eljson
eljsonThis is how python package should look like!FeaturesObject oriented work withJSONInstallationpipinstallelsonExamplefromelson.strict_jsonimportStrictJsonfromelson.jsonimportJsonDocStrictJson.from_string(JsonDoc.from_string('{"hello": {"world": "!"}}',),"""{"$schema": "http://json-schema.org/draft-04/schema#","type": "object","properties": {"hello": {"type": "object","properties": {"world": {"type": "string"}},"required": ["world"]}},"required": ["hello"]}""",).path('$.hello.world')LicenseMITCreditsThis project was generated withwemake-python-package. Current template version is:a10c1e14ff468a4328dbe36a6b9a6a321d80da60. See what isupdatedsince then.
Package: elk
Synopsisimport elk


class Point(elk.Elk):
    x = elk.ElkAttribute(mode='rw', type=int)
    y = elk.ElkAttribute(mode='rw', type=int)

    def clear(self):
        self.x = 0
        self.y = 0


class Point3D(Point):
    z = elk.ElkAttribute(mode='rw', type=int)

    @elk.after('clear')
    def clear_z(self):
        self.z = 0What is Elk?Elk (homepage) is an object system for Python inspired byMoosefor Perl.  It implements many of the features of Moose including:attribute delegationdefault attribute valueslazy attribute initialisationread-only attributesrequired attributesattribute type constraintsrolesmethod modifiersElk is written in pure Python and there are no dependencies beyond
the standard library.How does Elk differ from Moose?Moose has many features that are not (yet) implemented in Elk.While Elk tries to faithfully implement Moose paradigms and patterns
in Python, it uses Python idioms and language features as much as
possible.  There are also some differences in terminology in order
to be consistent with Python terminology or idioms.There is not yet a namespace for Elk extensions, nor any convenient
mechanism for extending it.Installationpip install elkLicenseElk is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.ContributingThe Elk source code is available fromhttps://github.com/frasertweedale/elk.Bug reports, patches, feature requests, code review and
documentation are welcomed.To submit a patch, please usegitsend-emailor generate a pull
request.  Write awell formed commit message.  If your patch is
nontrivial, update the copyright notice at the top of each changed
file.
Package: elkai
elkai - a Python library for solving TSP problemsbased onLKHby Keld Helsgaun: with proven optimal solutions up to N=315 and more accurate results thanGoogle's OR toolsasymmetric and symmetrictravelling salesman problemssupportclean and simple API: get results with one line callsInstallation💾To install itrunpip install elkaiExample usageimportelkaicities=elkai.Coordinates2D({'city1':(0,0),'city2':(0,4),'city3':(5,0)})print(cities.solve_tsp())importelkaicities=elkai.DistanceMatrix([[0,4,0],[0,0,5],[0,0,0]])print(cities.solve_tsp())Notesolve_int_matrixandsolve_float_matrixare deprecated in v1. Also, they don't contain the departure to origin in the result by default.LicenseThe LKH native code by Helsgaun is released for non-commercial use only. Therefore the same restriction applies to elkai, which is explained in theLICENSEfile.How it works internallyWe refactored LKH such that it doesn't have global state and you don't need to restart the program in order to run another input problemWe added a hook in ReadProblem that allows reading problems from memory instead of filesWe read the solution from theTourvariable and put it in a PyObject (Python list).✓ Valgrind passed ond3d8c12.⚠️ elkai takes theglobal interpreter lock (GIL)during the solving phase which means two threads cannot solve problems at the same time. If you want to run other workloads at the same time, you have to run another process - for example by using themultiprocessingmodule.If there isn't a prebuilt wheel for your platform, you'll have to follow thescikit-buildprocess.
Package: elkatip
Elkaptip0. DescriptionThis is a Uyghur text convert tool for gui. sometimes u want to display uyghur language in graphic softwares like photoshop or game engines like cocos2dx and unity3d, and u may find chat the characters displayed is not connecting each other. this time u will neet this tool to convert the common uyghur language text and display the converted language.1. Installingpipinstallelkatip# python32. Use of graphical interfaceif u only want to convert some texts to show in graphic softwares like ps , u can use the gui program to do that. u can start the gui program bypython elkatipcomand in root directory or create your own script and show it like this:fromelkatipinportElkatipktp=Elkatip()ktp.showGui()3. Use of program interfaceif u want to display lots of text in your game or watemark in a photo, then u can use the the string converted by this tool.fromelkatipinportElkatipktp=Elkatip()uyghurqa1=""# the common unicode base area stringuighurche1=ktp.toExt(uyghurqa1)# the unicode extended area stringuighurche2=""# the unicode extended area stringuyghurqa2=ktp.toBase(uighurche2)# the common unicode base area stringnote: uyghurqa1 and uyghurqa2 are the common text typed by modern input method. and uighurche1 and uighurche2 are the extended area string which u can dislay normally in a graphic program4. othershttps://github.com/xirwajim/UyghurCharUtilitieshttps://github.com/Alimjan2009/uyghur_convert_utilhttps://github.com/almasgeek/UyghurLanguagehttps://github.com/menzil/uyghur-unicode-lettershttps://github.com/Uyghur-LRs/Uyghur-Wordlisthttps://github.com/mardan/Uyghur-SpellChecking-Libhttps://github.com/neouyghur/fonts-for-uyghur-arabic-scripthttps://github.com/gheyret/test_word2vec_uyghurhttps://github.com/neouyghur/uyghur-text-to-speechhttps://github.com/UyghurDev/Yulghun-vkbhttps://github.com/azmat21/Syllabification-for-Uyghurhttps://github.com/neouyghur/Multiple-Uyghur-Script-Converterhttps://github.com/mardan/Uyghur-Tokenizerhttps://github.com/UyghurDev/UySort5. At the endhonestly, this tool is a java utils when i found it, and i need a python version. so i had to implement the python version myself, and i dont want u to do the same thing i did. hope it is helpful for u.