Saravanan666/pypi-org huggingface dataset:
Package: dewloosh.plotly
dewloosh.plotly- Domain specific data visualization with PlotlyThis a lightweight library serving as a place to gather code snippets for
working with Plotly. The uses cases are usually domain specific, likely to be related
to other dewloosh projects.DocumentationClickhereto read the documentation.InstallationThis is optional, but we suggest you to create a dedicated virtual enviroment at all times to avoid conflicts with your other projects. Create a folder, open a command shell in that folder and use the following command>>> python -m venv venv_nameOnce the enviroment is created, activate it via typing>>> .\venv_name\Scripts\activatelatexdocscan be installed (either in a virtual enviroment or globally) from PyPI usingpipon Python >= 3.7:>>> pip install dewloosh.plotlyLicenseCopyright 2022 Bence Balogh, underthe MIT license.
Package: de-workflow
DE WorkflowThis is a small wrapper program around thedrug-extraction-cliprogram.It is effectively a convenience wrapper for us and our typical use-case.Benefits over the standard CLI:Multi-column support (itexpectstwo columns -- a primary and a secondary)Wide form data created automaticallyWide form data attached to source data ready for analysisAutomated report generationUse of either our/your custom search templatewith tags!It can generate a nice report usingdatapanefor some quick eye-ball analysis.It usesdata/drug_info.json(link) as our template for custom search wordswith tags. This can be extended or edited where you can provide ANY custom search file you want as long as it matches our format. Alternatively you can enable--livemode and just use ours 🙂.DE WorkflowRequirementsInstallationUsageSample OutputSupportContributingMIT LicenseRequirementspipxdrug-extraction-cli programInstallationYou can install this program withpipx:pipxinstallde-workflowYou can then easily get help for the only command (execute) like so:de-workflowexecute--helpWhich should look something like this:UsageTo run this tool all you will need to know is:The name of your fileYour ID column for linkingYour Target column(s) to search inYou can then run the tool:de-workflowexecute../cli/data/records.csv"Case Number""Primary Cause""Secondary Cause"This will run the underlying drug extraction program so youMUSThave the mainCLItool installed.There are additional flags for reporting and custom file searching.--report/--no-reportidentifies whether or not to produce adatapanereport at the end. Suggested and default value is--report.--live/no-liveidentifies whether or not you want you use ourtemplate.If you doNOTwant to use our template, you can disable live (--no-live) but you then MUST provide a custom--search-filefor the program to use. This file should be injsonformat and match the structure of our template so that the tool can work correctly.Sample OutputSupportIf you encounter any issues or need support please either contact@nanthony007oropen an issue.ContributingContributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make aregreatly appreciated.If you have a suggestion that would make this better, please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement".
Don't forget to give the project a star! Thanks again!Fork the ProjectCreate your Feature Branch (git checkout -b feature/AmazingFeature)Commit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull RequestSeeCONTRIBUTING.mdfor more details.MIT LicenseLICENSE
Package: dew-pacman
DevelopmentEnvironmentWranglerWhat is this?Dew is a dependency manager for C/C++ dependencies. It aims to make dependency management and configuration easier,
while keeping out of the way. For each dependency listed in a ‘dewfile’, Dew downloads the source of the dependency, builds
it, and installs it’s files in a prefix directory which can be used by your project.Dew is inspired by Cargo, the defacto package manager and build system for Rust.Is it stable? Is it a good idea to use this for projects in production?It’s getting there. Most of the architecture and scope of Dew is hardening, so be sure to check back for a 1.0 release.InstallationDew is hosted on PyPI and can be installed with pip.pip3installdew-pacmanNote: dew requires python 3.6 and above.It is recommended to include a requirements.txt file in your dew-using projects specifying the version of dew you are
using.UsageCheck out the following pages for information on how to use dew:The DewtorialCommand Reference
Package: dewr
dewrFeature:Restart job when start or files change.Kill job when exit.Installpip3install-UdewrUsageimportloggingimportdewrlogging.basicConfig(level=logging.INFO,format="%(asctime)s\t%(levelname)s\t%(name)s\t%(message)s")dewr.WatchRestart(["."],r"\.(?:pid|log)$",["sh","sleep66.sh"])dewr-d./Another/Dir/To/Watch-e"\.(pid|log)$|^(dist|bin|log|node_modules|\.git)(/|$)"--sleep66.sh
Package: dewy-langchain
Dewy LangChain PluginThis package provides Dewy integration for LangChain.Example:from langchain_core.runnables import RunnableParallel, RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate

from dewy_langchain import DewyRetriever

retriever = DewyRetriever.for_collection("main", base_url="http://localhost:8000")
prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            """
            You're a helpful AI assistant. Given a user question and some retrieved content, answer the user question.
            If none of the articles answer the question, just say you don't know.

            Here is the retrieved content:
            {context}
            """,
        ),
        ("human", "{question}"),
    ]
)

def format_chunks(chunks):
    return "\n\n".join([d.page_content for d in chunks])

chain = (
    { "context": retriever | format_chunks, "question": RunnablePassthrough() }
    | prompt
    | llm
    | StrOutputParser()
)
Package: dex2call
# Dex2Call[![PyPI version](https://badge.fury.io/py/dex2call.svg)](https://badge.fury.io/py/dex2call)A simple script that takes an APK or a DEX files and returns the method calls made by the developer's code to the android.jar classes.Tested on Python 2.7 and 3.7 but should be a polyglot script.## Installationpip install dex2call## Usage$ dex2call --helpUsage: dex2call [OPTIONS] <dex or apk>This script reads the bytecode of a dex file or an apk file and yields theAPI calls made by the developer code. By default only shows the API callsmade to android.jar.The script by default looks for ./classes.dex.Options:-o, --output <file>             Location where to dump the results. Defaultstdout (-)--android-only / --all-methods  Set to true to remove any method call thatdoesn't point to an android method--help                          Show this message and exit.## Example:As command line tool:$ dex2call classes.dex(android.location.Location getLatitude () None)(android.location.Location getLongitude () None)(android.app.Activity <init> () None)(android.app.Activity onCreate (android.os.Bundle) None)(android.location.LocationManager requestLocationUpdates (java.lang.String android.location.LocationListener) None)(android.app.Activity onResume () None)(android.util.Log d (java.lang.String java.lang.String) None)(android.util.Log d (java.lang.String java.lang.String) None)(android.widget.Toast makeText (android.content.Context java.lang.CharSequence) android.widget.Toast)(android.widget.Toast show () None)(android.widget.Toast makeText (android.content.Context java.lang.CharSequence) android.widget.Toast)(android.widget.Toast show () None)If an APK is passed to the tool, it will extract each dex file and also will infer the package name.An example can be found in `example.py` of how to use dex2call as a python module.
Package: dexa-protocol
Data Exchange Agreements (DEXA) Protcol ImplementationAbout•Release Status•Contributing•LicensingAboutThis repository hosts source code for DEXA didcomm protocol plugin for aca-py. This is part of the deliverables for Provenance services with smart data agreement (PS-SDA) project that has received funding from the European Union’s Horizon 2020 research and innovation programme under grant agreement No 957338.Release StatusNot released, work in progress. Planned release: September 2022InstallationRequirements:Python 3.8.9 or higherPlugin InstallationInstall this plugin into the virtual environment:$pipinstalldexa-protocolContributingFeel free to improve the plugin and send us a pull request. If you found any problems, please create an issue in this repo.LicensingCopyright (c) 2022-25 LCubed AB (iGrant.io), SwedenLicensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.You may obtain a copy of the License athttps://www.apache.org/licenses/LICENSE-2.0.Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the LICENSE for the specific language governing permissions and limitations under the License.
Package: dexchange-sms
DSMS PackageDSMS is a Python package that provides a simple way to interact with the Dexchange SMS API. With DSMS, you can send SMS messages and authenticate users via SMS.https://dexchange-sms.comInstallationYou can install the DSMS package using pip:UsageTo use DSMS, you need to have an API key. You can get one by signing up atDexchange.fromdsmsimportDSMS# Create an instance of DSMS with your API keydsms=DSMS(api_key='your-api-key')# Send an SMSsms_data={'number':['1234567890'],# List of recipient numbers'signature':'YourApp','content':'Hello, World!'}response=dsms.send_sms(data=sms_data)print(response)# Send an authentication SMSauth_data={'number':'1234567890','service':'YourApp','lang':'en'}response=dsms.send_auth_sms(data=auth_data)print(response)# Verify an authentication SMSverify_data={'number':'1234567890','service':'YourApp','otp':'123456'}response=dsms.verify_auth_sms(data=verify_data)print(response)### Make sure to replace 'your-api-key' with your actual DSMS API key.
Package: dexcolor
dexcolordexcoloris a Python package that provides a simple and convenient way to add color and style to text output in the terminal. It supports various ANSI escape sequences for text formatting and provides a cross-platform solution for both POSIX and Windows operating systems.InstallationYou can installdexcolorusing pip:pip install dexcolorUsageUsing Colors OnlyYou can usedexcolorto add colors to your text. Available colors are:GRAYREDGREENYELLOWBLUEMAGENTACYANWHITEBRIGHT_BLACKBRIGHT_REDBRIGHT_GREENBRIGHT_YELLOWBRIGHT_BLUEBRIGHT_MAGENTABRIGHT_CYANBRIGHT_WHITEExample:fromdexcolorimportDEXprint(DEX.RED("Hello, World!"))Using Colors and StylesYou can combine colors with styles to customize the appearance of your text even further. Available styles are:BOLDDIMITALICUNDERLINEBLINKREVERSEExample:fromdexcolorimportDEXprint(DEX.MAGENTA("Hello, World!",style='BOLD'))Using Styles OnlyYou can also apply styles without any specific color:fromdexcolorimportSTYLEprint(STYLE.DIM("Hello, World!"))Resetting Colors and StylesTo reset the text color and style to the default, you can use the RESET attribute:fromdexcolorimportDEXprint(DEX.RED("Hello, World!")+DEX.RESET)print(DEX.RED("Hello, World!",style='BOLD')+DEX.RESET)Windows Compatibilitydexcoloris compatible with Windows operating systems. If you are working on Windows and want to convert ANSI escape sequences to the Win32 format, you can use the provided conversion function.ANSI Escape Sequences Conversion (Windows)To convert ANSI escape sequences to the Win32 format on Windows, you can use the following code:fromdexcolorimportconvert_ansi_to_win32text='\033[31mHello, World!\033[0m'# Example text with ANSI escape sequencesconverted_text=convert_ansi_to_win32(text)# Convert ANSI escape sequences to Win32 formatprint(converted_text)# Display the converted textThis conversion function is specifically useful on Windows to ensure proper rendering of colored and styled text.Compatibilitydexcoloris compatible with Linux, macOS, and Windows operating systems. It utilizes ANSI escape sequences, which are widely supported on various platforms.GitHub RepositoryPyPI PackageIf you have any questions or need further assistance, feel free to ask!
Package: dexcom_reader
dexcom_reader=============This is a handful of scripts for dumping data from a Dexcom G4 Glucose Monitorconnected to a computer with USB.Out of the box dumps data like:% python readdata.pyFound Dexcom G4 Receiver S/N: SMXXXXXXXXTransmitter paired: 6XXXXXBattery Status: CHARGING (83%)Record count:- Meter records: 340- CGM records: 3340- CGM commitable records: 3340- Event records: 15- Insertion records: 4
Package: dexec
dexec (Docker exec)dexec allows you to easily run commands inside project-based Docker containers.Installationpython3 -m pip install dexecUsageSimply create a.dexecfile like this:[dexec]
container=my_container
path=/dataWherecontaineris the name of the container, andpaththe path inside the
container of the directory in which the.dexecfile is placed.Now, just run:dexec ls -lAnd you'll see the directory listing from inside the container. Other commands
can be executed just the same, and they can be relative to the path:dexec ./bin/my-script
Package: dexguru-sdk
dexguru-sdk.pydexguru-sdk.py allows you to accessdex.gurupublic methods
from your async python scripts.InstallationTo install latest version, just run:pip install dexguru-sdkGetting StartedTake API key of your project fromdevelopers.dex.guruimportasynciofromdexguru_sdkimportDexGuruYOUR_API_KEY='abc123'sdk=DexGuru(api_key=YOUR_API_KEY)asyncdefmain():response=awaitsdk.get_chains()returnresponseif__name__=='__main__':asyncio.run(main())ResponseSDK response is Pydantic's models, so you can do whateverPydanticallows with them.You can find all models atdexguru_sdk.models:classChainModel(BaseModel):chain_id:intname:strdescription:strclassChainsListModel(BaseModel):total:intdata:List[ChainModel]fromtypingimportListfromdexguru_sdk.modelsimportChainModel,ChainsListModelresponse:ChainsListModeltotal:int=response.totaldata:List[ChainModel]=response.dataif you need a simple dict from response, Pydantic can convert it:response=response.dict()Usage ExamplesOk, we want to see how your favorite wallets are trading:importasynciofromdexguru_sdkimportDexGurusdk=DexGuru(api_key='my_sweet_key_from_sweet_project')wallets=['bot_wallet_address1','mistake_wallet_address2','heavy_wallet_address3']asyncdefmain():wallets_info:WalletsListModel=awaitsdk.get_wallets_info(chain_id=1,wallet_addresses=wallets,)returnwallets_infoif__name__=='__main__':asyncio.run(main())wallets_info.total == 2because we have mistake in address2 and it was skippedPrintwallets_infoobject:total=2data=[WalletModel(wallet_address='bot_wallet_address1',volume_1m_usd=5000.123456,txns_1m=999999,category='bot',timestamp=1621635936# last tx timestamp),WalletModel(wallet_address='whale_wallet_address3',volume_1m_usd=107382.62431031652,txns_1m=8699,category='heavy',timestamp=1621635936# last tx timestamp)]Wow, they are good traders! Let's see what transactions they made:wallets=['bot_wallet_address1','mistake_wallet_address2','heavy_wallet_address3']asyncdefget_txs_from_list_of_wallets(wallets:List[str])->List:result=[]forwalletinwallets:txs=awaitsdk.get_wallet_transactions(chain_id=1,wallet_address=wallet)result.append(txs)returnresultif__name__=='__main__':result=asyncio.run(get_txs_from_list_of_wallets(wallets))
Package: dexible
Dexible is a fully automated Execution Management System for DeFi. In its simplest form, Dexible takes on the responsibility of executing DeFi “orders” according to user-specified “policies”. Policies dictate how execution should be carried out. The SDK is a Python 3 library that gives developers and trade strategists a simple way of interacting with the Dexible infrastructure. From getting quotes, submitting orders, and querying for past orders, the SDK makes it easier to call the appropriate API endpoints with the proper signatures.
Package: dexml
Let’s face it: xml is a fact of modern life.  I’d even go so far as to say
that it’sgoodat what is does.  But that doesn’t mean it’s easy to work
with and it doesn’t mean that we have to like it.  Most of the time, XML
just needs to get out of the way and let you do some actual work instead
of writing code to traverse and manipulate yet another DOM.The dexml module takes the obvious mapping between XML tags and Python objects
and lets you capture that as cleanly as possible.  Loosely inspired by Django’s
ORM, you write simple class definitions to define the expected structure of
your XML document.  Like so:>>> import dexml
>>> from dexml import fields
>>> class Person(dexml.Model):
...   name = fields.String()
...   age = fields.Integer(tagname='age')Then you can parse an XML document into an object like this:>>> p = Person.parse("<Person name='Foo McBar'><age>42</age></Person>")
>>> p.name
u'Foo McBar'
>>> p.age
42And you can render an object into an XML document like this:>>> p = Person(name="Handsome B. Wonderful",age=36)
>>> p.render()
'<?xml version="1.0" ?><Person name="Handsome B. Wonderful"><age>36</age></Person>'Malformed documents will raise a ParseError:>>> p = Person.parse("<Person><age>92</age></Person>")
Traceback (most recent call last):
    ...
ParseError: required field not found: 'name'Of course, it gets more interesting when you nest Model definitions, like this:>>> class Group(dexml.Model):
...   name = fields.String(attrname="name")
...   members = fields.List(Person)
...
>>> g = Group(name="Monty Python")
>>> g.members.append(Person(name="John Cleese",age=69))
>>> g.members.append(Person(name="Terry Jones",age=67))
>>> g.render(fragment=True)
'<Group name="Monty Python"><Person name="John Cleese"><age>69</age></Person><Person name="Terry Jones"><age>67</age></Person></Group>'There’s support for XML namespaces, default field values, case-insensitive
parsing, and more fun stuff.  Check out the documentation on the following
classes for more details:Model:the base class for objects that map into XMLField:the base class for individual model fieldsMeta:meta-information about how to parse/render a model
Package: dexml2
Let’s face it: xml is a fact of modern life.  I’d even go so far as to say
that it’sgoodat what is does.  But that doesn’t mean it’s easy to work
with and it doesn’t mean that we have to like it.  Most of the time, XML
just needs to get out of the way and let you do some actual work instead
of writing code to traverse and manipulate yet another DOM.The dexml module takes the obvious mapping between XML tags and Python objects
and lets you capture that as cleanly as possible.  Loosely inspired by Django’s
ORM, you write simple class definitions to define the expected structure of
your XML document.  Like so:>>> import dexml2
>>> from dexml2 import fields
>>> class Person(dexml2.Model):
...   name = fields.String()
...   age = fields.Integer(tagname='age')Then you can parse an XML document into an object like this:>>> p = Person.parse("<Person name='Foo McBar'><age>42</age></Person>")
>>> p.name
u'Foo McBar'
>>> p.age
42And you can render an object into an XML document like this:>>> p = Person(name="Handsome B. Wonderful",age=36)
>>> p.render()
'<?xml version="1.0" ?><Person name="Handsome B. Wonderful"><age>36</age></Person>'Malformed documents will raise a ParseError:>>> p = Person.parse("<Person><age>92</age></Person>")
Traceback (most recent call last):
    ...
ParseError: required field not found: 'name'Of course, it gets more interesting when you nest Model definitions, like this:>>> class Group(dexml2.Model):
...   name = fields.String(attrname="name")
...   members = fields.List(Person)
...
>>> g = Group(name="Monty Python")
>>> g.members.append(Person(name="John Cleese",age=69))
>>> g.members.append(Person(name="Terry Jones",age=67))
>>> g.render(fragment=True)
'<Group name="Monty Python"><Person name="John Cleese"><age>69</age></Person><Person name="Terry Jones"><age>67</age></Person></Group>'There’s support for XML namespaces, default field values, case-insensitive
parsing, and more fun stuff.  Check out the documentation on the following
classes for more details:Model:the base class for objects that map into XMLField:the base class for individual model fieldsMeta:meta-information about how to parse/render a model
Package: dexml3
Let’s face it: xml is a fact of modern life.  I’d even go so far as to say
that it’sgoodat what is does.  But that doesn’t mean it’s easy to work
with and it doesn’t mean that we have to like it.  Most of the time, XML
just needs to get out of the way and let you do some actual work instead
of writing code to traverse and manipulate yet another DOM.The dexml module takes the obvious mapping between XML tags and Python objects
and lets you capture that as cleanly as possible.  Loosely inspired by Django’s
ORM, you write simple class definitions to define the expected structure of
your XML document.  Like so:>>> import dexml
>>> from dexml import fields
>>> class Person(dexml.Model):
...   name = fields.String()
...   age = fields.Integer(tagname='age')Then you can parse an XML document into an object like this:>>> p = Person.parse("<Person name='Foo McBar'><age>42</age></Person>")
>>> p.name
u'Foo McBar'
>>> p.age
42And you can render an object into an XML document like this:>>> p = Person(name="Handsome B. Wonderful",age=36)
>>> p.render()
'<?xml version="1.0" ?><Person name="Handsome B. Wonderful"><age>36</age></Person>'Malformed documents will raise a ParseError:>>> p = Person.parse("<Person><age>92</age></Person>")
Traceback (most recent call last):
    ...
ParseError: required field not found: 'name'Of course, it gets more interesting when you nest Model definitions, like this:>>> class Group(dexml.Model):
...   name = fields.String(attrname="name")
...   members = fields.List(Person)
...
>>> g = Group(name="Monty Python")
>>> g.members.append(Person(name="John Cleese",age=69))
>>> g.members.append(Person(name="Terry Jones",age=67))
>>> g.render(fragment=True)
'<Group name="Monty Python"><Person name="John Cleese"><age>69</age></Person><Person name="Terry Jones"><age>67</age></Person></Group>'There’s support for XML namespaces, default field values, case-insensitive
parsing, and more fun stuff.  Check out the documentation on the following
classes for more details:Model:the base class for objects that map into XMLField:the base class for individual model fieldsMeta:meta-information about how to parse/render a model
Package: dexo
DexoA python based command line utility for quick and easy
web development project initialisation.Installation:To install dexo on windows,> pip install dexoand to install dexo on unix systems$ pip3 install dexoUsage:To create a new project> dexo { project_name }and you can give project_name as your project's name.
dexo creates the following files for you,index.htmlstyle.cssapp.jsREADME.mdLinksgithub